perf(dashboard): gate event mirror on live viewers — no clone, no send for unwatched sessions

DashboardEventBroadcaster.Publish ran a deep protobuf Clone (redaction is on by
default) and a group SendAsync for every event of every session, before anything
checked whether a dashboard client was actually watching. In the steady state the
session:{id} group is empty, so that work was thrown away per event.

SignalR does not expose group membership, so EventsHub now mirrors its own
add/remove into a singleton EventsHubViewerRegistry, and OnDisconnectedAsync
releases everything a dropped connection held (SessionDetailsPage disposes the
connection rather than unsubscribing). Publish returns early when the session has
no viewers, before the redaction clone. Watched sessions behave exactly as before.

Lazy mirror-lease start/stop was deliberately not attempted — it entangles the
dashboard with SessionEventDistributor subscribe lifetime for no saving beyond
this gate; recorded in docs/GatewayDashboardDesign.md.

src/ZB.MOM.WW.MxGateway.Server/Dashboard/Hubs/EventsHub.cs

@@ -9,8 +9,14 @@ namespace ZB.MOM.WW.MxGateway.Server.Dashboard.Hubs;
 /// session; <see cref="DashboardEventBroadcaster"/> sends messages to
 /// <c>session:{id}</c> as events arrive from the live gRPC stream.
 /// </summary>
+/// <remarks>
+/// Group membership is mirrored into <see cref="EventsHubViewerRegistry"/>
+/// because SignalR does not expose it, and the broadcaster consults the
+/// registry to skip all mirror work for sessions nobody is watching.
+/// </remarks>
+/// <param name="viewerRegistry">Registry tracking which sessions have live subscribers.</param>
 [Authorize(Policy = DashboardAuthenticationDefaults.HubClientsPolicy)]
-public sealed class EventsHub : Hub
+public sealed class EventsHub(EventsHubViewerRegistry viewerRegistry) : Hub
 {
     /// <summary>Method name used to push individual <c>MxEvent</c> values to clients.</summary>
     public const string EventMessage = "MxEvent";
@@ -55,19 +61,43 @@ public sealed class EventsHub : Hub
             return Task.CompletedTask;
         }
 
+        // Register before joining the group: the reverse order would leave a window
+        // in which this connection is a group member but the broadcaster's gate still
+        // reports the session unwatched, silently dropping events it should receive.
+        viewerRegistry.AddViewer(Context.ConnectionId, sessionId);
+
         return Groups.AddToGroupAsync(Context.ConnectionId, GroupName(sessionId));
     }
 
     /// <summary>Unsubscribes the calling SignalR connection from the per-session events group.</summary>
     /// <param name="sessionId">Session id to unsubscribe the caller from.</param>
     /// <returns>A task representing the unsubscription operation.</returns>
-    public Task UnsubscribeSession(string sessionId)
+    public async Task UnsubscribeSession(string sessionId)
     {
         if (string.IsNullOrWhiteSpace(sessionId))
         {
-            return Task.CompletedTask;
+            return;
         }
 
-        return Groups.RemoveFromGroupAsync(Context.ConnectionId, GroupName(sessionId));
+        // Leave the group first, deregister after — the mirror stays enabled for the
+        // brief overlap rather than dropping events still owed to other subscribers.
+        await Groups.RemoveFromGroupAsync(Context.ConnectionId, GroupName(sessionId)).ConfigureAwait(false);
+
+        viewerRegistry.RemoveViewer(Context.ConnectionId, sessionId);
+    }
+
+    /// <summary>
+    /// Releases every session subscription the dropped connection held. A browser
+    /// tab that closes never calls <see cref="UnsubscribeSession"/>, so without
+    /// this the session would look watched forever and the mirror would keep
+    /// cloning and sending events to an empty group.
+    /// </summary>
+    /// <param name="exception">The exception that terminated the connection, if any.</param>
+    /// <returns>A task representing the disconnect handling.</returns>
+    public override Task OnDisconnectedAsync(Exception? exception)
+    {
+        viewerRegistry.ReleaseConnection(Context.ConnectionId);
+
+        return base.OnDisconnectedAsync(exception);
     }
 }