Implement Blazor Server dashboard

2026-04-26 18:37:16 -04:00
30 changed files with 881 additions and 916 deletions
@@ -1,51 +0,0 @@
-# Gateway Testing
-
-Gateway tests run without installed MXAccess by using fake workers, fake
-transports, and in-process gRPC service fakes. Live MXAccess verification belongs
-in opt-in integration tests because it depends on installed COM components and
-provider state.
-
-## Fake Worker Harness
-
-`FakeWorkerHarness` in `src/MxGateway.Tests/Gateway/Workers/Fakes/` provides an
-in-process worker side for named-pipe IPC tests. It uses the same
-`WorkerFrameReader`, `WorkerFrameWriter`, and `WorkerEnvelope` contract as the
-gateway so tests exercise real frame validation and worker-client state changes.
-
-Use the harness when a gateway or session test needs worker behavior without
-starting `MxGateway.Worker.exe` or loading MXAccess COM. The harness scripts:
-
- `WorkerHello` and `WorkerReady` startup,
- command replies with matching correlation ids,
- ordered `WorkerEvent` frames,
- `WorkerFault` frames,
- shutdown acknowledgements,
- malformed protobuf payloads and oversized frame headers,
- slow or hung workers by withholding a reply.
-
-Session-level tests can connect the harness to the pipe created by
-`SessionWorkerClientFactory` with `ConnectToGatewayPipeAsync`. Lower-level
-`WorkerClient` tests can use `CreateConnectedPairAsync` to create both pipe ends
-inside the test.
-
-## Focused Commands
-
-Run the fake worker tests after changing gateway worker IPC, session startup, or
-event streaming behavior:
-
-```bash
-dotnet test src/MxGateway.Tests/MxGateway.Tests.csproj --filter FullyQualifiedName~FakeWorkerHarnessTests
-dotnet test src/MxGateway.Tests/MxGateway.Tests.csproj --filter FullyQualifiedName~SessionWorkerClientFactoryFakeWorkerTests
-```
-
-Run the gateway test project after shared gateway test infrastructure changes:
-
-```bash
-dotnet test src/MxGateway.Tests/MxGateway.Tests.csproj
-```
-
-## Related Documentation
-
- [Gateway Process Design](./gateway-process-design.md)
- [Worker Frame Protocol](./WorkerFrameProtocol.md)
- [MXAccess Worker Instance Detailed Design](./mxaccess-worker-instance-design.md)
@@ -34,9 +34,13 @@ SignalR circuit. Bootstrap is sufficient for a basic dashboard.

 ## Hosting Model

-The dashboard is hosted by `MxGateway.Server` alongside the gRPC API.
+The dashboard is hosted by `MxGateway.Server` alongside the gRPC API. When
+`MxGateway:Dashboard:Enabled` is `true`, `MapGatewayDashboard()` maps the
+configured `Dashboard:PathBase` to the Blazor Server app and maps the login,
+logout, and access-denied HTTP endpoints beside it. When dashboard hosting is
+disabled, those routes are not mapped.

-Suggested endpoint layout:
+Endpoint layout:

 ```text
 /dashboard
@@ -45,7 +49,7 @@ Suggested endpoint layout:
 /dashboard/workers
 /dashboard/events
 /dashboard/settings
-/_blazor
+/dashboard/_blazor
 ```

 The app should redirect `/` to `/dashboard` only if the deployment wants the
@@ -59,9 +63,10 @@ MxGateway.Server
    Components/
      App.razor
      Routes.razor
+      DashboardPageBase.cs
+      DashboardDisplay.cs
      Layout/
        DashboardLayout.razor
-        NavMenu.razor
      Pages/
        DashboardHome.razor
        SessionsPage.razor
@@ -69,26 +74,21 @@ MxGateway.Server
        WorkersPage.razor
        EventsPage.razor
        SettingsPage.razor
-      Components/
+      Shared/
        MetricCard.razor
-        SessionTable.razor
-        WorkerTable.razor
-        EventRatePanel.razor
+        StatusBadge.razor
        FaultList.razor
-    Services/
-      DashboardSnapshotService.cs
-      DashboardUpdateHub.cs
-      DashboardAuthorization.cs
-    Models/
-      DashboardSnapshot.cs
-      SessionSummary.cs
-      WorkerSummary.cs
-      MetricSummary.cs
+    DashboardSnapshotService.cs
+    DashboardAuthorizationHandler.cs
+    DashboardAuthenticator.cs
+    DashboardSnapshot.cs
+    DashboardSessionSummary.cs
+    DashboardWorkerSummary.cs
+    DashboardMetricSummary.cs
 ```

-`DashboardUpdateHub` here means an internal application update service, not a
-separate public SignalR hub unless implementation proves one is needed. Blazor
-Server already uses SignalR for UI circuits.
+Blazor Server provides the SignalR circuit for UI updates. The implementation
+does not add a separate public dashboard hub.

 ## Dashboard Data Source

@@ -137,7 +137,7 @@ gateway internals.

 Use Blazor Server component state updates for real-time dashboard refresh.

-Recommended pattern:
+Implemented pattern:

 1. Page/component subscribes to `WatchSnapshotsAsync`.
 2. Snapshot service emits updates from a bounded channel or timer.
@@ -147,10 +147,8 @@ Recommended pattern:

 Default update cadence:

- immediate update on session create/close/fault,
- immediate update on worker fault,
 - periodic metrics refresh every 1 second,
- event-rate windows updated every 1 second.
+- event counters update on the next snapshot tick.

 Avoid pushing every MXAccess data-change event to the dashboard. Aggregate event
 counts and rates instead.
@@ -320,7 +318,9 @@ Suggested configuration:

 ## Styling

-Use Bootstrap utility classes and a small local stylesheet.
+The dashboard serves Bootstrap 5.3.3 assets from
+`src/MxGateway.Server/wwwroot/lib/bootstrap/` and local layout/status styling
+from `src/MxGateway.Server/wwwroot/css/dashboard.css`.

 Recommended visual language:

@@ -361,15 +361,18 @@ Integration tests should verify:

 ## Initial Implementation Slice

-The first dashboard slice should implement:
+The first dashboard slice implements:

 1. Blazor Server hosting in `MxGateway.Server`.
-2. Bootstrap static assets.
+2. local Bootstrap static assets.
 3. dashboard configuration binding.
 4. dashboard auth using API key login and HTTP-only cookie.
 5. read-only `DashboardSnapshotService`.
 6. home page with metric cards.
-7. sessions page with active session table.
+7. sessions page with active session table and session details.
 8. workers page with worker table.
-9. 1-second realtime refresh through Blazor Server.
-10. redaction tests for secrets.
+9. events page with aggregate counters.
+10. settings page with redacted effective configuration.
+11. periodic realtime refresh through Blazor Server.
+12. route-mapping tests, disabled-dashboard tests, auth tests, and snapshot
+    projection/redaction tests.
@@ -891,11 +891,6 @@ behavior unless an explicit non-parity backend is designed.
 Gateway tests should be able to run without installed MXAccess by using fake
 workers and fake transports.

-Use `FakeWorkerHarness` for tests that need real gateway-to-worker framing,
-handshake, command, event, fault, or malformed-protocol behavior without loading
-MXAccess COM. See [Gateway Testing](./GatewayTesting.md) for the harness scope
-and focused test commands.
-
 Focused tests:

 - session state transitions,
@@ -109,13 +109,22 @@ histograms through .NET `Meter` and a snapshot API that dashboard services can
 project without binding to a metrics exporter.
 `DashboardSnapshotService` projects sessions, workers, metrics, faults, and
 effective configuration into immutable DTOs for read-only dashboard rendering.
+The Blazor Server dashboard renders those snapshots at `/dashboard`,
+`/dashboard/sessions`, `/dashboard/workers`, `/dashboard/events`, and
+`/dashboard/settings`. Components subscribe to
+`IDashboardSnapshotService.WatchSnapshotsAsync()` and update on the configured
+snapshot interval without mutating session or worker state. The dashboard uses
+local Bootstrap CSS and JavaScript plus a small local stylesheet; it does not
+use a Blazor UI component library.
+
 Dashboard routes use the same API-key verifier as gRPC. `/dashboard/login`
 accepts the API key in a form body, validates the configured `admin` scope,
 and issues an HTTP-only secure cookie for subsequent dashboard requests.
 `/dashboard/logout` clears that cookie. Login and logout posts validate
 anti-forgery tokens, and API keys are never accepted through query strings.
 `Dashboard:AllowAnonymousLocalhost` can bypass the cookie requirement for
-loopback requests only when explicitly enabled.
+loopback requests only when explicitly enabled. Setting
+`MxGateway:Dashboard:Enabled` to `false` leaves the dashboard routes unmapped.

 ### Worker Process

@@ -0,0 +1,34 @@
+@inject IOptions<GatewayOptions> GatewayOptions
+
+<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <base href="@DashboardBaseHref" />
+    <link rel="stylesheet" href="/lib/bootstrap/css/bootstrap.min.css" />
+    <link rel="stylesheet" href="/css/dashboard.css" />
+    <HeadOutlet @rendermode="InteractiveServer" />
+</head>
+<body class="dashboard-body">
+    <Routes @rendermode="InteractiveServer" />
+    <script src="/lib/bootstrap/js/bootstrap.bundle.min.js"></script>
+    <script src="_framework/blazor.web.js"></script>
+</body>
+</html>
+
+@code {
+    private string DashboardBaseHref
+    {
+        get
+        {
+            string pathBase = GatewayOptions.Value.Dashboard.PathBase.TrimEnd('/');
+            if (string.IsNullOrWhiteSpace(pathBase))
+            {
+                pathBase = "/dashboard";
+            }
+
+            return $"{pathBase}/";
+        }
+    }
+}
@@ -0,0 +1,30 @@
+namespace MxGateway.Server.Dashboard.Components;
+
+public static class DashboardDisplay
+{
+    public static string DateTime(DateTimeOffset? value)
+    {
+        return value.HasValue
+            ? value.Value.UtcDateTime.ToString("yyyy-MM-dd HH:mm:ss 'UTC'", System.Globalization.CultureInfo.InvariantCulture)
+            : "-";
+    }
+
+    public static string Duration(TimeSpan value)
+    {
+        return value.TotalDays >= 1
+            ? value.ToString(@"d\.hh\:mm\:ss", System.Globalization.CultureInfo.InvariantCulture)
+            : value.ToString(@"hh\:mm\:ss", System.Globalization.CultureInfo.InvariantCulture);
+    }
+
+    public static string Text(string? value)
+    {
+        return string.IsNullOrWhiteSpace(value) ? "-" : value;
+    }
+
+    public static long MetricValue(DashboardSnapshot snapshot, string name, string? dimension = null)
+    {
+        return snapshot.Metrics.FirstOrDefault(metric =>
+            string.Equals(metric.Name, name, StringComparison.Ordinal)
+            && string.Equals(metric.Dimension, dimension, StringComparison.Ordinal))?.Value ?? 0;
+    }
+}
@@ -0,0 +1,48 @@
+using Microsoft.AspNetCore.Components;
+
+namespace MxGateway.Server.Dashboard.Components;
+
+public abstract class DashboardPageBase : ComponentBase, IAsyncDisposable
+{
+    private readonly CancellationTokenSource _disposeCancellation = new();
+    private Task? _watchTask;
+
+    [Inject]
+    protected IDashboardSnapshotService SnapshotService { get; set; } = null!;
+
+    protected DashboardSnapshot? Snapshot { get; private set; }
+
+    protected override void OnInitialized()
+    {
+        _watchTask = WatchSnapshotsAsync();
+    }
+
+    public async ValueTask DisposeAsync()
+    {
+        await _disposeCancellation.CancelAsync().ConfigureAwait(false);
+        if (_watchTask is not null)
+        {
+            await _watchTask.ConfigureAwait(false);
+        }
+
+        _disposeCancellation.Dispose();
+        GC.SuppressFinalize(this);
+    }
+
+    private async Task WatchSnapshotsAsync()
+    {
+        try
+        {
+            await foreach (DashboardSnapshot snapshot in SnapshotService
+                .WatchSnapshotsAsync(_disposeCancellation.Token)
+                .ConfigureAwait(false))
+            {
+                Snapshot = snapshot;
+                await InvokeAsync(StateHasChanged).ConfigureAwait(false);
+            }
+        }
+        catch (OperationCanceledException) when (_disposeCancellation.IsCancellationRequested)
+        {
+        }
+    }
+}
@@ -0,0 +1,53 @@
+@inherits LayoutComponentBase
+@inject IOptions<GatewayOptions> GatewayOptions
+
+<div class="dashboard-shell">
+    <nav class="navbar navbar-expand-lg bg-body border-bottom dashboard-navbar">
+        <div class="container-fluid">
+            <a class="navbar-brand" href="">MXAccess Gateway</a>
+            <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#dashboardNav"
+                    aria-controls="dashboardNav" aria-expanded="false" aria-label="Toggle navigation">
+                <span class="navbar-toggler-icon"></span>
+            </button>
+            <div class="collapse navbar-collapse" id="dashboardNav">
+                <ul class="navbar-nav me-auto mb-2 mb-lg-0">
+                    <li class="nav-item">
+                        <NavLink class="nav-link" href="" Match="NavLinkMatch.All">Overview</NavLink>
+                    </li>
+                    <li class="nav-item">
+                        <NavLink class="nav-link" href="sessions">Sessions</NavLink>
+                    </li>
+                    <li class="nav-item">
+                        <NavLink class="nav-link" href="workers">Workers</NavLink>
+                    </li>
+                    <li class="nav-item">
+                        <NavLink class="nav-link" href="events">Events</NavLink>
+                    </li>
+                    <li class="nav-item">
+                        <NavLink class="nav-link" href="settings">Settings</NavLink>
+                    </li>
+                </ul>
+                <form method="post" action="@DashboardPath("/logout")" class="d-flex">
+                    <AntiforgeryToken />
+                    <button class="btn btn-outline-secondary btn-sm" type="submit">Sign out</button>
+                </form>
+            </div>
+        </div>
+    </nav>
+    <main class="container-fluid dashboard-content">
+        @Body
+    </main>
+</div>
+
+@code {
+    private string DashboardPath(string relativePath)
+    {
+        string pathBase = GatewayOptions.Value.Dashboard.PathBase.TrimEnd('/');
+        if (string.IsNullOrWhiteSpace(pathBase))
+        {
+            pathBase = "/dashboard";
+        }
+
+        return $"{pathBase}{relativePath}";
+    }
+}
@@ -0,0 +1,37 @@
+@page "/"
+@inherits DashboardPageBase
+
+<PageTitle>MXAccess Gateway Dashboard</PageTitle>
+
+@if (Snapshot is null)
+{
+    <div class="empty-state">Loading dashboard snapshot.</div>
+}
+else
+{
+    <div class="dashboard-page-header">
+        <div>
+            <h1>Overview</h1>
+            <div class="text-secondary">Generated @DashboardDisplay.DateTime(Snapshot.GeneratedAt)</div>
+        </div>
+        <StatusBadge Text="@Snapshot.GatewayStatus" />
+    </div>
+
+    <section class="metric-grid">
+        <MetricCard Label="Uptime" Value="@DashboardDisplay.Duration(Snapshot.GatewayUptime)" Detail="@Snapshot.GatewayVersion" />
+        <MetricCard Label="Open Sessions" Value="@DashboardDisplay.MetricValue(Snapshot, "mxgateway.sessions.open").ToString(System.Globalization.CultureInfo.InvariantCulture)" />
+        <MetricCard Label="Workers Running" Value="@DashboardDisplay.MetricValue(Snapshot, "mxgateway.workers.running").ToString(System.Globalization.CultureInfo.InvariantCulture)" />
+        <MetricCard Label="Event Queue Depth" Value="@DashboardDisplay.MetricValue(Snapshot, "mxgateway.events.queue.depth").ToString(System.Globalization.CultureInfo.InvariantCulture)" />
+        <MetricCard Label="Commands Failed" Value="@DashboardDisplay.MetricValue(Snapshot, "mxgateway.commands.failed").ToString(System.Globalization.CultureInfo.InvariantCulture)" />
+        <MetricCard Label="Events Received" Value="@DashboardDisplay.MetricValue(Snapshot, "mxgateway.events.received").ToString(System.Globalization.CultureInfo.InvariantCulture)" />
+        <MetricCard Label="Faults" Value="@DashboardDisplay.MetricValue(Snapshot, "mxgateway.faults").ToString(System.Globalization.CultureInfo.InvariantCulture)" />
+        <MetricCard Label="Queue Overflows" Value="@DashboardDisplay.MetricValue(Snapshot, "mxgateway.queues.overflows").ToString(System.Globalization.CultureInfo.InvariantCulture)" />
+    </section>
+
+    <section class="dashboard-section">
+        <div class="section-heading">
+            <h2>Recent Faults</h2>
+        </div>
+        <FaultList Faults="@Snapshot.Faults" />
+    </section>
+}
@@ -0,0 +1,64 @@
+@page "/events"
+@inherits DashboardPageBase
+
+<PageTitle>Dashboard Events</PageTitle>
+
+@if (Snapshot is null)
+{
+    <div class="empty-state">Loading event diagnostics.</div>
+}
+else
+{
+    <div class="dashboard-page-header">
+        <div>
+            <h1>Events</h1>
+            <div class="text-secondary">Generated @DashboardDisplay.DateTime(Snapshot.GeneratedAt)</div>
+        </div>
+    </div>
+
+    <section class="metric-grid compact">
+        <MetricCard Label="Events Received" Value="@DashboardDisplay.MetricValue(Snapshot, "mxgateway.events.received").ToString(System.Globalization.CultureInfo.InvariantCulture)" />
+        <MetricCard Label="Event Queue Depth" Value="@DashboardDisplay.MetricValue(Snapshot, "mxgateway.events.queue.depth").ToString(System.Globalization.CultureInfo.InvariantCulture)" />
+        <MetricCard Label="Queue Overflows" Value="@DashboardDisplay.MetricValue(Snapshot, "mxgateway.queues.overflows").ToString(System.Globalization.CultureInfo.InvariantCulture)" />
+        <MetricCard Label="Stream Disconnects" Value="@DashboardDisplay.MetricValue(Snapshot, "mxgateway.grpc.streams.disconnected").ToString(System.Globalization.CultureInfo.InvariantCulture)" />
+    </section>
+
+    <section class="dashboard-section">
+        <div class="section-heading">
+            <h2>Event Families</h2>
+        </div>
+        @if (EventFamilyMetrics.Count == 0)
+        {
+            <div class="empty-state">No event family counters recorded.</div>
+        }
+        else
+        {
+            <div class="table-responsive">
+                <table class="table table-sm dashboard-table">
+                    <thead>
+                        <tr>
+                            <th scope="col">Family</th>
+                            <th scope="col">Count</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        @foreach (DashboardMetricSummary metric in EventFamilyMetrics)
+                        {
+                            <tr>
+                                <td>@metric.Dimension</td>
+                                <td>@metric.Value</td>
+                            </tr>
+                        }
+                    </tbody>
+                </table>
+            </div>
+        }
+    </section>
+}
+
+@code {
+    private IReadOnlyList<DashboardMetricSummary> EventFamilyMetrics => Snapshot?.Metrics
+        .Where(metric => metric.Name == "mxgateway.events.received" && metric.Dimension is not null)
+        .OrderBy(metric => metric.Dimension, StringComparer.OrdinalIgnoreCase)
+        .ToArray() ?? [];
+}
@@ -0,0 +1,69 @@
+@page "/sessions/{SessionId}"
+@inherits DashboardPageBase
+
+<PageTitle>Dashboard Session</PageTitle>
+
+@if (Snapshot is null)
+{
+    <div class="empty-state">Loading session.</div>
+}
+else if (CurrentSession is null)
+{
+    <section class="dashboard-section">
+        <h1 class="h4 mb-3">Session Not Found</h1>
+        <p class="mb-0">The session is not present in the current snapshot.</p>
+    </section>
+}
+else
+{
+    <div class="dashboard-page-header">
+        <div>
+            <h1>Session Details</h1>
+            <div class="text-secondary"><code>@CurrentSession.SessionId</code></div>
+        </div>
+        <StatusBadge Text="@CurrentSession.State.ToString()" />
+    </div>
+
+    <section class="dashboard-section">
+        <div class="section-heading">
+            <h2>Session</h2>
+        </div>
+        <div class="table-responsive">
+            <table class="table table-sm dashboard-table details-table">
+                <tbody>
+                    <tr><th scope="row">Backend</th><td>@CurrentSession.BackendName</td></tr>
+                    <tr><th scope="row">Client identity</th><td>@DashboardDisplay.Text(CurrentSession.ClientIdentity)</td></tr>
+                    <tr><th scope="row">Client session</th><td>@DashboardDisplay.Text(CurrentSession.ClientSessionName)</td></tr>
+                    <tr><th scope="row">Client correlation</th><td>@DashboardDisplay.Text(CurrentSession.ClientCorrelationId)</td></tr>
+                    <tr><th scope="row">Opened</th><td>@DashboardDisplay.DateTime(CurrentSession.OpenedAt)</td></tr>
+                    <tr><th scope="row">Last activity</th><td>@DashboardDisplay.DateTime(CurrentSession.LastClientActivityAt)</td></tr>
+                    <tr><th scope="row">Lease expires</th><td>@DashboardDisplay.DateTime(CurrentSession.LeaseExpiresAt)</td></tr>
+                    <tr><th scope="row">Last fault</th><td>@DashboardDisplay.Text(CurrentSession.LastFault)</td></tr>
+                </tbody>
+            </table>
+        </div>
+    </section>
+
+    <section class="dashboard-section">
+        <div class="section-heading">
+            <h2>Worker</h2>
+        </div>
+        <div class="table-responsive">
+            <table class="table table-sm dashboard-table details-table">
+                <tbody>
+                    <tr><th scope="row">Process id</th><td>@(CurrentSession.WorkerProcessId?.ToString(System.Globalization.CultureInfo.InvariantCulture) ?? "-")</td></tr>
+                    <tr><th scope="row">State</th><td><StatusBadge Text="@(CurrentSession.WorkerState?.ToString() ?? "-")" /></td></tr>
+                    <tr><th scope="row">Last heartbeat</th><td>@DashboardDisplay.DateTime(CurrentSession.LastWorkerHeartbeatAt)</td></tr>
+                </tbody>
+            </table>
+        </div>
+    </section>
+}
+
+@code {
+    [Parameter]
+    public string SessionId { get; set; } = string.Empty;
+
+    private DashboardSessionSummary? CurrentSession => Snapshot?.Sessions.FirstOrDefault(session =>
+        string.Equals(session.SessionId, SessionId, StringComparison.Ordinal));
+}
@@ -0,0 +1,67 @@
+@page "/sessions"
+@inherits DashboardPageBase
+
+<PageTitle>Dashboard Sessions</PageTitle>
+
+@if (Snapshot is null)
+{
+    <div class="empty-state">Loading sessions.</div>
+}
+else
+{
+    <div class="dashboard-page-header">
+        <div>
+            <h1>Sessions</h1>
+            <div class="text-secondary">@Snapshot.Sessions.Count session rows</div>
+        </div>
+    </div>
+
+    <section class="dashboard-section">
+        @if (Snapshot.Sessions.Count == 0)
+        {
+            <div class="empty-state">No sessions are active or retained.</div>
+        }
+        else
+        {
+            <div class="table-responsive">
+                <table class="table table-sm align-middle dashboard-table">
+                    <thead>
+                        <tr>
+                            <th scope="col">Session</th>
+                            <th scope="col">State</th>
+                            <th scope="col">Client</th>
+                            <th scope="col">Backend</th>
+                            <th scope="col">Worker</th>
+                            <th scope="col">Opened</th>
+                            <th scope="col">Activity</th>
+                            <th scope="col">Heartbeat</th>
+                            <th scope="col">Fault</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        @foreach (DashboardSessionSummary session in Snapshot.Sessions)
+                        {
+                            <tr>
+                                <td><NavLink href="@($"sessions/{Uri.EscapeDataString(session.SessionId)}")"><code>@session.SessionId</code></NavLink></td>
+                                <td><StatusBadge Text="@session.State.ToString()" /></td>
+                                <td>@DashboardDisplay.Text(session.ClientIdentity)</td>
+                                <td>@session.BackendName</td>
+                                <td>
+                                    @(session.WorkerProcessId?.ToString(System.Globalization.CultureInfo.InvariantCulture) ?? "-")
+                                    @if (session.WorkerState is not null)
+                                    {
+                                        <span class="ms-1"><StatusBadge Text="@session.WorkerState.ToString()" /></span>
+                                    }
+                                </td>
+                                <td>@DashboardDisplay.DateTime(session.OpenedAt)</td>
+                                <td>@DashboardDisplay.DateTime(session.LastClientActivityAt)</td>
+                                <td>@DashboardDisplay.DateTime(session.LastWorkerHeartbeatAt)</td>
+                                <td>@DashboardDisplay.Text(session.LastFault)</td>
+                            </tr>
+                        }
+                    </tbody>
+                </table>
+            </div>
+        }
+    </section>
+}
@@ -0,0 +1,47 @@
+@page "/settings"
+@inherits DashboardPageBase
+
+<PageTitle>Dashboard Settings</PageTitle>
+
+@if (Snapshot is null)
+{
+    <div class="empty-state">Loading settings.</div>
+}
+else
+{
+    <div class="dashboard-page-header">
+        <div>
+            <h1>Settings</h1>
+            <div class="text-secondary">Effective gateway configuration</div>
+        </div>
+    </div>
+
+    <section class="dashboard-section">
+        <div class="table-responsive">
+            <table class="table table-sm dashboard-table details-table">
+                <tbody>
+                    <tr><th scope="row">Authentication mode</th><td>@Snapshot.Configuration.Authentication.Mode</td></tr>
+                    <tr><th scope="row">Auth database</th><td><code>@Snapshot.Configuration.Authentication.SqlitePath</code></td></tr>
+                    <tr><th scope="row">Pepper secret</th><td>@Snapshot.Configuration.Authentication.PepperSecretName</td></tr>
+                    <tr><th scope="row">Run migrations</th><td>@Snapshot.Configuration.Authentication.RunMigrationsOnStartup</td></tr>
+                    <tr><th scope="row">Worker executable</th><td><code>@Snapshot.Configuration.Worker.ExecutablePath</code></td></tr>
+                    <tr><th scope="row">Worker architecture</th><td>@Snapshot.Configuration.Worker.RequiredArchitecture</td></tr>
+                    <tr><th scope="row">Startup timeout</th><td>@Snapshot.Configuration.Worker.StartupTimeoutSeconds seconds</td></tr>
+                    <tr><th scope="row">Shutdown timeout</th><td>@Snapshot.Configuration.Worker.ShutdownTimeoutSeconds seconds</td></tr>
+                    <tr><th scope="row">Heartbeat grace</th><td>@Snapshot.Configuration.Worker.HeartbeatGraceSeconds seconds</td></tr>
+                    <tr><th scope="row">Default command timeout</th><td>@Snapshot.Configuration.Sessions.DefaultCommandTimeoutSeconds seconds</td></tr>
+                    <tr><th scope="row">Max sessions</th><td>@Snapshot.Configuration.Sessions.MaxSessions</td></tr>
+                    <tr><th scope="row">Event queue capacity</th><td>@Snapshot.Configuration.Events.QueueCapacity</td></tr>
+                    <tr><th scope="row">Backpressure policy</th><td>@Snapshot.Configuration.Events.BackpressurePolicy</td></tr>
+                    <tr><th scope="row">Dashboard enabled</th><td>@Snapshot.Configuration.Dashboard.Enabled</td></tr>
+                    <tr><th scope="row">Dashboard path</th><td>@Snapshot.Configuration.Dashboard.PathBase</td></tr>
+                    <tr><th scope="row">Require admin scope</th><td>@Snapshot.Configuration.Dashboard.RequireAdminScope</td></tr>
+                    <tr><th scope="row">Anonymous localhost</th><td>@Snapshot.Configuration.Dashboard.AllowAnonymousLocalhost</td></tr>
+                    <tr><th scope="row">Snapshot interval</th><td>@Snapshot.Configuration.Dashboard.SnapshotIntervalMilliseconds ms</td></tr>
+                    <tr><th scope="row">Show tag values</th><td>@Snapshot.Configuration.Dashboard.ShowTagValues</td></tr>
+                    <tr><th scope="row">Worker protocol</th><td>@Snapshot.Configuration.Protocol.WorkerProtocolVersion</td></tr>
+                </tbody>
+            </table>
+        </div>
+    </section>
+}
@@ -0,0 +1,53 @@
+@page "/workers"
+@inherits DashboardPageBase
+
+<PageTitle>Dashboard Workers</PageTitle>
+
+@if (Snapshot is null)
+{
+    <div class="empty-state">Loading workers.</div>
+}
+else
+{
+    <div class="dashboard-page-header">
+        <div>
+            <h1>Workers</h1>
+            <div class="text-secondary">@Snapshot.Workers.Count worker rows</div>
+        </div>
+    </div>
+
+    <section class="dashboard-section">
+        @if (Snapshot.Workers.Count == 0)
+        {
+            <div class="empty-state">No worker processes are attached.</div>
+        }
+        else
+        {
+            <div class="table-responsive">
+                <table class="table table-sm align-middle dashboard-table">
+                    <thead>
+                        <tr>
+                            <th scope="col">Process</th>
+                            <th scope="col">State</th>
+                            <th scope="col">Session</th>
+                            <th scope="col">Heartbeat</th>
+                            <th scope="col">Fault</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        @foreach (DashboardWorkerSummary worker in Snapshot.Workers)
+                        {
+                            <tr>
+                                <td>@(worker.ProcessId?.ToString(System.Globalization.CultureInfo.InvariantCulture) ?? "-")</td>
+                                <td><StatusBadge Text="@worker.State.ToString()" /></td>
+                                <td><NavLink href="@($"sessions/{Uri.EscapeDataString(worker.SessionId)}")"><code>@worker.SessionId</code></NavLink></td>
+                                <td>@DashboardDisplay.DateTime(worker.LastHeartbeatAt)</td>
+                                <td>@DashboardDisplay.Text(worker.LastFault)</td>
+                            </tr>
+                        }
+                    </tbody>
+                </table>
+            </div>
+        }
+    </section>
+}
@@ -0,0 +1,15 @@
+<Router AppAssembly="@typeof(Routes).Assembly">
+    <Found Context="routeData">
+        <RouteView RouteData="@routeData" DefaultLayout="@typeof(DashboardLayout)" />
+        <FocusOnNavigate RouteData="@routeData" Selector="h1" />
+    </Found>
+    <NotFound>
+        <LayoutView Layout="@typeof(DashboardLayout)">
+            <PageTitle>Dashboard - Not Found</PageTitle>
+            <section class="dashboard-section">
+                <h1 class="h4 mb-3">Not Found</h1>
+                <p class="mb-0">The requested dashboard page does not exist.</p>
+            </section>
+        </LayoutView>
+    </NotFound>
+</Router>
@@ -0,0 +1,39 @@
+@if (Faults.Count == 0)
+{
+    <div class="empty-state">No faults recorded.</div>
+}
+else
+{
+    <div class="table-responsive">
+        <table class="table table-sm align-middle dashboard-table">
+            <thead>
+                <tr>
+                    <th scope="col">Observed</th>
+                    <th scope="col">Source</th>
+                    <th scope="col">Session</th>
+                    <th scope="col">Worker</th>
+                    <th scope="col">State</th>
+                    <th scope="col">Message</th>
+                </tr>
+            </thead>
+            <tbody>
+                @foreach (DashboardFaultSummary fault in Faults)
+                {
+                    <tr>
+                        <td>@DashboardDisplay.DateTime(fault.ObservedAt)</td>
+                        <td>@fault.Source</td>
+                        <td><code>@DashboardDisplay.Text(fault.SessionId)</code></td>
+                        <td>@(fault.WorkerProcessId?.ToString(System.Globalization.CultureInfo.InvariantCulture) ?? "-")</td>
+                        <td><StatusBadge Text="@fault.State" /></td>
+                        <td>@fault.Message</td>
+                    </tr>
+                }
+            </tbody>
+        </table>
+    </div>
+}
+
+@code {
+    [Parameter]
+    public IReadOnlyList<DashboardFaultSummary> Faults { get; set; } = [];
+}
@@ -0,0 +1,21 @@
+<div class="card metric-card h-100">
+    <div class="card-body">
+        <div class="metric-label">@Label</div>
+        <div class="metric-value">@Value</div>
+        @if (!string.IsNullOrWhiteSpace(Detail))
+        {
+            <div class="metric-detail">@Detail</div>
+        }
+    </div>
+</div>
+
+@code {
+    [Parameter]
+    public string Label { get; set; } = string.Empty;
+
+    [Parameter]
+    public string Value { get; set; } = string.Empty;
+
+    [Parameter]
+    public string? Detail { get; set; }
+}
@@ -0,0 +1,15 @@
+<span class="badge @CssClass">@Text</span>
+
+@code {
+    [Parameter]
+    public string? Text { get; set; }
+
+    private string CssClass => Text switch
+    {
+        "Ready" or "Healthy" => "text-bg-success",
+        "Creating" or "StartingWorker" or "WaitingForPipe" or "InitializingWorker" or "Closing" => "text-bg-info",
+        "Closed" => "text-bg-secondary",
+        "Faulted" => "text-bg-danger",
+        _ => "text-bg-light text-dark border"
+    };
+}
@@ -0,0 +1,12 @@
+@using Microsoft.AspNetCore.Components.Authorization
+@using Microsoft.AspNetCore.Components.Forms
+@using Microsoft.AspNetCore.Components.Routing
+@using Microsoft.AspNetCore.Components.Web
+@using Microsoft.Extensions.Options
+@using MxGateway.Contracts.Proto
+@using MxGateway.Server.Configuration
+@using MxGateway.Server.Dashboard
+@using MxGateway.Server.Dashboard.Components.Layout
+@using MxGateway.Server.Dashboard.Components.Shared
+@using MxGateway.Server.Workers
+@using static Microsoft.AspNetCore.Components.Web.RenderMode
@@ -3,6 +3,7 @@ using Microsoft.AspNetCore.Antiforgery;
 using Microsoft.AspNetCore.Authentication;
 using Microsoft.AspNetCore.Http.HttpResults;
 using MxGateway.Server.Configuration;
+using MxGateway.Server.Dashboard.Components;

 namespace MxGateway.Server.Dashboard;

@@ -22,13 +23,6 @@ public static class DashboardEndpointRouteBuilderExtensions
        string pathBase = NormalizePathBase(dashboardSection["PathBase"] ?? new DashboardOptions().PathBase);
        RouteGroupBuilder dashboard = endpoints.MapGroup(pathBase);

-        dashboard.MapGet(
-                "/",
-                (HttpContext httpContext, IAntiforgery antiforgery, IDashboardSnapshotService snapshotService) =>
-                    GetDashboardHomeAsync(httpContext, antiforgery, snapshotService, pathBase))
-            .RequireAuthorization(DashboardAuthenticationDefaults.AuthorizationPolicy)
-            .WithName("DashboardHome");
-
        dashboard.MapGet(
                "/login",
                (HttpContext httpContext, IAntiforgery antiforgery) => GetLoginAsync(httpContext, antiforgery, pathBase))
@@ -54,36 +48,13 @@ public static class DashboardEndpointRouteBuilderExtensions
            .AllowAnonymous()
            .WithName("DashboardAccessDenied");

+        dashboard.MapRazorComponents<App>()
+            .AddInteractiveServerRenderMode()
+            .RequireAuthorization(DashboardAuthenticationDefaults.AuthorizationPolicy);
+
        return endpoints;
    }

-    private static ContentHttpResult GetDashboardHomeAsync(
-        HttpContext httpContext,
-        IAntiforgery antiforgery,
-        IDashboardSnapshotService snapshotService,
-        string pathBase)
-    {
-        AntiforgeryTokenSet tokens = antiforgery.GetAndStoreTokens(httpContext);
-        DashboardSnapshot snapshot = snapshotService.GetSnapshot();
-        string requestToken = tokens.RequestToken ?? string.Empty;
-        string body = $"""
-            <form method="post" action="{HtmlEncoder.Default.Encode(pathBase + "/logout")}" class="mb-3">
-                <input name="{tokens.FormFieldName}" type="hidden" value="{HtmlEncoder.Default.Encode(requestToken)}" />
-                <button type="submit">Sign out</button>
-            </form>
-            <dl>
-                <dt>Open sessions</dt>
-                <dd>{snapshot.Sessions.Count}</dd>
-                <dt>Workers</dt>
-                <dd>{snapshot.Workers.Count}</dd>
-                <dt>Faults</dt>
-                <dd>{snapshot.Faults.Count}</dd>
-            </dl>
-            """;
-
-        return TypedResults.Content(RenderPage("MXAccess Gateway Dashboard", body), "text/html");
-    }
-
    private static Task<ContentHttpResult> GetLoginAsync(
        HttpContext httpContext,
        IAntiforgery antiforgery,
@@ -159,14 +130,20 @@ public static class DashboardEndpointRouteBuilderExtensions
            : $"<p role=\"alert\">{HtmlEncoder.Default.Encode(failureMessage)}</p>";

        string body = $"""
-            {alert}
-            <form method="post" action="{HtmlEncoder.Default.Encode(pathBase + "/login")}">
-                <input name="{tokens.FormFieldName}" type="hidden" value="{HtmlEncoder.Default.Encode(requestToken)}" />
-                <input name="returnUrl" type="hidden" value="{HtmlEncoder.Default.Encode(returnUrl)}" />
-                <label for="apiKey">API key</label>
-                <input id="apiKey" name="apiKey" type="password" autocomplete="off" />
-                <button type="submit">Sign in</button>
-            </form>
+            <section class="dashboard-login">
+                {alert}
+                <form method="post" action="{HtmlEncoder.Default.Encode(pathBase + "/login")}" class="card login-card">
+                    <div class="card-body">
+                        <input name="{tokens.FormFieldName}" type="hidden" value="{HtmlEncoder.Default.Encode(requestToken)}" />
+                        <input name="returnUrl" type="hidden" value="{HtmlEncoder.Default.Encode(returnUrl)}" />
+                        <div class="mb-3">
+                            <label for="apiKey" class="form-label">API key</label>
+                            <input id="apiKey" name="apiKey" type="password" autocomplete="off" class="form-control" />
+                        </div>
+                        <button type="submit" class="btn btn-primary">Sign in</button>
+                    </div>
+                </form>
+            </section>
            """;

        return RenderPage("Dashboard Sign In", body);
@@ -181,12 +158,15 @@ public static class DashboardEndpointRouteBuilderExtensions
                <meta charset="utf-8" />
                <meta name="viewport" content="width=device-width, initial-scale=1" />
                <title>{HtmlEncoder.Default.Encode(title)}</title>
+                <link rel="stylesheet" href="/lib/bootstrap/css/bootstrap.min.css" />
+                <link rel="stylesheet" href="/css/dashboard.css" />
            </head>
-            <body>
-                <main>
-                    <h1>{HtmlEncoder.Default.Encode(title)}</h1>
+            <body class="dashboard-body">
+                <main class="container py-5">
+                    <h1 class="h3 mb-4">{HtmlEncoder.Default.Encode(title)}</h1>
                    {body}
                </main>
+                <script src="/lib/bootstrap/js/bootstrap.bundle.min.js"></script>
            </body>
            </html>
            """;
@@ -13,6 +13,9 @@ public static class DashboardServiceCollectionExtensions
        services.AddSingleton<IDashboardAuthenticator, DashboardAuthenticator>();
        services.AddHttpContextAccessor();
        services.AddAntiforgery();
+        services.AddCascadingAuthenticationState();
+        services.AddRazorComponents()
+            .AddInteractiveServerComponents();
        services
            .AddAuthentication(DashboardAuthenticationDefaults.AuthenticationScheme)
            .AddCookie(DashboardAuthenticationDefaults.AuthenticationScheme);
@@ -19,8 +19,10 @@ public static class GatewayApplication
        WebApplication app = builder.Build();

        app.UseGatewayRequestLoggingScope();
+        app.UseStaticFiles();
        app.UseAuthentication();
        app.UseAuthorization();
+        app.UseAntiforgery();
        app.MapGatewayEndpoints();

        return app;
@@ -0,0 +1,14 @@
+{
+  "version": "1.0",
+  "defaultProvider": "cdnjs",
+  "libraries": [
+    {
+      "library": "bootstrap@5.3.3",
+      "destination": "wwwroot/lib/bootstrap/",
+      "files": [
+        "css/bootstrap.min.css",
+        "js/bootstrap.bundle.min.js"
+      ]
+    }
+  ]
+}
@@ -0,0 +1,138 @@
+:root {
+    --mxgw-surface: #f7f8fa;
+    --mxgw-border: #d8dee6;
+    --mxgw-ink-muted: #667085;
+    --mxgw-accent: #146c64;
+}
+
+.dashboard-body {
+    background: var(--mxgw-surface);
+    color: #1f2933;
+}
+
+.dashboard-navbar {
+    min-height: 3.5rem;
+}
+
+.dashboard-content {
+    padding: 1.25rem;
+}
+
+.dashboard-page-header {
+    align-items: center;
+    display: flex;
+    gap: 1rem;
+    justify-content: space-between;
+    margin-bottom: 1rem;
+}
+
+.dashboard-page-header h1,
+.section-heading h2 {
+    font-size: 1.35rem;
+    font-weight: 650;
+    letter-spacing: 0;
+    margin: 0;
+}
+
+.section-heading {
+    margin-bottom: .75rem;
+}
+
+.dashboard-section {
+    background: #fff;
+    border-top: 1px solid var(--mxgw-border);
+    margin-top: 1rem;
+    padding: 1rem 0 0;
+}
+
+.metric-grid {
+    display: grid;
+    gap: .75rem;
+    grid-template-columns: repeat(auto-fit, minmax(12rem, 1fr));
+}
+
+.metric-grid.compact {
+    grid-template-columns: repeat(auto-fit, minmax(10rem, 1fr));
+}
+
+.metric-card {
+    border-color: var(--mxgw-border);
+    border-radius: .375rem;
+    box-shadow: none;
+}
+
+.metric-label {
+    color: var(--mxgw-ink-muted);
+    font-size: .78rem;
+    font-weight: 650;
+    letter-spacing: 0;
+    text-transform: uppercase;
+}
+
+.metric-value {
+    color: var(--mxgw-accent);
+    font-size: 1.7rem;
+    font-weight: 700;
+    letter-spacing: 0;
+    line-height: 1.25;
+    overflow-wrap: anywhere;
+}
+
+.metric-detail {
+    color: var(--mxgw-ink-muted);
+    font-size: .85rem;
+    overflow-wrap: anywhere;
+}
+
+.dashboard-table {
+    --bs-table-bg: #fff;
+    border-color: var(--mxgw-border);
+    margin-bottom: 0;
+}
+
+.dashboard-table th {
+    color: #344054;
+    font-weight: 650;
+    white-space: nowrap;
+}
+
+.dashboard-table td {
+    max-width: 24rem;
+    overflow-wrap: anywhere;
+}
+
+.details-table th {
+    width: 14rem;
+}
+
+.empty-state {
+    background: #fff;
+    border: 1px dashed var(--mxgw-border);
+    border-radius: .375rem;
+    color: var(--mxgw-ink-muted);
+    padding: 1rem;
+}
+
+.dashboard-login {
+    max-width: 28rem;
+}
+
+.login-card {
+    border-color: var(--mxgw-border);
+    border-radius: .375rem;
+}
+
+@media (max-width: 700px) {
+    .dashboard-content {
+        padding: .75rem;
+    }
+
+    .dashboard-page-header {
+        align-items: flex-start;
+        flex-direction: column;
+    }
+
+    .details-table th {
+        width: 9rem;
+    }
+}
@@ -33,6 +33,37 @@ public sealed class GatewayApplicationTests
        Assert.NotNull(metrics);
    }

+    [Fact]
+    public void Build_WhenDashboardEnabled_MapsBlazorDashboardAndAuthEndpoints()
+    {
+        WebApplication app = GatewayApplication.Build([]);
+        IReadOnlyList<RouteEndpoint> endpoints = GetRouteEndpoints(app);
+
+        Assert.Contains(endpoints, endpoint => endpoint.RoutePattern.RawText == "/dashboard/");
+        Assert.Contains(endpoints, endpoint => endpoint.RoutePattern.RawText == "/dashboard/sessions");
+        Assert.Contains(endpoints, endpoint => endpoint.RoutePattern.RawText == "/dashboard/workers");
+        Assert.Contains(endpoints, endpoint => endpoint.RoutePattern.RawText == "/dashboard/events");
+        Assert.Contains(endpoints, endpoint => endpoint.RoutePattern.RawText == "/dashboard/settings");
+        Assert.Contains(endpoints, endpoint =>
+            endpoint.Metadata.GetMetadata<IEndpointNameMetadata>()?.EndpointName == "DashboardLogin");
+        Assert.Contains(endpoints, endpoint =>
+            endpoint.Metadata.GetMetadata<IEndpointNameMetadata>()?.EndpointName == "DashboardLogout");
+    }
+
+    [Fact]
+    public void Build_WhenDashboardDisabled_DoesNotMapDashboardRoutes()
+    {
+        WebApplication app = GatewayApplication.Build(["--MxGateway:Dashboard:Enabled=false"]);
+        IReadOnlyList<RouteEndpoint> endpoints = GetRouteEndpoints(app);
+
+        Assert.DoesNotContain(endpoints, endpoint =>
+            endpoint.RoutePattern.RawText?.StartsWith("/dashboard", StringComparison.Ordinal) == true);
+        Assert.DoesNotContain(endpoints, endpoint =>
+            endpoint.Metadata.GetMetadata<IEndpointNameMetadata>()?.EndpointName?.StartsWith(
+                "Dashboard",
+                StringComparison.Ordinal) == true);
+    }
+
    [Theory]
    [InlineData(
        "MxGateway:Worker:ExecutablePath",
@@ -65,4 +96,12 @@ public sealed class GatewayApplicationTests
            exception.Failures,
            failure => failure.Contains(expectedFailure, StringComparison.Ordinal));
    }
+
+    private static IReadOnlyList<RouteEndpoint> GetRouteEndpoints(WebApplication app)
+    {
+        return ((IEndpointRouteBuilder)app).DataSources
+            .SelectMany(dataSource => dataSource.Endpoints)
+            .OfType<RouteEndpoint>()
+            .ToArray();
+    }
 }
@@ -1,216 +0,0 @@
-using Microsoft.Extensions.Logging.Abstractions;
-using Microsoft.Extensions.Options;
-using MxGateway.Contracts;
-using MxGateway.Contracts.Proto;
-using MxGateway.Server.Configuration;
-using MxGateway.Server.Metrics;
-using MxGateway.Server.Sessions;
-using MxGateway.Server.Workers;
-using MxGateway.Tests.Gateway.Workers.Fakes;
-
-namespace MxGateway.Tests.Gateway.Sessions;
-
-public sealed class SessionWorkerClientFactoryFakeWorkerTests
-{
-    private static readonly TimeSpan TestTimeout = TimeSpan.FromSeconds(5);
-
-    [Fact]
-    public async Task CreateAsync_WithScriptedFakeWorker_ReturnsReadyClient()
-    {
-        ScriptedFakeWorkerProcessLauncher launcher = new();
-        using GatewayMetrics metrics = new();
-        SessionWorkerClientFactory factory = new(
-            launcher,
-            Options.Create(CreateOptions()),
-            metrics,
-            NullLoggerFactory.Instance);
-        GatewaySession session = CreateSession();
-
-        await using IWorkerClient workerClient = await factory.CreateAsync(
-            session,
-            CancellationToken.None);
-
-        Assert.Equal(WorkerClientState.Ready, workerClient.State);
-        Assert.Equal(ScriptedFakeWorkerProcessLauncher.ProcessId, workerClient.ProcessId);
-        Assert.NotNull(launcher.Harness);
-
-        Task<WorkerCommandReply> invokeTask = workerClient.InvokeAsync(
-            CreateCommand(MxCommandKind.Ping),
-            TestTimeout,
-            CancellationToken.None);
-        WorkerEnvelope commandEnvelope = await launcher.Harness.ReadCommandAsync();
-        await launcher.Harness.ReplyToCommandAsync(commandEnvelope);
-        WorkerCommandReply reply = await invokeTask.WaitAsync(TestTimeout);
-
-        Assert.Equal(MxCommandKind.Ping, reply.Reply.Kind);
-        Assert.Equal(ProtocolStatusCode.Ok, reply.Reply.ProtocolStatus.Code);
-    }
-
-    [Fact]
-    public async Task CreateAsync_WhenFakeWorkerStartupFails_ThrowsWorkerClientException()
-    {
-        FailingStartupWorkerProcessLauncher launcher = new();
-        using GatewayMetrics metrics = new();
-        SessionWorkerClientFactory factory = new(
-            launcher,
-            Options.Create(CreateOptions()),
-            metrics,
-            NullLoggerFactory.Instance);
-        GatewaySession session = CreateSession();
-
-        WorkerClientException exception = await Assert.ThrowsAsync<WorkerClientException>(
-            async () => await factory.CreateAsync(session, CancellationToken.None).WaitAsync(TestTimeout));
-
-        Assert.Equal(WorkerClientErrorCode.ProtocolViolation, exception.ErrorCode);
-        Assert.True(launcher.Process.IsDisposed);
-    }
-
-    private static GatewayOptions CreateOptions()
-    {
-        return new GatewayOptions
-        {
-            Worker = new WorkerOptions
-            {
-                StartupTimeoutSeconds = 5,
-                ShutdownTimeoutSeconds = 5,
-                HeartbeatIntervalSeconds = 30,
-                HeartbeatGraceSeconds = 30,
-                MaxMessageBytes = WorkerFrameProtocolOptions.DefaultMaxMessageBytes,
-            },
-            Events = new EventOptions
-            {
-                QueueCapacity = 16,
-            },
-        };
-    }
-
-    private static GatewaySession CreateSession()
-    {
-        return new GatewaySession(
-            FakeWorkerHarness.DefaultSessionId,
-            GatewayContractInfo.DefaultBackendName,
-            $"mxaccessgw-session-fake-worker-{Guid.NewGuid():N}",
-            FakeWorkerHarness.DefaultNonce,
-            "test-client",
-            "fake-worker-session-test",
-            "client-correlation-1",
-            TestTimeout,
-            TestTimeout,
-            TestTimeout,
-            DateTimeOffset.UtcNow);
-    }
-
-    private static WorkerCommand CreateCommand(MxCommandKind kind)
-    {
-        return new WorkerCommand
-        {
-            Command = new MxCommand
-            {
-                Kind = kind,
-            },
-        };
-    }
-
-    private sealed class ScriptedFakeWorkerProcessLauncher : IWorkerProcessLauncher
-    {
-        public const int ProcessId = 2468;
-        private readonly FakeWorkerProcess _process = new(ProcessId);
-
-        public FakeWorkerHarness? Harness { get; private set; }
-
-        public Task<WorkerProcessHandle> LaunchAsync(
-            WorkerProcessLaunchRequest request,
-            CancellationToken cancellationToken = default)
-        {
-            _ = RunWorkerAsync(request, cancellationToken);
-
-            return Task.FromResult(CreateHandle(_process));
-        }
-
-        private async Task RunWorkerAsync(
-            WorkerProcessLaunchRequest request,
-            CancellationToken cancellationToken)
-        {
-            Harness = await FakeWorkerHarness.ConnectToGatewayPipeAsync(
-                request.SessionId,
-                request.Nonce,
-                request.PipeName,
-                request.ProtocolVersion,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
-            await Harness.CompleteStartupAsync(ProcessId, cancellationToken: cancellationToken).ConfigureAwait(false);
-        }
-    }
-
-    private sealed class FailingStartupWorkerProcessLauncher : IWorkerProcessLauncher
-    {
-        public FakeWorkerProcess Process { get; } = new(processId: 3579);
-
-        public Task<WorkerProcessHandle> LaunchAsync(
-            WorkerProcessLaunchRequest request,
-            CancellationToken cancellationToken = default)
-        {
-            _ = RunWorkerAsync(request, cancellationToken);
-
-            return Task.FromResult(CreateHandle(Process));
-        }
-
-        private async Task RunWorkerAsync(
-            WorkerProcessLaunchRequest request,
-            CancellationToken cancellationToken)
-        {
-            await using FakeWorkerHarness harness = await FakeWorkerHarness.ConnectToGatewayPipeAsync(
-                request.SessionId,
-                request.Nonce,
-                request.PipeName,
-                request.ProtocolVersion,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
-            _ = await harness.ReadGatewayEnvelopeAsync(cancellationToken).ConfigureAwait(false);
-            await harness.SendWorkerHelloAsync(
-                workerProcessId: Process.Id,
-                workerProtocolVersion: request.ProtocolVersion + 1,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
-        }
-    }
-
-    private static WorkerProcessHandle CreateHandle(IWorkerProcess process)
-    {
-        return new WorkerProcessHandle(
-            process,
-            new WorkerProcessCommandLine("fake-worker.exe", []),
-            DateTimeOffset.UtcNow);
-    }
-
-    private sealed class FakeWorkerProcess(int processId) : IWorkerProcess
-    {
-        private bool _disposed;
-
-        public int Id { get; } = processId;
-
-        public bool HasExited { get; private set; }
-
-        public int? ExitCode { get; private set; }
-
-        public int KillCount { get; private set; }
-
-        public ValueTask WaitForExitAsync(CancellationToken cancellationToken)
-        {
-            HasExited = true;
-            ExitCode = 0;
-            return ValueTask.CompletedTask;
-        }
-
-        public void Kill(bool entireProcessTree)
-        {
-            KillCount++;
-            HasExited = true;
-            ExitCode = -1;
-        }
-
-        public void Dispose()
-        {
-            _disposed = true;
-        }
-
-        public bool IsDisposed => _disposed;
-    }
-}
@@ -1,190 +0,0 @@
-using MxGateway.Contracts;
-using MxGateway.Contracts.Proto;
-using MxGateway.Server.Workers;
-using MxGateway.Tests.Gateway.Workers.Fakes;
-
-namespace MxGateway.Tests.Gateway.Workers;
-
-public sealed class FakeWorkerHarnessTests
-{
-    private static readonly TimeSpan TestTimeout = TimeSpan.FromSeconds(5);
-
-    [Fact]
-    public async Task CompleteStartupAsync_WithHelloAndReady_TransitionsClientToReady()
-    {
-        await using FakeWorkerHarness fakeWorker = await FakeWorkerHarness.CreateConnectedPairAsync();
-        await using WorkerClient client = fakeWorker.CreateClient();
-
-        Task startTask = client.StartAsync(CancellationToken.None);
-        WorkerEnvelope gatewayHello = await fakeWorker.CompleteStartupAsync();
-        await startTask.WaitAsync(TestTimeout);
-
-        Assert.Equal(WorkerEnvelope.BodyOneofCase.GatewayHello, gatewayHello.BodyCase);
-        Assert.Equal(FakeWorkerHarness.DefaultNonce, gatewayHello.GatewayHello.Nonce);
-        Assert.Equal(WorkerClientState.Ready, client.State);
-        Assert.Equal(FakeWorkerHarness.DefaultWorkerProcessId, client.ProcessId);
-    }
-
-    [Fact]
-    public async Task StartAsync_WithProtocolMismatch_FailsStartup()
-    {
-        await using FakeWorkerHarness fakeWorker = await FakeWorkerHarness.CreateConnectedPairAsync();
-        await using WorkerClient client = fakeWorker.CreateClient();
-
-        Task startTask = client.StartAsync(CancellationToken.None);
-        WorkerEnvelope gatewayHello = await fakeWorker.ReadGatewayEnvelopeAsync();
-        Assert.Equal(WorkerEnvelope.BodyOneofCase.GatewayHello, gatewayHello.BodyCase);
-        await fakeWorker.SendWorkerHelloAsync(
-            workerProtocolVersion: GatewayContractInfo.WorkerProtocolVersion + 1);
-
-        WorkerClientException exception = await Assert.ThrowsAsync<WorkerClientException>(
-            async () => await startTask.WaitAsync(TestTimeout));
-
-        Assert.Equal(WorkerClientErrorCode.ProtocolViolation, exception.ErrorCode);
-    }
-
-    [Fact]
-    public async Task InvokeAsync_WithScriptedReply_CompletesCommand()
-    {
-        await using FakeWorkerHarness fakeWorker = await FakeWorkerHarness.CreateConnectedPairAsync();
-        await using WorkerClient client = fakeWorker.CreateClient();
-        await StartClientAsync(fakeWorker, client);
-
-        Task<WorkerCommandReply> invokeTask = client.InvokeAsync(
-            CreateCommand(MxCommandKind.Ping),
-            TestTimeout,
-            CancellationToken.None);
-        WorkerEnvelope commandEnvelope = await fakeWorker.ReadCommandAsync();
-        await fakeWorker.ReplyToCommandAsync(commandEnvelope);
-
-        WorkerCommandReply reply = await invokeTask.WaitAsync(TestTimeout);
-
-        Assert.Equal(commandEnvelope.CorrelationId, reply.Reply.CorrelationId);
-        Assert.Equal(MxCommandKind.Ping, reply.Reply.Kind);
-        Assert.Equal(ProtocolStatusCode.Ok, reply.Reply.ProtocolStatus.Code);
-    }
-
-    [Fact]
-    public async Task ReadEventsAsync_WithScriptedEvents_YieldsOrderedEvents()
-    {
-        await using FakeWorkerHarness fakeWorker = await FakeWorkerHarness.CreateConnectedPairAsync();
-        await using WorkerClient client = fakeWorker.CreateClient();
-        await StartClientAsync(fakeWorker, client);
-        using CancellationTokenSource cancellationTokenSource = new(TestTimeout);
-
-        await using IAsyncEnumerator<WorkerEvent> events =
-            client.ReadEventsAsync(cancellationTokenSource.Token).GetAsyncEnumerator(cancellationTokenSource.Token);
-
-        await fakeWorker.EmitEventAsync(MxEventFamily.OnDataChange, cancellationTokenSource.Token);
-        await fakeWorker.EmitEventAsync(MxEventFamily.OperationComplete, cancellationTokenSource.Token);
-
-        Assert.True(await events.MoveNextAsync());
-        Assert.Equal((ulong)3, events.Current.Event.WorkerSequence);
-        Assert.Equal(MxEventFamily.OnDataChange, events.Current.Event.Family);
-
-        Assert.True(await events.MoveNextAsync());
-        Assert.Equal((ulong)4, events.Current.Event.WorkerSequence);
-        Assert.Equal(MxEventFamily.OperationComplete, events.Current.Event.Family);
-    }
-
-    [Fact]
-    public async Task ReadLoop_WithScriptedFault_FaultsClient()
-    {
-        await using FakeWorkerHarness fakeWorker = await FakeWorkerHarness.CreateConnectedPairAsync();
-        await using WorkerClient client = fakeWorker.CreateClient();
-        await StartClientAsync(fakeWorker, client);
-
-        await fakeWorker.EmitFaultAsync(
-            WorkerFaultCategory.MxaccessCommandFailed,
-            "scripted MXAccess command fault");
-
-        await WaitUntilAsync(
-            () => client.State == WorkerClientState.Faulted,
-            TestTimeout);
-
-        Assert.Equal(WorkerClientState.Faulted, client.State);
-    }
-
-    [Fact]
-    public async Task InvokeAsync_WithHungWorker_TimesOutPendingCommand()
-    {
-        await using FakeWorkerHarness fakeWorker = await FakeWorkerHarness.CreateConnectedPairAsync();
-        await using WorkerClient client = fakeWorker.CreateClient();
-        await StartClientAsync(fakeWorker, client);
-
-        Task<WorkerCommandReply> invokeTask = client.InvokeAsync(
-            CreateCommand(MxCommandKind.Ping),
-            TimeSpan.FromMilliseconds(50),
-            CancellationToken.None);
-        WorkerEnvelope commandEnvelope = await fakeWorker.ReadCommandAsync();
-
-        WorkerClientException exception = await Assert.ThrowsAsync<WorkerClientException>(
-            async () => await invokeTask.WaitAsync(TestTimeout));
-
-        Assert.Equal(WorkerEnvelope.BodyOneofCase.WorkerCommand, commandEnvelope.BodyCase);
-        Assert.Equal(WorkerClientErrorCode.CommandTimeout, exception.ErrorCode);
-    }
-
-    [Fact]
-    public async Task ReadLoop_WithMalformedFrame_FaultsClient()
-    {
-        await using FakeWorkerHarness fakeWorker = await FakeWorkerHarness.CreateConnectedPairAsync();
-        await using WorkerClient client = fakeWorker.CreateClient();
-        await StartClientAsync(fakeWorker, client);
-
-        await fakeWorker.WriteMalformedPayloadAsync(new byte[] { 0x08, 0x96, 0x01 });
-
-        await WaitUntilAsync(
-            () => client.State == WorkerClientState.Faulted,
-            TestTimeout);
-
-        Assert.Equal(WorkerClientState.Faulted, client.State);
-    }
-
-    [Fact]
-    public async Task ShutdownAsync_WithShutdownAck_ClosesClient()
-    {
-        await using FakeWorkerHarness fakeWorker = await FakeWorkerHarness.CreateConnectedPairAsync();
-        await using WorkerClient client = fakeWorker.CreateClient();
-        await StartClientAsync(fakeWorker, client);
-
-        Task shutdownTask = client.ShutdownAsync(TestTimeout, CancellationToken.None);
-        WorkerEnvelope shutdownEnvelope = await fakeWorker.ReadShutdownAsync();
-        await fakeWorker.SendShutdownAckAsync();
-        await shutdownTask.WaitAsync(TestTimeout);
-
-        Assert.Equal(WorkerEnvelope.BodyOneofCase.WorkerShutdown, shutdownEnvelope.BodyCase);
-        Assert.Equal(WorkerClientState.Closed, client.State);
-    }
-
-    private static async Task StartClientAsync(
-        FakeWorkerHarness fakeWorker,
-        WorkerClient client)
-    {
-        Task startTask = client.StartAsync(CancellationToken.None);
-        await fakeWorker.CompleteStartupAsync().ConfigureAwait(false);
-        await startTask.WaitAsync(TestTimeout).ConfigureAwait(false);
-    }
-
-    private static WorkerCommand CreateCommand(MxCommandKind kind)
-    {
-        return new WorkerCommand
-        {
-            Command = new MxCommand
-            {
-                Kind = kind,
-            },
-        };
-    }
-
-    private static async Task WaitUntilAsync(
-        Func<bool> predicate,
-        TimeSpan timeout)
-    {
-        using CancellationTokenSource cancellationTokenSource = new(timeout);
-        while (!predicate())
-        {
-            await Task.Delay(TimeSpan.FromMilliseconds(10), cancellationTokenSource.Token);
-        }
-    }
-}
@@ -1,378 +0,0 @@
-using System.Buffers.Binary;
-using System.IO.Pipes;
-using Google.Protobuf.WellKnownTypes;
-using MxGateway.Contracts;
-using MxGateway.Contracts.Proto;
-using MxGateway.Server.Metrics;
-using MxGateway.Server.Workers;
-
-namespace MxGateway.Tests.Gateway.Workers.Fakes;
-
-public sealed class FakeWorkerHarness : IAsyncDisposable
-{
-    public const string DefaultSessionId = "session-fake-worker";
-    public const string DefaultNonce = "nonce-fake-worker";
-    public const int DefaultWorkerProcessId = 9321;
-
-    private readonly NamedPipeServerStream? _gatewayStream;
-    private readonly NamedPipeClientStream _workerStream;
-    private readonly WorkerFrameProtocolOptions _frameOptions;
-    private readonly WorkerFrameReader _reader;
-    private readonly WorkerFrameWriter _writer;
-    private bool _workerSideDisposed;
-
-    private FakeWorkerHarness(
-        string sessionId,
-        string nonce,
-        NamedPipeServerStream? gatewayStream,
-        NamedPipeClientStream workerStream,
-        WorkerFrameProtocolOptions frameOptions)
-    {
-        SessionId = sessionId;
-        Nonce = nonce;
-        _gatewayStream = gatewayStream;
-        _workerStream = workerStream;
-        _frameOptions = frameOptions;
-        _reader = new WorkerFrameReader(_workerStream, frameOptions);
-        _writer = new WorkerFrameWriter(_workerStream, frameOptions);
-    }
-
-    public string SessionId { get; }
-
-    public string Nonce { get; }
-
-    public ulong NextWorkerSequence { get; private set; }
-
-    public static async Task<FakeWorkerHarness> CreateConnectedPairAsync(
-        string sessionId = DefaultSessionId,
-        string nonce = DefaultNonce,
-        uint protocolVersion = GatewayContractInfo.WorkerProtocolVersion,
-        int maxMessageBytes = WorkerFrameProtocolOptions.DefaultMaxMessageBytes,
-        CancellationToken cancellationToken = default)
-    {
-        string pipeName = $"mxaccessgw-fake-worker-{Guid.NewGuid():N}";
-        NamedPipeServerStream gatewayStream = new(
-            pipeName,
-            PipeDirection.InOut,
-            maxNumberOfServerInstances: 1,
-            PipeTransmissionMode.Byte,
-            PipeOptions.Asynchronous);
-        NamedPipeClientStream workerStream = CreateWorkerStream(pipeName);
-
-        Task waitForConnectionTask = gatewayStream.WaitForConnectionAsync(cancellationToken);
-        await workerStream.ConnectAsync(cancellationToken).ConfigureAwait(false);
-        await waitForConnectionTask.ConfigureAwait(false);
-
-        return new FakeWorkerHarness(
-            sessionId,
-            nonce,
-            gatewayStream,
-            workerStream,
-            new WorkerFrameProtocolOptions(sessionId, protocolVersion, maxMessageBytes));
-    }
-
-    public static async Task<FakeWorkerHarness> ConnectToGatewayPipeAsync(
-        string sessionId,
-        string nonce,
-        string pipeName,
-        uint protocolVersion = GatewayContractInfo.WorkerProtocolVersion,
-        int maxMessageBytes = WorkerFrameProtocolOptions.DefaultMaxMessageBytes,
-        CancellationToken cancellationToken = default)
-    {
-        NamedPipeClientStream workerStream = CreateWorkerStream(pipeName);
-        await workerStream.ConnectAsync(cancellationToken).ConfigureAwait(false);
-
-        return new FakeWorkerHarness(
-            sessionId,
-            nonce,
-            gatewayStream: null,
-            workerStream,
-            new WorkerFrameProtocolOptions(sessionId, protocolVersion, maxMessageBytes));
-    }
-
-    public WorkerClient CreateClient(
-        WorkerClientOptions? options = null,
-        GatewayMetrics? metrics = null,
-        TimeProvider? timeProvider = null)
-    {
-        if (_gatewayStream is null)
-        {
-            throw new InvalidOperationException("This fake worker is connected to a gateway-owned pipe.");
-        }
-
-        WorkerClientConnection connection = new(
-            SessionId,
-            Nonce,
-            _gatewayStream,
-            _frameOptions);
-
-        return new WorkerClient(connection, options, metrics, timeProvider);
-    }
-
-    public async Task<WorkerEnvelope> CompleteStartupAsync(
-        int workerProcessId = DefaultWorkerProcessId,
-        string workerVersion = "fake-worker",
-        string mxaccessProgid = "LMXProxy.LMXProxyServer.1",
-        string mxaccessClsid = "{C30B52F5-2CB5-4760-AF0A-3A344A7EB5DC}",
-        CancellationToken cancellationToken = default)
-    {
-        WorkerEnvelope gatewayHello = await ReadGatewayEnvelopeAsync(cancellationToken).ConfigureAwait(false);
-        if (gatewayHello.BodyCase != WorkerEnvelope.BodyOneofCase.GatewayHello)
-        {
-            throw new InvalidOperationException($"Expected GatewayHello but received {gatewayHello.BodyCase}.");
-        }
-
-        await SendWorkerHelloAsync(
-            workerProcessId,
-            workerVersion,
-            cancellationToken: cancellationToken).ConfigureAwait(false);
-        await SendWorkerReadyAsync(
-            workerProcessId,
-            mxaccessProgid,
-            mxaccessClsid,
-            cancellationToken).ConfigureAwait(false);
-
-        return gatewayHello;
-    }
-
-    public async Task<WorkerEnvelope> ReadGatewayEnvelopeAsync(CancellationToken cancellationToken = default)
-    {
-        return await _reader.ReadAsync(cancellationToken).ConfigureAwait(false);
-    }
-
-    public async Task<WorkerEnvelope> ReadCommandAsync(CancellationToken cancellationToken = default)
-    {
-        WorkerEnvelope envelope = await ReadGatewayEnvelopeAsync(cancellationToken).ConfigureAwait(false);
-        if (envelope.BodyCase != WorkerEnvelope.BodyOneofCase.WorkerCommand)
-        {
-            throw new InvalidOperationException($"Expected WorkerCommand but received {envelope.BodyCase}.");
-        }
-
-        return envelope;
-    }
-
-    public async Task<WorkerEnvelope> ReadShutdownAsync(CancellationToken cancellationToken = default)
-    {
-        WorkerEnvelope envelope = await ReadGatewayEnvelopeAsync(cancellationToken).ConfigureAwait(false);
-        if (envelope.BodyCase != WorkerEnvelope.BodyOneofCase.WorkerShutdown)
-        {
-            throw new InvalidOperationException($"Expected WorkerShutdown but received {envelope.BodyCase}.");
-        }
-
-        return envelope;
-    }
-
-    public async Task SendWorkerHelloAsync(
-        int workerProcessId = DefaultWorkerProcessId,
-        string workerVersion = "fake-worker",
-        uint? workerProtocolVersion = null,
-        string? nonce = null,
-        CancellationToken cancellationToken = default)
-    {
-        await _writer.WriteAsync(
-            CreateEnvelope(
-                correlationId: string.Empty,
-                envelope => envelope.WorkerHello = new WorkerHello
-                {
-                    ProtocolVersion = workerProtocolVersion ?? _frameOptions.ProtocolVersion,
-                    Nonce = nonce ?? Nonce,
-                    WorkerProcessId = workerProcessId,
-                    WorkerVersion = workerVersion,
-                }),
-            cancellationToken).ConfigureAwait(false);
-    }
-
-    public async Task SendWorkerReadyAsync(
-        int workerProcessId = DefaultWorkerProcessId,
-        string mxaccessProgid = "LMXProxy.LMXProxyServer.1",
-        string mxaccessClsid = "{C30B52F5-2CB5-4760-AF0A-3A344A7EB5DC}",
-        CancellationToken cancellationToken = default)
-    {
-        await _writer.WriteAsync(
-            CreateEnvelope(
-                correlationId: string.Empty,
-                envelope => envelope.WorkerReady = new WorkerReady
-                {
-                    WorkerProcessId = workerProcessId,
-                    MxaccessProgid = mxaccessProgid,
-                    MxaccessClsid = mxaccessClsid,
-                    ReadyTimestamp = Timestamp.FromDateTimeOffset(DateTimeOffset.UtcNow),
-                }),
-            cancellationToken).ConfigureAwait(false);
-    }
-
-    public async Task ReplyToCommandAsync(
-        WorkerEnvelope commandEnvelope,
-        ProtocolStatusCode statusCode = ProtocolStatusCode.Ok,
-        string statusMessage = "OK",
-        CancellationToken cancellationToken = default)
-    {
-        if (commandEnvelope.BodyCase != WorkerEnvelope.BodyOneofCase.WorkerCommand)
-        {
-            throw new ArgumentException("Command envelope must contain WorkerCommand.", nameof(commandEnvelope));
-        }
-
-        MxCommandKind kind = commandEnvelope.WorkerCommand.Command?.Kind ?? MxCommandKind.Unspecified;
-        await _writer.WriteAsync(
-            CreateEnvelope(
-                commandEnvelope.CorrelationId,
-                envelope => envelope.WorkerCommandReply = new WorkerCommandReply
-                {
-                    Reply = new MxCommandReply
-                    {
-                        SessionId = SessionId,
-                        CorrelationId = commandEnvelope.CorrelationId,
-                        Kind = kind,
-                        ProtocolStatus = new ProtocolStatus
-                        {
-                            Code = statusCode,
-                            Message = statusMessage,
-                        },
-                    },
-                    CompletedTimestamp = Timestamp.FromDateTimeOffset(DateTimeOffset.UtcNow),
-                }),
-            cancellationToken).ConfigureAwait(false);
-    }
-
-    public async Task EmitEventAsync(
-        MxEventFamily family,
-        CancellationToken cancellationToken = default)
-    {
-        ulong sequence = NextWorkerSequence + 1;
-        await _writer.WriteAsync(
-            CreateEnvelope(
-                correlationId: string.Empty,
-                envelope => envelope.WorkerEvent = new WorkerEvent
-                {
-                    Event = new MxEvent
-                    {
-                        SessionId = SessionId,
-                        Family = family,
-                        WorkerSequence = sequence,
-                        WorkerTimestamp = Timestamp.FromDateTimeOffset(DateTimeOffset.UtcNow),
-                    },
-                }),
-            cancellationToken).ConfigureAwait(false);
-    }
-
-    public async Task EmitFaultAsync(
-        WorkerFaultCategory category,
-        string diagnosticMessage,
-        CancellationToken cancellationToken = default)
-    {
-        await _writer.WriteAsync(
-            CreateEnvelope(
-                correlationId: string.Empty,
-                envelope => envelope.WorkerFault = new WorkerFault
-                {
-                    Category = category,
-                    DiagnosticMessage = diagnosticMessage,
-                    ProtocolStatus = new ProtocolStatus
-                    {
-                        Code = ProtocolStatusCode.WorkerUnavailable,
-                        Message = diagnosticMessage,
-                    },
-                }),
-            cancellationToken).ConfigureAwait(false);
-    }
-
-    public async Task SendShutdownAckAsync(
-        ProtocolStatusCode statusCode = ProtocolStatusCode.Ok,
-        CancellationToken cancellationToken = default)
-    {
-        await _writer.WriteAsync(
-            CreateEnvelope(
-                correlationId: string.Empty,
-                envelope => envelope.WorkerShutdownAck = new WorkerShutdownAck
-                {
-                    Status = new ProtocolStatus
-                    {
-                        Code = statusCode,
-                        Message = statusCode.ToString(),
-                    },
-                }),
-            cancellationToken).ConfigureAwait(false);
-    }
-
-    public async Task WriteMalformedPayloadAsync(
-        ReadOnlyMemory<byte> payload,
-        CancellationToken cancellationToken = default)
-    {
-        if (payload.IsEmpty)
-        {
-            throw new ArgumentException("Malformed payload must include at least one byte.", nameof(payload));
-        }
-
-        byte[] lengthPrefix = new byte[sizeof(uint)];
-        BinaryPrimitives.WriteUInt32LittleEndian(lengthPrefix, (uint)payload.Length);
-        await _workerStream.WriteAsync(lengthPrefix, cancellationToken).ConfigureAwait(false);
-        await _workerStream.WriteAsync(payload, cancellationToken).ConfigureAwait(false);
-    }
-
-    public async Task WriteOversizedFrameHeaderAsync(
-        uint payloadLength,
-        CancellationToken cancellationToken = default)
-    {
-        if (payloadLength <= _frameOptions.MaxMessageBytes)
-        {
-            throw new ArgumentOutOfRangeException(
-                nameof(payloadLength),
-                payloadLength,
-                "Payload length must exceed the configured maximum.");
-        }
-
-        byte[] lengthPrefix = new byte[sizeof(uint)];
-        BinaryPrimitives.WriteUInt32LittleEndian(lengthPrefix, payloadLength);
-        await _workerStream.WriteAsync(lengthPrefix, cancellationToken).ConfigureAwait(false);
-    }
-
-    public async ValueTask DisposeWorkerSideAsync()
-    {
-        if (_workerSideDisposed)
-        {
-            return;
-        }
-
-        await _workerStream.DisposeAsync().ConfigureAwait(false);
-        _workerSideDisposed = true;
-    }
-
-    public async ValueTask DisposeAsync()
-    {
-        await DisposeWorkerSideAsync().ConfigureAwait(false);
-        if (_gatewayStream is not null)
-        {
-            await _gatewayStream.DisposeAsync().ConfigureAwait(false);
-        }
-    }
-
-    private WorkerEnvelope CreateEnvelope(
-        string correlationId,
-        Action<WorkerEnvelope> setBody)
-    {
-        WorkerEnvelope envelope = new()
-        {
-            ProtocolVersion = _frameOptions.ProtocolVersion,
-            SessionId = SessionId,
-            Sequence = AdvanceSequence(),
-            CorrelationId = correlationId,
-        };
-        setBody(envelope);
-
-        return envelope;
-    }
-
-    private ulong AdvanceSequence()
-    {
-        return ++NextWorkerSequence;
-    }
-
-    private static NamedPipeClientStream CreateWorkerStream(string pipeName)
-    {
-        return new NamedPipeClientStream(
-            ".",
-            pipeName,
-            PipeDirection.InOut,
-            PipeOptions.Asynchronous);
-    }
-}