From e472c2e0f1fae4964003a5484c8b1e6b1cf50639 Mon Sep 17 00:00:00 2001
From: Danielle <logicallysynced@gmail.com>
Date: Wed, 10 Jun 2026 20:23:52 +1000
Subject: [PATCH 1/7] Codebase audit: fix 44 verified bugs, races and hot-path
 allocations (v4.2.73 -> v4.3.1)

Multi-agent audit of the full codebase (67 raw findings, adversarially
verified down to 47; 3 build-script credential items handled separately
by the owner). Fixes by area:

Core: lock discipline for _runningEffects and _activeDevices,
_layergroups swapped to ConcurrentDictionary (game loop vs RGB.NET
timer thread race), dead CPU-throttle branch removed, Sentry heartbeat
no longer blocks a thread-pool thread.

Layers: DamageFlash min-opacity clamp inverted the whole (0,1) range,
JobGaugeA/B/C interpolate mode rebuilt LED groups every tick, missing
_disposed guard in TargetCastbar, per-tick brush and dictionary
allocations hoisted across nine processors, CutsceneAnimation dead
decorator allocation removed, GetLedArray O(n*m) scan now a HashSet.

Decorators: ArenaLightShow blended a 0-1 base color into a 0-255 scale
(base color invisible), Strobe/Pulse detach race guards,
RectangularGradient bottom-edge interpolation typo.

Devices: Yeelight dedup state no longer poisoned by failed sends (bulb
recovers after Wi-Fi drops, errors surface once per outage), Music Mode
accept task leak fixed, LIFX and QMK inter-chunk sleeps moved outside
the device lock (UI no longer freezes on multizone re-enable),
per-frame buffer allocations removed in DynamicLighting, Alienware,
EVision, Redragon and QMK queues.

Helpers: settings deserialization NRE in DictionaryConverter,
Blacksmith job used Black Mage palette colors, palette/effects/settings
saves now atomic (tmp + replace), GetMaxCpuUsage read a memory counter.

UI: Hue adoption dialog mutated ObservableCollection off the UI thread,
LocalizationService subscription leaks in layer items and adoption
dialogs, console trim no longer fires 500 list shifts, registry key in
SettingsViewModel now scoped and disposed.

Harness: SavePreset now round-trips all 28 effect parameters.

Build clean, 133/133 tests pass.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../MainViewModel.cs                          |  24 ++
 Chromatics/Chromatics.csproj                  |   4 +-
 Chromatics/Core/GameController.cs             |  21 +-
 Chromatics/Core/RGBController.cs              | 116 ++++++----
 Chromatics/Core/SentryService.cs              | 218 +++++++++---------
 .../Decorators/ArenaLightShowDecorator.cs     |   6 +-
 .../RGB.NET/Decorators/PulseDecorator.cs      |  10 +-
 .../RGB.NET/Decorators/StrobeDecorator.cs     | 212 +++++++++--------
 .../Devices/Alienware/AlienwareUpdateQueue.cs |  42 ++--
 .../DynamicLightingUpdateQueue.cs             |  17 +-
 .../Devices/EVision/EVisionUpdateQueue.cs     |  10 +-
 .../RGB.NET/Devices/LIFX/LifxUpdateQueue.cs   |  80 +++++--
 .../Devices/QmkRawHid/QmkRawHidUpdateQueue.cs |  94 ++++++--
 .../Devices/Redragon/RedragonUpdateQueue.cs   |  17 +-
 .../Yeelight/Protocol/YeelightConnection.cs   |   8 +-
 .../Devices/Yeelight/YeelightUpdateQueue.cs   |  90 +++++++-
 .../RGB.NET/Gradients/RectangularGradient.cs  |   2 +-
 Chromatics/Helpers/DictionaryConverter.cs     |   2 +-
 Chromatics/Helpers/FileOperationsHelper.cs    |  42 +---
 Chromatics/Helpers/GameHelper.cs              |   4 +-
 Chromatics/Helpers/SystemMonitorHelper.cs     |   6 +-
 .../Layers/BaseLayers/AudioVisualizer.cs      |   2 +-
 Chromatics/Layers/BaseLayers/BattleStance.cs  |  14 +-
 Chromatics/Layers/BaseLayers/JobClasses.cs    |  14 +-
 .../Layers/BaseLayers/ReactiveWeather.cs      |   2 +-
 Chromatics/Layers/BaseLayers/ScreenCapture.cs |   2 +-
 Chromatics/Layers/BaseLayers/Static.cs        |   2 +-
 .../Layers/DynamicLayers/BattleStance.cs      |  15 +-
 Chromatics/Layers/DynamicLayers/Castbar.cs    |   2 +-
 .../Layers/DynamicLayers/EnmityTracker.cs     |   2 +-
 .../Layers/DynamicLayers/ExperienceTracker.cs |   2 +-
 Chromatics/Layers/DynamicLayers/HPTracker.cs  |   2 +-
 Chromatics/Layers/DynamicLayers/Highlight.cs  |  14 +-
 .../DynamicLayers/JobClassesHighlight.cs      |  14 +-
 Chromatics/Layers/DynamicLayers/JobGaugeA.cs  |  34 +--
 Chromatics/Layers/DynamicLayers/JobGaugeB.cs  |  34 +--
 Chromatics/Layers/DynamicLayers/JobGaugeC.cs  |  33 +--
 Chromatics/Layers/DynamicLayers/Keybinds.cs   |  48 ++--
 Chromatics/Layers/DynamicLayers/MPTracker.cs  |   2 +-
 .../DynamicLayers/ReactiveWeatherHighlight.cs |   2 +-
 .../Layers/DynamicLayers/TargetCastbar.cs     |  13 +-
 Chromatics/Layers/DynamicLayers/TargetHP.cs   |   2 +-
 .../Layers/EffectLayers/CutsceneAnimation.cs  |   3 +-
 Chromatics/Layers/EffectLayers/DamageFlash.cs |  43 ++--
 .../Layers/EffectLayers/DutyFinderBell.cs     |   2 +-
 Chromatics/Layers/LayerProcessor.cs           |   6 +-
 Chromatics/ViewModels/ConsoleViewModel.cs     |  11 +-
 .../ViewModels/HueAdoptionDialogViewModel.cs  |  11 +-
 .../ViewModels/LifxAdoptionDialogViewModel.cs |   7 +-
 .../ViewModels/Mapping/LayerItemViewModel.cs  |   7 +-
 .../ViewModels/Mapping/MappingViewModel.cs    |   3 +
 Chromatics/ViewModels/SettingsViewModel.cs    |   7 +-
 .../YeelightAdoptionDialogViewModel.cs        |   7 +-
 Chromatics/Views/HueAdoptionDialog.axaml.cs   |   1 +
 Chromatics/Views/LifxAdoptionDialog.axaml.cs  |   1 +
 .../Views/YeelightAdoptionDialog.axaml.cs     |   1 +
 56 files changed, 855 insertions(+), 535 deletions(-)

diff --git a/Chromatics.DecoratorHarnessUI/MainViewModel.cs b/Chromatics.DecoratorHarnessUI/MainViewModel.cs
index 817d61da..fe7c4f8e 100644
--- a/Chromatics.DecoratorHarnessUI/MainViewModel.cs
+++ b/Chromatics.DecoratorHarnessUI/MainViewModel.cs
@@ -739,6 +739,18 @@ private void ApplyDefaults(EffectEntry effect)
             ParamWaveSpeed = snap.WaveSpeed; ParamWaveFreq = snap.WaveFreq;
             ParamFadeTime = snap.FadeTime; ParamGroupSize = snap.GroupSize;
             ParamBlockSize = snap.BlockSize; ParamBlocks = snap.Blocks; ParamSize = snap.Size;
+            ParamNumberOfLeds = snap.NumberOfLeds; ParamStepSpeed = snap.StepSpeed;
+            ParamSustain = snap.Sustain; ParamRelease = snap.Release; ParamRepetitions = snap.Repetitions;
+            ParamDirection = snap.Direction; ParamRandomise = snap.Randomise;
+            ParamTextureType = snap.TextureType; ParamDiagonalDir = snap.DiagonalDir; ParamFallDir = snap.FallDir;
+            ParamIntensity = snap.Intensity; ParamFlickerSpeed = snap.FlickerSpeed;
+            ParamBeamWidth = snap.BeamWidth; ParamPulseRadius = snap.PulseRadius; ParamFadeWidth = snap.FadeWidth;
+            ParamTailLength = snap.TailLength; ParamSpawnInterval = snap.SpawnInterval;
+            ParamRippleSpeed = snap.RippleSpeed; ParamLaserDir = snap.LaserDir;
+            ParamBpmSpeed = snap.BpmSpeed; ParamBeatsPerCycle = snap.BeatsPerCycle;
+            ParamSimultaneousBeams = snap.SimultaneousBeams; ParamFlickerOpacity = snap.FlickerOpacity;
+            ParamMatrixDir = snap.MatrixDir; ParamFadeBetween = snap.FadeBetween;
+            ParamAccentEvery = snap.AccentEvery; ParamDecay = snap.Decay; ParamWedgeDegrees = snap.WedgeDegrees;
             ColorBase = snap.Base;
             SetColors(snap.Colors);
             return;
@@ -1259,6 +1271,12 @@ private void SavePreset()
             ParamBpm, ParamSpeed, ParamInterval, ParamFadeSpeed, ParamDensity,
             ParamWaveSpeed, ParamWaveFreq, ParamFadeTime, ParamGroupSize,
             ParamBlockSize, ParamBlocks, ParamSize,
+            ParamNumberOfLeds, ParamStepSpeed, ParamSustain, ParamRelease, ParamRepetitions,
+            ParamDirection, ParamRandomise, ParamTextureType, ParamDiagonalDir, ParamFallDir,
+            ParamIntensity, ParamFlickerSpeed, ParamBeamWidth, ParamPulseRadius, ParamFadeWidth,
+            ParamTailLength, ParamSpawnInterval, ParamRippleSpeed, ParamLaserDir,
+            ParamBpmSpeed, ParamBeatsPerCycle, ParamSimultaneousBeams, ParamFlickerOpacity,
+            ParamMatrixDir, ParamFadeBetween, ParamAccentEvery, ParamDecay, ParamWedgeDegrees,
             ColorBase, ColorSlots.Select(s => s.Color).ToArray());
         _savedParams[name] = snap;
 
@@ -1273,6 +1291,12 @@ private record SavedParams(
         int Bpm, int Speed, double Interval, double FadeSpeed, double Density,
         double WaveSpeed, double WaveFreq, double FadeTime, int GroupSize,
         int BlockSize, int Blocks, int Size,
+        int NumberOfLeds, int StepSpeed, double Sustain, double Release, int Repetitions,
+        bool Direction, bool Randomise, string TextureType, string DiagonalDir, string FallDir,
+        double Intensity, double FlickerSpeed, double BeamWidth, double PulseRadius, double FadeWidth,
+        double TailLength, double SpawnInterval, double RippleSpeed, string LaserDir,
+        string BpmSpeed, double BeatsPerCycle, int SimultaneousBeams, double FlickerOpacity,
+        string MatrixDir, double FadeBetween, int AccentEvery, double Decay, double WedgeDegrees,
         AvColor Base, AvColor[] Colors);
 
     // ── Code snippet generator ──────────────────────────────────────────
diff --git a/Chromatics/Chromatics.csproj b/Chromatics/Chromatics.csproj
index 5b42a532..df556b9c 100644
--- a/Chromatics/Chromatics.csproj
+++ b/Chromatics/Chromatics.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <OutputType>WinExe</OutputType>
@@ -10,7 +10,7 @@
     <TargetFramework>net10.0-windows10.0.19041.0</TargetFramework>
     <SupportedOSPlatformVersion>10.0.17763.0</SupportedOSPlatformVersion>
     <StartupObject>Chromatics.Program</StartupObject>
-    <Version>4.2.73.0</Version>
+    <Version>4.3.1.0</Version>
     <Authors>Danielle Thompson</Authors>
     <!-- ApplicationManifest is conditional: local Debug + Release builds embed
          app.manifest (no fusion-identity <msix> element) so VS debug runs and
diff --git a/Chromatics/Core/GameController.cs b/Chromatics/Core/GameController.cs
index f8c8f794..700e6fa2 100644
--- a/Chromatics/Core/GameController.cs
+++ b/Chromatics/Core/GameController.cs
@@ -45,7 +45,6 @@ public static class GameController
         private static int activeProcessId = -1;
         private static bool gameConnected;
         private static bool gameSetup;
-        private static bool memoryEfficientLoop;
         private static bool _isInGame;
         private static bool _onTitle;
         private static bool wasPreviewed;
@@ -386,18 +385,6 @@ private static async Task GameLoop(CancellationToken cancellationToken)
 
                 // Wait for the interval before continuing
                 var delay = _loopInterval;
-                memoryEfficientLoop = false;
-
-                if (memoryEfficientLoop)
-                {
-                    var currentCpuUsage = SystemMonitorHelper.GetCurrentCpuUsage();
-                    var _maxCpuUsage = SystemMonitorHelper.GetMaxCpuUsage();
-
-                    if (currentCpuUsage > _maxCpuUsage)
-                    {
-                        delay += (int)(currentCpuUsage - _maxCpuUsage) * 10;
-                    }
-                }
 
                 await Task.Delay(delay, cancellationToken).ConfigureAwait(ConfigureAwaitOptions.SuppressThrowing);
                 if (cancellationToken.IsCancellationRequested || _isShuttingDown) break;
@@ -559,8 +546,6 @@ private static void GameProcessLayers()
                     var getCurrentPlayer = handler.Reader.GetCurrentPlayer();
                     var isLoggedIn = handler.Reader.GetGameState().IsLoggedIn;
 
-                    var runningEffects = RGBController.GetRunningEffects();
-
                     // Title-screen detection: player entity not loaded AND
                     // not logged in. Debounced via _titleStateConsecutiveTicks
                     // so a brief Entity-null window during zone-in doesn't
@@ -656,7 +641,7 @@ private static void GameProcessLayers()
                                         g?.RemoveAllDecorators();
                                         g?.Detach();
                                     }
-                                    liveGroups.Remove(layer.layerID);
+                                    liveGroups.TryRemove(layer.layerID, out _);
                                 }
                             }
                             baseProcessor.Process(layer);
@@ -679,7 +664,7 @@ private static void GameProcessLayers()
                                 {
                                     foreach (var g in prevGroups)
                                         g?.Detach();
-                                    liveGroups.Remove(layer.layerID);
+                                    liveGroups.TryRemove(layer.layerID, out _);
                                 }
                                 // Per-processor model cleanup (overridden on JobGaugeA/B/C).
                                 foreach (var p in _layerProcessorFactory.GetActiveDynamicProcessors())
@@ -753,7 +738,7 @@ private static void GameProcessLayers()
                                         g?.RemoveAllDecorators();
                                         g?.Detach();
                                     }
-                                    effectLiveGroups.Remove(layer.layerID);
+                                    effectLiveGroups.TryRemove(layer.layerID, out _);
                                 }
                             }
                             var effectProcessors = EffectLayerProcessorFactory.GetProcessors();
diff --git a/Chromatics/Core/RGBController.cs b/Chromatics/Core/RGBController.cs
index ce9309f2..da46b7a4 100644
--- a/Chromatics/Core/RGBController.cs
+++ b/Chromatics/Core/RGBController.cs
@@ -49,6 +49,7 @@ public static class RGBController
         private static readonly System.Threading.Lock _devicesLock = new();
         private static Dictionary<Guid, IRGBDevice> _devices = new Dictionary<Guid, IRGBDevice>();
 
+        private static readonly System.Threading.Lock _activeDevicesLock = new();
         private static Dictionary<IRGBDevice, bool> _activeDevices = new Dictionary<IRGBDevice, bool>();
 
         // Per-device brightness corrections, keyed by the device GUID stamped in
@@ -73,7 +74,11 @@ private static readonly System.Collections.Concurrent.ConcurrentDictionary<Guid,
         private static readonly Dictionary<string, Dictionary<Guid, ListLedGroup>> _taggedEffectsByDevice = new();
         private static readonly System.Threading.Lock _taggedEffectsLock = new();
 
-        private static Dictionary<int, ListLedGroup[]> _layergroups = new Dictionary<int, ListLedGroup[]>();
+        // ConcurrentDictionary because the game-loop thread mutates this while
+        // RaidEffectProcessor / GoldSaucerVegas read it from the RGB.NET timer
+        // thread via surface.Updating.
+        private static readonly System.Collections.Concurrent.ConcurrentDictionary<int, ListLedGroup[]> _layergroups
+            = new System.Collections.Concurrent.ConcurrentDictionary<int, ListLedGroup[]>();
 
         private static List<Led> _layergroupledcollection = new List<Led>();
 
@@ -81,6 +86,7 @@ private static readonly System.Collections.Concurrent.ConcurrentDictionary<Guid,
 
         private static EffectTypesModel _effects = new EffectTypesModel();
 
+        private static readonly System.Threading.Lock _runningEffectsLock = new();
         private static List<ListLedGroup> _runningEffects = new List<ListLedGroup>();
 
         private static bool _baseLayerEffectRunning;
@@ -700,14 +706,12 @@ public static void RemoveDevice(IRGBDevice device)
 
                 surface.Detach(device);
 
-
-                if (_activeDevices.ContainsKey(device))
-                {
-                    _activeDevices[device] = false;
-                }
-                else
+                lock (_activeDevicesLock)
                 {
-                    _activeDevices.Add(device, false);
+                    if (_activeDevices.ContainsKey(device))
+                        _activeDevices[device] = false;
+                    else
+                        _activeDevices.Add(device, false);
                 }
 
             }
@@ -825,13 +829,12 @@ public static void AddDevice(IRGBDevice device)
                 // as the surface.Update flush above lands. No equivalent
                 // power-on call needed.
 
-                if (_activeDevices.ContainsKey(device))
-                {
-                    _activeDevices[device] = true;
-                }
-                else
+                lock (_activeDevicesLock)
                 {
-                    _activeDevices.Add(device, true);
+                    if (_activeDevices.ContainsKey(device))
+                        _activeDevices[device] = true;
+                    else
+                        _activeDevices.Add(device, true);
                 }
 
             }
@@ -974,13 +977,12 @@ private static void DevicesChanged(object sender, DevicesChangedEventArgs e)
                     Logger.WriteConsole(Enums.LoggerTypes.Devices, $"Found {device.DeviceInfo.Manufacturer} {device.DeviceInfo.DeviceType}: {device.DeviceInfo.DeviceName}.");
                 #endif
 
-                if (_activeDevices.ContainsKey(device))
+                lock (_activeDevicesLock)
                 {
-                    _activeDevices[device] = !isDisabled;
-                }
-                else
-                {
-                    _activeDevices.Add(device, !isDisabled);
+                    if (_activeDevices.ContainsKey(device))
+                        _activeDevices[device] = !isDisabled;
+                    else
+                        _activeDevices.Add(device, !isDisabled);
                 }
 
                 // Hot-plug into a running startup animation: rebuild the
@@ -1031,13 +1033,12 @@ private static void DevicesChanged(object sender, DevicesChangedEventArgs e)
                         _devices.Remove(guid);
                 }
 
-                if (_activeDevices.ContainsKey(device))
+                lock (_activeDevicesLock)
                 {
-                    _activeDevices[device] = false;
-                }
-                else
-                {
-                    _activeDevices.Add(device, false);
+                    if (_activeDevices.ContainsKey(device))
+                        _activeDevices[device] = false;
+                    else
+                        _activeDevices.Add(device, false);
                 }
 
                 DeviceConnectionChanged?.Invoke(null, EventArgs.Empty);
@@ -1194,10 +1195,13 @@ public static bool LoadDeviceProvider(IRGBDeviceProvider provider, out Exception
                             hueDev.SetPerDeviceDisabled(true);
                         else if (device is Extensions.RGB.NET.Devices.QmkRawHid.QmkRawHidDevice qmkDev)
                             qmkDev.SetPerDeviceDisabled(true);
-                        if (_activeDevices.ContainsKey(device))
-                            _activeDevices[device] = false;
-                        else
-                            _activeDevices.Add(device, false);
+                        lock (_activeDevicesLock)
+                        {
+                            if (_activeDevices.ContainsKey(device))
+                                _activeDevices[device] = false;
+                            else
+                                _activeDevices.Add(device, false);
+                        }
                     }
 
                     if (_loaded)
@@ -1314,7 +1318,8 @@ public static void UnloadDeviceProvider(IRGBDeviceProvider provider, bool remove
                                 _devices.Remove(key);
                         }
 
-                        _activeDevices.Remove(device);
+                        lock (_activeDevicesLock)
+                            _activeDevices.Remove(device);
                         anyRemoved = true;
                     }
 
@@ -1469,7 +1474,8 @@ private static void SyncTaggedEffectForDevice(string tag, Guid deviceGuid, IRGBD
                     if (_taggedEffectsByDevice.TryGetValue(tag, out var byDevice))
                         byDevice.Remove(deviceGuid);
                 }
-                _runningEffects.Remove(existing);
+                lock (_runningEffectsLock)
+                    _runningEffects.Remove(existing);
                 try { existing.RemoveAllDecorators(); } catch { }
                 try { existing.Detach(); } catch { }
             }
@@ -1578,7 +1584,14 @@ public static void StopEffects(bool gameFirstConnected = false)
                 SetIdleUpdateRate(false);
             }
 
-            foreach (var effects in _runningEffects)
+            List<ListLedGroup> snapshot;
+            lock (_runningEffectsLock)
+            {
+                snapshot = new List<ListLedGroup>(_runningEffects);
+                _runningEffects.Clear();
+            }
+
+            foreach (var effects in snapshot)
             {
                 foreach (var decorator in effects.Decorators)
                 {
@@ -1589,8 +1602,6 @@ public static void StopEffects(bool gameFirstConnected = false)
                 effects.Detach();
             }
 
-            _runningEffects.Clear();
-
             // Clear all tagged-effect lists too. The groups they pointed at
             // are now detached (above), so any future StopTaggedEffects(tag)
             // would no-op anyway — but keeping the dict in sync prevents
@@ -1630,7 +1641,8 @@ public static void RegisterTaggedEffect(string tag, Guid deviceGuid, ListLedGrou
                     byDevice[deviceGuid] = group;
                 }
             }
-            _runningEffects.Add(group);
+            lock (_runningEffectsLock)
+                _runningEffects.Add(group);
         }
 
         // Tear down ONLY the groups registered under `tag` — used when the
@@ -1691,11 +1703,14 @@ public static void StopTaggedEffects(string tag)
             // Force a render so the black hits hardware before we detach.
             try { surface?.Update(); } catch { }
 
-            foreach (var g in snapshot)
+            lock (_runningEffectsLock)
             {
-                g.Detach();
-                _runningEffects.Remove(g);
+                foreach (var g in snapshot)
+                    _runningEffects.Remove(g);
             }
+
+            foreach (var g in snapshot)
+                g.Detach();
         }
 
         public static bool IsBaseLayerEffectRunning()
@@ -1708,6 +1723,10 @@ public static void SetBaseLayerEffect(bool toggle)
             _baseLayerEffectRunning = toggle;
         }
 
+        // Returns the LIVE list, not a snapshot — ReactiveWeather, RaidEffect
+        // and CutsceneAnimation register their groups by mutating it from the
+        // game-loop thread. Internal teardown paths snapshot under
+        // _runningEffectsLock so they can't crash on a concurrent mutation.
         public static List<ListLedGroup> GetRunningEffects()
         {
             return _runningEffects;
@@ -1726,7 +1745,8 @@ public static Dictionary<Guid, IRGBDevice> GetLiveDevices()
 
         public static Dictionary<IRGBDevice, bool> GetActiveDevices()
         {
-            return _activeDevices;
+            lock (_activeDevicesLock)
+                return new Dictionary<IRGBDevice, bool>(_activeDevices);
         }
 
         public static List<IRGBDeviceProvider> GetDeviceProviders()
@@ -1739,26 +1759,25 @@ public static List<Led> GetLiveLayerGroupCollection()
             return _layergroupledcollection;
         }
 
-        public static Dictionary<int, ListLedGroup[]> GetLiveLayerGroups()
+        public static System.Collections.Concurrent.ConcurrentDictionary<int, ListLedGroup[]> GetLiveLayerGroups()
         {
             return _layergroups;
         }
 
         public static void RemoveLayerGroup(int targetId)
         {
-            if (_layergroups.ContainsKey(targetId))
+            // Remove before detaching so the timer-thread readers never see a
+            // half-detached group set.
+            if (_layergroups.TryRemove(targetId, out var removedGroups))
             {
-                foreach (var layer in _layergroups[targetId])
+                foreach (var layer in removedGroups)
                 {
                     layer.RemoveAllDecorators();
                     layer.Detach();
 
-                    if (_runningEffects.Contains(layer))
+                    lock (_runningEffectsLock)
                         _runningEffects.Remove(layer);
                 }
-                
-                _layergroups.Remove(targetId);
-                               
             }
         }
 
@@ -1778,7 +1797,8 @@ public static void ResetLayerGroups()
                 mapping.Value.requestUpdate = true;
             }
 
-            _runningEffects.Clear();
+            lock (_runningEffectsLock)
+                _runningEffects.Clear();
             _layergroups.Clear();
             _layergroupledcollection.Clear();
         }
diff --git a/Chromatics/Core/SentryService.cs b/Chromatics/Core/SentryService.cs
index 8116bfe9..e763d58d 100644
--- a/Chromatics/Core/SentryService.cs
+++ b/Chromatics/Core/SentryService.cs
@@ -221,119 +221,127 @@ private static void StartHeartbeat()
             // Interval is every 60s — enough to populate the Performance tab
             // and provide profile samples without eating quota.
             _heartbeatTimer?.Dispose();
-            _heartbeatTimer = new System.Threading.Timer(_ =>
+            _heartbeatTimer = new System.Threading.Timer(
+                _ => _ = RunHeartbeatAsync(),
+                null,
+                TimeSpan.FromSeconds(HeartbeatInitialDelaySeconds),
+                TimeSpan.FromSeconds(HeartbeatIntervalSeconds));
+        }
+
+        private static async System.Threading.Tasks.Task RunHeartbeatAsync()
+        {
+            try
             {
+                if (!SentrySdk.IsEnabled) return;
+                // Consent gate: no telemetry during normal runtime when
+                // opted out. Transactions are also dropped by
+                // BeforeSendTransaction, but skipping the work entirely
+                // saves the allocation + profiler overhead.
+                var s = _settings;
+                if (s != null && !s.enableCrashReports) return;
+
+                // NOTE: requires the Sentry project's "Filter out health
+                // check transactions" inbound filter to be DISABLED.
+                // That filter regex-matches transaction names containing
+                // health / heart / ping / alive / ready and silently
+                // drops the entire envelope server-side regardless of
+                // transaction shape, scope binding, or measurements.
+                // If app.heartbeat events stop arriving, check that
+                // filter first (Project Settings → Inbound Filters).
+                var tx = SentrySdk.StartTransaction("app.heartbeat", "task");
+                tx.Description = "Periodic process-metrics heartbeat";
+
+                // Bind to the active scope so the transaction inherits
+                // the scope's tags (channel/language/admin from
+                // ApplySettings) and so any breadcrumbs / spans
+                // generated inside `work` automatically attach. Mirrors
+                // RunInstrumented's pattern (which is what app.startup
+                // uses).
+                SentrySdk.ConfigureScope(scope => scope.Transaction = tx);
+
+                var span = tx.StartChild("metrics.collect", "collect process metrics");
                 try
                 {
-                    if (!SentrySdk.IsEnabled) return;
-                    // Consent gate: no telemetry during normal runtime when
-                    // opted out. Transactions are also dropped by
-                    // BeforeSendTransaction, but skipping the work entirely
-                    // saves the allocation + profiler overhead.
-                    var s = _settings;
-                    if (s != null && !s.enableCrashReports) return;
-
-                    // NOTE: requires the Sentry project's "Filter out health
-                    // check transactions" inbound filter to be DISABLED.
-                    // That filter regex-matches transaction names containing
-                    // health / heart / ping / alive / ready and silently
-                    // drops the entire envelope server-side regardless of
-                    // transaction shape, scope binding, or measurements.
-                    // If app.heartbeat events stop arriving, check that
-                    // filter first (Project Settings → Inbound Filters).
-                    var tx = SentrySdk.StartTransaction("app.heartbeat", "task");
-                    tx.Description = "Periodic process-metrics heartbeat";
-
-                    // Bind to the active scope so the transaction inherits
-                    // the scope's tags (channel/language/admin from
-                    // ApplySettings) and so any breadcrumbs / spans
-                    // generated inside `work` automatically attach. Mirrors
-                    // RunInstrumented's pattern (which is what app.startup
-                    // uses).
-                    SentrySdk.ConfigureScope(scope => scope.Transaction = tx);
-
-                    var span = tx.StartChild("metrics.collect", "collect process metrics");
-                    try
+                    using var p = System.Diagnostics.Process.GetCurrentProcess();
+
+                    long workingSetMb = p.WorkingSet64 / 1024 / 1024;
+                    long privateMb = p.PrivateMemorySize64 / 1024 / 1024;
+                    long managedHeapMb = GC.GetTotalMemory(forceFullCollection: false) / 1024 / 1024;
+                    int gc0 = GC.CollectionCount(0);
+                    int gc1 = GC.CollectionCount(1);
+                    int gc2 = GC.CollectionCount(2);
+                    int threads = p.Threads.Count;
+
+                    // Measurements: numeric, unit-aware values that
+                    // Sentry plots as time series in the transaction
+                    // detail view and that are queryable via
+                    // `measurements.<name>:>=<value>` in the Trace
+                    // Explorer. Proper primitive for "stat that varies
+                    // per transaction" — the ingest-side equivalent of
+                    // a Prometheus gauge.
+                    tx.SetMeasurement("working_set_mb", workingSetMb, MeasurementUnit.Information.Megabyte);
+                    tx.SetMeasurement("private_memory_mb", privateMb, MeasurementUnit.Information.Megabyte);
+                    tx.SetMeasurement("managed_heap_mb", managedHeapMb, MeasurementUnit.Information.Megabyte);
+                    tx.SetMeasurement("gc_gen0", gc0, MeasurementUnit.None);
+                    tx.SetMeasurement("gc_gen1", gc1, MeasurementUnit.None);
+                    tx.SetMeasurement("gc_gen2", gc2, MeasurementUnit.None);
+                    tx.SetMeasurement("thread_count", threads, MeasurementUnit.None);
+
+                    // Span data: same numeric values mirrored on the
+                    // child span so the event-detail "Additional Data"
+                    // panel surfaces them in-place rather than only via
+                    // the Measurements section.
+                    span.SetData("working_set_mb", workingSetMb);
+                    span.SetData("private_memory_mb", privateMb);
+                    span.SetData("managed_heap_mb", managedHeapMb);
+                    span.SetData("gc_gen0", gc0);
+                    span.SetData("gc_gen1", gc1);
+                    span.SetData("gc_gen2", gc2);
+                    span.SetData("thread_count", threads);
+
+                    // CPU usage: percent of a single core used since the
+                    // last heartbeat. Divided by core count so 100% = one
+                    // core fully saturated, capped across many-core
+                    // machines. First sample is 0 (no baseline delta).
+                    var now = DateTime.UtcNow;
+                    var cpuTime = p.TotalProcessorTime;
+                    if (_lastSampleTime != DateTime.MinValue)
                     {
-                        using var p = System.Diagnostics.Process.GetCurrentProcess();
-
-                        long workingSetMb = p.WorkingSet64 / 1024 / 1024;
-                        long privateMb = p.PrivateMemorySize64 / 1024 / 1024;
-                        long managedHeapMb = GC.GetTotalMemory(forceFullCollection: false) / 1024 / 1024;
-                        int gc0 = GC.CollectionCount(0);
-                        int gc1 = GC.CollectionCount(1);
-                        int gc2 = GC.CollectionCount(2);
-                        int threads = p.Threads.Count;
-
-                        // Measurements: numeric, unit-aware values that
-                        // Sentry plots as time series in the transaction
-                        // detail view and that are queryable via
-                        // `measurements.<name>:>=<value>` in the Trace
-                        // Explorer. Proper primitive for "stat that varies
-                        // per transaction" — the ingest-side equivalent of
-                        // a Prometheus gauge.
-                        tx.SetMeasurement("working_set_mb", workingSetMb, MeasurementUnit.Information.Megabyte);
-                        tx.SetMeasurement("private_memory_mb", privateMb, MeasurementUnit.Information.Megabyte);
-                        tx.SetMeasurement("managed_heap_mb", managedHeapMb, MeasurementUnit.Information.Megabyte);
-                        tx.SetMeasurement("gc_gen0", gc0, MeasurementUnit.None);
-                        tx.SetMeasurement("gc_gen1", gc1, MeasurementUnit.None);
-                        tx.SetMeasurement("gc_gen2", gc2, MeasurementUnit.None);
-                        tx.SetMeasurement("thread_count", threads, MeasurementUnit.None);
-
-                        // Span data: same numeric values mirrored on the
-                        // child span so the event-detail "Additional Data"
-                        // panel surfaces them in-place rather than only via
-                        // the Measurements section.
-                        span.SetData("working_set_mb", workingSetMb);
-                        span.SetData("private_memory_mb", privateMb);
-                        span.SetData("managed_heap_mb", managedHeapMb);
-                        span.SetData("gc_gen0", gc0);
-                        span.SetData("gc_gen1", gc1);
-                        span.SetData("gc_gen2", gc2);
-                        span.SetData("thread_count", threads);
-
-                        // CPU usage: percent of a single core used since the
-                        // last heartbeat. Divided by core count so 100% = one
-                        // core fully saturated, capped across many-core
-                        // machines. First sample is 0 (no baseline delta).
-                        var now = DateTime.UtcNow;
-                        var cpuTime = p.TotalProcessorTime;
-                        if (_lastSampleTime != DateTime.MinValue)
+                        var cpuDelta = (cpuTime - _lastProcessorTime).TotalMilliseconds;
+                        var wallDelta = (now - _lastSampleTime).TotalMilliseconds;
+                        if (wallDelta > 0)
                         {
-                            var cpuDelta = (cpuTime - _lastProcessorTime).TotalMilliseconds;
-                            var wallDelta = (now - _lastSampleTime).TotalMilliseconds;
-                            if (wallDelta > 0)
-                            {
-                                var cores = Math.Max(1, Environment.ProcessorCount);
-                                var cpuPct = Math.Round(Math.Clamp((cpuDelta / (wallDelta * cores)) * 100.0, 0, 100), 1);
-                                tx.SetMeasurement("cpu_percent", cpuPct, MeasurementUnit.Fraction.Percent);
-                                span.SetData("cpu_percent", cpuPct);
-                            }
+                            var cores = Math.Max(1, Environment.ProcessorCount);
+                            var cpuPct = Math.Round(Math.Clamp((cpuDelta / (wallDelta * cores)) * 100.0, 0, 100), 1);
+                            tx.SetMeasurement("cpu_percent", cpuPct, MeasurementUnit.Fraction.Percent);
+                            span.SetData("cpu_percent", cpuPct);
                         }
-                        _lastProcessorTime = cpuTime;
-                        _lastSampleTime = now;
-
-                        // Wall-clock duration similar to app.startup (~1.5s).
-                        // Runs on the thread pool — zero impact on UI.
-                        System.Threading.Thread.Sleep(1500);
                     }
-                    catch { /* non-critical */ }
-                    span.Finish(SpanStatus.Ok);
-                    tx.Finish(SpanStatus.Ok);
-
-                    // Detach the transaction from scope so subsequent
-                    // unrelated events don't inherit a stale trace context.
-                    SentrySdk.ConfigureScope(scope => scope.Transaction = null);
-
-                    // Force-flush so the envelope leaves the process now
-                    // rather than sitting in the SDK's background queue.
-                    // For a 1/min cadence on an app that the user might
-                    // close at any moment, an explicit flush guarantees
-                    // each tick reaches the backend.
-                    try { SentrySdk.FlushAsync(TimeSpan.FromSeconds(2)).GetAwaiter().GetResult(); } catch { }
+                    _lastProcessorTime = cpuTime;
+                    _lastSampleTime = now;
+
+                    // Keep the transaction span open ~1.5s so the profiler
+                    // collects samples comparable to app.startup duration.
+                    // Uses async delay so the thread-pool thread is released
+                    // during the wait rather than blocked.
+                    await System.Threading.Tasks.Task.Delay(1500).ConfigureAwait(false);
                 }
-                catch { /* heartbeat must never throw */ }
-            }, null, TimeSpan.FromSeconds(HeartbeatInitialDelaySeconds), TimeSpan.FromSeconds(HeartbeatIntervalSeconds));
+                catch { /* non-critical */ }
+                span.Finish(SpanStatus.Ok);
+                tx.Finish(SpanStatus.Ok);
+
+                // Detach the transaction from scope so subsequent
+                // unrelated events don't inherit a stale trace context.
+                SentrySdk.ConfigureScope(scope => scope.Transaction = null);
+
+                // Force-flush so the envelope leaves the process now
+                // rather than sitting in the SDK's background queue.
+                // For a 1/min cadence on an app that the user might
+                // close at any moment, an explicit flush guarantees
+                // each tick reaches the backend.
+                try { await SentrySdk.FlushAsync(TimeSpan.FromSeconds(2)).ConfigureAwait(false); } catch { }
+            }
+            catch { /* heartbeat must never throw */ }
         }
 
         /// <summary>
diff --git a/Chromatics/Extensions/RGB.NET/Decorators/ArenaLightShowDecorator.cs b/Chromatics/Extensions/RGB.NET/Decorators/ArenaLightShowDecorator.cs
index 2b7b209e..b324bf4d 100644
--- a/Chromatics/Extensions/RGB.NET/Decorators/ArenaLightShowDecorator.cs
+++ b/Chromatics/Extensions/RGB.NET/Decorators/ArenaLightShowDecorator.cs
@@ -83,9 +83,9 @@ protected override void Update(double deltaTime)
                     var color = Lerp(currentColor, nextColor, (float)intensity);
 
                     var newCol = new Color(
-                        (int)(color.R * 255 * intensity + baseColor.R * (1 - intensity)),
-                        (int)(color.G * 255 * intensity + baseColor.G * (1 - intensity)),
-                        (int)(color.B * 255 * intensity + baseColor.B * (1 - intensity))
+                        (int)(color.R * 255 * intensity + baseColor.R * 255 * (1 - intensity)),
+                        (int)(color.G * 255 * intensity + baseColor.G * 255 * (1 - intensity)),
+                        (int)(color.B * 255 * intensity + baseColor.B * 255 * (1 - intensity))
                     );
 
                     led.Color = newCol;
diff --git a/Chromatics/Extensions/RGB.NET/Decorators/PulseDecorator.cs b/Chromatics/Extensions/RGB.NET/Decorators/PulseDecorator.cs
index 1bad1304..bbbcda77 100644
--- a/Chromatics/Extensions/RGB.NET/Decorators/PulseDecorator.cs
+++ b/Chromatics/Extensions/RGB.NET/Decorators/PulseDecorator.cs
@@ -81,6 +81,9 @@ public override void OnDetached(IDecoratable decoratable)
 
         protected override void Update(double deltaTime)
         {
+            if (savedColors == null || fadingInLeds == null || fadingOutLeds == null || currentColors == null) return;
+            try
+            {
             // increment the Timing variable
             Timing += deltaTime;
 
@@ -381,7 +384,12 @@ protected override void Update(double deltaTime)
                 led.Key.Color = led.Value;
                 //Surface.Update(true);
             }
-            
+
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine($"Exception: {ex.Message}");
+            }
         }
 
 
diff --git a/Chromatics/Extensions/RGB.NET/Decorators/StrobeDecorator.cs b/Chromatics/Extensions/RGB.NET/Decorators/StrobeDecorator.cs
index 601b7121..d25fbacb 100644
--- a/Chromatics/Extensions/RGB.NET/Decorators/StrobeDecorator.cs
+++ b/Chromatics/Extensions/RGB.NET/Decorators/StrobeDecorator.cs
@@ -75,144 +75,152 @@ public override void OnDetached(IDecoratable decoratable)
 
         protected override void Update(double deltaTime)
         {
-            // increment the Timing variable
-            Timing += deltaTime;
-
-            var minBrightness = 0;
-            var maxBrightness = 1;
-
-            if (Timing >= startDelay)
+            if (fadingInLeds == null || fadingOutLeds == null) return;
+            try
             {
-                var availableLeds = ledGroup.Where(led => !fadingInLeds.ContainsKey(led) && !fadingOutLeds.ContainsKey(led));
+                // increment the Timing variable
+                Timing += deltaTime;
 
-                foreach (var led in availableLeds)
+                var minBrightness = 0;
+                var maxBrightness = 1;
+
+                if (Timing >= startDelay)
                 {
-                    
-                    fadingInLeds.TryAdd(led, baseColor);
+                    var availableLeds = ledGroup.Where(led => !fadingInLeds.ContainsKey(led) && !fadingOutLeds.ContainsKey(led));
+
+                    foreach (var led in availableLeds)
+                    {
 
-                    var colorIndex = random.Next(colors.Length);
+                        fadingInLeds.TryAdd(led, baseColor);
 
-                    if (!currentColors.ContainsKey(led))
-                        currentColors.Add(led, colors[colorIndex]);
+                        var colorIndex = random.Next(colors.Length);
 
-                    
-                }
+                        if (!currentColors.ContainsKey(led))
+                            currentColors.Add(led, colors[colorIndex]);
 
-                // Update startDelay to be a few milliseconds earlier than the current interval
-                if (!oneshot)
-                {
-                    if (randomise)
-                    {
-                        var rng = GetRandomStartTime();
 
-                        if (GetRandomBoolean(0.35))
+                    }
+
+                    // Update startDelay to be a few milliseconds earlier than the current interval
+                    if (!oneshot)
+                    {
+                        if (randomise)
                         {
-                            startDelay = Timing + (fadeSpeed / 1000);
+                            var rng = GetRandomStartTime();
+
+                            if (GetRandomBoolean(0.35))
+                            {
+                                startDelay = Timing + (fadeSpeed / 1000);
+                            }
+                            else
+                            {
+                                startDelay = Timing + (rng / 1000);
+                            }
+
+
                         }
                         else
                         {
-                            startDelay = Timing + (rng / 1000);
+                            startDelay = Timing + (interval / 1000);
                         }
-
-                    
-                    }
-                    else
-                    {
-                        startDelay = Timing + (interval / 1000);
                     }
-                }
-                
-            }
 
-            foreach (var led in fadingInLeds)
-            {
-                // check if the current brightness of the LED is already stored in the dictionary
-                if (!currentBrightness.ContainsKey(led.Key))
-                {
-                    // if not, add the current brightness of the LED to the dictionary
-                    currentBrightness.Add(led.Key, minBrightness);
                 }
 
-                // increment the current brightness of the LED
-                currentBrightness[led.Key] += (float)(deltaTime * (maxBrightness - minBrightness) / (fadeSpeed / 1000));
-
-                // check if the current brightness of the LED has reached the max brightness
-                if (currentBrightness[led.Key] >= maxBrightness)
+                foreach (var led in fadingInLeds)
                 {
-                    // if it has, add the LED to the list of fading out LEDs
-                    fadingOutLeds.TryAdd(led.Key, currentColors[led.Key]);
+                    // check if the current brightness of the LED is already stored in the dictionary
+                    if (!currentBrightness.ContainsKey(led.Key))
+                    {
+                        // if not, add the current brightness of the LED to the dictionary
+                        currentBrightness.Add(led.Key, minBrightness);
+                    }
 
-                    // remove the LED from the list of fading in LEDs
-                    fadingInLeds.TryRemove(led);
-                }
-                else
-                {
-                    // if not, choose a random color from the passed in color array
-                    
-                    
-                    var lerpAmount = Map(currentBrightness[led.Key], minBrightness, maxBrightness, 0, 1);
-                    var color = Lerp(baseColor, currentColors[led.Key], lerpAmount);
-                    fadingInLeds[led.Key] = color;
+                    // increment the current brightness of the LED
+                    currentBrightness[led.Key] += (float)(deltaTime * (maxBrightness - minBrightness) / (fadeSpeed / 1000));
 
-                }
-            }
+                    // check if the current brightness of the LED has reached the max brightness
+                    if (currentBrightness[led.Key] >= maxBrightness)
+                    {
+                        // if it has, add the LED to the list of fading out LEDs
+                        fadingOutLeds.TryAdd(led.Key, currentColors[led.Key]);
 
-            // iterate through the list of fading out LEDs
-            foreach (var led in fadingOutLeds)
-            {
-                // check if the current brightness of the LED is already stored in the dictionary
-                if (!currentBrightness.ContainsKey(led.Key))
-                {
-                    // if not, add the current brightness of the LED to the dictionary
-                    currentBrightness.Add(led.Key, maxBrightness);
-                }
+                        // remove the LED from the list of fading in LEDs
+                        fadingInLeds.TryRemove(led);
+                    }
+                    else
+                    {
+                        // if not, choose a random color from the passed in color array
 
-                // decrement the current brightness of the LED
-                currentBrightness[led.Key] -= (float)(deltaTime * (maxBrightness - minBrightness) / (fadeSpeed / 1000));
 
-                // check if the current brightness of the LED has reached the min brightness
-                if (currentBrightness[led.Key] <= minBrightness)
-                {
-                    // if it has, remove the LED from the list of fading out LEDs
-                    fadingOutLeds.TryRemove(led);
-                    currentBrightness.Remove(led.Key);
-                    currentColors.Remove(led.Key);
-                    startTimes.Remove(led.Key);
+                        var lerpAmount = Map(currentBrightness[led.Key], minBrightness, maxBrightness, 0, 1);
+                        var color = Lerp(baseColor, currentColors[led.Key], lerpAmount);
+                        fadingInLeds[led.Key] = color;
 
-                    if (fadingInLeds.ContainsKey(led.Key))
-                        fadingInLeds.TryRemove(led);
+                    }
                 }
-                else
+
+                // iterate through the list of fading out LEDs
+                foreach (var led in fadingOutLeds)
                 {
-                    // if not, set the LED's color to the base color with the current brightness
-                    var lerpAmount = Map(currentBrightness[led.Key], minBrightness, maxBrightness, 0, 1);
-                    var color = Lerp(baseColor, currentColors[led.Key], lerpAmount);
-                    fadingOutLeds[led.Key] = color;
+                    // check if the current brightness of the LED is already stored in the dictionary
+                    if (!currentBrightness.ContainsKey(led.Key))
+                    {
+                        // if not, add the current brightness of the LED to the dictionary
+                        currentBrightness.Add(led.Key, maxBrightness);
+                    }
+
+                    // decrement the current brightness of the LED
+                    currentBrightness[led.Key] -= (float)(deltaTime * (maxBrightness - minBrightness) / (fadeSpeed / 1000));
+
+                    // check if the current brightness of the LED has reached the min brightness
+                    if (currentBrightness[led.Key] <= minBrightness)
+                    {
+                        // if it has, remove the LED from the list of fading out LEDs
+                        fadingOutLeds.TryRemove(led);
+                        currentBrightness.Remove(led.Key);
+                        currentColors.Remove(led.Key);
+                        startTimes.Remove(led.Key);
+
+                        if (fadingInLeds.ContainsKey(led.Key))
+                            fadingInLeds.TryRemove(led);
+                    }
+                    else
+                    {
+                        // if not, set the LED's color to the base color with the current brightness
+                        var lerpAmount = Map(currentBrightness[led.Key], minBrightness, maxBrightness, 0, 1);
+                        var color = Lerp(baseColor, currentColors[led.Key], lerpAmount);
+                        fadingOutLeds[led.Key] = color;
 
+                    }
                 }
-            }
 
 
-            foreach (var led in ledGroup)
-            {
-                if (fadingInLeds.ContainsKey(led))
+                foreach (var led in ledGroup)
                 {
-                    led.Color = fadingInLeds[led];
+                    if (fadingInLeds.ContainsKey(led))
+                    {
+                        led.Color = fadingInLeds[led];
+                    }
+                    else if (fadingOutLeds.ContainsKey(led))
+                    {
+                        led.Color = fadingOutLeds[led];
+                    }
+                    else
+                    {
+                        led.Color = baseColor;
+                    }
+
                 }
-                else if (fadingOutLeds.ContainsKey(led))
-                {
-                    led.Color = fadingOutLeds[led];
-                } 
-                else
+
+                if (fadingOutLeds.Count == 0 && oneshot)
                 {
-                    led.Color = baseColor;
+                    Detach();
                 }
-                    
             }
-
-            if (fadingOutLeds.Count == 0 && oneshot)
+            catch (Exception ex)
             {
-                Detach();
+                Debug.WriteLine($"Exception: {ex.Message}");
             }
         }
 
diff --git a/Chromatics/Extensions/RGB.NET/Devices/Alienware/AlienwareUpdateQueue.cs b/Chromatics/Extensions/RGB.NET/Devices/Alienware/AlienwareUpdateQueue.cs
index dc7f6e85..009d5416 100644
--- a/Chromatics/Extensions/RGB.NET/Devices/Alienware/AlienwareUpdateQueue.cs
+++ b/Chromatics/Extensions/RGB.NET/Devices/Alienware/AlienwareUpdateQueue.cs
@@ -6,6 +6,7 @@
 using RGB.NET.Core;
 using System;
 using System.Collections.Generic;
+using System.Runtime.InteropServices;
 using System.Threading;
 using Color = RGB.NET.Core.Color;
 
@@ -37,6 +38,16 @@ public class AlienwareUpdateQueue : UpdateQueue
         // per frame.
         private byte _v8BatchCounter;
 
+        // Reused per-frame dirty-index list. Cleared at the start of each
+        // Update() call. Safe to reuse because Update() runs serially
+        // under _lock on the trigger thread.
+        private readonly List<int> _dirty = new();
+
+        // Reused colour-grouping dictionary for the V4 zone send path.
+        // Cleared on each SendV4Frame call to avoid per-frame dictionary
+        // allocation. Safe because SendV4Frame runs serially under _lock.
+        private readonly Dictionary<uint, List<byte>> _v4ByColor = new();
+
         #endregion
 
         #region Constructors
@@ -109,8 +120,10 @@ protected override bool Update(ReadOnlySpan<(object key, Color color)> dataSet)
 
                     // Patch dirty lights into the per-light cache. Track
                     // the dirty index list so we only resend lights whose
-                    // value changed.
-                    var dirty = new List<int>(dataSet.Length);
+                    // value changed. _dirty is a pre-allocated reusable
+                    // field; it is safe because Update() runs serially
+                    // under _lock on the trigger thread.
+                    _dirty.Clear();
                     foreach (var (key, color) in dataSet)
                     {
                         int idx = ResolveLightIndex(key);
@@ -123,21 +136,21 @@ protected override bool Update(ReadOnlySpan<(object key, Color color)> dataSet)
                         _ledBytes[off]     = r;
                         _ledBytes[off + 1] = g;
                         _ledBytes[off + 2] = b;
-                        dirty.Add(idx);
+                        _dirty.Add(idx);
                     }
 
-                    if (dirty.Count == 0) return true;
+                    if (_dirty.Count == 0) return true;
 
                     switch (_def.ApiVersion)
                     {
                         case AlienwareApiVersion.PerKeyV5:
-                            SendV5Frame(dirty);
+                            SendV5Frame(_dirty);
                             break;
                         case AlienwareApiVersion.PerKeyV8:
-                            SendV8Frame(dirty);
+                            SendV8Frame(_dirty);
                             break;
                         case AlienwareApiVersion.ZoneV4:
-                            SendV4Frame(dirty);
+                            SendV4Frame(_dirty);
                             break;
                         default:
                             // Unknown version — silent no-op so we don't
@@ -258,15 +271,17 @@ private void SendV4Frame(List<int> dirty)
 
             // Group dirty lights by colour so lights sharing a colour go
             // out in one HID write rather than N. Common case for static
-            // overlays / single-colour layers.
-            var byColor = new Dictionary<uint, List<byte>>();
+            // overlays / single-colour layers. Reuse _v4ByColor to avoid
+            // per-frame dictionary allocation. Safe because SendV4Frame
+            // runs serially under _lock on the trigger thread.
+            _v4ByColor.Clear();
             foreach (int idx in dirty)
             {
                 int off = idx * 3;
                 byte r = _ledBytes[off], g = _ledBytes[off + 1], b = _ledBytes[off + 2];
                 uint packed = (uint)((r << 16) | (g << 8) | b);
-                if (!byColor.TryGetValue(packed, out var list))
-                    byColor[packed] = list = new List<byte>(dirty.Count);
+                if (!_v4ByColor.TryGetValue(packed, out var list))
+                    _v4ByColor[packed] = list = new List<byte>(dirty.Count);
                 list.Add((byte)idx);
             }
 
@@ -274,18 +289,19 @@ private void SendV4Frame(List<int> dirty)
             // (ReportLength=34 minus 8-byte header). Split colour groups
             // larger than that across multiple writes.
             const int maxIdsPerWrite = 34 - 8;
-            foreach (var kvp in byColor)
+            foreach (var kvp in _v4ByColor)
             {
                 byte r = (byte)((kvp.Key >> 16) & 0xFF);
                 byte g = (byte)((kvp.Key >> 8) & 0xFF);
                 byte b = (byte)(kvp.Key & 0xFF);
                 var ids = kvp.Value;
+                var idsSpan = CollectionsMarshal.AsSpan(ids);
                 for (int start = 0; start < ids.Count; start += maxIdsPerWrite)
                 {
                     int chunk = Math.Min(maxIdsPerWrite, ids.Count - start);
                     AlienwareZoneV4Protocol.BuildSetColor(
                         buffer, r, g, b,
-                        new ReadOnlySpan<byte>(ids.GetRange(start, chunk).ToArray()));
+                        idsSpan.Slice(start, chunk));
                     WriteOutputReport(buffer);
                 }
             }
diff --git a/Chromatics/Extensions/RGB.NET/Devices/DynamicLighting/DynamicLightingUpdateQueue.cs b/Chromatics/Extensions/RGB.NET/Devices/DynamicLighting/DynamicLightingUpdateQueue.cs
index fb5e2060..fe1a8239 100644
--- a/Chromatics/Extensions/RGB.NET/Devices/DynamicLighting/DynamicLightingUpdateQueue.cs
+++ b/Chromatics/Extensions/RGB.NET/Devices/DynamicLighting/DynamicLightingUpdateQueue.cs
@@ -143,11 +143,18 @@ protected override bool Update(ReadOnlySpan<(object key, Color color)> dataSet)
                     // WinRT call. Cheaper than N SetSingleColor calls
                     // (one IPC trip vs N), and the WinRT layer batches
                     // the underlying HID multi-update reports for us.
-                    var indicesSlice = new int[dirtyCount];
-                    var colorsSlice = new WinColor[dirtyCount];
-                    Array.Copy(_dirtyIndicesBuffer, indicesSlice, dirtyCount);
-                    Array.Copy(_dirtyColorsBuffer, colorsSlice, dirtyCount);
-                    lampArray.SetColorsForIndices(colorsSlice, indicesSlice);
+                    // The pre-allocated buffers are passed whole to avoid a
+                    // per-frame slice allocation, so the tail beyond
+                    // dirtyCount is padded with copies of entry 0. Leaving
+                    // stale entries there instead would repaint a lamp with
+                    // an OLDER colour whenever its position in the dirty
+                    // ordering drops between frames.
+                    for (int i = dirtyCount; i < _lampCount; i++)
+                    {
+                        _dirtyIndicesBuffer[i] = _dirtyIndicesBuffer[0];
+                        _dirtyColorsBuffer[i] = _dirtyColorsBuffer[0];
+                    }
+                    lampArray.SetColorsForIndices(_dirtyColorsBuffer, _dirtyIndicesBuffer);
                     return true;
                 }
                 catch (Exception ex)
diff --git a/Chromatics/Extensions/RGB.NET/Devices/EVision/EVisionUpdateQueue.cs b/Chromatics/Extensions/RGB.NET/Devices/EVision/EVisionUpdateQueue.cs
index 13480aa4..342d1a90 100644
--- a/Chromatics/Extensions/RGB.NET/Devices/EVision/EVisionUpdateQueue.cs
+++ b/Chromatics/Extensions/RGB.NET/Devices/EVision/EVisionUpdateQueue.cs
@@ -43,6 +43,12 @@ public class EVisionUpdateQueue : UpdateQueue
         // ACK buffer reused across reads.
         private readonly byte[] _ackBuffer = new byte[EVisionKeyboardProtocol.ReportLength];
 
+        // Write buffer reused across all WriteAndAck calls in a single
+        // frame. Avoids the per-call buf.ToArray() heap allocation.
+        // Safe because WriteAndAck runs serially under _lock on the
+        // trigger thread.
+        private readonly byte[] _writeBuffer = new byte[EVisionKeyboardProtocol.ReportLength];
+
         #endregion
 
         #region Constructors
@@ -165,10 +171,10 @@ private bool SendFrame()
 
         private bool WriteAndAck(ReadOnlySpan<byte> buf)
         {
-            byte[] arr = buf.ToArray();
+            buf.CopyTo(_writeBuffer);
             try
             {
-                _stream.Write(arr);
+                _stream.Write(_writeBuffer);
                 // ReadExactly because the firmware returns a fixed 64-byte
                 // ACK per packet; partial reads would mean we'd accept the
                 // next write before the device finished signalling.
diff --git a/Chromatics/Extensions/RGB.NET/Devices/LIFX/LifxUpdateQueue.cs b/Chromatics/Extensions/RGB.NET/Devices/LIFX/LifxUpdateQueue.cs
index 0d982d78..93b12c2b 100644
--- a/Chromatics/Extensions/RGB.NET/Devices/LIFX/LifxUpdateQueue.cs
+++ b/Chromatics/Extensions/RGB.NET/Devices/LIFX/LifxUpdateQueue.cs
@@ -6,6 +6,7 @@
 using RGB.NET.Core;
 using System;
 using System.Buffers.Binary;
+using System.Collections.Generic;
 using System.Net.Sockets;
 using System.Threading;
 using System.Threading.Tasks;
@@ -241,6 +242,11 @@ public async Task RestoreOriginalStateAsync(CancellationToken ct = default)
 
         protected override bool Update(ReadOnlySpan<(object key, Color color)> dataSet)
         {
+            // Multizone extended chunks are collected inside the lock and
+            // sent outside it so that ResetCache (called from the Avalonia
+            // UI thread on device re-enable) doesn't wait behind the
+            // Thread.Sleep(30) pacing that sits between each chunk.
+            List<byte[]> deferredChunks = null;
             lock (_lock)
             {
                 if (_shuttingDown || _perDeviceDisable) return true;
@@ -260,18 +266,22 @@ protected override bool Update(ReadOnlySpan<(object key, Color color)> dataSet)
 
                     if (isMultizone)
                     {
-                        SendMultizoneFrame(dataSet, brightnessScale);
+                        // Collect packets inside the lock (patching _strip),
+                        // but send them below outside the lock so ResetCache
+                        // on the UI thread doesn't block behind the 30ms sleeps.
+                        deferredChunks = CollectMultizoneChunks(dataSet, brightnessScale);
+                        // Fall through to post-lock send.
                     }
                     else if (_product.IsMatrix)
                     {
                         SendMatrixFrame(dataSet, brightnessScale);
+                        return true;
                     }
                     else
                     {
                         SendSingleColorFrame(dataSet, brightnessScale);
+                        return true;
                     }
-
-                    return true;
                 }
                 catch (Exception ex)
                 {
@@ -279,6 +289,28 @@ protected override bool Update(ReadOnlySpan<(object key, Color color)> dataSet)
                     return false;
                 }
             }
+
+            // Send dirty chunks with 30ms inter-chunk pacing outside _lock.
+            // Sparse updates (1-2 zones change in starfield) dirty 1 chunk →
+            // 1 packet, no sleep. Dense updates (gradient sweep) dirty all
+            // chunks → 30ms pacing keeps them under the firmware burst-drop
+            // threshold (6ms wasn't enough; 30ms × 3 = 90ms total send time
+            // leaves the trigger thread ~10ms of slack within a 100ms budget).
+            if (deferredChunks == null || deferredChunks.Count == 0) return true;
+
+            bool firstSent = true;
+            foreach (var chunk in deferredChunks)
+            {
+                if (!firstSent)
+                {
+                    if (_shuttingDown || _perDeviceDisable) return true;
+                    Thread.Sleep(30);
+                }
+                firstSent = false;
+                if (_shuttingDown || _perDeviceDisable) return true;
+                SendPacket(chunk);
+            }
+            return true;
         }
 
         private void SendSingleColorFrame(ReadOnlySpan<(object key, Color color)> dataSet, double brightnessScale)
@@ -319,7 +351,13 @@ private void SendSingleColorFrame(ReadOnlySpan<(object key, Color color)> dataSe
         private byte[] _strip;       // persistent zone HSBK state, [zoneCount * 8] bytes
         private int _stripZones;     // cached zone count for _strip's allocation
 
-        private void SendMultizoneFrame(ReadOnlySpan<(object key, Color color)> dataSet, double brightnessScale)
+        // Builds the per-chunk packets for a multizone frame and returns them
+        // for deferred sending outside _lock. The _strip state is patched
+        // here (inside the lock) so the persistent zone cache stays consistent.
+        // Returns null when the legacy (non-extended) path is used — legacy
+        // packets are sent immediately inside the lock because that path has
+        // no inter-chunk sleep.
+        private List<byte[]> CollectMultizoneChunks(ReadOnlySpan<(object key, Color color)> dataSet, double brightnessScale)
         {
             int zones = _def.ZoneCount > 0 ? _def.ZoneCount : 1;
             if (_strip == null || _stripZones != zones)
@@ -354,34 +392,29 @@ private void SendMultizoneFrame(ReadOnlySpan<(object key, Color color)> dataSet,
             }
 
             // Devices flagged as non-extended in the catalog use legacy
-            // SetColorZones (run-length-encoded over the full strip).
+            // SetColorZones (run-length-encoded over the full strip). That
+            // path sends multiple small packets without any inter-packet
+            // sleep so it can stay inside the lock.
             if (_product.IsMultizone && !_product.IsExtendedMultizone)
             {
                 bool anyDirty = false;
                 foreach (var d in chunkDirty) if (d) { anyDirty = true; break; }
                 if (anyDirty) SendLegacyMultizoneFrame(_strip, zones);
-                return;
+                return null;
             }
 
-            // Send each dirty chunk, paced. Sparse updates (1-2 zones
-            // change in starfield) typically dirty 1 chunk → 1 packet, no
-            // pacing. Dense updates (gradient sweep) dirty all chunks →
-            // 30ms pacing keeps them under the firmware's burst-drop
-            // threshold (6ms wasn't enough; 30ms × 3 = 90ms total send
-            // time leaves the trigger thread ~10ms of slack within a 100ms
-            // budget).
-            bool firstSent = true;
+            // Build each dirty chunk's packet while we still hold _lock
+            // (so _strip can't be reset mid-build). Return the list for
+            // paced sending outside _lock in Update().
+            var packets = new List<byte[]>(chunkCount);
             for (int c = 0; c < chunkCount; c++)
             {
                 if (!chunkDirty[c]) continue;
-
-                if (!firstSent) Thread.Sleep(30);
-                firstSent = false;
-
                 int start = c * ChunkSize;
                 int count = Math.Min(ChunkSize, zones - start);
-                SendExtendedChunk(_strip, start, count, durationMs: 150);
+                packets.Add(BuildExtendedChunkPacket(_strip, start, count, durationMs: 150));
             }
+            return packets;
         }
 
         private static int ZoneIndexFromKey(object key)
@@ -394,7 +427,7 @@ private static int ZoneIndexFromKey(object key)
             };
         }
 
-        private void SendExtendedChunk(byte[] frame, int start, int count, uint durationMs)
+        private byte[] BuildExtendedChunkPacket(byte[] frame, int start, int count, uint durationMs)
         {
             byte[] payload = new byte[8 + count * 8];
             BinaryPrimitives.WriteUInt32LittleEndian(payload.AsSpan(0, 4), durationMs);
@@ -402,9 +435,12 @@ private void SendExtendedChunk(byte[] frame, int start, int count, uint duration
             BinaryPrimitives.WriteUInt16LittleEndian(payload.AsSpan(5, 2), (ushort)start);
             payload[7] = (byte)count;
             Array.Copy(frame, start * 8, payload, 8, count * 8);
+            return BuildPacket(LifxMessageTypes.SetExtendedColorZones, payload);
+        }
 
-            byte[] packet = BuildPacket(LifxMessageTypes.SetExtendedColorZones, payload);
-            SendPacket(packet);
+        private void SendExtendedChunk(byte[] frame, int start, int count, uint durationMs)
+        {
+            SendPacket(BuildExtendedChunkPacket(frame, start, count, durationMs));
         }
 
         // Legacy SetColorZones path: one packet per run of consecutive
diff --git a/Chromatics/Extensions/RGB.NET/Devices/QmkRawHid/QmkRawHidUpdateQueue.cs b/Chromatics/Extensions/RGB.NET/Devices/QmkRawHid/QmkRawHidUpdateQueue.cs
index 49f2dd9a..1728d83b 100644
--- a/Chromatics/Extensions/RGB.NET/Devices/QmkRawHid/QmkRawHidUpdateQueue.cs
+++ b/Chromatics/Extensions/RGB.NET/Devices/QmkRawHid/QmkRawHidUpdateQueue.cs
@@ -52,6 +52,11 @@ public class QmkRawHidUpdateQueue : UpdateQueue
         private readonly int _inputReportByteLength;
         private readonly int _payloadOutBytes;
 
+        // Pre-allocated output buffer for the VIA path. Only ever written on
+        // the update thread (inside _lock), so no additional synchronisation
+        // is needed.
+        private byte[] _outBuf;
+
         #endregion
 
         #region Constructors
@@ -67,6 +72,7 @@ public QmkRawHidUpdateQueue(IDeviceUpdateTrigger trigger, QmkRawHidClientDefinit
             _ledIndexByLedId = new Dictionary<LedId, int>(def.Layout.Count);
             for (int i = 0; i < def.Layout.Count; i++)
                 _ledIndexByLedId[def.Layout[i].PreferredLedId] = def.Layout[i].FirmwareIndex;
+            _outBuf = new byte[_outputReportByteLength];
         }
 
         #endregion
@@ -124,6 +130,10 @@ public void SetPerDeviceBrightness(PerDeviceBrightnessCorrection correction)
 
         protected override bool Update(ReadOnlySpan<(object key, Color color)> dataSet)
         {
+            // For OpenRGB-QMK, dirty chunks are collected inside the lock
+            // and sent outside it so that ResetCache / BeginShutdown don't
+            // block behind the 1ms inter-chunk pacing sleeps.
+            OpenRgbPendingWrite pending = default;
             lock (_lock)
             {
                 if (_shuttingDown || _perDeviceDisable) return true;
@@ -136,11 +146,15 @@ protected override bool Update(ReadOnlySpan<(object key, Color color)> dataSet)
                     double brightnessScale = (globalPct / 100.0) * (perDevicePct / 100.0);
 
                     if (_def.Protocol == QmkRawHidProtocolMode.OpenRgbQmk)
-                        SendOpenRgbQmkFrame(dataSet, brightnessScale);
+                    {
+                        pending = CollectOpenRgbQmkChunks(dataSet, brightnessScale);
+                        // Fall through to send pending packets outside the lock.
+                    }
                     else
+                    {
                         SendViaFrame(dataSet, brightnessScale);
-
-                    return true;
+                        return true;
+                    }
                 }
                 catch (Exception ex)
                 {
@@ -148,6 +162,30 @@ protected override bool Update(ReadOnlySpan<(object key, Color color)> dataSet)
                     return false;
                 }
             }
+
+            if (pending.Packets == null) return true;
+
+            for (int i = 0; i < pending.Packets.Length; i++)
+            {
+                if (_shuttingDown || _perDeviceDisable) return true;
+                if (i > 0) Thread.Sleep(1);
+                WritePayload(pending.Packets[i]);
+            }
+
+            if (pending.LogFirst)
+                Logger.WriteVerbose(
+                    $"[QMK] {_def.Product}: first paint frame — {pending.Packets.Length} SET_LEDS packet(s), {pending.ChunkSize} LEDs/packet, first LED RGB = ({pending.FirstR}, {pending.FirstG}, {pending.FirstB}).");
+
+            return true;
+        }
+
+        // Deferred write descriptor for the OpenRGB-QMK chunked path.
+        private struct OpenRgbPendingWrite
+        {
+            public byte[][] Packets;
+            public int ChunkSize;
+            public bool LogFirst;
+            public byte FirstR, FirstG, FirstB;
         }
 
         // ── VIA path (Tier 1: single representative colour) ──────────
@@ -163,7 +201,7 @@ private void SendViaFrame(ReadOnlySpan<(object key, Color color)> dataSet, doubl
             if (hash == _lastViaHsbHash) return;
             _lastViaHsbHash = hash;
 
-            byte[] outBuf = new byte[_outputReportByteLength];
+            byte[] outBuf = _outBuf;
 
             ViaProtocol.BuildSetRgbMatrixEffect(new Span<byte>(outBuf, 1, _payloadOutBytes), ViaProtocol.Effect_SolidColor);
             WritePayload(outBuf);
@@ -177,10 +215,15 @@ private void SendViaFrame(ReadOnlySpan<(object key, Color color)> dataSet, doubl
 
         // ── OpenRGB-QMK path (Tier 2: per-LED) ───────────────────────
 
-        private void SendOpenRgbQmkFrame(ReadOnlySpan<(object key, Color color)> dataSet, double brightnessScale)
+        // Collect all dirty-chunk packets under the caller's lock. The actual
+        // I/O + inter-chunk pacing happens in Update() after the lock is
+        // released, keeping ResetCache / BeginShutdown from blocking behind
+        // the sleep loop.
+        private OpenRgbPendingWrite CollectOpenRgbQmkChunks(
+            ReadOnlySpan<(object key, Color color)> dataSet, double brightnessScale)
         {
             int total = _def.LedCount;
-            if (total <= 0) return;
+            if (total <= 0) return default;
 
             if (_ledBytes == null) _ledBytes = new byte[total * 3];
 
@@ -215,31 +258,42 @@ private void SendOpenRgbQmkFrame(ReadOnlySpan<(object key, Color color)> dataSet
                 dirty[idx / chunkSize] = true;
             }
 
-            byte[] outBuf = new byte[_outputReportByteLength];
-            bool first = true;
-            int packetsSent = 0;
+            int dirtyCount = 0;
+            for (int c = 0; c < chunkCount; c++)
+                if (dirty[c]) dirtyCount++;
+
+            if (dirtyCount == 0) return default;
+
+            bool logFirst = !_firstFrameLogged;
+            if (logFirst) _firstFrameLogged = true;
+
+            // Build the pre-filled packet array under the lock. Each packet
+            // is a separate byte[] so the caller can send them with arbitrary
+            // pacing without holding the lock or re-entering it.
+            byte[][] packets = new byte[dirtyCount][];
+            int pIdx = 0;
             for (int c = 0; c < chunkCount; c++)
             {
                 if (!dirty[c]) continue;
-                if (!first) Thread.Sleep(1);
-                first = false;
-
                 int start = c * chunkSize;
                 int count = Math.Min(chunkSize, total - start);
+                byte[] pkt = new byte[_outputReportByteLength];
                 OpenRgbQmkProtocol.BuildDirectModeSetLeds(
-                    new Span<byte>(outBuf, 1, _payloadOutBytes),
+                    new Span<byte>(pkt, 1, _payloadOutBytes),
                     (byte)start, (byte)count,
                     new ReadOnlySpan<byte>(_ledBytes, start * 3, count * 3));
-                WritePayload(outBuf);
-                packetsSent++;
+                packets[pIdx++] = pkt;
             }
 
-            if (!_firstFrameLogged && packetsSent > 0)
+            return new OpenRgbPendingWrite
             {
-                _firstFrameLogged = true;
-                Logger.WriteVerbose(
-                    $"[QMK] {_def.Product}: first paint frame — {packetsSent} SET_LEDS packet(s), {chunkSize} LEDs/packet, first LED RGB = ({_ledBytes[0]}, {_ledBytes[1]}, {_ledBytes[2]}).");
-            }
+                Packets   = packets,
+                ChunkSize = chunkSize,
+                LogFirst  = logFirst,
+                FirstR    = _ledBytes[0],
+                FirstG    = _ledBytes[1],
+                FirstB    = _ledBytes[2],
+            };
         }
 
         private bool _firstFrameLogged;
diff --git a/Chromatics/Extensions/RGB.NET/Devices/Redragon/RedragonUpdateQueue.cs b/Chromatics/Extensions/RGB.NET/Devices/Redragon/RedragonUpdateQueue.cs
index c395011f..283c885f 100644
--- a/Chromatics/Extensions/RGB.NET/Devices/Redragon/RedragonUpdateQueue.cs
+++ b/Chromatics/Extensions/RGB.NET/Devices/Redragon/RedragonUpdateQueue.cs
@@ -35,6 +35,11 @@ public class RedragonUpdateQueue : UpdateQueue
         private volatile bool _perDeviceDisable;
         private bool _initialized;
 
+        // Pre-allocated staging buffer for HID feature reports. HidSharp's
+        // SetFeature requires a byte[]; we copy the stackalloc span into this
+        // buffer instead of allocating a new array on every write.
+        private readonly byte[] _featureReportBuffer = new byte[RedragonMouseProtocol.ReportLength];
+
         private PerDeviceBrightnessCorrection _perDeviceBrightness;
 
         // Last frame's RGB triplet. Used to skip the two-report HID write
@@ -166,16 +171,16 @@ private bool SendColorFrame(byte r, byte g, byte b)
             return SendFeatureReport(buf);
         }
 
-        // HidSharp's SetFeature wants a byte[]. Allocate once per write —
-        // single-LED firmware writes are infrequent enough that pooling
-        // would be overkill. Returns false on any I/O failure so the
-        // caller can short-circuit the rest of the frame.
+        // HidSharp's SetFeature wants a byte[]. Copy into _featureReportBuffer
+        // to avoid a heap allocation on every write.
+        // Returns false on any I/O failure so the caller can short-circuit
+        // the rest of the frame.
         private bool SendFeatureReport(ReadOnlySpan<byte> buf)
         {
-            byte[] arr = buf.ToArray();
+            buf.CopyTo(_featureReportBuffer);
             try
             {
-                _stream.SetFeature(arr);
+                _stream.SetFeature(_featureReportBuffer);
                 return true;
             }
             catch (System.IO.IOException ex)
diff --git a/Chromatics/Extensions/RGB.NET/Devices/Yeelight/Protocol/YeelightConnection.cs b/Chromatics/Extensions/RGB.NET/Devices/Yeelight/Protocol/YeelightConnection.cs
index b7082df8..aa7b7588 100644
--- a/Chromatics/Extensions/RGB.NET/Devices/Yeelight/Protocol/YeelightConnection.cs
+++ b/Chromatics/Extensions/RGB.NET/Devices/Yeelight/Protocol/YeelightConnection.cs
@@ -120,7 +120,7 @@ public async Task<bool> EnterMusicModeAsync(IPAddress localAddress, TimeSpan acc
                 using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
                 cts.CancelAfter(acceptTimeout);
 
-                Task<TcpClient> acceptTask = listener.AcceptTcpClientAsync();
+                Task<TcpClient> acceptTask = listener.AcceptTcpClientAsync(cts.Token).AsTask();
                 Task winner = await Task.WhenAny(acceptTask, Task.Delay(acceptTimeout, cts.Token)).ConfigureAwait(false);
 
                 if (winner == acceptTask && acceptTask.IsCompletedSuccessfully)
@@ -131,6 +131,12 @@ public async Task<bool> EnterMusicModeAsync(IPAddress localAddress, TimeSpan acc
                     return true;
                 }
 
+                // Accept lost the race — observe the task and discard any
+                // late-arriving connection so the socket isn't leaked.
+                _ = acceptTask.ContinueWith(
+                    t => { try { t.Result?.Dispose(); } catch { /* discard */ } },
+                    TaskContinuationOptions.OnlyOnRanToCompletion);
+
                 // Reverse connect didn't happen in time. Tell the bulb to
                 // turn Music Mode back off so we don't sit in a half-state.
                 try
diff --git a/Chromatics/Extensions/RGB.NET/Devices/Yeelight/YeelightUpdateQueue.cs b/Chromatics/Extensions/RGB.NET/Devices/Yeelight/YeelightUpdateQueue.cs
index b0283c9c..719d5e66 100644
--- a/Chromatics/Extensions/RGB.NET/Devices/Yeelight/YeelightUpdateQueue.cs
+++ b/Chromatics/Extensions/RGB.NET/Devices/Yeelight/YeelightUpdateQueue.cs
@@ -25,6 +25,11 @@ public class YeelightUpdateQueue : UpdateQueue
         // dropped while the user has the bulb disabled in the Mapping tab.
         private volatile bool _perDeviceDisable;
 
+        // Latches after the first failed send is surfaced so a bulb that
+        // stays unreachable doesn't repeat the device error every retry
+        // interval. Cleared by the next successful send.
+        private bool _sendFaultSurfaced;
+
         private PerDeviceBrightnessCorrection _perDeviceBrightness;
 
         // Throttle: Yeelight LAN protocol caps outbound commands at 60 per
@@ -157,7 +162,13 @@ protected override bool Update(ReadOnlySpan<(object key, Color color)> dataSet)
                             byte r = (byte)((_lastSentRgbMain >> 16) & 0xFF);
                             byte g = (byte)((_lastSentRgbMain >> 8) & 0xFF);
                             byte b = (byte)(_lastSentRgbMain & 0xFF);
-                            _ = _connection.SetRgbAsync(r, g, b);
+                            _connection.SetRgbAsync(r, g, b).ContinueWith(t =>
+                            {
+                                if (t.IsCompletedSuccessfully)
+                                    lock (_lock) _sendFaultSurfaced = false;
+                                else
+                                    SurfaceSendFault(t.Exception);
+                            }, TaskContinuationOptions.ExecuteSynchronously);
                         }
                     }
                     return true;
@@ -210,9 +221,28 @@ private static YeelightDevice.LightChannel ResolveChannel(object key)
             return YeelightDevice.LightChannel.MainLight;
         }
 
+        // Surfaces a failed send through the provider error path, at most
+        // once per outage so a bulb that stays unreachable doesn't repeat
+        // the error every retry interval.
+        private void SurfaceSendFault(AggregateException ex)
+        {
+            lock (_lock)
+            {
+                if (_sendFaultSurfaced) return;
+                _sendFaultSurfaced = true;
+            }
+            if (ex != null)
+                YeelightRGBDeviceProvider.Instance?.Throw(ex.InnerException ?? ex);
+        }
+
         // Send one channel (main or bg). Returns through `sent` whether any
         // network traffic actually fired; caller uses this for the keep-alive
         // and lastSendMs bookkeeping.
+        //
+        // Dedup state is only updated on successful I/O: the ContinueWith
+        // continuations write the new value on success, or reset the cached
+        // value on failure so the next frame retries. Both paths surface
+        // exceptions through the provider error route without blocking.
         private void SendChannel(Color color, double brightnessScale, bool isBackground,
                                  ref uint lastSentRgb, ref int lastSentBrightness, out bool sent)
         {
@@ -226,16 +256,62 @@ private void SendChannel(Color color, double brightnessScale, bool isBackground,
 
             if (changedRgb)
             {
-                if (isBackground) _ = _connection.SetBackgroundRgbAsync(r, g, b);
-                else              _ = _connection.SetRgbAsync(r, g, b);
-                lastSentRgb = packed;
+                Task rgbTask = isBackground
+                    ? _connection.SetBackgroundRgbAsync(r, g, b)
+                    : _connection.SetRgbAsync(r, g, b);
+                uint capturedPacked = packed;
+                rgbTask.ContinueWith(t =>
+                {
+                    if (t.IsCompletedSuccessfully)
+                    {
+                        lock (_lock)
+                        {
+                            if (isBackground) _lastSentRgbBg    = capturedPacked;
+                            else              _lastSentRgbMain   = capturedPacked;
+                            _sendFaultSurfaced = false;
+                        }
+                    }
+                    else
+                    {
+                        // Reset so the next frame retries rather than silently
+                        // skipping a colour the bulb never received.
+                        lock (_lock)
+                        {
+                            if (isBackground) _lastSentRgbBg    = uint.MaxValue;
+                            else              _lastSentRgbMain   = uint.MaxValue;
+                        }
+                        SurfaceSendFault(t.Exception);
+                    }
+                }, TaskContinuationOptions.ExecuteSynchronously);
                 sent = true;
             }
             if (changedBright)
             {
-                if (isBackground) _ = _connection.SetBackgroundBrightnessAsync(brightnessPct);
-                else              _ = _connection.SetBrightnessAsync(brightnessPct);
-                lastSentBrightness = brightnessPct;
+                Task brightTask = isBackground
+                    ? _connection.SetBackgroundBrightnessAsync(brightnessPct)
+                    : _connection.SetBrightnessAsync(brightnessPct);
+                int capturedBrightness = brightnessPct;
+                brightTask.ContinueWith(t =>
+                {
+                    if (t.IsCompletedSuccessfully)
+                    {
+                        lock (_lock)
+                        {
+                            if (isBackground) _lastSentBrightnessBg   = capturedBrightness;
+                            else              _lastSentBrightnessMain  = capturedBrightness;
+                            _sendFaultSurfaced = false;
+                        }
+                    }
+                    else
+                    {
+                        lock (_lock)
+                        {
+                            if (isBackground) _lastSentBrightnessBg   = -1;
+                            else              _lastSentBrightnessMain  = -1;
+                        }
+                        SurfaceSendFault(t.Exception);
+                    }
+                }, TaskContinuationOptions.ExecuteSynchronously);
                 sent = true;
             }
         }
diff --git a/Chromatics/Extensions/RGB.NET/Gradients/RectangularGradient.cs b/Chromatics/Extensions/RGB.NET/Gradients/RectangularGradient.cs
index bc456ef1..d67b6e62 100644
--- a/Chromatics/Extensions/RGB.NET/Gradients/RectangularGradient.cs
+++ b/Chromatics/Extensions/RGB.NET/Gradients/RectangularGradient.cs
@@ -28,7 +28,7 @@ public RectangularGradient(System.Drawing.Color topLeft, System.Drawing.Color to
         public override Color GetColor(float value) 
         {
             var x = value % 1;
-            var y = (int)value / 1;
+            var y = value % 1;
             System.Drawing.Color c1 = System.Drawing.Color.FromArgb(
                 (int) (topLeft.R + (topRight.R - topLeft.R) * x),
                 (int) (topLeft.G + (topRight.G - topLeft.G) * x),
diff --git a/Chromatics/Helpers/DictionaryConverter.cs b/Chromatics/Helpers/DictionaryConverter.cs
index f92b54f6..6d941c50 100644
--- a/Chromatics/Helpers/DictionaryConverter.cs
+++ b/Chromatics/Helpers/DictionaryConverter.cs
@@ -76,7 +76,7 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist
                                      : dictionaryTypes.Where(z => z.IsGenericTypeDefinition)
                                                       .FirstOrDefault();
 
-                if (dictionaryType == null) dictionaryTypes.First();
+                if (dictionaryType == null) dictionaryType = dictionaryTypes.First();
 
                 keyType = !dictionaryType.IsGenericType
                               ? typeof(object)
diff --git a/Chromatics/Helpers/FileOperationsHelper.cs b/Chromatics/Helpers/FileOperationsHelper.cs
index 447a363d..dd02e000 100644
--- a/Chromatics/Helpers/FileOperationsHelper.cs
+++ b/Chromatics/Helpers/FileOperationsHelper.cs
@@ -714,19 +714,7 @@ public static void SaveColorMappings(PaletteColorModel palette)
 
             try
             {
-                using (var sw = new StreamWriter(path, false))
-                {
-                    var serializer = new JsonSerializer
-                    {
-                        NullValueHandling = NullValueHandling.Ignore
-                    };
-
-                    serializer.Serialize(sw, palette);
-                    sw.WriteLine();
-                    sw.Close();
-                }
-
-
+                WriteJsonAtomic(path, palette);
             }
             catch (Exception ex)
             {
@@ -911,19 +899,7 @@ public static void SaveEffectSettings(EffectTypesModel palette)
 
             try
             {
-                using (var sw = new StreamWriter(path, false))
-                {
-                    var serializer = new JsonSerializer
-                    {
-                        NullValueHandling = NullValueHandling.Ignore
-                    };
-
-                    serializer.Serialize(sw, palette);
-                    sw.WriteLine();
-                    sw.Close();
-                }
-
-
+                WriteJsonAtomic(path, palette);
             }
             catch (Exception ex)
             {
@@ -973,19 +949,7 @@ public static void SaveSettings(SettingsModel settings)
 
             try
             {
-                using (var sw = new StreamWriter(path, false))
-                {
-                    var serializer = new JsonSerializer
-                    {
-                        NullValueHandling = NullValueHandling.Ignore
-                    };
-
-                    serializer.Serialize(sw, settings);
-                    sw.WriteLine();
-                    sw.Close();
-                }
-
-
+                WriteJsonAtomic(path, settings);
             }
             catch (Exception ex)
             {
diff --git a/Chromatics/Helpers/GameHelper.cs b/Chromatics/Helpers/GameHelper.cs
index d3d8a5ca..e9aa8cd2 100644
--- a/Chromatics/Helpers/GameHelper.cs
+++ b/Chromatics/Helpers/GameHelper.cs
@@ -90,9 +90,9 @@ public static Color GetJobClassColor(Actor.Job job, PaletteColorModel colorPalet
                         return ColorHelper.ColorToRGBColor(colorPalette.JobCPTHighlight.Color);
                 case Actor.Job.BSM:
                     if (!highlight)
-                        return ColorHelper.ColorToRGBColor(colorPalette.JobBLMBase.Color);
+                        return ColorHelper.ColorToRGBColor(colorPalette.JobBSMBase.Color);
                     else
-                        return ColorHelper.ColorToRGBColor(colorPalette.JobBLMHighlight.Color);
+                        return ColorHelper.ColorToRGBColor(colorPalette.JobBSMHighlight.Color);
                 case Actor.Job.ARM:
                     if (!highlight)
                         return ColorHelper.ColorToRGBColor(colorPalette.JobARMBase.Color);
diff --git a/Chromatics/Helpers/SystemMonitorHelper.cs b/Chromatics/Helpers/SystemMonitorHelper.cs
index 60755cb0..b01a7b33 100644
--- a/Chromatics/Helpers/SystemMonitorHelper.cs
+++ b/Chromatics/Helpers/SystemMonitorHelper.cs
@@ -20,11 +20,7 @@ public static float GetCurrentCpuUsage()
 
         public static int GetMaxCpuUsage()
         {
-            var counter = new PerformanceCounter("Memory", "Available Mbytes");
-            var memUsage = counter.NextValue();
-            var maxCpuUsage = (int)(100 - memUsage);
-            _maxCpuUsage = maxCpuUsage;
-
+            _maxCpuUsage = (int)_cpuCounter.NextValue();
             return _maxCpuUsage;
         }
     }
diff --git a/Chromatics/Layers/BaseLayers/AudioVisualizer.cs b/Chromatics/Layers/BaseLayers/AudioVisualizer.cs
index ea1f4b0c..f2ae6b51 100644
--- a/Chromatics/Layers/BaseLayers/AudioVisualizer.cs
+++ b/Chromatics/Layers/BaseLayers/AudioVisualizer.cs
@@ -93,7 +93,7 @@ public override void Process(IMappingLayer layer)
                 };
 
                 var lg = new ListLedGroup[] { layergroup };
-                _layergroups.Add(layer.layerID, lg);
+                _layergroups[layer.layerID] = lg;
                 layergroup.Detach();
             }
 
diff --git a/Chromatics/Layers/BaseLayers/BattleStance.cs b/Chromatics/Layers/BaseLayers/BattleStance.cs
index c13b0fb7..71fbe80c 100644
--- a/Chromatics/Layers/BaseLayers/BattleStance.cs
+++ b/Chromatics/Layers/BaseLayers/BattleStance.cs
@@ -15,6 +15,7 @@ public class BaseBattleStanceProcessor : LayerProcessor
         private static BaseBattleStanceProcessor _instance;
         private bool _disposed = false;
         private Dictionary<int, HashSet<Led>> _layergroupledcollections = new Dictionary<int, HashSet<Led>>();
+        private readonly Dictionary<int, SolidColorBrush> _brushCache = new Dictionary<int, SolidColorBrush>();
 
         // Private constructor to prevent direct instantiation
         private BaseBattleStanceProcessor() { }
@@ -71,7 +72,7 @@ public override void Process(IMappingLayer layer)
                 };
 
                 var lg = new ListLedGroup[] { layergroup };
-                _layergroups.Add(layer.layerID, lg);
+                _layergroups[layer.layerID] = lg;
             }
 
             if (!layer.Enabled)
@@ -111,7 +112,15 @@ public override void Process(IMappingLayer layer)
             }
 
             // Apply lighting
-            var brush = new SolidColorBrush(engaged_color);
+            if (!_brushCache.TryGetValue(layer.layerID, out var brush))
+            {
+                brush = new SolidColorBrush(engaged_color);
+                _brushCache[layer.layerID] = brush;
+            }
+            else
+            {
+                brush.Color = engaged_color;
+            }
             layergroup.Brush = brush;
             _init = true;
             layer.requestUpdate = false;
@@ -124,6 +133,7 @@ protected override void Dispose(bool disposing)
                 if (disposing)
                 {
                     // Dispose managed resources
+                    _brushCache.Clear();
                     _layergroupledcollections.Clear();
                     var _layergroups = RGBController.GetLiveLayerGroups();
                     foreach (var layergroup in _layergroups.Values.SelectMany(lg => lg))
diff --git a/Chromatics/Layers/BaseLayers/JobClasses.cs b/Chromatics/Layers/BaseLayers/JobClasses.cs
index 437196b2..3fc1c7bb 100644
--- a/Chromatics/Layers/BaseLayers/JobClasses.cs
+++ b/Chromatics/Layers/BaseLayers/JobClasses.cs
@@ -15,6 +15,7 @@ public class JobClassesProcessor : LayerProcessor
         private static JobClassesProcessor _instance;
         private bool _disposed = false;
         private Dictionary<int, HashSet<Led>> _layergroupledcollections = new Dictionary<int, HashSet<Led>>();
+        private readonly Dictionary<int, SolidColorBrush> _brushCache = new Dictionary<int, SolidColorBrush>();
 
         // Private constructor to prevent direct instantiation
         private JobClassesProcessor() { }
@@ -69,7 +70,7 @@ public override void Process(IMappingLayer layer)
                 };
 
                 var lg = new ListLedGroup[] { layergroup };
-                _layergroups.Add(layer.layerID, lg);
+                _layergroups[layer.layerID] = lg;
             }
 
             var highlight_col = Color.Transparent;
@@ -107,7 +108,15 @@ public override void Process(IMappingLayer layer)
             }
 
             // Apply lighting
-            var brush = new SolidColorBrush(highlight_col);
+            if (!_brushCache.TryGetValue(layer.layerID, out var brush))
+            {
+                brush = new SolidColorBrush(highlight_col);
+                _brushCache[layer.layerID] = brush;
+            }
+            else
+            {
+                brush.Color = highlight_col;
+            }
             layergroup.Brush = brush;
             _init = true;
             layer.requestUpdate = false;
@@ -120,6 +129,7 @@ protected override void Dispose(bool disposing)
                 if (disposing)
                 {
                     // Dispose managed resources
+                    _brushCache.Clear();
                     _layergroupledcollections.Clear();
                     var _layergroups = RGBController.GetLiveLayerGroups();
                     foreach (var layergroup in _layergroups.Values.SelectMany(lg => lg))
diff --git a/Chromatics/Layers/BaseLayers/ReactiveWeather.cs b/Chromatics/Layers/BaseLayers/ReactiveWeather.cs
index f25ecca0..e69dee96 100644
--- a/Chromatics/Layers/BaseLayers/ReactiveWeather.cs
+++ b/Chromatics/Layers/BaseLayers/ReactiveWeather.cs
@@ -137,7 +137,7 @@ public override void Process(IMappingLayer layer)
                 };
 
                 var lg = new ListLedGroup[] { layergroup };
-                _layergroups.Add(layer.layerID, lg);
+                _layergroups[layer.layerID] = lg;
 
                 layergroup.Brush = weather_brush;
                 layergroup.Detach();
diff --git a/Chromatics/Layers/BaseLayers/ScreenCapture.cs b/Chromatics/Layers/BaseLayers/ScreenCapture.cs
index 94a48340..d4dd3047 100644
--- a/Chromatics/Layers/BaseLayers/ScreenCapture.cs
+++ b/Chromatics/Layers/BaseLayers/ScreenCapture.cs
@@ -39,7 +39,7 @@ public override void Process(IMappingLayer layer)
             else
             {
                 layergroup = new ListLedGroup(surface, ledArray) { ZIndex = layer.zindex };
-                _layergroups.Add(layer.layerID, new[] { layergroup });
+                _layergroups[layer.layerID] = new[] { layergroup };
                 layergroup.Detach();
             }
 
diff --git a/Chromatics/Layers/BaseLayers/Static.cs b/Chromatics/Layers/BaseLayers/Static.cs
index 5344b34a..e5890c10 100644
--- a/Chromatics/Layers/BaseLayers/Static.cs
+++ b/Chromatics/Layers/BaseLayers/Static.cs
@@ -70,7 +70,7 @@ public override void Process(IMappingLayer layer)
                 };
 
                 var lg = new ListLedGroup[] { layergroup };
-                _layergroups.Add(layer.layerID, lg);
+                _layergroups[layer.layerID] = lg;
             }
 
             if (!layer.Enabled)
diff --git a/Chromatics/Layers/DynamicLayers/BattleStance.cs b/Chromatics/Layers/DynamicLayers/BattleStance.cs
index 57771b99..e0f34353 100644
--- a/Chromatics/Layers/DynamicLayers/BattleStance.cs
+++ b/Chromatics/Layers/DynamicLayers/BattleStance.cs
@@ -13,6 +13,7 @@ public class DynamicBattleStanceProcessor : LayerProcessor
     {
         private static DynamicBattleStanceProcessor _instance;
         private bool _disposed = false;
+        private readonly Dictionary<int, SolidColorBrush> _brushCache = new Dictionary<int, SolidColorBrush>();
 
         // Private constructor to prevent direct instantiation
         private DynamicBattleStanceProcessor() { }
@@ -65,7 +66,7 @@ public override void Process(IMappingLayer layer)
                 };
 
                 var lg = new ListLedGroup[] { updatedLayerGroup };
-                _layergroups.Add(layer.layerID, lg);
+                _layergroups[layer.layerID] = lg;
                 updatedLayerGroup.Detach();
             }
 
@@ -77,7 +78,16 @@ public override void Process(IMappingLayer layer)
 
             // Process data from FFXIV
             var _memoryHandler = GameController.GetGameData();
-            var brush = new SolidColorBrush(engaged_color);
+
+            if (!_brushCache.TryGetValue(layer.layerID, out var brush))
+            {
+                brush = new SolidColorBrush(engaged_color);
+                _brushCache[layer.layerID] = brush;
+            }
+            else
+            {
+                brush.Color = engaged_color;
+            }
 
             if (_memoryHandler?.Reader != null && _memoryHandler.Reader.CanGetActors())
             {
@@ -105,6 +115,7 @@ protected override void Dispose(bool disposing)
             {
                 if (disposing)
                 {
+                    _brushCache.Clear();
                     var _layergroups = RGBController.GetLiveLayerGroups();
                     if (_layergroups != null)
                     {
diff --git a/Chromatics/Layers/DynamicLayers/Castbar.cs b/Chromatics/Layers/DynamicLayers/Castbar.cs
index 4b0afdac..3ce3b634 100644
--- a/Chromatics/Layers/DynamicLayers/Castbar.cs
+++ b/Chromatics/Layers/DynamicLayers/Castbar.cs
@@ -181,7 +181,7 @@ public override void Process(IMappingLayer layer)
                 }
                 else
                 {
-                    _layergroups.Add(layer.layerID, lg);
+                    _layergroups[layer.layerID] = lg;
                 }
             }
 
diff --git a/Chromatics/Layers/DynamicLayers/EnmityTracker.cs b/Chromatics/Layers/DynamicLayers/EnmityTracker.cs
index 560e524f..1ad56635 100644
--- a/Chromatics/Layers/DynamicLayers/EnmityTracker.cs
+++ b/Chromatics/Layers/DynamicLayers/EnmityTracker.cs
@@ -254,7 +254,7 @@ public override void Process(IMappingLayer layer)
                 }
                 else
                 {
-                    _layergroups.Add(layer.layerID, lg);
+                    _layergroups[layer.layerID] = lg;
                 }
             }
 
diff --git a/Chromatics/Layers/DynamicLayers/ExperienceTracker.cs b/Chromatics/Layers/DynamicLayers/ExperienceTracker.cs
index 5ee22061..3009e0c1 100644
--- a/Chromatics/Layers/DynamicLayers/ExperienceTracker.cs
+++ b/Chromatics/Layers/DynamicLayers/ExperienceTracker.cs
@@ -211,7 +211,7 @@ public override void Process(IMappingLayer layer)
                 }
                 else
                 {
-                    _layergroups.Add(layer.layerID, lg);
+                    _layergroups[layer.layerID] = lg;
                 }
             }
 
diff --git a/Chromatics/Layers/DynamicLayers/HPTracker.cs b/Chromatics/Layers/DynamicLayers/HPTracker.cs
index 553d5e4a..f974e757 100644
--- a/Chromatics/Layers/DynamicLayers/HPTracker.cs
+++ b/Chromatics/Layers/DynamicLayers/HPTracker.cs
@@ -171,7 +171,7 @@ public override void Process(IMappingLayer layer)
                 }
                 else
                 {
-                    _layergroups.Add(layer.layerID, lg);
+                    _layergroups[layer.layerID] = lg;
                 }
             }
 
diff --git a/Chromatics/Layers/DynamicLayers/Highlight.cs b/Chromatics/Layers/DynamicLayers/Highlight.cs
index 5b40087e..4e127fdd 100644
--- a/Chromatics/Layers/DynamicLayers/Highlight.cs
+++ b/Chromatics/Layers/DynamicLayers/Highlight.cs
@@ -13,6 +13,7 @@ public class HighlightProcessor : LayerProcessor
     {
         private static HighlightProcessor _instance;
         private bool _disposed = false;
+        private readonly Dictionary<int, SolidColorBrush> _brushCache = new Dictionary<int, SolidColorBrush>();
 
         // Private constructor to prevent direct instantiation
         private HighlightProcessor() { }
@@ -59,7 +60,7 @@ public override void Process(IMappingLayer layer)
                 };
 
                 var lg = new ListLedGroup[] { updatedLayerGroup };
-                _layergroups.Add(layer.layerID, lg);
+                _layergroups[layer.layerID] = lg;
                 updatedLayerGroup.Detach();
             }
 
@@ -77,7 +78,15 @@ public override void Process(IMappingLayer layer)
                 }
             }
 
-            var brush = new SolidColorBrush(highlight_col);
+            if (!_brushCache.TryGetValue(layer.layerID, out var brush))
+            {
+                brush = new SolidColorBrush(highlight_col);
+                _brushCache[layer.layerID] = brush;
+            }
+            else
+            {
+                brush.Color = highlight_col;
+            }
             updatedLayerGroup.Brush = brush;
             updatedLayerGroup.Attach(surface);
             _init = true;
@@ -90,6 +99,7 @@ protected override void Dispose(bool disposing)
             {
                 if (disposing)
                 {
+                    _brushCache.Clear();
                     var _layergroups = RGBController.GetLiveLayerGroups();
                     if (_layergroups != null)
                     {
diff --git a/Chromatics/Layers/DynamicLayers/JobClassesHighlight.cs b/Chromatics/Layers/DynamicLayers/JobClassesHighlight.cs
index 14bd8424..869a5660 100644
--- a/Chromatics/Layers/DynamicLayers/JobClassesHighlight.cs
+++ b/Chromatics/Layers/DynamicLayers/JobClassesHighlight.cs
@@ -14,6 +14,7 @@ public class JobClassesHighlightProcessor : LayerProcessor
     {
         private static JobClassesHighlightProcessor _instance;
         private bool _disposed = false;
+        private readonly Dictionary<int, SolidColorBrush> _brushCache = new Dictionary<int, SolidColorBrush>();
 
         // Private constructor to prevent direct instantiation
         private JobClassesHighlightProcessor() { }
@@ -63,7 +64,7 @@ public override void Process(IMappingLayer layer)
                 };
 
                 var lg = new ListLedGroup[] { updatedLayerGroup };
-                _layergroups.Add(layer.layerID, lg);
+                _layergroups[layer.layerID] = lg;
                 updatedLayerGroup.Detach();
             }
 
@@ -94,7 +95,15 @@ public override void Process(IMappingLayer layer)
             }
 
             // Apply lighting
-            var brush = new SolidColorBrush(highlight_col);
+            if (!_brushCache.TryGetValue(layer.layerID, out var brush))
+            {
+                brush = new SolidColorBrush(highlight_col);
+                _brushCache[layer.layerID] = brush;
+            }
+            else
+            {
+                brush.Color = highlight_col;
+            }
             updatedLayerGroup.Brush = brush;
             updatedLayerGroup.Attach(surface);
             _init = true;
@@ -117,6 +126,7 @@ protected override void Dispose(bool disposing)
                 if (disposing)
                 {
                     // Dispose managed resources
+                    _brushCache.Clear();
                     var _layergroups = RGBController.GetLiveLayerGroups();
                     if (_layergroups != null && _layergroups.Values != null)
                     {
diff --git a/Chromatics/Layers/DynamicLayers/JobGaugeA.cs b/Chromatics/Layers/DynamicLayers/JobGaugeA.cs
index 3bb5ab0d..7db855f2 100644
--- a/Chromatics/Layers/DynamicLayers/JobGaugeA.cs
+++ b/Chromatics/Layers/DynamicLayers/JobGaugeA.cs
@@ -113,25 +113,29 @@ public override void Process(IMappingLayer layer)
                         // Interpolate implementation
                         var currentVal_Interpolate = LinearInterpolation.Interpolate<double>(jobGauge.currentValue, jobGauge.minValue, jobGauge.maxValue, 0, countKeys + jobGauge.offset);
 
-                        // Process Lighting
-                        var ledGroups = new List<ListLedGroup>();
-
-                        for (int i = 0; i < countKeys; i++)
+                        // Only rebuild groups when the interpolated position or a forced update changes
+                        if (currentVal_Interpolate != model._interpolateValue || layer.requestUpdate)
                         {
-                            var ledGroup = new ListLedGroup(surface, ledArray[i])
+                            var ledGroups = new List<ListLedGroup>();
+
+                            for (int i = 0; i < countKeys; i++)
                             {
-                                ZIndex = layer.zindex,
-                            };
+                                var ledGroup = new ListLedGroup(surface, ledArray[i])
+                                {
+                                    ZIndex = layer.zindex,
+                                };
 
-                            ledGroup.Detach();
+                                ledGroup.Detach();
 
-                            ledGroup.Brush = i <= currentVal_Interpolate ? model.highlight_brush : model.empty_brush;
+                                ledGroup.Brush = i <= currentVal_Interpolate ? model.highlight_brush : model.empty_brush;
 
-                            ledGroups.Add(ledGroup);
-                        }
+                                ledGroups.Add(ledGroup);
+                            }
 
-                        DetachAndClearGroups(model._localgroups);
-                        model._localgroups = ledGroups;
+                            DetachAndClearGroups(model._localgroups);
+                            model._localgroups = ledGroups;
+                            model._interpolateValue = currentVal_Interpolate;
+                        }
                     }
                     else if (layer.layerModes == Enums.LayerModes.Fade)
                     {
@@ -164,7 +168,7 @@ public override void Process(IMappingLayer layer)
                 }
                 else
                 {
-                    _layergroups.Add(layer.layerID, lg);
+                    _layergroups[layer.layerID] = lg;
                 }
             }
 
@@ -768,7 +772,7 @@ private class JobGaugeADynamicModel
             public SolidColorBrush empty_brush { get; set; }
             public SolidColorBrush highlight_brush { get; set; }
             public LayerModes _currentMode { get; set; }
-            public int _interpolateValue { get; set; } = -1;
+            public double _interpolateValue { get; set; } = -1;
             public Color _faderValue { get; set; }
             public Actor.Job _currentJob { get; set; }
             public bool init { get; set; }
diff --git a/Chromatics/Layers/DynamicLayers/JobGaugeB.cs b/Chromatics/Layers/DynamicLayers/JobGaugeB.cs
index 4c767fce..a3cc30f3 100644
--- a/Chromatics/Layers/DynamicLayers/JobGaugeB.cs
+++ b/Chromatics/Layers/DynamicLayers/JobGaugeB.cs
@@ -109,24 +109,28 @@ public override void Process(IMappingLayer layer)
                         // Interpolate implementation
                         var currentVal_Interpolate = LinearInterpolation.Interpolate<double>(jobGauge.currentValue, jobGauge.minValue, jobGauge.maxValue, 0, countKeys + jobGauge.offset);
 
-                        // Process Lighting
-                        var ledGroups = new List<ListLedGroup>();
-
-                        for (int i = 0; i < countKeys; i++)
+                        // Only rebuild groups when the interpolated position or a forced update changes
+                        if (currentVal_Interpolate != model._interpolateValue || layer.requestUpdate)
                         {
-                            var ledGroup = new ListLedGroup(surface, ledArray[i])
+                            var ledGroups = new List<ListLedGroup>();
+
+                            for (int i = 0; i < countKeys; i++)
                             {
-                                ZIndex = layer.zindex,
-                            };
+                                var ledGroup = new ListLedGroup(surface, ledArray[i])
+                                {
+                                    ZIndex = layer.zindex,
+                                };
 
-                            ledGroup.Detach();
+                                ledGroup.Detach();
 
-                            ledGroup.Brush = i <= currentVal_Interpolate ? model.highlight_brush : model.empty_brush;
-                            ledGroups.Add(ledGroup);
-                        }
+                                ledGroup.Brush = i <= currentVal_Interpolate ? model.highlight_brush : model.empty_brush;
+                                ledGroups.Add(ledGroup);
+                            }
 
-                        DetachAndClearGroups(model._localgroups);
-                        model._localgroups = ledGroups;
+                            DetachAndClearGroups(model._localgroups);
+                            model._localgroups = ledGroups;
+                            model._interpolateValue = currentVal_Interpolate;
+                        }
                     }
                     else if (layer.layerModes == Enums.LayerModes.Fade)
                     {
@@ -159,7 +163,7 @@ public override void Process(IMappingLayer layer)
                 }
                 else
                 {
-                    _layergroups.Add(layer.layerID, lg);
+                    _layergroups[layer.layerID] = lg;
                 }
             }
 
@@ -713,7 +717,7 @@ private class JobGaugeBDynamicModel
             public SolidColorBrush empty_brush { get; set; }
             public SolidColorBrush highlight_brush { get; set; }
             public LayerModes _currentMode { get; set; }
-            public int _interpolateValue { get; set; } = -1;
+            public double _interpolateValue { get; set; } = -1;
             public Color _faderValue { get; set; }
             public Actor.Job _currentJob { get; set; }
             public bool init { get; set; }
diff --git a/Chromatics/Layers/DynamicLayers/JobGaugeC.cs b/Chromatics/Layers/DynamicLayers/JobGaugeC.cs
index 1443386b..67570616 100644
--- a/Chromatics/Layers/DynamicLayers/JobGaugeC.cs
+++ b/Chromatics/Layers/DynamicLayers/JobGaugeC.cs
@@ -103,23 +103,28 @@ public override void Process(IMappingLayer layer)
                     {
                         var currentVal_Interpolate = LinearInterpolation.Interpolate<double>(jobGauge.currentValue, jobGauge.minValue, jobGauge.maxValue, 0, countKeys + jobGauge.offset);
 
-                        var ledGroups = new List<ListLedGroup>();
-
-                        for (int i = 0; i < countKeys; i++)
+                        // Only rebuild groups when the interpolated position or a forced update changes
+                        if (currentVal_Interpolate != model._interpolateValue || layer.requestUpdate)
                         {
-                            var ledGroup = new ListLedGroup(surface, ledArray[i])
+                            var ledGroups = new List<ListLedGroup>();
+
+                            for (int i = 0; i < countKeys; i++)
                             {
-                                ZIndex = layer.zindex,
-                            };
+                                var ledGroup = new ListLedGroup(surface, ledArray[i])
+                                {
+                                    ZIndex = layer.zindex,
+                                };
 
-                            ledGroup.Detach();
+                                ledGroup.Detach();
 
-                            ledGroup.Brush = i <= currentVal_Interpolate ? model.highlight_brush : model.empty_brush;
-                            ledGroups.Add(ledGroup);
-                        }
+                                ledGroup.Brush = i <= currentVal_Interpolate ? model.highlight_brush : model.empty_brush;
+                                ledGroups.Add(ledGroup);
+                            }
 
-                        DetachAndClearGroups(model._localgroups);
-                        model._localgroups = ledGroups;
+                            DetachAndClearGroups(model._localgroups);
+                            model._localgroups = ledGroups;
+                            model._interpolateValue = currentVal_Interpolate;
+                        }
                     }
                     else if (layer.layerModes == Enums.LayerModes.Fade)
                     {
@@ -150,7 +155,7 @@ public override void Process(IMappingLayer layer)
                 }
                 else
                 {
-                    _layergroups.Add(layer.layerID, lg);
+                    _layergroups[layer.layerID] = lg;
                 }
             }
 
@@ -437,7 +442,7 @@ private class JobGaugeCDynamicModel
             public SolidColorBrush empty_brush { get; set; }
             public SolidColorBrush highlight_brush { get; set; }
             public LayerModes _currentMode { get; set; }
-            public int _interpolateValue { get; set; } = -1;
+            public double _interpolateValue { get; set; } = -1;
             public Color _faderValue { get; set; }
             public Actor.Job _currentJob { get; set; }
             public bool init { get; set; }
diff --git a/Chromatics/Layers/DynamicLayers/Keybinds.cs b/Chromatics/Layers/DynamicLayers/Keybinds.cs
index cc1e207c..0847152b 100644
--- a/Chromatics/Layers/DynamicLayers/Keybinds.cs
+++ b/Chromatics/Layers/DynamicLayers/Keybinds.cs
@@ -22,6 +22,7 @@ public class KeybindsProcessor : LayerProcessor
     {
         private static KeybindsProcessor _instance;
         private Dictionary<Led, ListLedGroup> _localgroups = new Dictionary<Led, ListLedGroup>();
+        private readonly Dictionary<string, Color> _specialActionColors = new Dictionary<string, Color>(19);
         private SolidColorBrush keybind_cd_brush;
         private SolidColorBrush keybind_na_brush;
         private SolidColorBrush keybind_outranged_brush;
@@ -81,29 +82,28 @@ public override void Process(IMappingLayer layer)
 
                 UpdateBrushColors(layer, _colorPalette);
 
-                // Define special action colors
-                var specialActionColors = new Dictionary<string, Color>
-                {
-                    {"Map", ColorHelper.ColorToRGBColor(_colorPalette.KeybindMap.Color)},
-                    {"Aether Currents", ColorHelper.ColorToRGBColor(_colorPalette.KeybindAetherCurrents.Color)},
-                    {"Signs", ColorHelper.ColorToRGBColor(_colorPalette.KeybindSigns.Color)},
-                    {"Waymarks", ColorHelper.ColorToRGBColor(_colorPalette.KeybindWaymarks.Color)},
-                    {"Record Ready Check", ColorHelper.ColorToRGBColor(_colorPalette.KeybindRecordReadyCheck.Color)},
-                    {"Ready Check", ColorHelper.ColorToRGBColor(_colorPalette.KeybindReadyCheck.Color)},
-                    {"Countdown", ColorHelper.ColorToRGBColor(_colorPalette.KeybindCountdown.Color)},
-                    {"Emotes", ColorHelper.ColorToRGBColor(_colorPalette.KeybindEmotes.Color)},
-                    {"Linkshells", ColorHelper.ColorToRGBColor(_colorPalette.KeybindLinkshells.Color)},
-                    {"Cross-world Linkshell", ColorHelper.ColorToRGBColor(_colorPalette.KeybindCrossWorldLS.Color)},
-                    {"Contacts", ColorHelper.ColorToRGBColor(_colorPalette.KeybindContacts.Color)},
-                    {"Sprint", ColorHelper.ColorToRGBColor(_colorPalette.KeybindSprint.Color)},
-                    {"Teleport", ColorHelper.ColorToRGBColor(_colorPalette.KeybindTeleport.Color)},
-                    {"Return", ColorHelper.ColorToRGBColor(_colorPalette.KeybindReturn.Color)},
-                    {"Limit Break", ColorHelper.ColorToRGBColor(_colorPalette.KeybindLimitBreak.Color)},
-                    {"Duty Action", ColorHelper.ColorToRGBColor(_colorPalette.KeybindDutyAction.Color)},
-                    {"Repair", ColorHelper.ColorToRGBColor(_colorPalette.KeybindRepair.Color)},
-                    {"Dig", ColorHelper.ColorToRGBColor(_colorPalette.KeybindDig.Color)},
-                    {"Inventory", ColorHelper.ColorToRGBColor(_colorPalette.KeybindInventory.Color)}
-                };
+                // Repopulate the reusable special-action color map for this tick
+                _specialActionColors.Clear();
+                _specialActionColors["Map"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindMap.Color);
+                _specialActionColors["Aether Currents"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindAetherCurrents.Color);
+                _specialActionColors["Signs"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindSigns.Color);
+                _specialActionColors["Waymarks"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindWaymarks.Color);
+                _specialActionColors["Record Ready Check"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindRecordReadyCheck.Color);
+                _specialActionColors["Ready Check"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindReadyCheck.Color);
+                _specialActionColors["Countdown"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindCountdown.Color);
+                _specialActionColors["Emotes"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindEmotes.Color);
+                _specialActionColors["Linkshells"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindLinkshells.Color);
+                _specialActionColors["Cross-world Linkshell"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindCrossWorldLS.Color);
+                _specialActionColors["Contacts"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindContacts.Color);
+                _specialActionColors["Sprint"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindSprint.Color);
+                _specialActionColors["Teleport"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindTeleport.Color);
+                _specialActionColors["Return"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindReturn.Color);
+                _specialActionColors["Limit Break"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindLimitBreak.Color);
+                _specialActionColors["Duty Action"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindDutyAction.Color);
+                _specialActionColors["Repair"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindRepair.Color);
+                _specialActionColors["Dig"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindDig.Color);
+                _specialActionColors["Inventory"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindInventory.Color);
+                var specialActionColors = _specialActionColors;
 
                 InitializeLedGroups(ledArray, layer.zindex);
 
@@ -128,7 +128,7 @@ public override void Process(IMappingLayer layer)
                 }
                 else
                 {
-                    _layergroups.Add(layer.layerID, lg);
+                    _layergroups[layer.layerID] = lg;
                 }
             }
 
diff --git a/Chromatics/Layers/DynamicLayers/MPTracker.cs b/Chromatics/Layers/DynamicLayers/MPTracker.cs
index 53c48c0f..914cf2d8 100644
--- a/Chromatics/Layers/DynamicLayers/MPTracker.cs
+++ b/Chromatics/Layers/DynamicLayers/MPTracker.cs
@@ -171,7 +171,7 @@ public override void Process(IMappingLayer layer)
                 }
                 else
                 {
-                    _layergroups.Add(layer.layerID, lg);
+                    _layergroups[layer.layerID] = lg;
                 }
             }
 
diff --git a/Chromatics/Layers/DynamicLayers/ReactiveWeatherHighlight.cs b/Chromatics/Layers/DynamicLayers/ReactiveWeatherHighlight.cs
index f15b59b2..b9c2f51e 100644
--- a/Chromatics/Layers/DynamicLayers/ReactiveWeatherHighlight.cs
+++ b/Chromatics/Layers/DynamicLayers/ReactiveWeatherHighlight.cs
@@ -85,7 +85,7 @@ public override void Process(IMappingLayer layer)
                 };
 
                 var lg = new ListLedGroup[] { layergroup };
-                _layergroups.Add(layer.layerID, lg);
+                _layergroups[layer.layerID] = lg;
 
                 layergroup.Brush = weather_brush;
                 layergroup.Detach();
diff --git a/Chromatics/Layers/DynamicLayers/TargetCastbar.cs b/Chromatics/Layers/DynamicLayers/TargetCastbar.cs
index 106c6fff..9bd3673c 100644
--- a/Chromatics/Layers/DynamicLayers/TargetCastbar.cs
+++ b/Chromatics/Layers/DynamicLayers/TargetCastbar.cs
@@ -36,6 +36,8 @@ public static TargetCastbarProcessor Instance
 
         public override void Process(IMappingLayer layer)
         {
+            if (_disposed) return;
+
             TargetCastbarDynamicModel model;
 
             if (!layerProcessorModel.ContainsKey(layer.layerID))
@@ -78,10 +80,11 @@ public override void Process(IMappingLayer layer)
                 var full_col = ColorHelper.ColorToRGBColor(_colorPalette.TargetCastbar.Color);
                 var empty_col = ColorHelper.ColorToRGBColor(_colorPalette.TargetCastbarEmpty.Color); // Bleed layer
 
-                model.full_brush = model.full_brush ?? new SolidColorBrush(full_col);
-                model.empty_brush = layer.allowBleed
-                    ? new SolidColorBrush(Color.Transparent)
-                    : new SolidColorBrush(empty_col);
+                model.full_brush ??= new SolidColorBrush(full_col);
+                model.full_brush.Color = full_col;
+
+                model.empty_brush ??= new SolidColorBrush(layer.allowBleed ? Color.Transparent : empty_col);
+                model.empty_brush.Color = layer.allowBleed ? Color.Transparent : empty_col;
 
                 // Check if layer mode has changed
                 if (model._currentMode != layer.layerModes)
@@ -149,7 +152,7 @@ public override void Process(IMappingLayer layer)
                 }
                 else
                 {
-                    _layergroups.Add(layer.layerID, lg);
+                    _layergroups[layer.layerID] = lg;
                 }
             }
 
diff --git a/Chromatics/Layers/DynamicLayers/TargetHP.cs b/Chromatics/Layers/DynamicLayers/TargetHP.cs
index 5ab6d351..2528c8e1 100644
--- a/Chromatics/Layers/DynamicLayers/TargetHP.cs
+++ b/Chromatics/Layers/DynamicLayers/TargetHP.cs
@@ -183,7 +183,7 @@ public override void Process(IMappingLayer layer)
                 }
                 else
                 {
-                    _layergroups.Add(layer.layerID, lg);
+                    _layergroups[layer.layerID] = lg;
                 }
             }
 
diff --git a/Chromatics/Layers/EffectLayers/CutsceneAnimation.cs b/Chromatics/Layers/EffectLayers/CutsceneAnimation.cs
index 7f57f59d..6f58a80b 100644
--- a/Chromatics/Layers/EffectLayers/CutsceneAnimation.cs
+++ b/Chromatics/Layers/EffectLayers/CutsceneAnimation.cs
@@ -76,7 +76,7 @@ public override void Process(IMappingLayer layer)
                 };
 
                 var lg = new ListLedGroup[] { layergroup };
-                _layergroups.Add(layer.layerID, lg);
+                _layergroups[layer.layerID] = lg;
                 layergroup.Detach();
             }
 
@@ -154,7 +154,6 @@ public override void Process(IMappingLayer layer)
                 new GradientStop(1.00f, baseColor));
 
             var gradientMove = new MoveGradientDecorator(surface, 80, true);
-            var animation = new StarfieldDecorator(layergroup, (layergroup.Count() / 4), 10, 500, highlightColors, surface, false, baseColor);
 
             // Process data from FFXIV
             var _memoryHandler = GameController.GetGameData();
diff --git a/Chromatics/Layers/EffectLayers/DamageFlash.cs b/Chromatics/Layers/EffectLayers/DamageFlash.cs
index b8119306..e21771d7 100644
--- a/Chromatics/Layers/EffectLayers/DamageFlash.cs
+++ b/Chromatics/Layers/EffectLayers/DamageFlash.cs
@@ -95,30 +95,11 @@ public override void Process(IMappingLayer layer)
                 };
 
                 var lg = new ListLedGroup[] { layergroup };
-                _layergroups.Add(layer.layerID, lg);
+                _layergroups[layer.layerID] = lg;
                 layergroup.Detach();
             }
 
             var highlight_col = ColorHelper.ColorToRGBColor(_colorPalette.DamageFlashAnimation.Color);
-            // Opacity 1.0 so peak-envelope renders at full alpha. RGB.NET's
-            // Led.Color setter alpha-blends via Color+, so a 0.5 default would
-            // only produce a ~50% tint over a bright raid decorator write —
-            // visually swamped. ShotFlashDecorator modulates A through its
-            // ADSR envelope, ramping in/out smoothly.
-            var highlight_brush = new SolidColorBrush(highlight_col)
-            {
-                Opacity = 1.0f
-            };
-
-            var flash = new ShotFlashDecorator(surface)
-            {
-                IsEnabled = true,
-                Order = 100,
-                Attack = 0.15f,
-                Release = 0.15f,
-                Sustain = 0.1f,
-                Repetitions = 1
-            };
 
             // Process data from FFXIV
             var _memoryHandler = GameController.GetGameData();
@@ -144,6 +125,26 @@ public override void Process(IMappingLayer layer)
                         const float autoAttackThreshold = 0.015f;
                         if (damageRatio >= autoAttackThreshold)
                         {
+                            // Opacity 1.0 so peak-envelope renders at full alpha. RGB.NET's
+                            // Led.Color setter alpha-blends via Color+, so a 0.5 default would
+                            // only produce a ~50% tint over a bright raid decorator write —
+                            // visually swamped. ShotFlashDecorator modulates A through its
+                            // ADSR envelope, ramping in/out smoothly.
+                            var highlight_brush = new SolidColorBrush(highlight_col)
+                            {
+                                Opacity = 1.0f
+                            };
+
+                            var flash = new ShotFlashDecorator(surface)
+                            {
+                                IsEnabled = true,
+                                Order = 100,
+                                Attack = 0.15f,
+                                Release = 0.15f,
+                                Sustain = 0.1f,
+                                Repetitions = 1
+                            };
+
                             // Scale flash opacity depending on how much damage taken. More damage = brighter flash
                             if (effectSettings.effect_damageflash_scaledamage)
                             {
@@ -152,7 +153,7 @@ public override void Process(IMappingLayer layer)
 
                                 var minOpacity = effectSettings.effect_damageflash_min_flash;
                                 if (minOpacity > 1) minOpacity = 1;
-                                if (minOpacity < 1) minOpacity = 0;
+                                if (minOpacity < 0) minOpacity = 0;
 
                                 var opacity = Math.Max((float)minOpacity, (float)damageRatio);
                                 highlight_brush.Opacity = opacity;
diff --git a/Chromatics/Layers/EffectLayers/DutyFinderBell.cs b/Chromatics/Layers/EffectLayers/DutyFinderBell.cs
index 22218f1f..996c12c3 100644
--- a/Chromatics/Layers/EffectLayers/DutyFinderBell.cs
+++ b/Chromatics/Layers/EffectLayers/DutyFinderBell.cs
@@ -69,7 +69,7 @@ public override void Process(IMappingLayer layer)
                 };
 
                 var lg = new ListLedGroup[] { layergroup };
-                _layergroups.Add(layer.layerID, lg);
+                _layergroups[layer.layerID] = lg;
                 layergroup.Detach();
             }
 
diff --git a/Chromatics/Layers/LayerProcessor.cs b/Chromatics/Layers/LayerProcessor.cs
index 72b5c53c..c81f5971 100644
--- a/Chromatics/Layers/LayerProcessor.cs
+++ b/Chromatics/Layers/LayerProcessor.cs
@@ -31,7 +31,8 @@ internal Led[] GetLedArray(IMappingLayer layer)
                 return Array.Empty<Led>();
             }
 
-            return device.Where(led => layer.deviceLeds.Any(v => v.Value.Equals(led.Id))).ToArray();
+            var ledSet = new HashSet<LedId>(layer.deviceLeds.Values);
+            return device.Where(led => ledSet.Contains(led.Id)).ToArray();
         }
 
         internal Led[] GetLedSortedArray(IMappingLayer layer)
@@ -59,7 +60,8 @@ internal Led[] GetLedBaseArray(IMappingLayer layer, Layer baseLayer)
                 return Array.Empty<Led>();
             }
 
-            return device.Where(led => baseLayer.deviceLeds.Any(v => v.Value.Equals(led.Id))).ToArray();
+            var ledSet = new HashSet<LedId>(baseLayer.deviceLeds.Values);
+            return device.Where(led => ledSet.Contains(led.Id)).ToArray();
         }
 
         internal IRGBDevice GetDevice(IMappingLayer layer)
diff --git a/Chromatics/ViewModels/ConsoleViewModel.cs b/Chromatics/ViewModels/ConsoleViewModel.cs
index ae027fd6..2ada8dc0 100644
--- a/Chromatics/ViewModels/ConsoleViewModel.cs
+++ b/Chromatics/ViewModels/ConsoleViewModel.cs
@@ -50,8 +50,15 @@ private void Append(OnConsoleLoggedEventArgs e)
 
             if (Entries.Count > MaxEntries)
             {
-                for (int i = 0; i < TrimChunk && Entries.Count > 0; i++)
-                    Entries.RemoveAt(0);
+                // Snapshot the entries we keep, then rebuild via Clear +
+                // re-Add. Each RemoveAt(0) shifts the whole backing array,
+                // so trimming 500 entries cost ~500 full-list shifts; the
+                // rebuild appends instead, trading the Remove notifications
+                // for one Reset plus the re-Adds.
+                var retained = Entries.Skip(TrimChunk).ToList();
+                Entries.Clear();
+                foreach (var entry in retained)
+                    Entries.Add(entry);
             }
 
             EntryAdded?.Invoke(this, EventArgs.Empty);
diff --git a/Chromatics/ViewModels/HueAdoptionDialogViewModel.cs b/Chromatics/ViewModels/HueAdoptionDialogViewModel.cs
index 82774347..e64a569c 100644
--- a/Chromatics/ViewModels/HueAdoptionDialogViewModel.cs
+++ b/Chromatics/ViewModels/HueAdoptionDialogViewModel.cs
@@ -10,7 +10,7 @@
 
 namespace Chromatics.ViewModels
 {
-    public partial class HueAdoptionDialogViewModel : ViewModelBase
+    public partial class HueAdoptionDialogViewModel : ViewModelBase, IDisposable
     {
         public ObservableCollection<HueBulbItem> Bulbs { get; } = new();
 
@@ -42,6 +42,11 @@ private void UpdateStatus()
                 StatusText = string.Format(LocalizationService.Instance["{0} Hue light(s) on this bridge."], Bulbs.Count);
         }
 
+        public void Dispose()
+        {
+            LocalizationService.Instance.PropertyChanged -= OnLocaleChanged;
+        }
+
         // Query the bridge for its lights, merging with the user's already-
         // adopted set so previously-adopted bulbs come back pre-checked. New
         // lights since the last adoption are unchecked by default.
@@ -54,8 +59,8 @@ public async Task LoadBulbsAsync(string bridgeIp, string bridgeKey, IReadOnlyDic
             try
             {
                 var api = new LocalHueApi(bridgeIp, bridgeKey);
-                var lights = await api.Light.GetAllAsync().ConfigureAwait(false);
-                var devices = await api.Device.GetAllAsync().ConfigureAwait(false);
+                var lights = await api.Light.GetAllAsync();
+                var devices = await api.Device.GetAllAsync();
 
                 var modelByDevice = new Dictionary<Guid, string>();
                 foreach (var d in devices.Data)
diff --git a/Chromatics/ViewModels/LifxAdoptionDialogViewModel.cs b/Chromatics/ViewModels/LifxAdoptionDialogViewModel.cs
index db232149..99c444fa 100644
--- a/Chromatics/ViewModels/LifxAdoptionDialogViewModel.cs
+++ b/Chromatics/ViewModels/LifxAdoptionDialogViewModel.cs
@@ -10,7 +10,7 @@
 
 namespace Chromatics.ViewModels
 {
-    public partial class LifxAdoptionDialogViewModel : ViewModelBase
+    public partial class LifxAdoptionDialogViewModel : ViewModelBase, IDisposable
     {
         // Discovered + already-adopted bulbs are merged into a single list,
         // pre-checked for any MAC that's already adopted. The dialog reads
@@ -45,6 +45,11 @@ private void UpdateStatus()
                 StatusText = string.Format(LocalizationService.Instance["{0} LIFX device(s) found."], Bulbs.Count);
         }
 
+        public void Dispose()
+        {
+            LocalizationService.Instance.PropertyChanged -= OnLocaleChanged;
+        }
+
         // Run discovery, merging results with the supplied list of already-
         // adopted MACs. Pre-existing devices stay pre-checked; newly-found
         // devices are unchecked; devices that were adopted but aren't on the
diff --git a/Chromatics/ViewModels/Mapping/LayerItemViewModel.cs b/Chromatics/ViewModels/Mapping/LayerItemViewModel.cs
index 0c9611da..9fc82f5c 100644
--- a/Chromatics/ViewModels/Mapping/LayerItemViewModel.cs
+++ b/Chromatics/ViewModels/Mapping/LayerItemViewModel.cs
@@ -22,7 +22,7 @@ namespace Chromatics.ViewModels.Mapping
     // Wraps a single Layer in MappingLayers. Mutations commit straight back
     // through MappingLayers.UpdateLayer so the VM and persistence stay in
     // sync without a separate save step per property.
-    public sealed partial class LayerItemViewModel : ObservableObject
+    public sealed partial class LayerItemViewModel : ObservableObject, IDisposable
     {
         private readonly Layer _layer;
         private readonly Action<int> _onDelete;
@@ -251,6 +251,11 @@ public string HelpText
             { (Actor.Job.AST, DynamicLayerType.JobGaugeC), "Draw Type (Astral / Umbral). Indicates which side of the draw cycle is currently active." },
         };
 
+        public void Dispose()
+        {
+            LocService.Instance.PropertyChanged -= OnLocaleVersionChanged;
+        }
+
         public void RefreshHelpText() => OnPropertyChanged(nameof(HelpText));
 
         [RelayCommand] private void Edit() => _onEdit?.Invoke(_layer.layerID);
diff --git a/Chromatics/ViewModels/Mapping/MappingViewModel.cs b/Chromatics/ViewModels/Mapping/MappingViewModel.cs
index e7a635a2..babe9951 100644
--- a/Chromatics/ViewModels/Mapping/MappingViewModel.cs
+++ b/Chromatics/ViewModels/Mapping/MappingViewModel.cs
@@ -328,6 +328,8 @@ private static void CreateDefaultLayers(Guid deviceId, IRGBDevice device)
 
         public void RefreshLayers()
         {
+            foreach (var item in Layers)
+                item.Dispose();
             Layers.Clear();
             if (SelectedDevice == null) return;
 
@@ -378,6 +380,7 @@ public void RemoveLayer(int layerId)
 
             if (_selectedLayerIdForDisplay == layerId) _selectedLayerIdForDisplay = -1;
 
+            vm.Dispose();
             Layers.Remove(vm);
             MappingLayers.RemoveLayer(layerId);
             MappingLayers.SaveMappings();
diff --git a/Chromatics/ViewModels/SettingsViewModel.cs b/Chromatics/ViewModels/SettingsViewModel.cs
index 7b601ac3..5556cfd5 100644
--- a/Chromatics/ViewModels/SettingsViewModel.cs
+++ b/Chromatics/ViewModels/SettingsViewModel.cs
@@ -41,8 +41,6 @@ namespace Chromatics.ViewModels
 {
     public sealed class SettingsViewModel : ViewModelBase
     {
-        private readonly RegistryKey _runKey = Registry.CurrentUser.OpenSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Run", true);
-
         public ObservableCollection<DeviceToggleItem> DeviceToggles { get; } = new();
         public ObservableCollection<ThemeOption> ThemeOptions { get; } = new();
         public ObservableCollection<LanguageOption> LanguageOptions { get; } = new();
@@ -1010,10 +1008,11 @@ public bool TrayOnStartup
 
                     try
                     {
+                        using var runKey = Registry.CurrentUser.OpenSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Run", true);
                         if (value)
-                            _runKey?.SetValue("Chromatics4", Environment.ProcessPath ?? Assembly.GetExecutingAssembly().Location);
+                            runKey?.SetValue("Chromatics4", Environment.ProcessPath ?? Assembly.GetExecutingAssembly().Location);
                         else
-                            _runKey?.DeleteValue("Chromatics4", false);
+                            runKey?.DeleteValue("Chromatics4", false);
                     }
                     catch (Exception ex)
                     {
diff --git a/Chromatics/ViewModels/YeelightAdoptionDialogViewModel.cs b/Chromatics/ViewModels/YeelightAdoptionDialogViewModel.cs
index 9627181e..0b3a8adf 100644
--- a/Chromatics/ViewModels/YeelightAdoptionDialogViewModel.cs
+++ b/Chromatics/ViewModels/YeelightAdoptionDialogViewModel.cs
@@ -11,7 +11,7 @@
 
 namespace Chromatics.ViewModels
 {
-    public partial class YeelightAdoptionDialogViewModel : ViewModelBase
+    public partial class YeelightAdoptionDialogViewModel : ViewModelBase, IDisposable
     {
         // Discovered + already-adopted bulbs are merged into a single list,
         // pre-checked for any Id that's already adopted. The dialog reads
@@ -46,6 +46,11 @@ private void UpdateStatus()
                 StatusText = string.Format(LocalizationService.Instance["{0} Yeelight device(s) found."], Bulbs.Count);
         }
 
+        public void Dispose()
+        {
+            LocalizationService.Instance.PropertyChanged -= OnLocaleChanged;
+        }
+
         public async Task StartDiscoveryAsync(IReadOnlyDictionary<string, YeelightAdoptedDevice> alreadyAdopted, CancellationToken ct)
         {
             IsDiscovering = true;
diff --git a/Chromatics/Views/HueAdoptionDialog.axaml.cs b/Chromatics/Views/HueAdoptionDialog.axaml.cs
index 71ba4925..80d979b9 100644
--- a/Chromatics/Views/HueAdoptionDialog.axaml.cs
+++ b/Chromatics/Views/HueAdoptionDialog.axaml.cs
@@ -37,6 +37,7 @@ public HueAdoptionDialog(string bridgeIp, string bridgeKey, IReadOnlyDictionary<
             {
                 _cts?.Cancel();
                 _cts?.Dispose();
+                _vm.Dispose();
             };
         }
 
diff --git a/Chromatics/Views/LifxAdoptionDialog.axaml.cs b/Chromatics/Views/LifxAdoptionDialog.axaml.cs
index d56965f1..ea78344d 100644
--- a/Chromatics/Views/LifxAdoptionDialog.axaml.cs
+++ b/Chromatics/Views/LifxAdoptionDialog.axaml.cs
@@ -35,6 +35,7 @@ public LifxAdoptionDialog(IReadOnlyDictionary<string, LifxAdoptedDevice> already
             {
                 _cts?.Cancel();
                 _cts?.Dispose();
+                _vm.Dispose();
             };
         }
 
diff --git a/Chromatics/Views/YeelightAdoptionDialog.axaml.cs b/Chromatics/Views/YeelightAdoptionDialog.axaml.cs
index 0ecc6635..5b64bc58 100644
--- a/Chromatics/Views/YeelightAdoptionDialog.axaml.cs
+++ b/Chromatics/Views/YeelightAdoptionDialog.axaml.cs
@@ -34,6 +34,7 @@ public YeelightAdoptionDialog(IReadOnlyDictionary<string, YeelightAdoptedDevice>
             {
                 _cts?.Cancel();
                 _cts?.Dispose();
+                _vm.Dispose();
             };
         }
 

From 51ab641020d06278cc093a36fbea142ad6ff93a3 Mon Sep 17 00:00:00 2001
From: Danielle <logicallysynced@gmail.com>
Date: Wed, 10 Jun 2026 20:41:14 +1000
Subject: [PATCH 2/7] Add 4.3.1 changelog entry + bump nick-fields/retry v3 ->
 v4 in CI (PR #203)

The retry v4 major only moves the action to the node24 runtime; inputs
and retry behaviour are unchanged, and windows-latest runners ship
node24. Applied here so the release branch carries it; dependabot
closes #203 once this reaches master.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .github/workflows/ci.yml | 2 +-
 CHANGELOG.md             | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 905de6fc..f32064ec 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -59,7 +59,7 @@ jobs:
       # build to absorb transient feed flakiness without needing a
       # manual re-run.
       - name: Restore
-        uses: nick-fields/retry@v3
+        uses: nick-fields/retry@v4
         with:
           timeout_minutes: 10
           max_attempts: 3
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 252e5d74..23a78566 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 All notable changes to Chromatics are documented here.
 
+## 4.3.1
+
+- Various performance improvements and bug fixes
+
 ## 4.2.73
 
 - Added support for FFXIV 7.51

From f9d43b66ae2fe1fae27445415f95a742f9640d6a Mon Sep 17 00:00:00 2001
From: Danielle <logicallysynced@gmail.com>
Date: Thu, 11 Jun 2026 16:48:00 +1000
Subject: [PATCH 3/7] Bump Sharlayan 9.0.39 -> 9.1.1-prerelease.58 + DrawnCards
 array migration (v4.3.1 -> v4.3.2)

Sharlayan 9.1.1 is the full-codebase-audit release (74 verified
fixes plus an FFXIVClientStructs submodule refresh, FFXIVAPP/sharlayan
PR #116). Referenced via NuGet in both Chromatics.csproj and
Chromatics.Tests.csproj as before.

Compile fixes for the one breaking change Chromatics touches:
AstrologianResources.DrawnCards went from List<AstrologianCard> to
AstrologianCard[], so the two .Count reads became .Length -
JobGaugeB.cs (AST next-card gauge) and JobGaugeC.cs (AST draw-state
gauge). The [0] indexer and null checks compile unchanged.

Verified non-impacts per the migration notes:
- ActionContainers / InventoryContainers ConcurrentBag -> List:
  Keybinds.cs uses null check + foreach only, compiles unchanged.
  The ConcurrentBag in LifxDiscovery.cs is Chromatics' own and
  unrelated.
- DancerResources.Steps -> DanceStep[]: no Chromatics usage.
- MonkResources.BeastChakra now get-only: no Chromatics usage
  (JobMNKBeastChakra is a palette entry, not the Sharlayan type).
- MateriaType ushort-backed: no (byte) casts anywhere in Chromatics.

User-visible wins inherited from the Sharlayan fixes, called out in
the 4.3.2 CHANGELOG entry:
- RPR / SGE levels and EXP now populate, so the Experience Tracker
  layer works for Reaper and Sage (previously read 0).
- Hotbar action ids above 32767 read correctly, fixing Keybinds
  layer dispatch on high-id actions.
- Party member Coordinate.Y no longer mirrors Z.

Build clean, 133/133 xUnit tests pass.
---
 CHANGELOG.md                                 | 7 +++++++
 Chromatics.Tests/Chromatics.Tests.csproj     | 2 +-
 Chromatics/Chromatics.csproj                 | 4 ++--
 Chromatics/Layers/DynamicLayers/JobGaugeB.cs | 2 +-
 Chromatics/Layers/DynamicLayers/JobGaugeC.cs | 2 +-
 5 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 23a78566..96ea1d6f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,13 @@
 
 All notable changes to Chromatics are documented here.
 
+## 4.3.2
+
+- Updated the FFXIV memory reader (Sharlayan) with a large batch of stability and accuracy fixes.
+- The Experience Tracker layer now works for Reaper and Sage. Their level and EXP data previously read as zero.
+- Fixed the Keybinds layer misreading hotbar actions with high action ids.
+- Fixed party member position data reporting the wrong Y coordinate.
+
 ## 4.3.1
 
 - Various performance improvements and bug fixes
diff --git a/Chromatics.Tests/Chromatics.Tests.csproj b/Chromatics.Tests/Chromatics.Tests.csproj
index a957dfc5..565fe1ce 100644
--- a/Chromatics.Tests/Chromatics.Tests.csproj
+++ b/Chromatics.Tests/Chromatics.Tests.csproj
@@ -38,7 +38,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Sharlayan" Version="9.0.39" />
+    <PackageReference Include="Sharlayan" Version="9.1.1-prerelease.58" />
   </ItemGroup>
 
 </Project>
diff --git a/Chromatics/Chromatics.csproj b/Chromatics/Chromatics.csproj
index df556b9c..0f8b8c1e 100644
--- a/Chromatics/Chromatics.csproj
+++ b/Chromatics/Chromatics.csproj
@@ -10,7 +10,7 @@
     <TargetFramework>net10.0-windows10.0.19041.0</TargetFramework>
     <SupportedOSPlatformVersion>10.0.17763.0</SupportedOSPlatformVersion>
     <StartupObject>Chromatics.Program</StartupObject>
-    <Version>4.3.1.0</Version>
+    <Version>4.3.2.0</Version>
     <Authors>Danielle Thompson</Authors>
     <!-- ApplicationManifest is conditional: local Debug + Release builds embed
          app.manifest (no fusion-identity <msix> element) so VS debug runs and
@@ -133,7 +133,7 @@
     <PackageReference Include="RGB.NET.Devices.Wooting" Version="3.2.0" />
     <PackageReference Include="RGB.NET.HID" Version="3.2.0" />
     <PackageReference Include="RGB.NET.Presets" Version="3.2.0" />
-    <PackageReference Include="Sharlayan" Version="9.0.39" />
+    <PackageReference Include="Sharlayan" Version="9.1.1-prerelease.58" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/Chromatics/Layers/DynamicLayers/JobGaugeB.cs b/Chromatics/Layers/DynamicLayers/JobGaugeB.cs
index a3cc30f3..0be7be4b 100644
--- a/Chromatics/Layers/DynamicLayers/JobGaugeB.cs
+++ b/Chromatics/Layers/DynamicLayers/JobGaugeB.cs
@@ -462,7 +462,7 @@ private static JobGaugeResponse ReturnJobGauge(CurrentPlayerResult currentPlayer
                     // immediate next play while Gauge A keeps the currently-active arcana.
                     {
                         var ast = jobResources.JobResourcesContainer.Astrologian;
-                        var nextCard = ast.DrawnCards != null && ast.DrawnCards.Count > 0
+                        var nextCard = ast.DrawnCards != null && ast.DrawnCards.Length > 0
                             ? ast.DrawnCards[0]
                             : AstrologianCard.None;
 
diff --git a/Chromatics/Layers/DynamicLayers/JobGaugeC.cs b/Chromatics/Layers/DynamicLayers/JobGaugeC.cs
index 67570616..ffe27095 100644
--- a/Chromatics/Layers/DynamicLayers/JobGaugeC.cs
+++ b/Chromatics/Layers/DynamicLayers/JobGaugeC.cs
@@ -274,7 +274,7 @@ private static JobGaugeResponse ReturnJobGauge(CurrentPlayerResult currentPlayer
                     // Draw cycle. Full-fill on the active colour; negative when no card is held.
                     {
                         var hasCard = container.Astrologian.CurrentArcana != AstrologianCard.None
-                                      || container.Astrologian.DrawnCards.Count > 0;
+                                      || container.Astrologian.DrawnCards.Length > 0;
 
                         jobGauge.emptyColor = ColorHelper.ColorToRGBColor(_colorPalette.JobASTNegative.Color);
                         jobGauge.minValue = 0;

From 075a97669c8a53f39b2087b8ad341b98779974a9 Mon Sep 17 00:00:00 2001
From: Danielle <logicallysynced@gmail.com>
Date: Thu, 11 Jun 2026 16:48:53 +1000
Subject: [PATCH 4/7] Update changelog

---
 CHANGELOG.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 96ea1d6f..4c963a86 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,8 +4,7 @@ All notable changes to Chromatics are documented here.
 
 ## 4.3.2
 
-- Updated the FFXIV memory reader (Sharlayan) with a large batch of stability and accuracy fixes.
-- The Experience Tracker layer now works for Reaper and Sage. Their level and EXP data previously read as zero.
+- Fixed a bug which caused the Experience Tracker layer to not work with Reaper and Sage.
 - Fixed the Keybinds layer misreading hotbar actions with high action ids.
 - Fixed party member position data reporting the wrong Y coordinate.
 

From 2cb830a0d983f19213968c4d6d531b8a9ab306ad Mon Sep 17 00:00:00 2001
From: Danielle <logicallysynced@gmail.com>
Date: Thu, 11 Jun 2026 17:02:58 +1000
Subject: [PATCH 5/7] Add Focus Target HP + Focus Target Castbar dynamic
 layers, layer-file forward-compat guard, schemaVersion 6 (v4.3.2 -> v4.3.3)

Two new dynamic layer types mirroring TargetHP / TargetCastbar but
reading TargetInfo.FocusTarget instead of CurrentTarget:

- DynamicLayerType.FocusTargetHP = 16, FocusTargetCastbar = 17.
  Enum values equal their _dynamicLayerOrder positions per the
  position == enum-value invariant; both order arrays
  (LayerItemViewModel + CopyLayersDialogViewModel) got the matching
  appends and LayerProcessorFactory.CreateDynamicProcessor got the
  two cases. The stale DynamicLayerProcessorFactory map in
  LayerProcessor.cs has no callers (it already lacks JobGaugeC) and
  was left untouched.
- FocusTargetHPProcessor clones the TargetHP structure: per-layerID
  model, claimed / friendly / idle brush selection from InCombat +
  IsAggressive, empty bar painted when nothing is focus targeted,
  Interpolate bar fill + Fade blend with the requestUpdate rebuild
  guard.
- FocusTargetCastbarProcessor clones TargetCastbar but fixes the
  no-target path while at it: instead of the early return that
  freezes the last cast frame, it tracks the focus-target id, casts
  at 0.0 with no focus target, and repaints the empty bar on target
  change. Same requestUpdate guard on both modes.
- Six new palette entries under Target/Enemy: Focus Target Cast Bar
  Charge Build / Empty and Focus Target HP Friendly / Claimed /
  Empty / Idle. Palette files saved by older versions load fine -
  missing fields fall back to the field initialisers.
- LayerDisplay names + descriptions localised: 4 new en.json keys,
  all six locale files regenerated via translate.py.

Forward-compat guard (per request): layers.chromatics4 written by a
newer Chromatics can carry dynamic positions this build's enum
doesn't define. MappingLayers.SanitizeLayerTypeIndexes validates
layerTypeindex against the matching enum for the layer's
rootLayerType and resets unknown positions to 0 (None) with a
console line naming the layer. Runs in LoadMappings (startup path)
and ImportMappings (Mapping-tab import + migration path). Without
it, an unknown position flows into GameController's
(DynamicLayerType) cast and the processor factory throws on every
frame. schemaVersion bumped 5 -> 6 in MappingFileV3,
SaveLayerMappings, and ExportLayerMappings to mark files that can
carry the new positions.

Build clean, 133/133 xUnit tests pass.
---
 CHANGELOG.md                                  |  10 +-
 Chromatics/Chromatics.csproj                  |   2 +-
 Chromatics/Enums/LayerTypes.cs                |   6 +-
 Chromatics/Helpers/FileOperationsHelper.cs    |   4 +-
 .../DynamicLayers/FocusTargetCastbar.cs       | 221 ++++++++++++++++
 .../Layers/DynamicLayers/FocusTargetHP.cs     | 239 ++++++++++++++++++
 Chromatics/Layers/LayerProcessorFactory.cs    |   2 +
 Chromatics/Layers/MappingLayers.cs            |  42 ++-
 Chromatics/Models/PaletteColorModel.cs        |   6 +
 .../ViewModels/CopyLayersDialogViewModel.cs   |   2 +
 .../ViewModels/Mapping/LayerItemViewModel.cs  |   2 +
 Chromatics/locale/de.json                     |   6 +-
 Chromatics/locale/en.json                     |   6 +-
 Chromatics/locale/es.json                     |   6 +-
 Chromatics/locale/fr.json                     |   6 +-
 Chromatics/locale/ja.json                     |   6 +-
 Chromatics/locale/ko.json                     |   6 +-
 Chromatics/locale/zh_CN.json                  |   6 +-
 18 files changed, 563 insertions(+), 15 deletions(-)
 create mode 100644 Chromatics/Layers/DynamicLayers/FocusTargetCastbar.cs
 create mode 100644 Chromatics/Layers/DynamicLayers/FocusTargetHP.cs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4c963a86..ad22aefc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,14 +2,18 @@
 
 All notable changes to Chromatics are documented here.
 
+## 4.3.3
+
+- **New:** Focus Target HP layer. Works like the Target HP layer but follows whatever you have focus targeted, with its own palette colours for claimed, friendly, idle, and empty states.
+- **New:** Focus Target Castbar layer. Shows your focus target's cast progress across selected keys, with its own palette colours.
+- Loading or importing a layer file that contains layer types from a newer Chromatics version no longer breaks. Unrecognised layer types reset to None and the rest of the file loads normally.
+
 ## 4.3.2
 
 - Fixed a bug which caused the Experience Tracker layer to not work with Reaper and Sage.
 - Fixed the Keybinds layer misreading hotbar actions with high action ids.
 - Fixed party member position data reporting the wrong Y coordinate.
-
-## 4.3.1
-
+- Updated Sharlayan to latest version
 - Various performance improvements and bug fixes
 
 ## 4.2.73
diff --git a/Chromatics/Chromatics.csproj b/Chromatics/Chromatics.csproj
index 0f8b8c1e..b191699d 100644
--- a/Chromatics/Chromatics.csproj
+++ b/Chromatics/Chromatics.csproj
@@ -10,7 +10,7 @@
     <TargetFramework>net10.0-windows10.0.19041.0</TargetFramework>
     <SupportedOSPlatformVersion>10.0.17763.0</SupportedOSPlatformVersion>
     <StartupObject>Chromatics.Program</StartupObject>
-    <Version>4.3.2.0</Version>
+    <Version>4.3.3.0</Version>
     <Authors>Danielle Thompson</Authors>
     <!-- ApplicationManifest is conditional: local Debug + Release builds embed
          app.manifest (no fusion-identity <msix> element) so VS debug runs and
diff --git a/Chromatics/Enums/LayerTypes.cs b/Chromatics/Enums/LayerTypes.cs
index ac23586b..7419ea27 100644
--- a/Chromatics/Enums/LayerTypes.cs
+++ b/Chromatics/Enums/LayerTypes.cs
@@ -69,7 +69,11 @@ public enum DynamicLayerType
         [LayerDisplay(Name = "Job Classes Highlight", Description = "Displays different colours across selected keys depending on the character's current class.\nUses highlight layer colours.", LayerTypeCompatibility = new LayerModes[]{ LayerModes.None })]
         JobClassesHighlight = 14,
         [LayerDisplay(Name = "Reactive Weather Highlight", Description = "Displays different colours across selected keys depending on current weather.\nUses highlight layer colours.", LayerTypeCompatibility = new LayerModes[]{ LayerModes.None })]
-        ReactiveWeatherHighlight = 15
+        ReactiveWeatherHighlight = 15,
+        [LayerDisplay(Name = "Focus Target HP", Description = "Shows your focus target's HP across selected keys.\n[Supported Modes: Interpolate, Fade]", LayerTypeCompatibility = new LayerModes[]{ LayerModes.Interpolate, LayerModes.Fade })]
+        FocusTargetHP = 16,
+        [LayerDisplay(Name = "Focus Target Castbar", Description = "Shows your focus target's cast progress across selected keys.\n[Supported Modes: Interpolate, Fade]", LayerTypeCompatibility = new LayerModes[]{ LayerModes.Interpolate, LayerModes.Fade })]
+        FocusTargetCastbar = 17
     };
     public enum EffectLayerType
     {
diff --git a/Chromatics/Helpers/FileOperationsHelper.cs b/Chromatics/Helpers/FileOperationsHelper.cs
index dd02e000..f32262fb 100644
--- a/Chromatics/Helpers/FileOperationsHelper.cs
+++ b/Chromatics/Helpers/FileOperationsHelper.cs
@@ -285,7 +285,7 @@ public static void SaveLayerMappings(ConcurrentDictionary<int, Layer> mappings,
 
                 var wrapper = new MappingFileV3
                 {
-                    schemaVersion = 5,
+                    schemaVersion = 6,
                     layers = layersSnapshot,
                     deviceLayouts = layoutsSnapshot,
                     deviceBrightness = brightnessSnapshot,
@@ -644,7 +644,7 @@ public static void ExportLayerMappingsToPath(ConcurrentDictionary<int, Layer> la
 
                 var wrapper = new MappingFileV3
                 {
-                    schemaVersion = 5,
+                    schemaVersion = 6,
                     layers = layersCopy,
                     deviceLayouts = deviceLayouts != null
                         ? new Dictionary<Guid, Dictionary<RGB.NET.Core.LedId, DeviceKeyPosition>>(deviceLayouts)
diff --git a/Chromatics/Layers/DynamicLayers/FocusTargetCastbar.cs b/Chromatics/Layers/DynamicLayers/FocusTargetCastbar.cs
new file mode 100644
index 00000000..696cc7e3
--- /dev/null
+++ b/Chromatics/Layers/DynamicLayers/FocusTargetCastbar.cs
@@ -0,0 +1,221 @@
+using Chromatics.Core;
+using Chromatics.Enums;
+using Chromatics.Extensions.RGB.NET;
+using Chromatics.Helpers;
+using Chromatics.Interfaces;
+using RGB.NET.Core;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using static Chromatics.Helpers.MathHelper;
+
+namespace Chromatics.Layers
+{
+    public class FocusTargetCastbarProcessor : LayerProcessor
+    {
+        private static FocusTargetCastbarProcessor _instance;
+        private static Dictionary<int, FocusTargetCastbarDynamicModel> layerProcessorModel = new Dictionary<int, FocusTargetCastbarDynamicModel>();
+        private bool _disposed = false;
+
+        private FocusTargetCastbarProcessor() { }
+
+        public static FocusTargetCastbarProcessor Instance
+        {
+            get
+            {
+                if (_instance == null)
+                {
+                    _instance = new FocusTargetCastbarProcessor();
+                }
+                return _instance;
+            }
+        }
+
+        public override void Process(IMappingLayer layer)
+        {
+            if (_disposed) return;
+
+            FocusTargetCastbarDynamicModel model;
+
+            if (!layerProcessorModel.ContainsKey(layer.layerID))
+            {
+                model = new FocusTargetCastbarDynamicModel();
+                layerProcessorModel.Add(layer.layerID, model);
+            }
+            else
+            {
+                model = layerProcessorModel[layer.layerID];
+            }
+
+            // Focus Target Castbar Layer Implementation
+            var _colorPalette = RGBController.GetActivePalette();
+            var _layergroups = RGBController.GetLiveLayerGroups();
+            var ledArray = GetLedSortedArray(layer);
+            var countKeys = ledArray.Count();
+
+            if (model.init && (layer.requestUpdate || !layer.Enabled))
+            {
+                DetachAndClearGroups(model._localgroups);
+
+                if (!layer.Enabled)
+                    return;
+            }
+
+            // Process data from FFXIV
+            var _memoryHandler = GameController.GetGameData();
+
+            if (_memoryHandler?.Reader != null && _memoryHandler.Reader.CanGetTargetInfo())
+            {
+                var getTargetInfo = _memoryHandler.Reader.GetTargetInfo().TargetInfo;
+                if (getTargetInfo == null) return;
+
+                var focusTarget = getTargetInfo.FocusTarget;
+                uint targetId = focusTarget?.ID ?? 0;
+
+                var full_col = ColorHelper.ColorToRGBColor(_colorPalette.FocusTargetCastbar.Color);
+                var empty_col = ColorHelper.ColorToRGBColor(_colorPalette.FocusTargetCastbarEmpty.Color); // Bleed layer
+
+                model.full_brush ??= new SolidColorBrush(full_col);
+                model.full_brush.Color = full_col;
+
+                model.empty_brush ??= new SolidColorBrush(layer.allowBleed ? Color.Transparent : empty_col);
+                model.empty_brush.Color = layer.allowBleed ? Color.Transparent : empty_col;
+
+                if (targetId != model._targetId)
+                {
+                    DetachAndClearGroups(model._localgroups);
+                    model._targetReset = true;
+                    model._targetId = targetId;
+                }
+
+                // Check if layer mode has changed
+                if (model._currentMode != layer.layerModes)
+                {
+                    DetachAndClearGroups(model._localgroups);
+                    model._currentMode = layer.layerModes;
+                }
+
+                // No focus target set: paint the empty bar instead of
+                // returning, so the selected keys hold the negative colour
+                // (or bleed) rather than freezing on the last cast state.
+                var currentVal = targetId != 0 ? focusTarget.CastingPercentage : 0.0;
+                var minVal = 0.0;
+                var maxVal = 1.0;
+
+                if (layer.layerModes == Enums.LayerModes.Interpolate)
+                {
+                    // Interpolate implementation
+                    var currentVal_Interpolate = Convert.ToInt32(LinearInterpolation.Interpolate(currentVal, minVal, maxVal, 0, countKeys));
+                    currentVal_Interpolate = Math.Max(0, Math.Min(countKeys, currentVal_Interpolate));
+
+                    // Process Lighting
+                    if (currentVal_Interpolate != model._interpolateValue || model._targetReset || layer.requestUpdate)
+                    {
+                        var ledGroups = new List<ListLedGroup>();
+
+                        for (int i = 0; i < countKeys; i++)
+                        {
+                            var ledGroup = new ListLedGroup(surface, ledArray[i])
+                            {
+                                ZIndex = layer.zindex,
+                            };
+
+                            ledGroup.Detach();
+
+                            ledGroup.Brush = i < currentVal_Interpolate ? model.full_brush : model.empty_brush;
+                            ledGroups.Add(ledGroup);
+                        }
+
+                        DetachAndClearGroups(model._localgroups);
+                        model._localgroups = ledGroups;
+                        model._interpolateValue = currentVal_Interpolate;
+                    }
+                }
+                else if (layer.layerModes == Enums.LayerModes.Fade)
+                {
+                    // Fade implementation
+                    var currentVal_Fader = ColorHelper.GetInterpolatedColor(currentVal, minVal, maxVal, model.empty_brush.Color, model.full_brush.Color);
+
+                    if (currentVal_Fader != model._faderValue || model._targetReset || layer.requestUpdate)
+                    {
+                        var ledGroup = new ListLedGroup(surface, ledArray)
+                        {
+                            ZIndex = layer.zindex,
+                            Brush = new SolidColorBrush(currentVal_Fader)
+                        };
+
+                        ledGroup.Detach();
+
+                        DetachAndClearGroups(model._localgroups);
+                        model._localgroups.Add(ledGroup);
+                        model._faderValue = currentVal_Fader;
+                    }
+                }
+
+                // Send layers to _layergroups Dictionary to be tracked outside this method
+                var lg = model._localgroups.ToArray();
+
+                if (_layergroups.ContainsKey(layer.layerID))
+                {
+                    _layergroups[layer.layerID] = lg;
+                }
+                else
+                {
+                    _layergroups[layer.layerID] = lg;
+                }
+            }
+
+            // Apply lighting
+            foreach (var layergroup in model._localgroups)
+            {
+                layergroup.Attach(surface);
+            }
+
+            model.init = true;
+            model._targetReset = false;
+            layer.requestUpdate = false;
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!_disposed)
+            {
+                if (disposing)
+                {
+                    foreach (var model in layerProcessorModel.Values)
+                    {
+                        DetachAndClearGroups(model._localgroups);
+                    }
+                    layerProcessorModel.Clear();
+                }
+
+                _disposed = true;
+            }
+
+            base.Dispose(disposing);
+            _instance = null;
+        }
+
+        private void DetachAndClearGroups(List<ListLedGroup> groups)
+        {
+            foreach (var group in groups)
+            {
+                group?.Detach();
+            }
+            groups.Clear();
+        }
+
+        private class FocusTargetCastbarDynamicModel
+        {
+            public List<ListLedGroup> _localgroups { get; set; } = new List<ListLedGroup>();
+            public SolidColorBrush empty_brush { get; set; }
+            public SolidColorBrush full_brush { get; set; }
+            public LayerModes _currentMode { get; set; }
+            public int _interpolateValue { get; set; }
+            public Color _faderValue { get; set; }
+            public uint _targetId { get; set; }
+            public bool _targetReset { get; set; }
+            public bool init { get; set; }
+        }
+    }
+}
diff --git a/Chromatics/Layers/DynamicLayers/FocusTargetHP.cs b/Chromatics/Layers/DynamicLayers/FocusTargetHP.cs
new file mode 100644
index 00000000..eaf87d1a
--- /dev/null
+++ b/Chromatics/Layers/DynamicLayers/FocusTargetHP.cs
@@ -0,0 +1,239 @@
+using Chromatics.Core;
+using Chromatics.Enums;
+using Chromatics.Extensions.RGB.NET;
+using Chromatics.Helpers;
+using Chromatics.Interfaces;
+using RGB.NET.Core;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using static Chromatics.Helpers.MathHelper;
+
+namespace Chromatics.Layers
+{
+    public class FocusTargetHPProcessor : LayerProcessor
+    {
+        private static FocusTargetHPProcessor _instance;
+        private static Dictionary<int, FocusTargetHPDynamicModel> layerProcessorModel = new Dictionary<int, FocusTargetHPDynamicModel>();
+        private bool _disposed = false;
+
+        private FocusTargetHPProcessor() { }
+
+        public static FocusTargetHPProcessor Instance
+        {
+            get
+            {
+                if (_instance == null)
+                {
+                    _instance = new FocusTargetHPProcessor();
+                }
+                return _instance;
+            }
+        }
+
+        public override void Process(IMappingLayer layer)
+        {
+            if (_disposed) return;
+
+            FocusTargetHPDynamicModel model;
+
+            if (!layerProcessorModel.ContainsKey(layer.layerID))
+            {
+                model = new FocusTargetHPDynamicModel();
+                layerProcessorModel.Add(layer.layerID, model);
+            }
+            else
+            {
+                model = layerProcessorModel[layer.layerID];
+            }
+
+            // Focus Target HP Tracker Dynamic Layer Implementation
+            var _colorPalette = RGBController.GetActivePalette();
+
+            var _layergroups = RGBController.GetLiveLayerGroups();
+            var ledArray = GetLedSortedArray(layer);
+            var countKeys = ledArray.Count();
+
+            if (model.init && (layer.requestUpdate || !layer.Enabled))
+            {
+                DetachAndClearGroups(model._localgroups);
+
+                if (!layer.Enabled)
+                    return;
+            }
+
+            // Process data from FFXIV
+            var _memoryHandler = GameController.GetGameData();
+
+            if (_memoryHandler?.Reader != null && _memoryHandler.Reader.CanGetTargetInfo())
+            {
+                var full_col = ColorHelper.ColorToRGBColor(_colorPalette.FocusTargetHpClaimed.Color);
+                var friendly_col = ColorHelper.ColorToRGBColor(_colorPalette.FocusTargetHpFriendly.Color);
+                var idle_col = ColorHelper.ColorToRGBColor(_colorPalette.FocusTargetHpIdle.Color);
+                var empty_col = ColorHelper.ColorToRGBColor(_colorPalette.FocusTargetHpEmpty.Color); // Bleed layer
+
+                model.full_brush = model.full_brush ?? new SolidColorBrush(full_col);
+                model.empty_brush = model.empty_brush ?? new SolidColorBrush(empty_col);
+
+                model.empty_brush.Color = layer.allowBleed ? Color.Transparent : empty_col;
+
+                var getTargetInfo = _memoryHandler.Reader.GetTargetInfo();
+                if (getTargetInfo.TargetInfo == null) return;
+
+                var focusTarget = getTargetInfo.TargetInfo.FocusTarget;
+                uint targetId = focusTarget?.ID ?? 0;
+
+                if (targetId != model._targetId)
+                {
+                    DetachAndClearGroups(model._localgroups);
+                    model._targetReset = true;
+                    model._targetId = targetId;
+                }
+
+                if (targetId == 0 || !model.init)
+                {
+                    if (model._targetReset || !model.init)
+                    {
+                        var ledGroup = new ListLedGroup(surface, ledArray)
+                        {
+                            ZIndex = layer.zindex,
+                            Brush = model.empty_brush
+                        };
+
+                        ledGroup.Detach();
+                        model._localgroups.Add(ledGroup);
+                    }
+                }
+                else
+                {
+                    var currentVal = focusTarget.HPCurrent;
+                    var maxVal = focusTarget.HPMax;
+
+                    if (maxVal <= 0) maxVal = currentVal + 1;
+
+                    model.full_brush.Color = focusTarget.InCombat
+                        ? (focusTarget.IsAggressive ? full_col : friendly_col)
+                        : idle_col;
+
+                    if (model._currentMode != layer.layerModes)
+                    {
+                        DetachAndClearGroups(model._localgroups);
+                        model._currentMode = layer.layerModes;
+                    }
+
+                    if (layer.layerModes == Enums.LayerModes.Interpolate)
+                    {
+                        var currentVal_Interpolate = LinearInterpolation.Interpolate(currentVal, 0, maxVal, 0, countKeys);
+                        currentVal_Interpolate = Math.Max(0, Math.Min(countKeys, currentVal_Interpolate));
+
+                        if (currentVal_Interpolate != model._interpolateValue || model._targetReset || layer.requestUpdate)
+                        {
+                            var ledGroups = new List<ListLedGroup>();
+
+                            for (int i = 0; i < countKeys; i++)
+                            {
+                                var ledGroup = new ListLedGroup(surface, ledArray[i])
+                                {
+                                    ZIndex = layer.zindex,
+                                };
+
+                                ledGroup.Detach();
+
+                                ledGroup.Brush = i < currentVal_Interpolate ? model.full_brush : model.empty_brush;
+
+                                ledGroups.Add(ledGroup);
+                            }
+
+                            DetachAndClearGroups(model._localgroups);
+
+                            model._localgroups = ledGroups;
+                            model._interpolateValue = currentVal_Interpolate;
+                        }
+                    }
+                    else if (layer.layerModes == Enums.LayerModes.Fade)
+                    {
+                        var currentVal_Fader = ColorHelper.GetInterpolatedColor(currentVal, 0, maxVal, model.empty_brush.Color, model.full_brush.Color);
+
+                        if (currentVal_Fader != model._faderValue || model._targetReset || layer.requestUpdate)
+                        {
+                            var ledGroup = new ListLedGroup(surface, ledArray)
+                            {
+                                ZIndex = layer.zindex,
+                                Brush = new SolidColorBrush(currentVal_Fader)
+                            };
+
+                            ledGroup.Detach();
+
+                            DetachAndClearGroups(model._localgroups);
+                            model._localgroups.Add(ledGroup);
+                            model._faderValue = currentVal_Fader;
+                        }
+                    }
+                }
+
+                var lg = model._localgroups.ToArray();
+
+                if (_layergroups.ContainsKey(layer.layerID))
+                {
+                    _layergroups[layer.layerID] = lg;
+                }
+                else
+                {
+                    _layergroups[layer.layerID] = lg;
+                }
+            }
+
+            // Apply lighting
+            foreach (var layergroup in model._localgroups)
+            {
+                layergroup.Attach(surface);
+            }
+
+            model.init = true;
+            model._targetReset = false;
+            layer.requestUpdate = false;
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!_disposed)
+            {
+                if (disposing)
+                {
+                    foreach (var model in layerProcessorModel.Values)
+                    {
+                        DetachAndClearGroups(model._localgroups);
+                    }
+                    layerProcessorModel.Clear();
+                }
+
+                _disposed = true;
+            }
+
+            base.Dispose(disposing);
+            _instance = null;
+        }
+
+        private void DetachAndClearGroups(List<ListLedGroup> groups)
+        {
+            foreach (var group in groups)
+            {
+                group?.Detach();
+            }
+            groups.Clear();
+        }
+
+        private class FocusTargetHPDynamicModel
+        {
+            public List<ListLedGroup> _localgroups { get; set; } = new List<ListLedGroup>();
+            public SolidColorBrush empty_brush { get; set; }
+            public SolidColorBrush full_brush { get; set; }
+            public LayerModes _currentMode { get; set; }
+            public int _interpolateValue { get; set; }
+            public Color _faderValue { get; set; }
+            public uint _targetId { get; set; }
+            public bool _targetReset { get; set; }
+            public bool init { get; set; }
+        }
+    }
+}
diff --git a/Chromatics/Layers/LayerProcessorFactory.cs b/Chromatics/Layers/LayerProcessorFactory.cs
index 86ffacc4..474cf47e 100644
--- a/Chromatics/Layers/LayerProcessorFactory.cs
+++ b/Chromatics/Layers/LayerProcessorFactory.cs
@@ -104,6 +104,8 @@ private LayerProcessor CreateDynamicProcessor(DynamicLayerType type)
                 DynamicLayerType.Castbar => CastbarProcessor.Instance,
                 DynamicLayerType.JobClassesHighlight => JobClassesHighlightProcessor.Instance,
                 DynamicLayerType.ReactiveWeatherHighlight => ReactiveWeatherHighlightProcessor.Instance,
+                DynamicLayerType.FocusTargetHP => FocusTargetHPProcessor.Instance,
+                DynamicLayerType.FocusTargetCastbar => FocusTargetCastbarProcessor.Instance,
                 _ => throw new ArgumentException("Unknown DynamicLayerType")
             };
         }
diff --git a/Chromatics/Layers/MappingLayers.cs b/Chromatics/Layers/MappingLayers.cs
index cd7be629..6294bc6d 100644
--- a/Chromatics/Layers/MappingLayers.cs
+++ b/Chromatics/Layers/MappingLayers.cs
@@ -395,6 +395,8 @@ public static bool LoadMappings(bool over = false)
             var (tempLayers, tempDeviceLayouts, tempDeviceBrightness, tempDisabledDevices) = FileOperationsHelper.LoadLayerMappings();
             if (tempLayers == null) return false;
 
+            SanitizeLayerTypeIndexes(tempLayers);
+
             // Device layout overrides live in a separate top-level field in the
             // V3 file, so they come through as-is without going near the layer
             // migration path. Always replace wholesale — partial merges would
@@ -484,12 +486,46 @@ public static bool SaveMappings()
             return true;
         }
 
+        // Resets any layer whose layerTypeindex this build doesn't recognise.
+        // A layers.chromatics4 written by a newer Chromatics can carry layer
+        // positions beyond this build's enums (the 4.3.3 focus-target dynamic
+        // layers at positions 16 / 17 are the first case). Without the reset
+        // the stored position flows into GameController's
+        // (DynamicLayerType)layer.layerTypeindex cast and
+        // LayerProcessorFactory throws "Unknown DynamicLayerType" on every
+        // frame. Resetting to position 0 (None for dynamic layers) keeps the
+        // rest of the file loadable and shows the layer as None in the
+        // Mappings tab for the user to reassign.
+        private static void SanitizeLayerTypeIndexes(ConcurrentDictionary<int, Layer> layers)
+        {
+            if (layers == null) return;
+            foreach (var layer in layers.Values)
+            {
+                bool known = layer.rootLayerType switch
+                {
+                    LayerType.BaseLayer => Enum.IsDefined(typeof(BaseLayerType), layer.layerTypeindex),
+                    LayerType.DynamicLayer => Enum.IsDefined(typeof(DynamicLayerType), layer.layerTypeindex),
+                    LayerType.EffectLayer => Enum.IsDefined(typeof(EffectLayerType), layer.layerTypeindex),
+                    _ => false
+                };
+
+                if (!known)
+                {
+                    Logger.WriteConsole(Enums.LoggerTypes.System,
+                        $"Layer {layer.layerID} uses layer type {layer.layerTypeindex}, which this version of Chromatics doesn't support. The layer was reset to None.");
+                    layer.layerTypeindex = 0;
+                    layer.requestUpdate = true;
+                }
+            }
+        }
+
         public static bool ImportMappings(ConcurrentDictionary<int, Layer> importedLayer = null, bool empty = false)
         {
             var layers = importedLayer;
 
             if (layers != null)
             {
+                SanitizeLayerTypeIndexes(layers);
 
 
                 var migratedLayers = new Dictionary<int, Layer>();
@@ -658,9 +694,13 @@ public class DeviceKeyPosition
     //   v5: + disabledDevices (set of GUIDs the user disabled in the
     //       Mapping tab; persisted across launches so the device stays
     //       detached from the surface until re-enabled)
+    //   v6: no shape change. Marks files that can carry the focus-target
+    //       dynamic layer positions (16 / 17) added in 4.3.3, paired with
+    //       the SanitizeLayerTypeIndexes guard that resets unknown
+    //       positions on load / import.
     public class MappingFileV3
     {
-        public int schemaVersion { get; set; } = 5;
+        public int schemaVersion { get; set; } = 6;
         public ConcurrentDictionary<int, Layer> layers { get; set; } = new ConcurrentDictionary<int, Layer>();
         public Dictionary<Guid, Dictionary<LedId, DeviceKeyPosition>> deviceLayouts { get; set; }
             = new Dictionary<Guid, Dictionary<LedId, DeviceKeyPosition>>();
diff --git a/Chromatics/Models/PaletteColorModel.cs b/Chromatics/Models/PaletteColorModel.cs
index fc0fb505..7ea5541b 100644
--- a/Chromatics/Models/PaletteColorModel.cs
+++ b/Chromatics/Models/PaletteColorModel.cs
@@ -67,6 +67,12 @@ public class PaletteColorModel
         public ColorMapping TargetHpClaimed = new("Target HP (Claimed)", PaletteTypes.TargetEnemy, Color.Red);
         public ColorMapping TargetHpEmpty = new("Target HP (Empty)", PaletteTypes.TargetEnemy, Color.Black);
         public ColorMapping TargetHpIdle = new("Target HP (Idle)", PaletteTypes.TargetEnemy, Color.Yellow);
+        public ColorMapping FocusTargetCastbar = new("Focus Target Cast Bar Charge Build", PaletteTypes.TargetEnemy, Color.Orange);
+        public ColorMapping FocusTargetCastbarEmpty = new("Focus Target Cast Bar Charge Empty", PaletteTypes.TargetEnemy, Color.Black);
+        public ColorMapping FocusTargetHpFriendly = new("Focus Target HP (Friendly)", PaletteTypes.TargetEnemy, Color.Lime);
+        public ColorMapping FocusTargetHpClaimed = new("Focus Target HP (Claimed)", PaletteTypes.TargetEnemy, Color.Red);
+        public ColorMapping FocusTargetHpEmpty = new("Focus Target HP (Empty)", PaletteTypes.TargetEnemy, Color.Black);
+        public ColorMapping FocusTargetHpIdle = new("Focus Target HP (Idle)", PaletteTypes.TargetEnemy, Color.Yellow);
 
         //Status Effects
         public ColorMapping Amnesia = new("Amnesia", PaletteTypes.StatusEffects, Color.Snow);
diff --git a/Chromatics/ViewModels/CopyLayersDialogViewModel.cs b/Chromatics/ViewModels/CopyLayersDialogViewModel.cs
index ad42aa3c..4a6c29da 100644
--- a/Chromatics/ViewModels/CopyLayersDialogViewModel.cs
+++ b/Chromatics/ViewModels/CopyLayersDialogViewModel.cs
@@ -269,6 +269,8 @@ private static string BuildLayerDisplayName(Layer layer)
             DynamicLayerType.Castbar,
             DynamicLayerType.JobClassesHighlight,
             DynamicLayerType.ReactiveWeatherHighlight,
+            DynamicLayerType.FocusTargetHP,
+            DynamicLayerType.FocusTargetCastbar,
         };
 
         private static DynamicLayerType DynamicLayerTypeFromComboIndex(int index)
diff --git a/Chromatics/ViewModels/Mapping/LayerItemViewModel.cs b/Chromatics/ViewModels/Mapping/LayerItemViewModel.cs
index 9fc82f5c..395bcd54 100644
--- a/Chromatics/ViewModels/Mapping/LayerItemViewModel.cs
+++ b/Chromatics/ViewModels/Mapping/LayerItemViewModel.cs
@@ -283,6 +283,8 @@ public void Dispose()
             DynamicLayerType.Castbar,
             DynamicLayerType.JobClassesHighlight,
             DynamicLayerType.ReactiveWeatherHighlight,
+            DynamicLayerType.FocusTargetHP,
+            DynamicLayerType.FocusTargetCastbar,
         ];
 
         private static IReadOnlyList<LayerTypeOption> BuildTypeOptions(LayerType layerType) => layerType switch
diff --git a/Chromatics/locale/de.json b/Chromatics/locale/de.json
index f8457fc4..5457b153 100644
--- a/Chromatics/locale/de.json
+++ b/Chromatics/locale/de.json
@@ -978,5 +978,9 @@
   "1 Highlight layer references keys by their printed letter. Translate it so the same letters stay lit on your new layout?": "1 Hervorhebungsebene referenziert Tasten anhand ihres aufgedruckten Buchstabens. Soll sie übertragen werden, damit dieselben Buchstaben auf Ihrem neuen Layout weiterhin leuchten?",
   "{0} Highlight layers reference keys by their printed letter. Translate them so the same letters stay lit on your new layout?": "{0} Hervorhebungsebenen referenzieren Tasten anhand ihres aufgedruckten Buchstabens. Sollen sie übertragen werden, damit dieselben Buchstaben auf Ihrem neuen Layout weiterhin leuchten?",
   "Update layers": "Ebenen aktualisieren",
-  "Keep as-is": "Unverändert beibehalten"
+  "Keep as-is": "Unverändert beibehalten",
+  "Focus Target HP": "LP des Fokusziels",
+  "Focus Target Castbar": "Zauberleiste des Fokusziels",
+  "Shows your focus target's HP across selected keys.\n[Supported Modes: Interpolate, Fade]": "Zeigt die LP deines Fokusziels über die ausgewählten Tasten an.\n[Unterstützte Modi: Interpolieren, Verblassen]",
+  "Shows your focus target's cast progress across selected keys.\n[Supported Modes: Interpolate, Fade]": "Zeigt den Zauberfortschritt deines Fokusziels über die ausgewählten Tasten an.\n[Unterstützte Modi: Interpolieren, Verblassen]"
 }
\ No newline at end of file
diff --git a/Chromatics/locale/en.json b/Chromatics/locale/en.json
index 11daebbf..4585a7f0 100644
--- a/Chromatics/locale/en.json
+++ b/Chromatics/locale/en.json
@@ -993,5 +993,9 @@
     "1 Highlight layer references keys by their printed letter. Translate it so the same letters stay lit on your new layout?":  "1 Highlight layer references keys by their printed letter. Translate it so the same letters stay lit on your new layout?",
     "{0} Highlight layers reference keys by their printed letter. Translate them so the same letters stay lit on your new layout?":  "{0} Highlight layers reference keys by their printed letter. Translate them so the same letters stay lit on your new layout?",
     "Update layers":  "Update layers",
-    "Keep as-is":  "Keep as-is"
+    "Keep as-is":  "Keep as-is",
+    "Focus Target HP":  "Focus Target HP",
+    "Focus Target Castbar":  "Focus Target Castbar",
+    "Shows your focus target's HP across selected keys.\n[Supported Modes: Interpolate, Fade]":  "Shows your focus target's HP across selected keys.\n[Supported Modes: Interpolate, Fade]",
+    "Shows your focus target's cast progress across selected keys.\n[Supported Modes: Interpolate, Fade]":  "Shows your focus target's cast progress across selected keys.\n[Supported Modes: Interpolate, Fade]"
 }
\ No newline at end of file
diff --git a/Chromatics/locale/es.json b/Chromatics/locale/es.json
index a77e21c7..b9d9c6cb 100644
--- a/Chromatics/locale/es.json
+++ b/Chromatics/locale/es.json
@@ -978,5 +978,9 @@
   "1 Highlight layer references keys by their printed letter. Translate it so the same letters stay lit on your new layout?": "1 capa de resaltado hace referencia a las teclas por la letra impresa. ¿Traducirla para que las mismas letras permanezcan iluminadas en tu nueva distribución?",
   "{0} Highlight layers reference keys by their printed letter. Translate them so the same letters stay lit on your new layout?": "{0} capas de resaltado hacen referencia a las teclas por la letra impresa. ¿Traducirlas para que las mismas letras permanezcan iluminadas en tu nueva distribución?",
   "Update layers": "Actualizar capas",
-  "Keep as-is": "Mantener tal cual"
+  "Keep as-is": "Mantener tal cual",
+  "Focus Target HP": "PS del objetivo de foco",
+  "Focus Target Castbar": "Barra de lanzamiento del objetivo de foco",
+  "Shows your focus target's HP across selected keys.\n[Supported Modes: Interpolate, Fade]": "Muestra los PS de tu objetivo de foco en las teclas seleccionadas.\n[Modos compatibles: Interpolar, Desvanecer]",
+  "Shows your focus target's cast progress across selected keys.\n[Supported Modes: Interpolate, Fade]": "Muestra el progreso de lanzamiento de tu objetivo de foco en las teclas seleccionadas.\n[Modos compatibles: Interpolar, Desvanecer]"
 }
\ No newline at end of file
diff --git a/Chromatics/locale/fr.json b/Chromatics/locale/fr.json
index cc2584a8..1661ef35 100644
--- a/Chromatics/locale/fr.json
+++ b/Chromatics/locale/fr.json
@@ -978,5 +978,9 @@
   "1 Highlight layer references keys by their printed letter. Translate it so the same letters stay lit on your new layout?": "1 calque de surbrillance fait référence aux touches d’après leur lettre imprimée. Le transposer pour que les mêmes lettres restent allumées sur votre nouvelle disposition ?",
   "{0} Highlight layers reference keys by their printed letter. Translate them so the same letters stay lit on your new layout?": "{0} calques de surbrillance font référence aux touches d’après leur lettre imprimée. Les transposer pour que les mêmes lettres restent allumées sur votre nouvelle disposition ?",
   "Update layers": "Mettre à jour les calques",
-  "Keep as-is": "Conserver tel quel"
+  "Keep as-is": "Conserver tel quel",
+  "Focus Target HP": "PV de la cible focalisée",
+  "Focus Target Castbar": "Barre d’incantation de la cible focalisée",
+  "Shows your focus target's HP across selected keys.\n[Supported Modes: Interpolate, Fade]": "Affiche les PV de votre cible focalisée sur les touches sélectionnées.\n[Modes pris en charge : Interpolation, Fondu]",
+  "Shows your focus target's cast progress across selected keys.\n[Supported Modes: Interpolate, Fade]": "Affiche la progression de l’incantation de votre cible focalisée sur les touches sélectionnées.\n[Modes pris en charge : Interpolation, Fondu]"
 }
\ No newline at end of file
diff --git a/Chromatics/locale/ja.json b/Chromatics/locale/ja.json
index 1b99a8b6..a683c6dc 100644
--- a/Chromatics/locale/ja.json
+++ b/Chromatics/locale/ja.json
@@ -979,5 +979,9 @@
   "1 Highlight layer references keys by their printed letter. Translate it so the same letters stay lit on your new layout?": "1つのハイライトレイヤーが、印字された文字でキーを参照しています。新しいレイアウトでも同じ文字のキーが点灯するように変換しますか？",
   "{0} Highlight layers reference keys by their printed letter. Translate them so the same letters stay lit on your new layout?": "{0}個のハイライトレイヤーが、印字された文字でキーを参照しています。新しいレイアウトでも同じ文字のキーが点灯するように変換しますか？",
   "Update layers": "レイヤーを更新",
-  "Keep as-is": "そのままにする"
+  "Keep as-is": "そのままにする",
+  "Focus Target HP": "フォーカスターゲットのHP",
+  "Focus Target Castbar": "フォーカスターゲットのキャストバー",
+  "Shows your focus target's HP across selected keys.\n[Supported Modes: Interpolate, Fade]": "選択したキー上にフォーカスターゲットのHPを表示します。\n［対応モード：補間、フェード］",
+  "Shows your focus target's cast progress across selected keys.\n[Supported Modes: Interpolate, Fade]": "選択したキー上にフォーカスターゲットのキャスト進行状況を表示します。\n［対応モード：補間、フェード］"
 }
\ No newline at end of file
diff --git a/Chromatics/locale/ko.json b/Chromatics/locale/ko.json
index 3758b3cf..9e6b79fb 100644
--- a/Chromatics/locale/ko.json
+++ b/Chromatics/locale/ko.json
@@ -979,5 +979,9 @@
   "1 Highlight layer references keys by their printed letter. Translate it so the same letters stay lit on your new layout?": "하이라이트 레이어 1개가 키에 인쇄된 글자를 기준으로 키를 참조합니다. 새 레이아웃에서도 같은 글자가 켜지도록 변환하시겠습니까?",
   "{0} Highlight layers reference keys by their printed letter. Translate them so the same letters stay lit on your new layout?": "하이라이트 레이어 {0}개가 키에 인쇄된 글자를 기준으로 키를 참조합니다. 새 레이아웃에서도 같은 글자가 켜지도록 변환하시겠습니까?",
   "Update layers": "레이어 업데이트",
-  "Keep as-is": "그대로 유지"
+  "Keep as-is": "그대로 유지",
+  "Focus Target HP": "주시 대상 HP",
+  "Focus Target Castbar": "주시 대상 시전 바",
+  "Shows your focus target's HP across selected keys.\n[Supported Modes: Interpolate, Fade]": "선택한 키 전반에 주시 대상의 HP를 표시합니다.\n[지원 모드: 보간, 페이드]",
+  "Shows your focus target's cast progress across selected keys.\n[Supported Modes: Interpolate, Fade]": "선택한 키 전반에 주시 대상의 시전 진행도를 표시합니다.\n[지원 모드: 보간, 페이드]"
 }
\ No newline at end of file
diff --git a/Chromatics/locale/zh_CN.json b/Chromatics/locale/zh_CN.json
index e76136cb..7ba9f29f 100644
--- a/Chromatics/locale/zh_CN.json
+++ b/Chromatics/locale/zh_CN.json
@@ -978,5 +978,9 @@
   "1 Highlight layer references keys by their printed letter. Translate it so the same letters stay lit on your new layout?": "1 个高亮层按键是按其印刷字母引用的。要转换它，以便在新布局上相同的字母保持点亮吗？",
   "{0} Highlight layers reference keys by their printed letter. Translate them so the same letters stay lit on your new layout?": "{0} 个高亮层按键是按其印刷字母引用的。要转换它们，以便在新布局上相同的字母保持点亮吗？",
   "Update layers": "更新层",
-  "Keep as-is": "保持原样"
+  "Keep as-is": "保持原样",
+  "Focus Target HP": "焦点目标生命值",
+  "Focus Target Castbar": "焦点目标施法条",
+  "Shows your focus target's HP across selected keys.\n[Supported Modes: Interpolate, Fade]": "在选定按键上显示你的焦点目标生命值。\n[支持模式：插值、渐隐]",
+  "Shows your focus target's cast progress across selected keys.\n[Supported Modes: Interpolate, Fade]": "在选定按键上显示你的焦点目标施法进度。\n[支持模式：插值、渐隐]"
 }
\ No newline at end of file

From 3abaf2e800c7e22c9a6db26f72b31a1db87de466 Mon Sep 17 00:00:00 2001
From: Danielle <logicallysynced@gmail.com>
Date: Thu, 11 Jun 2026 17:10:57 +1000
Subject: [PATCH 6/7] Delete dead BaseLayerProcessorFactory +
 DynamicLayerProcessorFactory maps (v4.3.3 -> v4.3.4)

Neither static factory map had a single caller - GameController
dispatches base and dynamic layers through
LayerProcessorFactory.GetProcessor. Both maps had also drifted out
of date: BaseLayerProcessorFactory was missing AudioVisualizer,
DynamicLayerProcessorFactory was missing JobGaugeC and the new
focus-target layers. Worse than harmless, their static initialisers
eagerly built every processor singleton the moment anything touched
the class.

EffectLayerProcessorFactory stays - GameController iterates its map
for effect-layer dispatch (GameController.cs:744). A comment above
it records why its two siblings are gone so they don't get
reintroduced by pattern-matching.

CHANGELOG header renamed 4.3.3 -> 4.3.4 to track the version (also
fixes the "Castbasr" typo in the focus-target bullet); the existing
"Various performance improvements and bug fixes" line covers this
cleanup.

Build clean, 133/133 xUnit tests pass.
---
 CHANGELOG.md                        |  9 ++---
 Chromatics/Chromatics.csproj        |  2 +-
 Chromatics/Layers/LayerProcessor.cs | 54 ++++-------------------------
 3 files changed, 10 insertions(+), 55 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ad22aefc..7de270e2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,14 +2,9 @@
 
 All notable changes to Chromatics are documented here.
 
-## 4.3.3
-
-- **New:** Focus Target HP layer. Works like the Target HP layer but follows whatever you have focus targeted, with its own palette colours for claimed, friendly, idle, and empty states.
-- **New:** Focus Target Castbar layer. Shows your focus target's cast progress across selected keys, with its own palette colours.
-- Loading or importing a layer file that contains layer types from a newer Chromatics version no longer breaks. Unrecognised layer types reset to None and the rest of the file loads normally.
-
-## 4.3.2
+## 4.3.4
 
+- Added new dynamic layers for Focus Target HP and Focus Target Castbar
 - Fixed a bug which caused the Experience Tracker layer to not work with Reaper and Sage.
 - Fixed the Keybinds layer misreading hotbar actions with high action ids.
 - Fixed party member position data reporting the wrong Y coordinate.
diff --git a/Chromatics/Chromatics.csproj b/Chromatics/Chromatics.csproj
index b191699d..925d42ca 100644
--- a/Chromatics/Chromatics.csproj
+++ b/Chromatics/Chromatics.csproj
@@ -10,7 +10,7 @@
     <TargetFramework>net10.0-windows10.0.19041.0</TargetFramework>
     <SupportedOSPlatformVersion>10.0.17763.0</SupportedOSPlatformVersion>
     <StartupObject>Chromatics.Program</StartupObject>
-    <Version>4.3.3.0</Version>
+    <Version>4.3.4.0</Version>
     <Authors>Danielle Thompson</Authors>
     <!-- ApplicationManifest is conditional: local Debug + Release builds embed
          app.manifest (no fusion-identity <msix> element) so VS debug runs and
diff --git a/Chromatics/Layers/LayerProcessor.cs b/Chromatics/Layers/LayerProcessor.cs
index c81f5971..d34bc09c 100644
--- a/Chromatics/Layers/LayerProcessor.cs
+++ b/Chromatics/Layers/LayerProcessor.cs
@@ -171,24 +171,13 @@ protected override void Dispose(bool disposing)
 
 
 
-    public static class BaseLayerProcessorFactory
-    {
-        private static readonly Dictionary<BaseLayerType, LayerProcessor> layerProcessors = new Dictionary<BaseLayerType, LayerProcessor>
-        {
-            { BaseLayerType.Static, StaticProcessor.Instance },
-            { BaseLayerType.ReactiveWeather, ReactiveWeatherProcessor.Instance },
-            { BaseLayerType.BattleStance, BaseBattleStanceProcessor.Instance },
-            { BaseLayerType.JobClasses, JobClassesProcessor.Instance },
-            { BaseLayerType.ScreenCapture, ScreenCaptureProcessor.Instance },
-        };
-
-        public static Dictionary<BaseLayerType, LayerProcessor> GetProcessors()
-        {
-            return layerProcessors;
-        }
-    }
-
-
+    // The matching BaseLayerProcessorFactory and DynamicLayerProcessorFactory
+    // maps were deleted: nothing called them, and their static initialisers
+    // eagerly built every processor singleton while the entries drifted out
+    // of date (missing AudioVisualizer, JobGaugeC, the focus-target layers).
+    // GameController dispatches base + dynamic layers through
+    // LayerProcessorFactory.GetProcessor instead. EffectLayerProcessorFactory
+    // stays - GameController iterates its map for effect-layer dispatch.
     public static class EffectLayerProcessorFactory
     {
         private static readonly Dictionary<EffectLayerType, LayerProcessor> layerProcessors = new Dictionary<EffectLayerType, LayerProcessor>
@@ -207,33 +196,4 @@ public static Dictionary<EffectLayerType, LayerProcessor> GetProcessors()
     }
 
 
-    public static class DynamicLayerProcessorFactory
-    {
-        private static readonly Dictionary<DynamicLayerType, LayerProcessor> layerProcessors = new Dictionary<DynamicLayerType, LayerProcessor>
-        {
-            { DynamicLayerType.None, NoneProcessor.Instance },
-            { DynamicLayerType.Highlight, HighlightProcessor.Instance },
-            { DynamicLayerType.Keybinds, KeybindsProcessor.Instance },
-            { DynamicLayerType.EnmityTracker, EnmityTrackerProcessor.Instance },
-            { DynamicLayerType.TargetHP, TargetHPProcessor.Instance },
-            { DynamicLayerType.TargetCastbar, TargetCastbarProcessor.Instance },
-            { DynamicLayerType.HPTracker, HPTrackerProcessor.Instance },
-            { DynamicLayerType.MPTracker, MPTrackerProcessor.Instance },
-            { DynamicLayerType.JobGaugeA, JobGaugeAProcessor.Instance },
-            { DynamicLayerType.JobGaugeB, JobGaugeBProcessor.Instance },
-            { DynamicLayerType.ExperienceTracker, ExperienceTrackerProcessor.Instance },
-            { DynamicLayerType.BattleStance, DynamicBattleStanceProcessor.Instance },
-            { DynamicLayerType.Castbar, CastbarProcessor.Instance },
-            { DynamicLayerType.JobClassesHighlight, JobClassesHighlightProcessor.Instance },
-            { DynamicLayerType.ReactiveWeatherHighlight, ReactiveWeatherHighlightProcessor.Instance }
-        };
-
-        public static Dictionary<DynamicLayerType, LayerProcessor> GetProcessors()
-        {
-            return layerProcessors;
-        }
-    }
-
-
-
 }

From 939d020fe874c4bd80bbd5d705b013b133458296 Mon Sep 17 00:00:00 2001
From: Danielle <logicallysynced@gmail.com>
Date: Thu, 11 Jun 2026 17:13:31 +1000
Subject: [PATCH 7/7] Update changelog

---
 CHANGELOG.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7de270e2..05585963 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,7 +7,6 @@ All notable changes to Chromatics are documented here.
 - Added new dynamic layers for Focus Target HP and Focus Target Castbar
 - Fixed a bug which caused the Experience Tracker layer to not work with Reaper and Sage.
 - Fixed the Keybinds layer misreading hotbar actions with high action ids.
-- Fixed party member position data reporting the wrong Y coordinate.
 - Updated Sharlayan to latest version
 - Various performance improvements and bug fixes