@@ -28,25 +28,11 @@ public static class SuspensionHostExtensions
     /// surface it without CA1859 demanding the concrete singleton type leak into their signatures.</summary>
     private static readonly IObservable<RxVoid> _completed = ImmutableReturnRxVoidSignal.Instance;
 
-    /// <summary>Func used to load app state exactly once. Backing field for testing purposes.</summary>
-    private static Func<IObservable<RxVoid>>? _ensureLoadAppStateFunc;
-
-    /// <summary>Suspension driver reference field. Backing field for testing purposes.</summary>
-    private static ISuspensionDriver? _suspensionDriver;
-
-    /// <summary>Gets or sets the ensure load app state function. Internal for testing purposes only.</summary>
-    internal static Func<IObservable<RxVoid>>? EnsureLoadAppStateFunc
-    {
-        get => Volatile.Read(ref _ensureLoadAppStateFunc);
-        set => Volatile.Write(ref _ensureLoadAppStateFunc, value);
-    }
-
-    /// <summary>Gets or sets the suspension driver. Internal for testing purposes only.</summary>
-    internal static ISuspensionDriver? SuspensionDriver
-    {
-        get => _suspensionDriver;
-        set => _suspensionDriver = value;
-    }
+    /// <summary>
+    /// The pending one-time app-state load of each host, keyed by host so that every host loads through the driver it
+    /// was set up with. The table holds its keys weakly, so it does not keep a host alive.
+    /// </summary>
+    private static readonly ConditionalWeakTable<ISuspensionHost, PendingLoad> _pendingLoads = new();
 
     /// <summary>Provides app-state access and suspend/resume setup extension members for <see cref="ISuspensionHost"/>.</summary>
     /// <param name="item">The suspension host.</param>
@@ -73,7 +59,7 @@ public T GetAppState<T>()
         {
             ArgumentExceptionHelper.ThrowIfNull(item);
 
-            Interlocked.Exchange(ref _ensureLoadAppStateFunc, null)?.Invoke();
+            RunPendingLoad(item);
 
             return (T)item.AppState!;
         }
@@ -148,18 +134,18 @@ public IDisposable SetupDefaultSuspendResume(ISuspensionDriver? driver)
         {
             ArgumentExceptionHelper.ThrowIfNull(item);
 
-            MultipleDisposable ret = [];
-            _suspensionDriver ??= driver ?? AppLocator.Current.GetService<ISuspensionDriver>();
+            var resolvedDriver = driver ?? AppLocator.Current.GetService<ISuspensionDriver>();
 
-            if (_suspensionDriver is null)
+            if (resolvedDriver is null)
             {
                 item.Log().Error("Could not find a valid driver and therefore cannot setup Suspend/Resume.");
                 return EmptyDisposable.Instance;
             }
 
-            _ensureLoadAppStateFunc = () => EnsureLoadAppState(item, _suspensionDriver);
+            var pendingLoad = _pendingLoads.GetValue(item, static _ => new PendingLoad());
+            pendingLoad.Arm(() => EnsureLoadAppState(item, resolvedDriver));
 
-            var resolvedDriver = _suspensionDriver!;
+            MultipleDisposable ret = [];
             ret.Add(item.ShouldInvalidateState.Subscribe(new DriverOperationObserver<RxVoid>(
                 item,
                 _ => resolvedDriver.InvalidateState(),
@@ -173,15 +159,15 @@ public IDisposable SetupDefaultSuspendResume(ISuspensionDriver? driver)
                 {
                     // Materialize app state (one-time load) before saving, so a shutdown that races ahead of
                     // the resume/launch load still persists real state rather than null (see #4353).
-                    RunPendingLoad();
+                    pendingLoad.Run();
                     return resolvedDriver.SaveState(item.AppState!);
                 },
                 static token => token.Dispose(),
                 "Persisted application state",
                 "Tried to persist app state")));
 
-            ret.Add(item.IsResuming.Subscribe(new DelegateObserver<RxVoid>(static _ => RunPendingLoad())));
-            ret.Add(item.IsLaunchingNew.Subscribe(new DelegateObserver<RxVoid>(static _ => RunPendingLoad())));
+            ret.Add(item.IsResuming.Subscribe(new DelegateObserver<RxVoid>(_ => pendingLoad.Run())));
+            ret.Add(item.IsLaunchingNew.Subscribe(new DelegateObserver<RxVoid>(_ => pendingLoad.Run())));
 
             return ret;
         }
@@ -203,7 +189,7 @@ public TAppState GetAppState()
         {
             ArgumentExceptionHelper.ThrowIfNull(item);
 
-            Interlocked.Exchange(ref _ensureLoadAppStateFunc, null)?.Invoke();
+            RunPendingLoad(item);
 
             return item.AppStateValue!;
         }
@@ -243,18 +229,18 @@ public IDisposable SetupDefaultSuspendResume(
             ArgumentExceptionHelper.ThrowIfNull(item);
             ArgumentExceptionHelper.ThrowIfNull(typeInfo);
 
-            MultipleDisposable ret = [];
-            _suspensionDriver ??= driver ?? AppLocator.Current.GetService<ISuspensionDriver>();
+            var resolvedDriver = driver ?? AppLocator.Current.GetService<ISuspensionDriver>();
 
-            if (_suspensionDriver is null)
+            if (resolvedDriver is null)
             {
                 item.Log().Error("Could not find a valid driver and therefore cannot setup Suspend/Resume.");
                 return EmptyDisposable.Instance;
             }
 
-            _ensureLoadAppStateFunc = () => EnsureLoadAppState(item, _suspensionDriver, typeInfo);
+            var pendingLoad = _pendingLoads.GetValue(item, static _ => new PendingLoad());
+            pendingLoad.Arm(() => EnsureLoadAppState(item, resolvedDriver, typeInfo));
 
-            var resolvedDriver = _suspensionDriver!;
+            MultipleDisposable ret = [];
             ret.Add(item.ShouldInvalidateState.Subscribe(new DriverOperationObserver<RxVoid>(
                 item,
                 _ => resolvedDriver.InvalidateState(),
@@ -268,15 +254,15 @@ public IDisposable SetupDefaultSuspendResume(
                 {
                     // Materialize app state (one-time load) before saving, so a shutdown that races ahead of
                     // the resume/launch load still persists real state rather than null (see #4353).
-                    RunPendingLoad();
+                    pendingLoad.Run();
                     return resolvedDriver.SaveState(item.AppStateValue!, typeInfo);
                 },
                 static token => token.Dispose(),
                 "Persisted application state",
                 "Tried to persist app state")));
 
-            ret.Add(item.IsResuming.Subscribe(new DelegateObserver<RxVoid>(static _ => RunPendingLoad())));
-            ret.Add(item.IsLaunchingNew.Subscribe(new DelegateObserver<RxVoid>(static _ => RunPendingLoad())));
+            ret.Add(item.IsResuming.Subscribe(new DelegateObserver<RxVoid>(_ => pendingLoad.Run())));
+            ret.Add(item.IsLaunchingNew.Subscribe(new DelegateObserver<RxVoid>(_ => pendingLoad.Run())));
 
             return ret;
         }
@@ -292,25 +278,17 @@ public IDisposable SetupDefaultSuspendResume(
     [RequiresDynamicCode(
         "This overload may invoke ISuspensionDriver.LoadState(), which is commonly reflection-based. "
         + "Prefer EnsureLoadAppState<TAppState>(ISuspensionHost<TAppState>, ISuspensionDriver?, JsonTypeInfo<TAppState>) for trimming/AOT scenarios.")]
-    private static IObservable<RxVoid> EnsureLoadAppState(ISuspensionHost item, ISuspensionDriver? driver = null)
+    private static IObservable<RxVoid> EnsureLoadAppState(ISuspensionHost item, ISuspensionDriver driver)
     {
         if (item.AppState is not null)
         {
             return _completed;
         }
 
-        _suspensionDriver ??= driver ?? AppLocator.Current.GetService<ISuspensionDriver>();
-
-        if (_suspensionDriver is null)
-        {
-            item.Log().Error("Could not find a valid driver and therefore cannot load app state.");
-            return _completed;
-        }
-
         try
         {
             // Fall back to a freshly created state when the driver yields no persisted state (see #4349).
-            item.AppState = WaitForResult(_suspensionDriver.LoadState()) ?? item.CreateNewAppState?.Invoke();
+            item.AppState = WaitForResult(driver.LoadState()) ?? item.CreateNewAppState?.Invoke();
         }
         catch (Exception ex)
         {
@@ -329,7 +307,7 @@ private static IObservable<RxVoid> EnsureLoadAppState(ISuspensionHost item, ISus
     /// <returns>A completed observable.</returns>
     private static IObservable<RxVoid> EnsureLoadAppState<TAppState>(
         ISuspensionHost<TAppState> item,
-        ISuspensionDriver? driver,
+        ISuspensionDriver driver,
         JsonTypeInfo<TAppState> typeInfo)
         where TAppState : class
     {
@@ -338,18 +316,10 @@ private static IObservable<RxVoid> EnsureLoadAppState<TAppState>(
             return _completed;
         }
 
-        _suspensionDriver ??= driver ?? AppLocator.Current.GetService<ISuspensionDriver>();
-
-        if (_suspensionDriver is null)
-        {
-            item.Log().Error("Could not find a valid driver and therefore cannot load app state.");
-            return _completed;
-        }
-
         try
         {
             // Fall back to a freshly created state when the driver yields no persisted state (see #4349).
-            item.AppStateValue = WaitForResult(_suspensionDriver.LoadState(typeInfo)) ?? item.CreateNewAppStateTyped?.Invoke();
+            item.AppStateValue = WaitForResult(driver.LoadState(typeInfo)) ?? item.CreateNewAppStateTyped?.Invoke();
         }
         catch (Exception ex)
         {
@@ -360,9 +330,17 @@ private static IObservable<RxVoid> EnsureLoadAppState<TAppState>(
         return _completed;
     }
 
-    /// <summary>Runs the pending one-time app-state load exactly once, if one is registered.</summary>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void RunPendingLoad() => Interlocked.Exchange(ref _ensureLoadAppStateFunc, null)?.Invoke();
+    /// <summary>Runs the host's pending one-time app-state load exactly once, if one is registered.</summary>
+    /// <param name="item">The suspension host.</param>
+    private static void RunPendingLoad(ISuspensionHost item)
+    {
+        if (!_pendingLoads.TryGetValue(item, out var pendingLoad))
+        {
+            return;
+        }
+
+        pendingLoad.Run();
+    }
 
     /// <summary>Subscribes to a single-value observable and blocks until it terminates, returning its last value.</summary>
     /// <typeparam name="T">The value type.</typeparam>
@@ -552,6 +530,22 @@ private void Finish()
         }
     }
 
+    /// <summary>Holds one host's pending one-time app-state load, bound to the driver that host was set up with.</summary>
+    private sealed class PendingLoad
+    {
+        /// <summary>The load to run, or <see langword="null"/> once it has run or before any setup.</summary>
+        private Func<IObservable<RxVoid>>? _load;
+
+        /// <summary>Registers the load to run, replacing any load that has not run yet.</summary>
+        /// <param name="load">The load to run.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Arm(Func<IObservable<RxVoid>> load) => Volatile.Write(ref _load, load);
+
+        /// <summary>Runs the registered load exactly once; later calls do nothing until the next <see cref="Arm"/>.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Run() => Interlocked.Exchange(ref _load, null)?.Invoke();
+    }
+
     /// <summary>Captures the last value (or terminal error) of a blocking subscription and signals on termination.</summary>
     /// <typeparam name="T">The value type.</typeparam>
     /// <param name="signal">Set when the source terminates.</param>
 
@@ -5,60 +5,11 @@
 
 using ReactiveUI.Tests.Utilities.AppBuilder;
 
-#if REACTIVE_SHIM
-using ISuspensionDriverContract = ReactiveUI.Reactive.ISuspensionDriver;
-#else
-using ISuspensionDriverContract = ReactiveUI.ISuspensionDriver;
-#endif
-
 namespace ReactiveUI.Tests.Utilities.SuspensionHost;
 
-/// <summary>
-/// Test executor that manages SuspensionHostExtensions static state for test isolation.
-/// Saves and restores static fields before and after each test to prevent state leakage.
-/// </summary>
+/// <summary>Test executor for SuspensionHostExtensions tests.</summary>
 /// <remarks>
-/// This executor manages:
-/// - SuspensionHostExtensions.EnsureLoadAppStateFunc
-/// - SuspensionHostExtensions.SuspensionDriver
-/// Tests using this executor should be marked with [NotInParallel] due to static state modifications.
+/// SuspensionHostExtensions keeps its suspend/resume state per host, so each test isolates itself by creating its own
+/// host. This executor only adds the AppBuilder isolation that the tests need for the service locator and logging.
 /// </remarks>
-public class SuspensionHostTestExecutor : AppBuilderTestExecutor
-{
-    /// <summary>The load-app-state func captured before the test, restored during cleanup.</summary>
-    private Func<IObservable<RxVoid>>? _previousEnsureLoadAppStateFunc;
-
-    /// <summary>The suspension driver captured before the test, restored during cleanup.</summary>
-    private ISuspensionDriverContract? _previousSuspensionDriver;
-
-    /// <inheritdoc/>
-    public override async ValueTask ExecuteTest(TestContext context, Func<ValueTask> action)
-    {
-        ArgumentNullException.ThrowIfNull(action);
-
-        SaveStaticState();
-
-        try
-        {
-            await base.ExecuteTest(context, action);
-        }
-        finally
-        {
-            RestoreStaticState();
-        }
-    }
-
-    /// <summary>Saves the current static state from SuspensionHostExtensions.</summary>
-    protected virtual void SaveStaticState()
-    {
-        _previousEnsureLoadAppStateFunc = SuspensionHostExtensions.EnsureLoadAppStateFunc;
-        _previousSuspensionDriver = SuspensionHostExtensions.SuspensionDriver;
-    }
-
-    /// <summary>Restores the previously saved static state to SuspensionHostExtensions.</summary>
-    protected virtual void RestoreStaticState()
-    {
-        SuspensionHostExtensions.EnsureLoadAppStateFunc = _previousEnsureLoadAppStateFunc;
-        SuspensionHostExtensions.SuspensionDriver = _previousSuspensionDriver;
-    }
-}
+public class SuspensionHostTestExecutor : AppBuilderTestExecutor;
@@ -231,10 +231,10 @@ public async Task EnsureLoadAppState_Typed_WithNullCreateNewAppState_SetsStateTo
         await Assert.That((object?)state).IsNull();
     }
 
-    /// <summary>Verifies the typed EnsureLoadAppState logs an error and leaves state null when the driver becomes null.</summary>
+    /// <summary>Verifies the typed EnsureLoadAppState still loads through the setup driver after the locator loses its drivers.</summary>
     /// <returns>A <see cref="Task" /> representing the asynchronous operation.</returns>
     [Test]
-    public async Task EnsureLoadAppState_Typed_DriverBecomesNull_LogsErrorAndStateRemainsNull()
+    public async Task EnsureLoadAppState_Typed_LocatorDriversRemovedAfterSetup_LoadsThroughSetupDriver()
     {
         using var host = new SuspensionHost<TestAppState>
         {
@@ -253,11 +253,10 @@ public async Task EnsureLoadAppState_Typed_DriverBecomesNull_LogsErrorAndStateRe
         Splat.Locator.CurrentMutable.UnregisterAll<ISuspensionDriver>();
         try
         {
-            SuspensionHostExtensions.SuspensionDriver = null;
-
             var state = host.GetAppState();
 
-            await Assert.That((object?)state).IsNull();
+            await Assert.That(state).IsSameReferenceAs(driver.StateToLoad);
+            await Assert.That(driver.LoadStateCallCount).IsEqualTo(1);
         }
         finally
         {
 
@@ -372,6 +372,49 @@ TestAppState CreateNewAppState()
         await Assert.That(driver.LastSavedState).IsSameReferenceAs(createdState);
     }
 
+    /// <summary>Verifies that two typed hosts set up with different drivers each load and save through their own driver.</summary>
+    /// <returns>A <see cref="Task" /> representing the asynchronous operation.</returns>
+    [Test]
+    public async Task SetupDefaultSuspendResume_Typed_TwoHostsWithDifferentDrivers_EachHostUsesItsOwnDriver()
+    {
+        var firstPersist = new Signal<IDisposable>();
+        using var firstHost = new SuspensionHost<TestAppState>
+        {
+            IsLaunchingNew = Signal.Silent<RxVoid>(),
+            IsResuming = Signal.Silent<RxVoid>(),
+            ShouldInvalidateState = Signal.Silent<RxVoid>(),
+            ShouldPersistState = firstPersist.ObserveOn(Sequencer.Immediate),
+        };
+        var secondPersist = new Signal<IDisposable>();
+        using var secondHost = new SuspensionHost<TestAppState>
+        {
+            IsLaunchingNew = Signal.Silent<RxVoid>(),
+            IsResuming = Signal.Silent<RxVoid>(),
+            ShouldInvalidateState = Signal.Silent<RxVoid>(),
+            ShouldPersistState = secondPersist.ObserveOn(Sequencer.Immediate),
+        };
+
+        var firstDriver = new TestSuspensionDriver<TestAppState> { StateToLoad = new() { Value = SampleStateValue } };
+        var secondDriver = new TestSuspensionDriver<TestAppState> { StateToLoad = new() { Value = LoadedStateValue } };
+
+        using var firstSetup = firstHost.SetupDefaultSuspendResume(TestAppStateContext.Default.TestAppState, firstDriver);
+        using var secondSetup = secondHost.SetupDefaultSuspendResume(TestAppStateContext.Default.TestAppState, secondDriver);
+
+        var firstState = firstHost.GetAppState();
+        var secondState = secondHost.GetAppState();
+        firstPersist.OnNext(Scope.Empty);
+        secondPersist.OnNext(Scope.Empty);
+
+        await Assert.That(firstState).IsSameReferenceAs(firstDriver.StateToLoad);
+        await Assert.That(secondState).IsSameReferenceAs(secondDriver.StateToLoad);
+        await Assert.That(firstDriver.LoadStateCallCount).IsEqualTo(1);
+        await Assert.That(secondDriver.LoadStateCallCount).IsEqualTo(1);
+        await Assert.That(firstDriver.SaveStateCallCount).IsEqualTo(1);
+        await Assert.That(secondDriver.SaveStateCallCount).IsEqualTo(1);
+        await Assert.That(firstDriver.LastSavedState).IsSameReferenceAs(firstDriver.StateToLoad);
+        await Assert.That(secondDriver.LastSavedState).IsSameReferenceAs(secondDriver.StateToLoad);
+    }
+
     /// <summary>A simple application state used by the typed suspension host tests.</summary>
     private sealed class TestAppState
     {
Original file line number	Diff line number	Diff line change
`@@ -231,10 +231,10 @@ public async Task EnsureLoadAppState_Typed_WithNullCreateNewAppState_SetsStateTo`
`231`	`231`	`await Assert.That((object?)state).IsNull();`
`232`	`232`	`}`
`233`	`233`
`234`		`- /// <summary>Verifies the typed EnsureLoadAppState logs an error and leaves state null when the driver becomes null.</summary>`
	`234`	`+ /// <summary>Verifies the typed EnsureLoadAppState still loads through the setup driver after the locator loses its drivers.</summary>`
`235`	`235`	`/// <returns>A <see cref="Task" /> representing the asynchronous operation.</returns>`
`236`	`236`	`[Test]`
`237`		`- public async Task EnsureLoadAppState_Typed_DriverBecomesNull_LogsErrorAndStateRemainsNull()`
	`237`	`+ public async Task EnsureLoadAppState_Typed_LocatorDriversRemovedAfterSetup_LoadsThroughSetupDriver()`
`238`	`238`	`{`
`239`	`239`	`using var host = new SuspensionHost<TestAppState>`
`240`	`240`	`{`
`@@ -253,11 +253,10 @@ public async Task EnsureLoadAppState_Typed_DriverBecomesNull_LogsErrorAndStateRe`
`253`	`253`	`Splat.Locator.CurrentMutable.UnregisterAll<ISuspensionDriver>();`
`254`	`254`	`try`
`255`	`255`	`{`
`256`		`- SuspensionHostExtensions.SuspensionDriver = null;`
`257`		`-`
`258`	`256`	`var state = host.GetAppState();`
`259`	`257`
`260`		`- await Assert.That((object?)state).IsNull();`
	`258`	`+ await Assert.That(state).IsSameReferenceAs(driver.StateToLoad);`
	`259`	`+ await Assert.That(driver.LoadStateCallCount).IsEqualTo(1);`
`261`	`260`	`}`
`262`	`261`	`finally`
`263`	`262`	`{`