Stabilize browser test isolation and route bootstrap

Author: KSemenenko

AGENTS.md

@@ -116,7 +116,7 @@ Rule format:
 - Every runnable test project must declare `MaxParallelTestsForPipeline : EnvironmentAwareParallelLimitBase` and rely on the base class limits by default; do not add per-suite `LocalLimit` or `CiLimit` overrides unless a specific suite has a documented exception.
 - Browser-suite CI parallelism is user-tunable. When the user wants higher throughput, keep in-suite browser-test CI parallelism in the `6-9` worker range when the harness can sustain it, and prefer extra GitHub Actions job splitting on top of that before reaching for timeout increases; do not pin browser suites back to `2` workers as a blanket fix.
 - Browser UI tests must be data-isolated and storage-isolated by default: each scenario should create or import its own script or workspace data, avoid shared persisted document IDs or browser-local state, and remain parallel-safe when multiple pages or contexts hit the app at the same time.
-- Local regression verification must include solution-level `dotnet test --solution ./PrompterOne.slnx --max-parallel-test-modules 1` so test-project split changes are proven under the real all-tests entrypoint, not only as isolated per-project runs.
+- Local regression verification must include a solution-level `dotnet test --solution ./PrompterOne.slnx` run so test-project split changes are proven under the real all-tests entrypoint with normal module parallelism; only force `--max-parallel-test-modules 1` when diagnosing a known module-level interference bug.
 - When the user explicitly asks to validate a test fix in actual GitHub Actions, do not spend more time on local `CI=true` emulation; push the fix and monitor the real CI run instead.
 - Do not use local `CI=true` browser-suite runs as a primary reproduction or validation signal unless the user explicitly asks for that exact experiment; in this repo it mostly changes in-suite parallelism and can hide the real CI failure mode instead of reproducing it.
 - When diagnosing browser-suite CI failures, always inspect and preserve Playwright screenshot artifacts from the failing run, and extend the harness so early bootstrap or fixture failures also leave a screenshot whenever the browser page still exists.
@@ -131,6 +131,7 @@ Rule format:
 - Repo-wide cleanup and review passes must explicitly inventory forbidden implementation string literals, `MarkupString` or raw-HTML UI composition, duplicated JS/CSS patterns, architecture-boundary drift, and `foreach`-driven test scenarios that should become isolated TUnit cases.
 - Repo-wide audits should use multiple independent reviewers with distinct focuses when the tooling is available, including external CLI reviewers such as Claude and Copilot plus internal agents, and all review outputs should be captured in root-level task files before remediation starts.
 - When CI browser suites keep flaking, use the available assistant CLIs and internal sub-agents as parallel investigators on the same failure cluster instead of debugging only through one serial line of inquiry.
+- Browser-suite stability fixes must prioritize per-test writable-state isolation and shared-harness correctness over retries, suite serialization, or other band-aids that only hide parallel interference.
 - Legacy, dead, duplicate, or speculative code paths should be deleted aggressively instead of being preserved behind compatibility instincts; if code has no clear runtime owner or authoritative contract, remove it rather than keep it as “just in case” ballast.
 - For repo-wide remediation passes, keep an explicit root-level accounting of fixed versus remaining feedback items, finish the code fixes first, and only then run and stabilize the test suites; do not bounce back into verification mid-remediation unless the user explicitly asks.
 - For task-scoped work, edit, stage, and commit only the files directly required for the requested change; do not widen the change set into unrelated user-owned or parallel worktree edits, do not touch changes owned by another agent, and if a blocker comes from that parallel work, wait briefly and re-check instead of patching around their in-flight fix.
@@ -140,7 +141,7 @@ Rule format:
 ### Commands
 
 - `build`: `dotnet build ./PrompterOne.slnx -warnaserror`
-- `test`: `dotnet test @./tests/dotnet-test-progress.rsp --solution ./PrompterOne.slnx --max-parallel-test-modules 1`
+- `test`: `dotnet test @./tests/dotnet-test-progress.rsp --solution ./PrompterOne.slnx`
 - `format`: `dotnet format ./PrompterOne.slnx`
 - `coverage`: `dotnet test @./tests/dotnet-test-progress.rsp --project ./tests/PrompterOne.Core.Tests/PrompterOne.Core.Tests.csproj --coverage --coverage-output-format cobertura && dotnet test @./tests/dotnet-test-progress.rsp --project ./tests/PrompterOne.Web.Tests/PrompterOne.Web.Tests.csproj --coverage --coverage-output-format cobertura && dotnet test @./tests/dotnet-test-progress.rsp --project ./tests/PrompterOne.Web.UITests.Shell/PrompterOne.Web.UITests.Shell.csproj --coverage --coverage-output-format cobertura && dotnet test @./tests/dotnet-test-progress.rsp --project ./tests/PrompterOne.Web.UITests.Studio/PrompterOne.Web.UITests.Studio.csproj --coverage --coverage-output-format cobertura && dotnet test @./tests/dotnet-test-progress.rsp --project ./tests/PrompterOne.Web.UITests.Editor/PrompterOne.Web.UITests.Editor.csproj --coverage --coverage-output-format cobertura && dotnet test @./tests/dotnet-test-progress.rsp --project ./tests/PrompterOne.Web.UITests.Reader/PrompterOne.Web.UITests.Reader.csproj --coverage --coverage-output-format cobertura`
 
@@ -158,7 +159,7 @@ Useful focused commands:
 - app run: `cd ./src/PrompterOne.Web && dotnet run`
 - core tests: `dotnet test @./tests/dotnet-test-progress.rsp --project ./tests/PrompterOne.Core.Tests/PrompterOne.Core.Tests.csproj`
 - component tests: `dotnet test @./tests/dotnet-test-progress.rsp --project ./tests/PrompterOne.Web.Tests/PrompterOne.Web.Tests.csproj`
-- all tests: `dotnet test @./tests/dotnet-test-progress.rsp --solution ./PrompterOne.slnx --max-parallel-test-modules 1`
+- all tests: `dotnet test @./tests/dotnet-test-progress.rsp --solution ./PrompterOne.slnx`
 - ui tests: `dotnet test @./tests/dotnet-test-progress.rsp --project ./tests/PrompterOne.Web.UITests.Shell/PrompterOne.Web.UITests.Shell.csproj && dotnet test @./tests/dotnet-test-progress.rsp --project ./tests/PrompterOne.Web.UITests.Studio/PrompterOne.Web.UITests.Studio.csproj && dotnet test @./tests/dotnet-test-progress.rsp --project ./tests/PrompterOne.Web.UITests.Editor/PrompterOne.Web.UITests.Editor.csproj && dotnet test @./tests/dotnet-test-progress.rsp --project ./tests/PrompterOne.Web.UITests.Reader/PrompterOne.Web.UITests.Reader.csproj`
 - ui shell tests: `dotnet test @./tests/dotnet-test-progress.rsp --project ./tests/PrompterOne.Web.UITests.Shell/PrompterOne.Web.UITests.Shell.csproj`
 - ui studio tests: `dotnet test @./tests/dotnet-test-progress.rsp --project ./tests/PrompterOne.Web.UITests.Studio/PrompterOne.Web.UITests.Studio.csproj`

full-suite-stabilization.plan.md

@@ -96,12 +96,20 @@ Tracked failing tests from the current baseline:
   Fix path:
   - remove the CI-only per-context routed warmup, keep only the one-time shared-runtime warmup, and make every returned test page follow the same bootstrap path locally and on CI
 - [ ] `StandaloneAppFixture` build break: `WarmUpContextPageIfNeededAsync` missing in `StandaloneAppFixture.cs`
+- [x] `StandaloneAppFixture` build break: `WarmUpContextPageIfNeededAsync` missing in `StandaloneAppFixture.cs`
   Symptom:
   - compiler reports `CS0103` for `WarmUpContextPageIfNeededAsync` from `tests/PrompterOne.Web.UITests/Infrastructure/StandaloneAppFixture.cs`
   Root cause:
-  - verify whether the current workspace already contains the moved helper in `StandaloneAppFixture.Warmup.cs` and whether the failing build came from an older not-yet-published tree versus a real current partial-class mismatch
+  - the warmup helper had already been split into the partial fixture, but the published tree and the active fixture callers drifted until the shared warmup path and callers were brought back into the same compiled partial surface
   Fix path:
-  - confirm the helper is present in the compiled partial, keep the calling signature aligned, and re-run the required local build after the active full-suite run completes
+  - keep the helper in the compiled partial, align the callers with that partial surface, and prove the fix with the required local build and full solution test commands
+- [x] `EditorDragDropFlowTests.EditorScreen_DropOnEmptyDraft_ReplacesTextAndSupportsUndoRedo`
+  Symptom:
+  - the blank-draft drop scenario updated the source text and title but intermittently left toolbar undo disabled, especially once untitled autosave assigned a real `?id=` route
+  Root cause:
+  - dropping onto an untitled draft triggered autosave self-navigation that reloaded the editor and reset document history, so slower runs could lose undo state before the assertion clicked it
+  Fix path:
+  - preserve editor history across untitled autosave self-navigation and make the browser regression wait for the persisted route before asserting undo/redo on the post-save editor surface
 - [ ] `Release Pipeline` run `24209085607` still fails on GitHub macOS despite the local full-suite baseline being green on the same `727d904` commit
   Symptom:
   - `Shell` and `Studio` fail remotely while local `dotnet build`, targeted suite runs, and the required solution-level `dotnet test` all pass on the exact pushed commit
@@ -197,6 +205,24 @@ Tracked failing tests from the current baseline:
   - detect when `BrowserRouteDriver` is opening the first routed page from the primed blank test page
   - give only that first routed bootstrap the longer runtime-warmup visibility budget and skip the CI blank bounce for that specific path
   - keep the shorter route-visible contract for already-booted routed pages so normal suite latency does not drift upward
+- [ ] `Release Pipeline` run `24221639706` fails remotely in all four browser suites after commit `7983efe`
+  Symptom:
+  - `Shell` fails `11` tests, mostly while opening `/library`, plus two invalid learn/teleprompter missing-script flows and two onboarding route-changing clicks
+  - `Studio` fails `6` tests, split between first-route `/library` boot, `go-live-back` hangs, and `StartRecording` click paths that stall on scheduled navigation waits
+  - `Reader` fails `3` tests: two responsive-layout screenshot captures on iPad Pro portrait and one teleprompter muted-chrome visual threshold
+  - `Editor` fails multiple route-changing action tests, including `Open in Library` from split results and import/drag-drop flows that do not wait on the real completion signal
+  Root cause:
+  - `BrowserRouteDriver` still lets `TimeoutException` escape from the page-visible probe, so the shared route retry loop is bypassed on CI
+  - the harness still contains route/open divergence between runtime warmup and scenario route opens, and shared contexts can be published before priming fully succeeds
+  - several suites still use raw SPA clicks that wait for scheduled navigation even though the tests already do explicit post-click route or readiness waits
+  - responsive screenshot capture is still a one-shot operation, so artifact generation itself can fail otherwise healthy route assertions
+  - a production Go Live route-leave path still blocks navigation on camera detach work
+  Fix path:
+  - make route-open retries catch timeout failures at the shared driver boundary and remove CI-only route-open behavior
+  - publish shared contexts only after priming succeeds and reuse the shared route driver from runtime warmup
+  - introduce a shared `NoWaitAfter` click helper for SPA route/state-changing controls and use it in the failing Shell, Studio, and Editor flows
+  - retry page screenshot capture in the shared artifact helper
+  - stop awaiting camera detach inside `GoLivePage` location-changing so route leaves are not blocked by cleanup
 
 ## Ordered Plan
 
@@ -234,6 +260,7 @@ Tracked failing tests from the current baseline:
   - `dotnet format ./PrompterOne.slnx` passed
   - `dotnet build ./PrompterOne.slnx -warnaserror` passed
   - `dotnet test @./tests/dotnet-test-progress.rsp --solution ./PrompterOne.slnx --max-parallel-test-modules 1` passed with `1162/1162` green in `7m 42.943s`
+  - post-format verification repeated successfully with `dotnet build ./PrompterOne.slnx -warnaserror` and `dotnet test @./tests/dotnet-test-progress.rsp --solution ./PrompterOne.slnx --max-parallel-test-modules 1`, ending at `1162/1162` green in `7m 35.996s`
 
 - [ ] Step 5. Publish directly to `main`.
   Actions:
@@ -258,6 +285,12 @@ Tracked failing tests from the current baseline:
   - `dotnet format ./PrompterOne.slnx` passed
   - `dotnet build ./PrompterOne.slnx -warnaserror` passed
   - `dotnet test @./tests/dotnet-test-progress.rsp --project ./tests/PrompterOne.Web.UITests.Studio/PrompterOne.Web.UITests.Studio.csproj` passed with `38/38`
+- [ ] Follow-up remediation for remote run `24221639706`
+  Pending focused validation:
+  - `dotnet test @./tests/dotnet-test-progress.rsp --project ./tests/PrompterOne.Web.UITests.Shell/PrompterOne.Web.UITests.Shell.csproj`
+  - `dotnet test @./tests/dotnet-test-progress.rsp --project ./tests/PrompterOne.Web.UITests.Studio/PrompterOne.Web.UITests.Studio.csproj`
+  - `dotnet test @./tests/dotnet-test-progress.rsp --project ./tests/PrompterOne.Web.UITests.Reader/PrompterOne.Web.UITests.Reader.csproj`
+  - `dotnet test @./tests/dotnet-test-progress.rsp --project ./tests/PrompterOne.Web.UITests.Editor/PrompterOne.Web.UITests.Editor.csproj`
   - `dotnet test @./tests/dotnet-test-progress.rsp --solution ./PrompterOne.slnx --max-parallel-test-modules 1` passed with `1162/1162` green in `7m 50.591s`
 - [x] Follow-up local verification after the first-route primed-blank bootstrap change
   Result:

src/PrompterOne.Shared/Editor/Pages/EditorPage.Loading.cs

@@ -30,9 +30,10 @@ await Diagnostics.RunAsync(
             {
                 await Bootstrapper.EnsureReadyAsync();
                 await EnsureSessionLoadedAsync();
+                var preserveHistoryOnLoad = ConsumePreserveHistoryOnNextLoad();
                 await LoadEditorFileWorkflowAsync();
                 PopulateEditorState(
-                    resetHistory: true,
+                    resetHistory: !preserveHistoryOnLoad,
                     clearSplitFeedback: !ConsumePreserveSplitFeedbackOnNextLoad());
                 StateHasChanged();
             });
@@ -57,18 +58,21 @@ private void UpdateDraftSessionOrigin(string? requestedScriptId)
         {
             _currentDraftSessionStartedUntitled = true;
             _pendingAutosaveSelfNavigationScriptId = null;
+            _preserveHistoryOnNextLoad = false;
             return;
         }
 
         if (_currentDraftSessionStartedUntitled &&
             string.Equals(requestedScriptId, _pendingAutosaveSelfNavigationScriptId, StringComparison.Ordinal))
         {
             _pendingAutosaveSelfNavigationScriptId = null;
+            _preserveHistoryOnNextLoad = true;
             return;
         }
 
         _currentDraftSessionStartedUntitled = false;
         _pendingAutosaveSelfNavigationScriptId = null;
+        _preserveHistoryOnNextLoad = false;
     }
 
     private async Task LoadScriptFromQueryAsync(string requestedScriptId)
@@ -129,6 +133,13 @@ private bool ConsumePreserveSplitFeedbackOnNextLoad()
         return shouldPreserveSplitFeedback;
     }
 
+    private bool ConsumePreserveHistoryOnNextLoad()
+    {
+        var shouldPreserveHistory = _preserveHistoryOnNextLoad;
+        _preserveHistoryOnNextLoad = false;
+        return shouldPreserveHistory;
+    }
+
     private void ResetMetadataDefaults(ScriptWorkspaceState state)
     {
         var defaultBaseWpm = state.ScriptData?.TargetWpm ?? 140;

src/PrompterOne.Shared/Editor/Pages/EditorPage.SourceEditing.cs

@@ -121,6 +121,7 @@ private async Task ApplyMutationAsync(string text, EditorSelectionRange selectio
             PersistDraftInBackground(text, documentNameOverride);
         }
 
+        await InvokeAsync(StateHasChanged);
         await FocusSourceRangeAsync(selection.Start, selection.End, revealSelection: false);
     }
 

src/PrompterOne.Shared/Editor/Pages/EditorPage.razor.cs

@@ -53,6 +53,7 @@ public partial class EditorPage
     private DateTimeOffset? _lastLocalSaveAt;
     private EditorMetadataRailTab _metadataRailSelectedTab = EditorMetadataRailTab.Metadata;
     private string _profile = DefaultProfileActor;
+    private bool _preserveHistoryOnNextLoad;
     private bool _preserveSplitFeedbackOnNextLoad;
     private string? _pendingAutosaveSelfNavigationScriptId;
     private string _screenTitle = ScriptWorkspaceState.UntitledScriptTitle;

src/PrompterOne.Shared/GoLive/Pages/GoLivePage.Notifications.cs

@@ -1,10 +1,13 @@
 using Microsoft.AspNetCore.Components.Routing;
+using Microsoft.JSInterop;
 using PrompterOne.Shared.Contracts;
+using PrompterOne.Shared.GoLive.Models;
 
 namespace PrompterOne.Shared.Pages;
 
 public partial class GoLivePage
 {
+    private const string BackgroundMaintenanceOperation = "GoLiveBackgroundMaintenance";
     private static readonly string GoLiveRoutePrefix = AppRoutes.GoLive.TrimStart('/');
     private static readonly TimeSpan SessionRefreshInterval = TimeSpan.FromMilliseconds(200);
 
@@ -30,9 +33,9 @@ public void Dispose()
         }
 
         _disposed = true;
-        _ = ReleaseCameraSurfacesAsync();
-        _ = StopPrimaryMicrophoneMonitorAsync();
-        _ = GoLiveRemoteSourceRuntime.StopAsync();
+        RunCleanupInBackground(ReleaseCameraSurfacesAsync);
+        RunCleanupInBackground(StopPrimaryMicrophoneMonitorAsync);
+        RunCleanupInBackground(GoLiveRemoteSourceRuntime.StopAsync);
         DisposeCore();
         GC.SuppressFinalize(this);
     }
@@ -45,9 +48,9 @@ public async ValueTask DisposeAsync()
         }
 
         _disposed = true;
-        await ReleaseCameraSurfacesAsync();
-        await StopPrimaryMicrophoneMonitorAsync();
-        await GoLiveRemoteSourceRuntime.StopAsync();
+        await RunCleanupSafelyAsync(ReleaseCameraSurfacesAsync);
+        await RunCleanupSafelyAsync(StopPrimaryMicrophoneMonitorAsync);
+        await RunCleanupSafelyAsync(GoLiveRemoteSourceRuntime.StopAsync);
         DisposeCore();
         GC.SuppressFinalize(this);
     }
@@ -114,6 +117,13 @@ private async Task RunSessionRefreshLoopAsync(PeriodicTimer timer, CancellationT
         catch (OperationCanceledException)
         {
         }
+        catch (Exception exception) when (IsIgnorableBackgroundFailure(exception))
+        {
+        }
+        catch (Exception exception)
+        {
+            ReportBackgroundFailure(exception);
+        }
     }
 
     private void StopSessionRefreshLoop()
@@ -132,7 +142,10 @@ private ValueTask HandleLocationChangingAsync(LocationChangingContext context)
             return ValueTask.CompletedTask;
         }
 
-        return new ValueTask(ReleaseCameraSurfacesAsync());
+        StopSessionRefreshLoop();
+        RunCleanupInBackground(ReleaseCameraSurfacesAsync);
+        RunCleanupInBackground(StopPrimaryMicrophoneMonitorAsync);
+        return ValueTask.CompletedTask;
     }
 
     private bool IsGoLiveTarget(string targetLocation)
@@ -152,4 +165,42 @@ private void DisposeCore()
         DisposePrimaryMicrophoneObserver();
         _interactionGate.Dispose();
     }
+
+    private void RunCleanupInBackground(Func<Task> cleanup) =>
+        _ = RunCleanupSafelyAsync(cleanup);
+
+    private async Task RunCleanupSafelyAsync(Func<Task> cleanup)
+    {
+        try
+        {
+            await cleanup();
+        }
+        catch (Exception exception) when (IsIgnorableBackgroundFailure(exception))
+        {
+        }
+        catch (Exception exception)
+        {
+            ReportBackgroundFailure(exception);
+        }
+    }
+
+    private static bool IsIgnorableBackgroundFailure(Exception exception) =>
+        exception is OperationCanceledException
+            or ObjectDisposedException
+            or TaskCanceledException
+            or JSException;
+
+    private void ReportBackgroundFailure(Exception exception)
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        Diagnostics.ReportRecoverable(
+            BackgroundMaintenanceOperation,
+            Text(GoLiveText.Load.LoadMessage),
+            exception,
+            alreadyLogged: false);
+    }
 }