Improve browser stability and transport robustness

Add multiple hardening changes to tolerate transient browser failures and concurrent load:

- Retry context/page creation in MSTest and NUnit bases to ride through browser restarts.
- Use fixture.CloseContextAsync and swallow cleanup exceptions so teardown doesn't mask test failures.
- Introduce a context concurrency throttle (BrowserFixture.s_contextThrottle) and CloseContextAsync to limit concurrent browser contexts and always release slots.
- Harden BrowserContext.NewPageAsync: retry transient TaskCanceledException, enforce a PageInitTimeout, copy/cleanup partially-created targets/sessions on failure, apply context options and storage/state reliably, and fire lifecycle hooks.
- Treat MotusTargetClosedException like CdpDisconnectedException in several catch blocks to avoid noisy errors when targets disconnect.
- Serialize websocket sends in BiDiTransport and CdpTransport with a send lock, copy received message bytes before deserialization to avoid buffer reuse, throw specific disconnected exceptions when disposed, and dispose the send lock during shutdown.

These changes reduce flakes under parallel CI load and improve resilience to browser/process crashes.

Author: TorreyBetts

src/Motus.Testing.MSTest/MotusTestBase.cs

@@ -69,8 +69,25 @@ public static async Task CloseBrowserAsync()
     [TestInitialize]
     public async Task MotusTestInitialize()
     {
-        _context = await s_fixture.NewContextAsync(ContextOptions).ConfigureAwait(false);
-        _page = await _context.NewPageAsync().ConfigureAwait(false);
+        // If Chrome crashed during a previous test, the fixture auto-restarts.
+        // Retry context+page creation to ride through the restart window.
+        const int maxAttempts = 3;
+        for (int attempt = 1; ; attempt++)
+        {
+            try
+            {
+                _context = await s_fixture.NewContextAsync(ContextOptions).ConfigureAwait(false);
+                _page = await _context.NewPageAsync().ConfigureAwait(false);
+                break;
+            }
+            catch when (attempt < maxAttempts)
+            {
+                // Give the browser fixture time to restart Chrome.
+                _context = null;
+                _page = null;
+                await Task.Delay(1000 * attempt).ConfigureAwait(false);
+            }
+        }
 
         _failureTracing = new FailureTracing();
         await _failureTracing.StartIfEnabledAsync(_context).ConfigureAwait(false);
@@ -96,13 +113,24 @@ public async Task MotusTestCleanup()
 
         if (_context is not null)
         {
-            var testFailed = TestContext?.CurrentTestOutcome != UnitTestOutcome.Passed;
-            if (_failureTracing is not null)
-                await _failureTracing.StopAsync(_context, testFailed).ConfigureAwait(false);
-
-            await _context.CloseAsync().ConfigureAwait(false);
-            _context = null;
-            _page = null;
+            try
+            {
+                var testFailed = TestContext?.CurrentTestOutcome != UnitTestOutcome.Passed;
+                if (_failureTracing is not null)
+                    await _failureTracing.StopAsync(_context, testFailed).ConfigureAwait(false);
+
+                await s_fixture.CloseContextAsync(_context).ConfigureAwait(false);
+            }
+            catch (Exception) when (_context is not null)
+            {
+                // Browser may have crashed or disconnected; swallow so we don't
+                // mask the original test failure with a cleanup exception.
+            }
+            finally
+            {
+                _context = null;
+                _page = null;
+            }
         }
     }
 }

src/Motus.Testing.NUnit/MotusTestBase.cs

@@ -62,8 +62,22 @@ public async Task OneTimeTearDown()
     [SetUp]
     public async Task SetUp()
     {
-        _context = await _fixture.NewContextAsync(ContextOptions);
-        _page = await _context.NewPageAsync();
+        const int maxAttempts = 3;
+        for (int attempt = 1; ; attempt++)
+        {
+            try
+            {
+                _context = await _fixture.NewContextAsync(ContextOptions);
+                _page = await _context.NewPageAsync();
+                break;
+            }
+            catch when (attempt < maxAttempts)
+            {
+                _context = null;
+                _page = null;
+                await Task.Delay(1000 * attempt);
+            }
+        }
 
         _failureTracing = new FailureTracing();
         await _failureTracing.StartIfEnabledAsync(_context);
@@ -89,13 +103,24 @@ public async Task TearDown()
 
         if (_context is not null)
         {
-            var testFailed = TestContext.CurrentContext.Result.Outcome.Status == global::NUnit.Framework.Interfaces.TestStatus.Failed;
-            if (_failureTracing is not null)
-                await _failureTracing.StopAsync(_context, testFailed);
+            try
+            {
+                var testFailed = TestContext.CurrentContext.Result.Outcome.Status == global::NUnit.Framework.Interfaces.TestStatus.Failed;
+                if (_failureTracing is not null)
+                    await _failureTracing.StopAsync(_context, testFailed);
 
-            await _context.CloseAsync();
-            _context = null;
-            _page = null;
+                await _fixture.CloseContextAsync(_context);
+            }
+            catch (Exception) when (_context is not null)
+            {
+                // Browser may have crashed or disconnected; swallow so we don't
+                // mask the original test failure with a cleanup exception.
+            }
+            finally
+            {
+                _context = null;
+                _page = null;
+            }
         }
     }
 }

src/Motus.Testing/BrowserFixture.cs

@@ -16,6 +16,13 @@ public sealed class BrowserFixture : IAsyncDisposable
     private SemaphoreSlim _restartGate = new(1, 1);
     private int _disposed;
 
+    /// <summary>
+    /// Limits concurrent browser contexts to prevent Chrome from becoming
+    /// unresponsive under heavy parallel test load. Chrome's renderer process
+    /// model can stall when too many targets compete for resources.
+    /// </summary>
+    private static readonly SemaphoreSlim s_contextThrottle = new(4, 4);
+
     /// <summary>
     /// Maximum number of launch attempts before giving up.
     /// Browser startup can fail transiently on CI runners or when antivirus
@@ -47,20 +54,44 @@ public async Task InitializeAsync(LaunchOptions? options = null)
     /// <summary>
     /// Creates a new isolated browser context. If a restart is in progress
     /// (due to a browser crash), callers block until the new browser is ready.
+    /// The context throttle limits concurrent contexts to avoid overwhelming Chrome.
     /// </summary>
     public async Task<IBrowserContext> NewContextAsync(ContextOptions? options = null)
     {
+        await s_contextThrottle.WaitAsync().ConfigureAwait(false);
+
         await _restartGate.WaitAsync().ConfigureAwait(false);
         try
         {
             return await Browser.NewContextAsync(options).ConfigureAwait(false);
         }
+        catch
+        {
+            s_contextThrottle.Release();
+            throw;
+        }
         finally
         {
             _restartGate.Release();
         }
     }
 
+    /// <summary>
+    /// Closes a context and releases its concurrency throttle slot.
+    /// Always releases the slot even if close fails (browser crashed).
+    /// </summary>
+    public async Task CloseContextAsync(IBrowserContext context)
+    {
+        try
+        {
+            await context.CloseAsync().ConfigureAwait(false);
+        }
+        finally
+        {
+            s_contextThrottle.Release();
+        }
+    }
+
     public async ValueTask DisposeAsync()
     {
         if (Interlocked.CompareExchange(ref _disposed, 1, 0) != 0)

src/Motus/Browser/Browser.cs

@@ -119,7 +119,7 @@ await _registry.BrowserSession.SendAsync(
                 CdpJsonContext.Default.BrowserCloseResult,
                 CancellationToken.None).ConfigureAwait(false);
         }
-        catch (CdpDisconnectedException)
+        catch (Exception ex) when (ex is CdpDisconnectedException or MotusTargetClosedException)
         {
             // Expected: browser closes the WebSocket on shutdown
         }