diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0b59e591..29cee641 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,32 @@
 
 All notable changes to Chromatics are documented here.
 
+## 4.3.36
+
+- Updated to Sharlayan 9.2.1.
+- A device provider that loses one device during start-up no longer reports the whole provider as failed. The skipped device is named and the rest of that provider's devices load as normal.
+- The first-run wizard no longer saves a provider as enabled when App Control blocked its library.
+
+## 4.3.35
+
+- Fixed a crash when turning a device provider on or off if Windows App Control had blocked that provider's library. The toggle now returns to its previous position and explains what happened.
+- Fixed a crash on the Continue button of the first-run wizard for the same reason.
+- Chromatics no longer reports App Control blocks and Hue bridge address problems as application errors, since both are settings on your machine or network rather than faults in Chromatics.
+
+## 4.3.34
+
+- The console tab now shows which version of Chromatics you are running at startup.
+- A device provider that fails to start now says so in the console tab, naming the provider and the reason. Providers that fail no longer look like they loaded, and the rest of your devices carry on loading as normal.
+
+## 4.3.33
+
+- Fixed lighting stopping for the rest of the session when the Screen Capture base layer was in use and you returned to the title or character select screen.
+- Yeelight, LIFX, Nanoleaf, and Alienware lights that are switched off or off the network at startup now log as device notices instead of errors.
+
+## 4.3.32
+
+- Improved the accuracy and speed of game-data reads on FFXIV patch 7.55, including inventory, chat log, job gauges, and player stats.
+
 ## 4.3.31
 
 - Added support for FFXIV patch 7.55.
diff --git a/Chromatics.Tests/Chromatics.Tests.csproj b/Chromatics.Tests/Chromatics.Tests.csproj
index 53d68223..8b58cfa7 100644
--- a/Chromatics.Tests/Chromatics.Tests.csproj
+++ b/Chromatics.Tests/Chromatics.Tests.csproj
@@ -38,7 +38,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Sharlayan" Version="9.1.3" />
+    <PackageReference Include="Sharlayan" Version="9.2.1" />
   </ItemGroup>
 
 </Project>
diff --git a/Chromatics.Tests/Core/ScreenCaptureProcessorLifetimeTests.cs b/Chromatics.Tests/Core/ScreenCaptureProcessorLifetimeTests.cs
new file mode 100644
index 00000000..891ebb6d
--- /dev/null
+++ b/Chromatics.Tests/Core/ScreenCaptureProcessorLifetimeTests.cs
@@ -0,0 +1,21 @@
+using Chromatics.Layers;
+
+namespace Chromatics.Tests.Core;
+
+public class ScreenCaptureProcessorLifetimeTests
+{
+    [Fact]
+    public void Instance_IsRebuiltAfterDispose()
+    {
+        // DisposeAll runs every time the player returns to the title screen and
+        // nulls the processor's surface. Handing the disposed object back out
+        // left the Screen Capture base layer attaching to a dead surface on
+        // every later tick, which killed lighting for the rest of the session.
+        var first = ScreenCaptureProcessor.Instance;
+        first.Dispose();
+
+        var second = ScreenCaptureProcessor.Instance;
+
+        Assert.NotSame(first, second);
+    }
+}
diff --git a/Chromatics.Tests/Helpers/AssemblyLoadGuardTests.cs b/Chromatics.Tests/Helpers/AssemblyLoadGuardTests.cs
new file mode 100644
index 00000000..c7724666
--- /dev/null
+++ b/Chromatics.Tests/Helpers/AssemblyLoadGuardTests.cs
@@ -0,0 +1,64 @@
+using System;
+using System.IO;
+using System.Reflection;
+using Chromatics.Helpers;
+
+namespace Chromatics.Tests.Helpers;
+
+public class AssemblyLoadGuardTests
+{
+    private static Exception AppControlBlock()
+        => new FileLoadException("An Application Control policy has blocked this file. (0x800711C7)");
+
+    [Fact]
+    public void DirectLoadFailure_IsReported()
+    {
+        Assert.True(AssemblyLoadGuard.TryReportLoadFailure("Razer", AppControlBlock()));
+        Assert.True(AssemblyLoadGuard.TryReportLoadFailure("Razer", new FileNotFoundException("missing")));
+        Assert.True(AssemblyLoadGuard.TryReportLoadFailure("Razer", new BadImageFormatException("bad")));
+        Assert.True(AssemblyLoadGuard.TryReportLoadFailure("Razer", new TypeLoadException("type")));
+    }
+
+    [Fact]
+    public void LoadFailureWrappedByAnEventHandler_IsReported()
+    {
+        // How it arrives from a routed-event handler (CHROMATICS-1N).
+        var ex = new TargetInvocationException(AppControlBlock());
+
+        Assert.True(AssemblyLoadGuard.TryReportLoadFailure("Logitech", ex));
+    }
+
+    [Fact]
+    public void LoadFailureInsideAggregate_IsReported()
+    {
+        // How it arrives from an unobserved task (CHROMATICS-1G / 1H).
+        var ex = new AggregateException(new InvalidOperationException("unrelated"), AppControlBlock());
+
+        Assert.True(AssemblyLoadGuard.TryReportLoadFailure("OpenRGB", ex));
+    }
+
+    [Fact]
+    public void TypeInitializerCarryingALoadFailure_IsReported()
+    {
+        var ex = new TypeInitializationException("SomeType", AppControlBlock());
+
+        Assert.True(AssemblyLoadGuard.TryReportLoadFailure("Corsair", ex));
+    }
+
+    [Fact]
+    public void UnrelatedFailures_AreNotReportedAsLoadFailures()
+    {
+        Assert.False(AssemblyLoadGuard.TryReportLoadFailure("Hue", new InvalidOperationException()));
+        Assert.False(AssemblyLoadGuard.TryReportLoadFailure("Hue", new TimeoutException()));
+        Assert.False(AssemblyLoadGuard.TryReportLoadFailure("Hue",
+            new InvalidOperationException("outer", new ArgumentOutOfRangeException())));
+    }
+
+    [Fact]
+    public void TryRun_ReturnsFalseWhenTheActionFaults()
+    {
+        Assert.True(AssemblyLoadGuard.TryRun("Razer", () => { }));
+        Assert.False(AssemblyLoadGuard.TryRun("Razer", () => throw AppControlBlock()));
+        Assert.False(AssemblyLoadGuard.TryRun("Razer", () => throw new InvalidOperationException()));
+    }
+}
diff --git a/Chromatics.Tests/Helpers/NetworkFailureHelperTests.cs b/Chromatics.Tests/Helpers/NetworkFailureHelperTests.cs
new file mode 100644
index 00000000..29ca8910
--- /dev/null
+++ b/Chromatics.Tests/Helpers/NetworkFailureHelperTests.cs
@@ -0,0 +1,53 @@
+using System;
+using System.IO;
+using System.Net.Http;
+using System.Net.Sockets;
+using Chromatics.Helpers;
+
+namespace Chromatics.Tests.Helpers;
+
+public class NetworkFailureHelperTests
+{
+    [Fact]
+    public void ConnectionRefused_IsUnreachable()
+    {
+        var ex = new SocketException((int)SocketError.ConnectionRefused);
+
+        Assert.True(NetworkFailureHelper.IsUnreachable(ex));
+    }
+
+    [Fact]
+    public void SocketFailureWrappedInIoException_IsUnreachable()
+    {
+        var ex = new IOException("write failed", new SocketException((int)SocketError.HostUnreachable));
+
+        Assert.True(NetworkFailureHelper.IsUnreachable(ex));
+    }
+
+    [Fact]
+    public void HttpAndTimeoutFailures_AreUnreachable()
+    {
+        Assert.True(NetworkFailureHelper.IsUnreachable(new HttpRequestException("no route")));
+        Assert.True(NetworkFailureHelper.IsUnreachable(new TimeoutException()));
+        Assert.True(NetworkFailureHelper.IsUnreachable(new TaskCanceledException()));
+    }
+
+    [Fact]
+    public void SocketFailureInsideAggregate_IsUnreachable()
+    {
+        var ex = new AggregateException(
+            new InvalidOperationException("unrelated"),
+            new SocketException((int)SocketError.TimedOut));
+
+        Assert.True(NetworkFailureHelper.IsUnreachable(ex));
+    }
+
+    [Fact]
+    public void ApplicationBugs_AreNotUnreachable()
+    {
+        Assert.False(NetworkFailureHelper.IsUnreachable(new NullReferenceException()));
+        Assert.False(NetworkFailureHelper.IsUnreachable(new InvalidOperationException()));
+        Assert.False(NetworkFailureHelper.IsUnreachable(
+            new InvalidOperationException("outer", new ArgumentOutOfRangeException())));
+    }
+}
diff --git a/Chromatics.Tests/Helpers/UpdateNotesTests.cs b/Chromatics.Tests/Helpers/UpdateNotesTests.cs
index f370b39b..c44e8290 100644
--- a/Chromatics.Tests/Helpers/UpdateNotesTests.cs
+++ b/Chromatics.Tests/Helpers/UpdateNotesTests.cs
@@ -57,7 +57,7 @@ public void EmptyOrWhitespaceNotes_ReturnEmpty()
     {
         Assert.Equal(string.Empty, UpdateService.TrimNotesToOwnSection("", "4.3.26"));
         Assert.Equal(string.Empty, UpdateService.TrimNotesToOwnSection("   ", "4.3.26"));
-        Assert.Equal(string.Empty, UpdateService.TrimNotesToOwnSection(null, "4.3.26"));
+        Assert.Equal(string.Empty, UpdateService.TrimNotesToOwnSection(null!, "4.3.26"));
     }
 
     [Fact]
diff --git a/Chromatics.Tests/ViewModels/DeviceToggleItemTests.cs b/Chromatics.Tests/ViewModels/DeviceToggleItemTests.cs
new file mode 100644
index 00000000..bdd93fe6
--- /dev/null
+++ b/Chromatics.Tests/ViewModels/DeviceToggleItemTests.cs
@@ -0,0 +1,63 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using Chromatics.ViewModels;
+
+namespace Chromatics.Tests.ViewModels;
+
+public class DeviceToggleItemTests
+{
+    // App Control blocking a vendor DLL threw out of the fire-and-forget task
+    // the property setter starts, so the finalizer rethrew it as a crash
+    // (CHROMATICS-1G / 1H). The toggle has to absorb it and show the real state.
+    private static Exception AppControlBlock()
+        => new FileLoadException("An Application Control policy has blocked this file. (0x800711C7)");
+
+    [Fact]
+    public void EnableFailure_RevertsToOff()
+    {
+        var item = new DeviceToggleItem("Razer", "tooltip", false,
+            () => throw AppControlBlock(),
+            () => { });
+
+        item.IsEnabled = true;
+
+        Assert.False(item.IsEnabled);
+    }
+
+    [Fact]
+    public void DisableFailure_LeavesToggleOn()
+    {
+        var item = new DeviceToggleItem("OpenRGB", "tooltip", true,
+            () => Task.FromResult(true),
+            () => throw AppControlBlock());
+
+        item.IsEnabled = false;
+
+        Assert.True(item.IsEnabled);
+    }
+
+    [Fact]
+    public void EnableVeto_LeavesToggleOff()
+    {
+        var item = new DeviceToggleItem("Hue", "tooltip", false,
+            () => Task.FromResult(false),
+            () => { });
+
+        item.IsEnabled = true;
+
+        Assert.False(item.IsEnabled);
+    }
+
+    [Fact]
+    public void SuccessfulEnable_TurnsToggleOn()
+    {
+        var item = new DeviceToggleItem("LIFX", "tooltip", false,
+            () => Task.FromResult(true),
+            () => { });
+
+        item.IsEnabled = true;
+
+        Assert.True(item.IsEnabled);
+    }
+}
diff --git a/Chromatics/Chromatics.csproj b/Chromatics/Chromatics.csproj
index 7e22007b..c7302bd4 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.31.0</Version>
+    <Version>4.3.36.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
@@ -97,7 +97,7 @@
     <PackageReference Include="System.Drawing.Common" Version="10.0.8" />
     <PackageReference Include="NAudio" Version="2.3.0" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.4" />
-    <PackageReference Include="NLog" Version="6.1.4" />
+    <PackageReference Include="NLog" Version="6.2.0" />
     <!-- RGB.NET.Core comes from a local DLL (Build Dependencies/RGB.NET/)
          that carries the CHROMATICS-15 disposed-singleton fix. The
          PackageReference stays so transitive references from the other
@@ -135,7 +135,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.1.3" />
+    <PackageReference Include="Sharlayan" Version="9.2.1" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/Chromatics/Core/RGBController.cs b/Chromatics/Core/RGBController.cs
index 1519d77b..e802dad5 100644
--- a/Chromatics/Core/RGBController.cs
+++ b/Chromatics/Core/RGBController.cs
@@ -1315,14 +1315,23 @@ public static bool LoadDeviceProvider(IRGBDeviceProvider provider, out Exception
                     showErrors = true;
 #endif
 
+                    provider.DevicesChanged += DevicesChanged;
+
+                    var initError = LoadProviderWithDiagnostics(provider);
+
+                    // Subscribed after the load so start-up failures are
+                    // reported once, by the probe, with the provider named.
+                    // This handler covers runtime errors from here on, and
+                    // stays behind the user's preference — a load failure is
+                    // actionable and reports either way.
                     if (showErrors)
                         provider.Exception += deviceExceptionEventHandler;
 
-                    provider.DevicesChanged += DevicesChanged;
-
-                    surface.Load(provider);
                     loadedDeviceProviders.Add(provider);
 
+                    if (initError != null)
+                        loadError ??= initError;
+
                     // Warn the user when a freshly-loaded provider gives us
                     // devices whose hardware/SDK can't accept per-LED writes
                     // (zone-only or single-colour fallback). Effects that
@@ -1421,6 +1430,80 @@ public static bool LoadDeviceProvider(IRGBDeviceProvider provider, out Exception
 
         }
 
+        // Stand-in for surface.Load(provider) that reports what went wrong
+        // instead of swallowing it, without changing which failures are fatal.
+        //
+        // RGB.NET's Load calls Initialize(throwExceptions: false), and its
+        // Throw() only rethrows when that flag is set — otherwise it raises
+        // the Exception event and returns to the caller, which carries on.
+        // A provider whose native SDK is missing or refused to start ends up
+        // reporting success: the HID scan still lists the hardware, so the
+        // devices show up in the Mapping tab and never light. Nothing reaches
+        // the console tab and nothing reaches our caller.
+        //
+        // Initializing with throwExceptions: true lets the probe below decide
+        // per exception. Non-critical ones keep today's behaviour exactly
+        // (logged, provider keeps going); critical ones abort the provider and
+        // are returned to the caller. Either way the exception is caught here,
+        // so one bad provider never stops the others from loading.
+        private static Exception LoadProviderWithDiagnostics(IRGBDeviceProvider provider)
+        {
+            Exception captured = null;
+            var label = provider.GetType().Name;
+
+            void Probe(object sender, ExceptionEventArgs args)
+            {
+                // Only a critical exception means the provider failed. RGB.NET
+                // also raises this event per device from GetLoadedDevices, with
+                // isCritical false, when one device of many fails to add - the
+                // load carries on and the rest attach normally. Treating those
+                // as the verdict reported a working provider as failed and
+                // handed the caller a load error it should not have had.
+                if (args.IsCritical)
+                    captured ??= args.Exception;
+                else
+                    Logger.WriteConsole(Enums.LoggerTypes.Devices,
+                        $"[{label}] a device was skipped: {args.Exception.Message}", forwardToSentry: false);
+
+                args.Throw = args.IsCritical;
+            }
+
+            provider.Exception += Probe;
+            try
+            {
+                if (!provider.IsInitialized)
+                    provider.Initialize(RGBDeviceType.All, throwExceptions: true);
+            }
+            catch (Exception ex)
+            {
+                captured ??= ex;
+            }
+            finally
+            {
+                provider.Exception -= Probe;
+            }
+
+            surface?.Attach(provider.Devices);
+
+            if (captured != null)
+            {
+                Logger.WriteConsole(Enums.LoggerTypes.Error,
+                    $"[{label}] failed to start: {captured.Message}", forwardToSentry: false);
+                LogLogitechSdkHintIfNeeded(captured);
+            }
+            else if (provider.Devices.Count == 0)
+            {
+                // Loaded without complaint and handed us nothing. Benign for
+                // the smart-light providers when the user owns no bulbs, but
+                // for an SDK provider it usually means the vendor software
+                // isn't running, so say so rather than leave a dead toggle.
+                Logger.WriteConsole(Enums.LoggerTypes.Devices,
+                    $"[{label}] loaded but reported no devices.", forwardToSentry: false);
+            }
+
+            return captured;
+        }
+
         // Surface a one-time console warning per provider load when devices
         // can't accept per-LED writes — zone-based or single-colour SDK
         // fallbacks. Effects that depend on per-LED spatial position
diff --git a/Chromatics/Extensions/RGB.NET/Devices/Alienware/AlienwareRGBDeviceProvider.cs b/Chromatics/Extensions/RGB.NET/Devices/Alienware/AlienwareRGBDeviceProvider.cs
index 59d772bc..d914e783 100644
--- a/Chromatics/Extensions/RGB.NET/Devices/Alienware/AlienwareRGBDeviceProvider.cs
+++ b/Chromatics/Extensions/RGB.NET/Devices/Alienware/AlienwareRGBDeviceProvider.cs
@@ -116,8 +116,10 @@ protected override IEnumerable<IRGBDevice> LoadDevices()
                 }
                 catch (Exception ex)
                 {
-                    Logger.WriteConsole(LoggerTypes.Error,
-                        $"[Alienware] failed to set up {def.Product}: {ex.Message}");
+                    bool unreachable = Chromatics.Helpers.NetworkFailureHelper.IsUnreachable(ex);
+                    Logger.WriteConsole(unreachable ? LoggerTypes.Devices : LoggerTypes.Error,
+                        $"[Alienware] failed to set up {def.Product}: {ex.Message}",
+                        forwardToSentry: !unreachable);
                 }
             }
 
diff --git a/Chromatics/Extensions/RGB.NET/Devices/Hue/HueUpdateQueue.cs b/Chromatics/Extensions/RGB.NET/Devices/Hue/HueUpdateQueue.cs
index eac3a2b9..c31ca40e 100644
--- a/Chromatics/Extensions/RGB.NET/Devices/Hue/HueUpdateQueue.cs
+++ b/Chromatics/Extensions/RGB.NET/Devices/Hue/HueUpdateQueue.cs
@@ -392,8 +392,13 @@ private static void LogJsonError(string message)
                 var now = DateTime.UtcNow;
                 if (now - _lastJsonErrorLog < ErrorLogInterval) return;
                 _lastJsonErrorLog = now;
+                // A bridge answering with HTML instead of JSON means the address
+                // now points at something else - a router page, a captive
+                // portal, or a reassigned DHCP lease. That is the user's
+                // network, so it stays out of Sentry (CHROMATICS-1J).
                 Logger.WriteConsole(LoggerTypes.Error,
-                    $"[Hue] JSON Exception (suppressed for {ErrorLogInterval.TotalSeconds:F0}s): {message}");
+                    $"[Hue] JSON Exception (suppressed for {ErrorLogInterval.TotalSeconds:F0}s): {message}",
+                    forwardToSentry: false);
             }
         }
 
diff --git a/Chromatics/Extensions/RGB.NET/Devices/LIFX/LifxRGBDeviceProvider.cs b/Chromatics/Extensions/RGB.NET/Devices/LIFX/LifxRGBDeviceProvider.cs
index 42c43313..91430db3 100644
--- a/Chromatics/Extensions/RGB.NET/Devices/LIFX/LifxRGBDeviceProvider.cs
+++ b/Chromatics/Extensions/RGB.NET/Devices/LIFX/LifxRGBDeviceProvider.cs
@@ -125,7 +125,10 @@ private async Task<IEnumerable<IRGBDevice>> LoadDevicesAsync()
                 }
                 catch (Exception ex)
                 {
-                    Logger.WriteConsole(LoggerTypes.Error, $"[LIFX] failed to set up {def.Label}: {ex.Message}");
+                    bool unreachable = Chromatics.Helpers.NetworkFailureHelper.IsUnreachable(ex);
+                    Logger.WriteConsole(unreachable ? LoggerTypes.Devices : LoggerTypes.Error,
+                        $"[LIFX] failed to set up {def.Label}: {ex.Message}",
+                        forwardToSentry: !unreachable);
                 }
             }
 
@@ -162,7 +165,10 @@ private async Task<Dictionary<string, IPEndPoint>> ResolveEndpointsAsync(IList<L
             }
             catch (Exception ex)
             {
-                Logger.WriteConsole(LoggerTypes.Error, $"[LIFX] discovery sweep failed: {ex.Message}");
+                bool unreachable = Chromatics.Helpers.NetworkFailureHelper.IsUnreachable(ex);
+                Logger.WriteConsole(unreachable ? LoggerTypes.Devices : LoggerTypes.Error,
+                    $"[LIFX] discovery sweep failed: {ex.Message}",
+                    forwardToSentry: !unreachable);
             }
 
             return result;
diff --git a/Chromatics/Extensions/RGB.NET/Devices/Nanoleaf/NanoleafRGBDeviceProvider.cs b/Chromatics/Extensions/RGB.NET/Devices/Nanoleaf/NanoleafRGBDeviceProvider.cs
index 574e5138..fdca8303 100644
--- a/Chromatics/Extensions/RGB.NET/Devices/Nanoleaf/NanoleafRGBDeviceProvider.cs
+++ b/Chromatics/Extensions/RGB.NET/Devices/Nanoleaf/NanoleafRGBDeviceProvider.cs
@@ -108,7 +108,10 @@ private async Task<IEnumerable<IRGBDevice>> LoadDevicesAsync()
                 }
                 catch (Exception ex)
                 {
-                    Logger.WriteConsole(LoggerTypes.Error, $"[Nanoleaf] failed to set up {def.Label}: {ex.Message}");
+                    bool unreachable = Chromatics.Helpers.NetworkFailureHelper.IsUnreachable(ex);
+                    Logger.WriteConsole(unreachable ? LoggerTypes.Devices : LoggerTypes.Error,
+                        $"[Nanoleaf] failed to set up {def.Label}: {ex.Message}",
+                        forwardToSentry: !unreachable);
                 }
             }
 
diff --git a/Chromatics/Extensions/RGB.NET/Devices/Yeelight/YeelightRGBDeviceProvider.cs b/Chromatics/Extensions/RGB.NET/Devices/Yeelight/YeelightRGBDeviceProvider.cs
index c0249e21..b59ac3a2 100644
--- a/Chromatics/Extensions/RGB.NET/Devices/Yeelight/YeelightRGBDeviceProvider.cs
+++ b/Chromatics/Extensions/RGB.NET/Devices/Yeelight/YeelightRGBDeviceProvider.cs
@@ -129,8 +129,10 @@ private async Task<IEnumerable<IRGBDevice>> LoadDevicesAsync()
                 }
                 catch (Exception ex)
                 {
-                    Logger.WriteConsole(LoggerTypes.Error,
-                        $"[Yeelight] failed to set up {def.Label}: {ex.Message}");
+                    bool unreachable = Chromatics.Helpers.NetworkFailureHelper.IsUnreachable(ex);
+                    Logger.WriteConsole(unreachable ? LoggerTypes.Devices : LoggerTypes.Error,
+                        $"[Yeelight] failed to set up {def.Label}: {ex.Message}",
+                        forwardToSentry: !unreachable);
                 }
             }
 
@@ -154,7 +156,10 @@ private async Task<Dictionary<string, IPEndPoint>> ResolveEndpointsAsync(IList<Y
             }
             catch (Exception ex)
             {
-                Logger.WriteConsole(LoggerTypes.Error, $"[Yeelight] discovery sweep failed: {ex.Message}");
+                bool unreachable = Chromatics.Helpers.NetworkFailureHelper.IsUnreachable(ex);
+                Logger.WriteConsole(unreachable ? LoggerTypes.Devices : LoggerTypes.Error,
+                    $"[Yeelight] discovery sweep failed: {ex.Message}",
+                    forwardToSentry: !unreachable);
             }
             return result;
         }
diff --git a/Chromatics/Helpers/AssemblyLoadGuard.cs b/Chromatics/Helpers/AssemblyLoadGuard.cs
index 6c15d9be..f600d5bc 100644
--- a/Chromatics/Helpers/AssemblyLoadGuard.cs
+++ b/Chromatics/Helpers/AssemblyLoadGuard.cs
@@ -22,23 +22,63 @@ public static bool TryRun(string label, Action action)
                 action();
                 return true;
             }
-            catch (Exception ex) when (ex is System.IO.FileLoadException or System.IO.FileNotFoundException
-                or BadImageFormatException or TypeInitializationException or TypeLoadException)
+            catch (Exception ex)
             {
-                var inner = ex is TypeInitializationException { InnerException: not null } tie ? tie.InnerException : ex;
-                bool appControl = inner.HResult == unchecked((int)0x800711C7)
-                    || (inner.Message?.Contains("Application Control", StringComparison.OrdinalIgnoreCase) ?? false);
-
-                Core.Logger.WriteConsole(Enums.LoggerTypes.Error, appControl
-                    ? $"[{label}] Windows App Control blocked a library this feature needs: {inner.Message} To use it, allow Chromatics in Windows Security (App & browser control -> Smart App Control) and restart."
-                    : $"[{label}] A library failed to load: {inner.Message}");
+                if (!TryReportLoadFailure(label, ex))
+                    Core.Logger.WriteConsole(Enums.LoggerTypes.Error, $"[{label}] Error: {ex.Message}");
                 return false;
             }
-            catch (Exception ex)
+        }
+
+        /// <summary>
+        /// Reports <paramref name="ex"/> if it is an assembly-load failure and
+        /// returns true, or returns false and stays silent if it is anything
+        /// else. Callers that catch faults from code they could not route
+        /// through <see cref="TryRun"/> - the toggle handlers, for instance -
+        /// use this to give the same App Control guidance rather than dumping
+        /// a raw loader message on the user.
+        /// </summary>
+        public static bool TryReportLoadFailure(string label, Exception ex)
+        {
+            var loadFailure = FindLoadFailure(ex);
+            if (loadFailure == null) return false;
+
+            bool appControl = loadFailure.HResult == unchecked((int)0x800711C7)
+                || (loadFailure.Message?.Contains("Application Control", StringComparison.OrdinalIgnoreCase) ?? false);
+
+            // An App Control block is the machine's policy doing its job, not a
+            // fault in Chromatics, so the user hears about it but Sentry
+            // doesn't. A load failure with any other cause could be a packaging
+            // mistake and still reports.
+            Core.Logger.WriteConsole(Enums.LoggerTypes.Error, appControl
+                ? $"[{label}] Windows App Control blocked a library this feature needs: {loadFailure.Message} To use it, allow Chromatics in Windows Security (App & browser control -> Smart App Control) and restart."
+                : $"[{label}] A library failed to load: {loadFailure.Message}",
+                forwardToSentry: !appControl);
+            return true;
+        }
+
+        // Walks the chain because the fault reaches some callers wrapped - a
+        // TargetInvocationException from an event handler, or the
+        // AggregateException an unobserved task carries.
+        private static Exception FindLoadFailure(Exception ex)
+        {
+            for (var current = ex; current != null; current = current.InnerException)
             {
-                Core.Logger.WriteConsole(Enums.LoggerTypes.Error, $"[{label}] Error: {ex.Message}");
-                return false;
+                if (current is System.IO.FileLoadException or System.IO.FileNotFoundException
+                    or BadImageFormatException or TypeLoadException)
+                    return current;
+
+                if (current is AggregateException aggregate)
+                {
+                    foreach (var candidate in aggregate.InnerExceptions)
+                    {
+                        var found = FindLoadFailure(candidate);
+                        if (found != null) return found;
+                    }
+                }
             }
+
+            return null;
         }
     }
 }
diff --git a/Chromatics/Helpers/NetworkFailureHelper.cs b/Chromatics/Helpers/NetworkFailureHelper.cs
new file mode 100644
index 00000000..9c81951d
--- /dev/null
+++ b/Chromatics/Helpers/NetworkFailureHelper.cs
@@ -0,0 +1,42 @@
+using System;
+using System.IO;
+using System.Net.Http;
+using System.Net.Sockets;
+
+namespace Chromatics.Helpers
+{
+    public static class NetworkFailureHelper
+    {
+        /// <summary>
+        /// True when an exception describes a network device that could not be
+        /// reached, rather than a fault in Chromatics. Callers log these for the
+        /// user but keep them out of Sentry, where a bulb switched off at the
+        /// wall would otherwise read as an application error.
+        /// </summary>
+        public static bool IsUnreachable(Exception ex)
+        {
+            for (var current = ex; current != null; current = current.InnerException)
+            {
+                switch (current)
+                {
+                    case SocketException:
+                    case TimeoutException:
+                    case HttpRequestException:
+                    case IOException:
+                    case OperationCanceledException:
+                        return true;
+                }
+
+                if (current is AggregateException aggregate)
+                {
+                    foreach (var inner in aggregate.InnerExceptions)
+                    {
+                        if (IsUnreachable(inner)) return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+    }
+}
diff --git a/Chromatics/Helpers/VersionHelper.cs b/Chromatics/Helpers/VersionHelper.cs
new file mode 100644
index 00000000..081dceb9
--- /dev/null
+++ b/Chromatics/Helpers/VersionHelper.cs
@@ -0,0 +1,25 @@
+using System.Reflection;
+
+namespace Chromatics.Helpers
+{
+    public static class VersionHelper
+    {
+        /// <summary>
+        /// The version as users see it, in the window title and the console tab.
+        /// Stops at the patch because the assembly version's fourth segment is a
+        /// legacy .NET slot that publish.py strips before a release advertises
+        /// itself, so showing it would name a version nobody can download.
+        /// </summary>
+        public static string DisplayVersion
+        {
+            get
+            {
+                var version = typeof(VersionHelper).Assembly.GetName().Version;
+                if (version == null) return "(unknown version)";
+
+                var betaSuffix = UpdateService.IsBetaChannel() ? " [BETA]" : string.Empty;
+                return $"{version.Major}.{version.Minor}.{version.Build}{betaSuffix}";
+            }
+        }
+    }
+}
diff --git a/Chromatics/Layers/BaseLayers/ScreenCapture.cs b/Chromatics/Layers/BaseLayers/ScreenCapture.cs
index d4dd3047..6665b68f 100644
--- a/Chromatics/Layers/BaseLayers/ScreenCapture.cs
+++ b/Chromatics/Layers/BaseLayers/ScreenCapture.cs
@@ -16,15 +16,34 @@ namespace Chromatics.Layers
 {
     public class ScreenCaptureProcessor : LayerProcessor
     {
-        private static readonly ScreenCaptureProcessor _instance = new();
+        private static ScreenCaptureProcessor _instance;
         private static ScreenCaptureExtension _screenCapture;
 
         private ScreenCaptureProcessor() { }
 
-        public static ScreenCaptureProcessor Instance => _instance;
+        // Rebuilt on demand rather than held in a readonly field: DisposeAll
+        // runs every time the player returns to the title screen and nulls
+        // the cached surface, so the processor has to be replaceable or every
+        // later tick attaches its group to a dead surface.
+        public static ScreenCaptureProcessor Instance
+        {
+            get
+            {
+                if (_instance == null)
+                {
+                    _instance = new ScreenCaptureProcessor();
+                }
+                return _instance;
+            }
+        }
 
         public override void Process(IMappingLayer layer)
         {
+            // Read once: Dispose runs from the UI thread at app exit and nulls
+            // the field mid-tick, so a second read here would attach to null.
+            var activeSurface = surface;
+            if (activeSurface == null) return;
+
             if (RGBController.IsBaseLayerEffectRunning()) return;
 
             var _layergroups = RGBController.GetLiveLayerGroups();
@@ -38,7 +57,7 @@ public override void Process(IMappingLayer layer)
             }
             else
             {
-                layergroup = new ListLedGroup(surface, ledArray) { ZIndex = layer.zindex };
+                layergroup = new ListLedGroup(activeSurface, ledArray) { ZIndex = layer.zindex };
                 _layergroups[layer.layerID] = new[] { layergroup };
                 layergroup.Detach();
             }
@@ -58,7 +77,7 @@ public override void Process(IMappingLayer layer)
                     : new SolidColorBrush(ColorHelper.ColorToRGBColor(System.Drawing.Color.Black));
             }
 
-            layergroup.Attach(surface);
+            layergroup.Attach(activeSurface);
             _init = true;
             layer.requestUpdate = false;
         }
@@ -109,6 +128,7 @@ protected override void Dispose(bool disposing)
                 _screenCapture = null;
             }
             base.Dispose(disposing);
+            _instance = null;
         }
     }
 }
diff --git a/Chromatics/ViewModels/DeviceToggleItem.cs b/Chromatics/ViewModels/DeviceToggleItem.cs
index a339f3d2..d048dd3f 100644
--- a/Chromatics/ViewModels/DeviceToggleItem.cs
+++ b/Chromatics/ViewModels/DeviceToggleItem.cs
@@ -71,34 +71,57 @@ private void OnLocaleVersionChanged(object sender, PropertyChangedEventArgs e)
 
         private async Task SetIsEnabledAsync(bool value)
         {
-            if (value)
+            try
             {
-                var accepted = await _enableAsync();
-                _suspendCommit = true;
-                try
+                if (value)
+                    Commit(await _enableAsync());
+                else
                 {
-                    _isEnabled = accepted;
-                    OnPropertyChanged(nameof(IsEnabled));
-                }
-                finally
-                {
-                    _suspendCommit = false;
+                    _disable();
+                    Commit(false);
                 }
             }
-            else
+            catch (Exception ex)
             {
-                _disable();
-                _suspendCommit = true;
-                try
-                {
-                    _isEnabled = false;
-                    OnPropertyChanged(nameof(IsEnabled));
-                }
-                finally
+                // The property setter starts this task and never awaits it, so
+                // anything escaping here becomes an UnobservedTaskException the
+                // finalizer rethrows as a crash (CHROMATICS-1G, a vendor DLL
+                // blocked by App Control). Report it and put the toggle back
+                // where the user found it.
+                //
+                // Reported here rather than in each provider's delegate: only
+                // the MakeDeviceToggle providers route through the guard, so
+                // the hand-built toggles (Logitech, OpenRGB, Hue, LIFX and the
+                // rest) would otherwise show a raw loader message instead of
+                // the App Control guidance.
+                if (!Helpers.AssemblyLoadGuard.TryReportLoadFailure(Label, ex))
+                    Core.Logger.WriteConsole(Enums.LoggerTypes.Error,
+                        $"[{Label}] could not be turned {(value ? "on" : "off")}: {ex.Message}");
+
+                // Guarded: a subscriber throwing on the property-changed
+                // notification would escape this catch and land right back in
+                // the unobserved-task crash the method exists to prevent.
+                try { Commit(!value); }
+                catch (Exception commitEx)
                 {
-                    _suspendCommit = false;
+                    Core.Logger.WriteConsole(Enums.LoggerTypes.Error,
+                        $"[{Label}] could not be restored to its previous state: {commitEx.Message}");
                 }
             }
         }
+
+        private void Commit(bool state)
+        {
+            _suspendCommit = true;
+            try
+            {
+                _isEnabled = state;
+                OnPropertyChanged(nameof(IsEnabled));
+            }
+            finally
+            {
+                _suspendCommit = false;
+            }
+        }
     }
 }
diff --git a/Chromatics/ViewModels/MainWindowViewModel.cs b/Chromatics/ViewModels/MainWindowViewModel.cs
index 1a0899b1..5869adef 100644
--- a/Chromatics/ViewModels/MainWindowViewModel.cs
+++ b/Chromatics/ViewModels/MainWindowViewModel.cs
@@ -39,12 +39,7 @@ public MainWindowViewModel()
             // LoadMappings has populated _layers — that would create default layers
             // for every device on every launch, overwriting any user customisation.
 
-            var version = typeof(MainWindowViewModel).Assembly.GetName().Version;
-            if (version != null)
-            {
-                var betaSuffix = UpdateService.IsBetaChannel() ? " [BETA]" : string.Empty;
-                Title = $"Chromatics {version.Major}.{version.Minor}.{version.Build}{betaSuffix}";
-            }
+            Title = $"Chromatics {Helpers.VersionHelper.DisplayVersion}";
 
             _isLightTheme = Avalonia.Application.Current?.ActualThemeVariant
                             != Avalonia.Styling.ThemeVariant.Dark;
diff --git a/Chromatics/ViewModels/SettingsViewModel.cs b/Chromatics/ViewModels/SettingsViewModel.cs
index c4c5801e..6a32fd98 100644
--- a/Chromatics/ViewModels/SettingsViewModel.cs
+++ b/Chromatics/ViewModels/SettingsViewModel.cs
@@ -994,13 +994,20 @@ private static DeviceToggleItem MakeDeviceToggle(
                     // out from the device list.
                     await ShowDynamicLightingOverlapPopupIfNeededAsync(label).ConfigureAwait(true);
 
-                    load();
+                    // The load/unload delegates reference vendor SDK types, so
+                    // they carry the assembly load that App Control can block.
+                    // Running them through the guard keeps the fault inside the
+                    // lambda where it can be caught, and a blocked provider
+                    // leaves the toggle off rather than saving as enabled.
+                    if (!Helpers.AssemblyLoadGuard.TryRun(label, load))
+                        return false;
+
                     saveFlag(true);
                     return true;
                 },
                 () =>
                 {
-                    unload();
+                    Helpers.AssemblyLoadGuard.TryRun(label, unload);
                     saveFlag(false);
                 });
         }
diff --git a/Chromatics/Views/Dialogs/FirstRunDialog.axaml.cs b/Chromatics/Views/Dialogs/FirstRunDialog.axaml.cs
index 37bbbfa4..69b39ebd 100644
--- a/Chromatics/Views/Dialogs/FirstRunDialog.axaml.cs
+++ b/Chromatics/Views/Dialogs/FirstRunDialog.axaml.cs
@@ -278,11 +278,34 @@ private async void OnContinue(object? sender, RoutedEventArgs e)
             // just produce zero devices), so this probe is Logitech-only.
             if (TileLogitech.IsChecked == true)
             {
-                RGBController.LoadDeviceProvider(LogitechDeviceProvider.Instance, out var loadError);
+                // The provider reference has to sit inside the lambda. A vendor
+                // type named in this method's own body resolves while OnContinue
+                // is being JIT-compiled, which is before any try here exists, so
+                // App Control blocking RGB.NET.Core took the whole handler down
+                // instead of the probe (CHROMATICS-1N).
+                Exception? loadError = null;
+                bool probeRan = Helpers.AssemblyLoadGuard.TryRun("Logitech", () =>
+                {
+                    RGBController.LoadDeviceProvider(LogitechDeviceProvider.Instance, out var probeError);
+                    loadError = probeError;
+                });
+
+                // The guard swallowing the fault leaves loadError null, so
+                // without this the wizard would save Logitech as enabled for a
+                // provider whose library never loaded - the exact outcome this
+                // probe exists to prevent. The guard has already told the user
+                // what happened, so just untick and carry on.
+                if (!probeRan)
+                {
+                    TileLogitech.IsChecked = false;
+                    UpdateContinueState();
+                }
+
                 if (loadError != null
                     && loadError.Message.Contains("Failed to initialize Logitech-SDK", StringComparison.OrdinalIgnoreCase))
                 {
-                    try { RGBController.UnloadDeviceProvider(LogitechDeviceProvider.Instance); } catch { /* best-effort */ }
+                    Helpers.AssemblyLoadGuard.TryRun("Logitech",
+                        () => RGBController.UnloadDeviceProvider(LogitechDeviceProvider.Instance));
                     TileLogitech.IsChecked = false;
                     UpdateContinueState();
                     await Views.Dialogs.DialogService.ShowAsync(
diff --git a/Chromatics/Views/MainWindow.axaml.cs b/Chromatics/Views/MainWindow.axaml.cs
index 51f6bf21..b72e4467 100644
--- a/Chromatics/Views/MainWindow.axaml.cs
+++ b/Chromatics/Views/MainWindow.axaml.cs
@@ -242,7 +242,9 @@ private async void OnOpened(object sender, EventArgs e)
             // SetWindowsHookEx path touches Process.MainModule, which blocks
             // for hundreds of ms to seconds on Windows while the OS resolves
             // the loaded-module list, freezing the UI and tab switching.
-            Logger.WriteConsole(LoggerTypes.System, "Chromatics is starting up..");
+            // Version in the first console line so a user pasting their log
+            // tells us which build they're on without being asked.
+            Logger.WriteConsole(LoggerTypes.System, $"Chromatics {VersionHelper.DisplayVersion} is starting up..");
 
             await Task.Run(() =>
             {