Fix LIFX/Hue per-device disable lifecycle (v4.1.37)

Per-device disable on the Mappings tab had four independent bugs uncovered
while testing with a LIFX Beam:

- Disable raced restore against in-flight decorator chunks. Added a per-device
  gate flag on the LIFX/Hue update queues and made LifxUpdateQueue's restore
  take _lock around both the colour and power sends, so the bulb returns
  cleanly to its pre-Chromatics state instead of being left half-decorator
  half-restored on chained Beam setups.

- Re-enable left the device dark and the Mapping preview blank when testing
  with the startup animation. RunStartupEffects only built tagged groups for
  attached devices, so a device that came up disabled never got its rainbow
  group. AddDevice now calls SyncTaggedEffectsForDevice and
  surface.Update(flushLeds: true) in a single locked pass, with
  layer.requestUpdate=true on every layer tied to the device so processors
  re-paint from scratch.

- Restart with a persisted-disabled LIFX bulb silently powered the bulb back
  on, because CaptureOriginalStateAsync's "turn on if off" branch fired
  before the post-Load detach. The next capture cycle then read Powered=true
  and poisoned _original, so subsequent disables stopped turning the bulb
  off — the runaway state. Capture now takes a turnOnIfOff flag; the LIFX
  provider passes false when the device is persisted-disabled, and gates
  the queue immediately to close the brief surface.Load to detach window.
  Hue gets the same defensive gate.

- Re-enable's recapture worker ran AFTER surface.Update(true) had already
  painted Chromatics colours onto the bulb, so the recaptured _original.Zones
  reflected the rainbow rather than pre-Chromatics. Dropped the recapture
  entirely and replaced its auto-on side effect with a dedicated
  EnsurePoweredOn() that sends SetLightPower(on=true) without touching
  _original. Hue's Update() already sends On=true with every paint, so it
  needs no equivalent.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: logicallysynced

CHANGELOG.md

@@ -2,7 +2,7 @@
 
 All notable changes to Chromatics are documented here.
 
-## 4.1.33
+## 4.1.37
 
 - Added Auto-discovery for Hue bridges.
 - Updated Hue light adoption. After pairing, Chromatics shows a picker so you can choose exactly which Hue lights it should control. Existing setups upgraded from earlier builds keep all their bulbs (one-time auto-adopt of whatever the bridge currently exposes); from then on you can deselect bulbs you don't want from the same dialog.

Chromatics/Chromatics.csproj

@@ -4,7 +4,7 @@
     <OutputType>WinExe</OutputType>
     <TargetFramework>net10.0-windows7.0</TargetFramework>
     <StartupObject>Chromatics.Program</StartupObject>
-    <Version>4.1.33.0</Version>
+    <Version>4.1.37.0</Version>
     <Authors>Danielle Thompson</Authors>
     <ApplicationManifest>app.manifest</ApplicationManifest>
     <Copyright>logicallysynced 2026</Copyright>

Chromatics/Core/RGBController.cs

@@ -351,8 +351,18 @@ public static void RemoveDevice(IRGBDevice device)
                 // last colour we sent — which is undesirable when the user
                 // explicitly disables a single device. Run on a worker so
                 // the UI thread doesn't block on the UDP / HTTP sends.
+                //
+                // SetPerDeviceDisabled is set BEFORE Task.Run kicks the
+                // restore so any decorator data still buffered in the
+                // queue's _currentDataSet from a TimerUpdateTrigger tick
+                // that raced surface.Detach gets dropped. Without this
+                // gate the restore's chunked SetExtendedColorZones
+                // packets interleave with the late decorator chunks and
+                // leave half a chained Beam strip stuck on the last
+                // decorator colour.
                 if (device is Extensions.RGB.NET.Devices.LIFX.LifxDevice lifxDev)
                 {
+                    lifxDev.SetPerDeviceDisabled(true);
                     System.Threading.Tasks.Task.Run(async () =>
                     {
                         try { await lifxDev.RestoreOriginalStateAsync(); }
@@ -361,6 +371,7 @@ public static void RemoveDevice(IRGBDevice device)
                 }
                 else if (device is Extensions.RGB.NET.Devices.Hue.HueDevice hueDev)
                 {
+                    hueDev.SetPerDeviceDisabled(true);
                     System.Threading.Tasks.Task.Run(async () =>
                     {
                         try { await hueDev.RestoreOriginalStateAsync(); }
@@ -401,27 +412,94 @@ public static void AddDevice(IRGBDevice device)
                 surface.Attach(device);
                 AttachGlobalBrightness(device);
 
-                // Re-capture the bulb's current state on per-device re-enable.
-                // The user may have changed the colour / power between the
-                // disable and re-enable (Hue / LIFX app, automation, etc.),
-                // and they expect the next disable to restore whatever was
-                // on the bulb just before Chromatics retook control.
+                // Open the queue back up SYNCHRONOUSLY — order matters because
+                // surface.Update(true) below is a single critical section that
+                // both renders LedGroups (populating RequestedColor on every
+                // painted LED) and dispatches a flushed device.Update for each
+                // attached device. If the queue is still gated when that
+                // dispatch fires, the resulting SetData would be drained by
+                // OnUpdate and ignored by Update, leaving the bulb at its
+                // restored "original" colour with no Chromatics paint.
                 if (device is Extensions.RGB.NET.Devices.LIFX.LifxDevice lifxDev)
                 {
-                    System.Threading.Tasks.Task.Run(async () =>
-                    {
-                        try { await lifxDev.CaptureOriginalStateAsync(); }
-                        catch { /* best-effort */ }
-                    });
+                    lifxDev.ResetCache();
+                    lifxDev.SetPerDeviceDisabled(false);
                 }
                 else if (device is Extensions.RGB.NET.Devices.Hue.HueDevice hueDev)
                 {
-                    System.Threading.Tasks.Task.Run(async () =>
+                    hueDev.SetPerDeviceDisabled(false);
+                }
+
+                // Tagged effects (startup rainbow, title-screen starfield)
+                // build their per-device ListLedGroup at the moment the tag
+                // is started — devices that were disabled at the time
+                // RunStartupEffects ran have no tagged group covering their
+                // LEDs, so Render never paints them and led.Color never
+                // changes. Without this, re-enabling a device while the
+                // startup rainbow is running leaves the bulb dark and the
+                // Mapping-tab preview shows no activity. Mirrors the
+                // behaviour of DevicesChanged.Added's "running animation,
+                // join the rig" path for hot-plug.
+                var deviceGuid = GetDeviceGuid(device);
+                if (deviceGuid != Guid.Empty)
+                    SyncTaggedEffectsForDevice(deviceGuid);
+
+                // Mark all layers tied to this device for re-process so
+                // their processors rebuild fresh ListLedGroups and re-paint
+                // the LEDs from scratch on the next GameController tick.
+                // This dirties the LEDs even when the layer's colour hasn't
+                // changed since pre-disable — without it, a Static red
+                // layer on a re-enabled bulb sees "RequestedColor==Color"
+                // (Render kept painting red during the disabled period and
+                // led.Update ran every surface tick to keep _color in
+                // sync), IsDirty=false, no SetData call, no UDP / HTTP.
+                foreach (var layer in MappingLayers.GetLayers().Values)
+                {
+                    if (layer.deviceGuid == deviceGuid)
+                        layer.requestUpdate = true;
+                }
+
+                // Force a full surface render + flushed device update in a
+                // single locked pass. Render walks every attached LedGroup
+                // and writes RequestedColor for each LED it covers; the
+                // following device.Update(true) phase then returns every
+                // LED with RequestedColor.A > 0 regardless of IsDirty,
+                // so the queue receives the LED state immediately on
+                // re-enable instead of waiting for the next decorator
+                // tick to dirty something. Caches in LIFX's queue are
+                // already cleared above so the per-zone diff doesn't
+                // suppress this flush.
+                try { surface.Update(flushLeds: true); } catch { }
+
+                // For LIFX, the bulb may have come up powered-off (we
+                // honour the persisted disable state at startup with
+                // CaptureOriginalStateAsync(turnOnIfOff: false)). The
+                // paint frames above pre-load the per-zone HSBK on the
+                // bulb but do not switch it on — SetExtendedColorZones
+                // doesn't toggle power. Send an explicit SetLightPower
+                // AFTER the flush so the bulb wakes up already showing
+                // the freshly-painted Chromatics state instead of the
+                // last restored frame. EnsurePoweredOn deliberately
+                // does NOT recapture _original — we used to re-run
+                // CaptureOriginalStateAsync here for its auto-on side
+                // effect, but the recapture's GetExtendedColorZones
+                // query saw the rainbow paints we'd just sent and
+                // poisoned _original.Zones, so the next disable
+                // restored to "rainbow" instead of pre-Chromatics.
+                // _original from app startup is still the right thing
+                // to restore to.
+                if (device is Extensions.RGB.NET.Devices.LIFX.LifxDevice lifxDevPower)
+                {
+                    System.Threading.Tasks.Task.Run(() =>
                     {
-                        try { await hueDev.CaptureOriginalStateAsync(); }
+                        try { lifxDevPower.EnsurePoweredOn(); }
                         catch { /* best-effort */ }
                     });
                 }
+                // Hue's Update() includes On=true on every paint frame,
+                // so the bridge powers the bulb on automatically as soon
+                // as the surface.Update flush above lands. No equivalent
+                // power-on call needed.
 
                 if (_activeDevices.ContainsKey(device))
                 {
@@ -754,13 +832,26 @@ public static bool LoadDeviceProvider(IRGBDeviceProvider provider)
                     // state we have to detach the disabled devices here,
                     // AFTER Load has populated provider.Devices and put
                     // them on the surface.
+                    //
+                    // For Hue/LIFX we ALSO set the queue's per-device
+                    // disable flag so any decorator data that managed to
+                    // get buffered during the brief surface-load window
+                    // (Load → render tick → device.Update → SetData) gets
+                    // dropped by the queue's next OnUpdate instead of
+                    // being sent to the bulb. The flag stays set until
+                    // the user re-enables the device via AddDevice, which
+                    // captures fresh state and clears the flag.
                     foreach (var device in provider.Devices)
                     {
                         var guidProbe = Helpers.DeviceHelper.GenerateDeviceGuid(device.DeviceInfo.DeviceName);
                         if (!Layers.MappingLayers.IsDeviceDisabled(guidProbe))
                             continue;
                         if (surface.Devices.Contains(device))
                             surface.Detach(device);
+                        if (device is Extensions.RGB.NET.Devices.LIFX.LifxDevice lifxDev)
+                            lifxDev.SetPerDeviceDisabled(true);
+                        else if (device is Extensions.RGB.NET.Devices.Hue.HueDevice hueDev)
+                            hueDev.SetPerDeviceDisabled(true);
                         if (_activeDevices.ContainsKey(device))
                             _activeDevices[device] = false;
                         else

Chromatics/Extensions/RGB.NET/Devices/Hue/HueDevice.cs

@@ -20,6 +20,8 @@ public HueDevice(HueDeviceInfo deviceInfo, HueUpdateQueue updateQueue) : base(de
     public Task CaptureOriginalStateAsync() => _updateQueue.CaptureOriginalStateAsync();
     public Task RestoreOriginalStateAsync() => _updateQueue.RestoreOriginalStateAsync();
 
+    public void SetPerDeviceDisabled(bool disabled) => _updateQueue.SetPerDeviceDisabled(disabled);
+
     // Forwarded into the update queue so SetBrightness on the bridge picks
     // up the per-device multiplier — uniform RGB scaling doesn't affect xy.
     public void SetPerDeviceBrightness(PerDeviceBrightnessCorrection correction)

Chromatics/Extensions/RGB.NET/Devices/Hue/HueRGBDeviceProvider.cs

@@ -139,6 +139,19 @@ private async Task<IEnumerable<IRGBDevice>> LoadDevicesAsync()
                                 var queue = new HueUpdateQueue(GetUpdateTrigger(), light, modelId, localHueApi);
                                 HueDevice device = new HueDevice(deviceInfo, queue);
 
+                                // Bulbs persisted-disabled in the Mapping tab
+                                // get the queue gated immediately so the brief
+                                // surface.Load → post-Load detach window in
+                                // RGBController can't drain a buffered LED
+                                // frame and send an UpdateLight to the bridge
+                                // before the disable flag is set. Hue's
+                                // CaptureOriginalStateAsync is harmless here
+                                // (it only reads), but Update sends colour +
+                                // power, which would visibly turn the bulb on.
+                                var deviceGuid = Chromatics.Helpers.DeviceHelper.GenerateDeviceGuid(deviceInfo.DeviceName);
+                                if (Chromatics.Layers.MappingLayers.IsDeviceDisabled(deviceGuid))
+                                    queue.SetPerDeviceDisabled(true);
+
                                 // Snapshot the bulb's current state before the
                                 // surface starts pushing colour updates. Failures
                                 // are logged inside; we still add the device to

Chromatics/Extensions/RGB.NET/Devices/Hue/HueUpdateQueue.cs

@@ -31,6 +31,11 @@ public class HueUpdateQueue : UpdateQueue
         private readonly string _modelId;
         private readonly Lock _lock = new();
         private volatile bool _shuttingDown;
+        // Set true while the device is disabled in the Mapping tab so any
+        // buffered LED data that arrives via OnUpdate after surface.Detach
+        // gets dropped instead of racing the restore-to-original UpdateAsync.
+        // Cleared on re-enable in RGBController.AddDevice.
+        private volatile bool _perDeviceDisable;
         private PerDeviceBrightnessCorrection _perDeviceBrightness;
 
         // Rate-limit error logs GLOBALLY across every HueUpdateQueue
@@ -87,6 +92,8 @@ public HueUpdateQueue(IDeviceUpdateTrigger updateTrigger, Light light, string mo
         // already sent TurnOff, racing the bridge into the wrong final state.
         public void BeginShutdown() => _shuttingDown = true;
 
+        public void SetPerDeviceDisabled(bool disabled) => _perDeviceDisable = disabled;
+
         public void SetPerDeviceBrightness(PerDeviceBrightnessCorrection correction)
             => _perDeviceBrightness = correction;
 
@@ -183,8 +190,10 @@ protected override bool Update(ReadOnlySpan<(object key, Color color)> dataSet)
             lock (_lock)
             {
                 // Provider has begun teardown — drop the update so it can't race
-                // ahead of (or behind) the explicit TurnOff sequence.
-                if (_shuttingDown) return true;
+                // ahead of (or behind) the explicit TurnOff sequence. Same
+                // for per-device disable from the Mapping tab so a buffered
+                // colour frame can't race the restore-to-original send.
+                if (_shuttingDown || _perDeviceDisable) return true;
 
                 try
                 {

Chromatics/Extensions/RGB.NET/Devices/LIFX/LifxDevice.cs

@@ -21,9 +21,13 @@ public LifxDevice(LifxDeviceInfo info, LifxUpdateQueue updateQueue, LifxClientDe
         public LifxClientDefinition Definition => _def;
 
         public void BeginShutdown() => _updateQueue.BeginShutdown();
-        public Task CaptureOriginalStateAsync() => _updateQueue.CaptureOriginalStateAsync();
+        public Task CaptureOriginalStateAsync(bool turnOnIfOff = true) => _updateQueue.CaptureOriginalStateAsync(turnOnIfOff);
         public Task RestoreOriginalStateAsync() => _updateQueue.RestoreOriginalStateAsync();
 
+        public void SetPerDeviceDisabled(bool disabled) => _updateQueue.SetPerDeviceDisabled(disabled);
+        public void ResetCache() => _updateQueue.ResetCache();
+        public void EnsurePoweredOn() => _updateQueue.EnsurePoweredOn();
+
         public void SetPerDeviceBrightness(PerDeviceBrightnessCorrection correction)
             => _updateQueue.SetPerDeviceBrightness(correction);
 

Chromatics/Extensions/RGB.NET/Devices/LIFX/LifxRGBDeviceProvider.cs

@@ -98,14 +98,28 @@ private async Task<IEnumerable<IRGBDevice>> LoadDevicesAsync()
                     var info = new LifxDeviceInfo(def);
                     var dev = new LifxDevice(info, queue, def);
 
-                    // Capture original state before the surface paints anything.
-                    // This races with the trigger ramping up but
-                    // CaptureOriginalStateAsync uses a separate UDP socket so
-                    // it can't deadlock against the SetColor stream.
-                    // CaptureOriginalStateAsync also turns the bulb on if it
-                    // was off, so layers become visible immediately rather
-                    // than waiting for the user to toggle physical power.
-                    await dev.CaptureOriginalStateAsync().ConfigureAwait(false);
+                    // Devices the user disabled in the Mapping tab in a
+                    // previous session must not be touched at startup. Two
+                    // things we'd otherwise do are wrong here:
+                    //   1) CaptureOriginalStateAsync's "turn on if off"
+                    //      branch would silently power the bulb back up
+                    //      every launch — and the next capture cycle would
+                    //      then observe Powered=true and poison _original
+                    //      so subsequent disables stop turning the bulb
+                    //      back off. Pass turnOnIfOff: false to skip it.
+                    //   2) The brief surface.Load → post-Load detach pass
+                    //      window in RGBController could let the queue's
+                    //      trigger drain a buffered LED frame and send a
+                    //      paint UDP packet before the per-device disable
+                    //      flag is set. Setting it here, before the device
+                    //      is added to the surface, closes that window.
+                    var deviceGuid = Chromatics.Helpers.DeviceHelper.GenerateDeviceGuid(info.DeviceName);
+                    bool disabled = Chromatics.Layers.MappingLayers.IsDeviceDisabled(deviceGuid);
+
+                    if (disabled)
+                        queue.SetPerDeviceDisabled(true);
+
+                    await dev.CaptureOriginalStateAsync(turnOnIfOff: !disabled).ConfigureAwait(false);
 
                     devices.Add(dev);
                 }