fix(fusion-rpc): server-side invalidation parity (F1, F9, F7, F10)

Align FusionHub's compute-call handling with C# RpcInboundComputeCall /
RpcComputeSystemCallSender:

- F1: wire server->client invalidation via `computed.whenInvalidated()`
  (ProcessStage2 parity) instead of the post-invoke onInvalidated
  subscription, so a computed invalidated mid-computation still sends
  $sys-c.Invalidate. The send is deferred past the dispatch loop's
  $sys.Ok so the result precedes the invalidation, matching C#'s
  ProcessStage1Plus-then-ProcessStage2 ordering (a client drops an
  Invalidate that arrives before its result).
- F9: route the invalidation through a Fusion-extended system-call sender
  (FusionSystemCallSender.invalidate) using the peer's current connection
  and serialization format, instead of a hand-rolled JSON serializeMessage
  on a captured connection. RpcHub gains a `_createSystemCallSender`
  factory; `_send` is now protected.
- F7: thread the inbound message CallType through RpcDispatchContext;
  a Regular call to a compute method returns its result and skips
  invalidation tracking (IsRegularCall parity).
- F10: `_buildServiceDef` now delegates to `super._buildServiceDef` and
  only patches callTypeId for compute methods, so decorator-declared
  noWait / remoteExecutionMode metadata is preserved.

Tests: moves the F1 repro into e2e-rpc.test.ts and adds regression tests
for F9 (msgpack hub pair: invalidation arrives as a binary frame, no JSON
text frame), F7 (regular call sends no $sys-c.Invalidate; compute call
does), and F10 (noWait / remoteExecutionMode survive FusionHub
registration). Full ts suite: 668 passing.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01SDiBQM5rnhyBG1asuP1kDi

Author: alexyakunin

docs/plans/ts-port-audit.md

@@ -796,6 +796,8 @@ Confidence: confirmed by full source trace. (Second-pass finding.)
 
 ### F1. Server→client invalidation is wired with a one-shot `onInvalidated.add()` that misses already-invalidated computeds → client stays stale forever
 
+Status: **closed** — fixed 2026-07-15 (batch fusionrpc1; `whenInvalidated().then(send)` with the send deferred one macrotask to preserve C#'s result-before-invalidation ordering — verified against the synchronous send path).
+
 Confidence: confirmed (re-verified).
 
 - TS: `FusionHub._wrapServerMethod` awaits `cf.invoke(...)`, and only *then* subscribes: `computed.onInvalidated.add(() => ... send($sys-c.Invalidate))` (`fusion-hub.ts:182-193`). `EventHandlerSet` has no replay, and `invalidate()` clears its handlers (K12). If the computed is invalidated *during* computation (mutation while a slow async server method runs), the pending-invalidate path re-invalidates **inside** `cf.invoke` before it resolves — the handler is added to a dead event set and **`$sys-c.Invalidate` is never sent**. The same hole exists for the microtask gap between `cf.invoke` resolving and `.add()` executing.
@@ -857,6 +859,8 @@ Confidence: confirmed (deliberate, test-codified deviation — but with a wastef
 
 ### F7. TS server ignores the message's `CallType` — regular calls to compute methods still get invalidation tracking
 
+Status: **closed** — fixed 2026-07-15 (batch fusionrpc1).
+
 Confidence: confirmed.
 
 - TS: `_wrapServerMethod` decides by the server-side `methodDef.callTypeId` only (`fusion-hub.ts:171`); `createRpcClient` produces exactly such regular calls (plain `RpcOutboundCall`, `removeOnOk = true` — `rpc-client.ts:72-90`).
@@ -877,13 +881,17 @@ Confidence: confirmed.
 
 ### F9. Server-side invalidation send bypasses the peer's serialization format and `systemCallSender` (low)
 
+Status: **closed** — fixed 2026-07-15 (batch fusionrpc1; `FusionSystemCallSender.invalidate()` resolving connection + format at fire time).
+
 Confidence: confirmed code path; impact plausible-low. `_wrapServerMethod` hand-rolls `serializeMessage(...)` — JSON-only (`rpc-serialization.ts:31-41`) — and writes to the captured `context.connection` (`fusion-hub.ts:186-192`), while all other responses go through `hub.systemCallSender` with `peer.serializationFormat`. On a msgpack connection the invalidation goes out as a JSON text frame; TS clients tolerate mixed frames, a .NET client would not. Also uses a possibly-dead captured connection.
 
 - **Recommended:** add an `invalidate()` to the (Fusion-extended) system-call sender, sending via the peer's *current* connection and serialization format — `RpcComputeSystemCallSender.Invalidate` parity. Natural companion to F1's fix, same code.
 - **Alternative:** keep the inline send but resolve the connection at send time and use the peer's format. Same effect, less structure; fine if F1 is fixed the minimal way.
 
 ### F10. `FusionHub._buildServiceDef` drifted from the base implementation (low)
 
+Status: **closed** — fixed 2026-07-15 (batch fusionrpc1; delegates to the base, patches only `callTypeId`).
+
 Confidence: confirmed. The override hardcodes `remoteExecutionMode: Default` and skips the base's `noWait → mode 0` and `meta.remoteExecutionMode` honoring (`fusion-hub.ts:146-160` vs `rpc-hub.ts:244-259`). A decorator-declared custom `remoteExecutionMode` is silently ignored when registered through a `FusionHub`.
 
 - **Recommended:** delegate to `super._buildServiceDef` and only patch `callTypeId` for compute methods — removes the duplicated logic and the drift with it.

ts/packages/fusion-rpc/src/fusion-hub.ts

@@ -41,12 +41,11 @@ import {
     RpcServerPeer,
     RpcWebSocketConnection,
     RpcSystemCallHandler,
-    serializeMessage,
+    RpcSystemCallSender,
     defineRpcService,
     wireMethodName,
-    RpcType,
-    RpcRemoteExecutionMode,
     type RpcConnection,
+    type RpcSerializationFormat,
     type WebSocketLike,
     type RpcServiceDef,
     type RpcMethodDef,
@@ -55,7 +54,6 @@ import {
     type RpcPeer,
     type RpcMessage,
     type RpcCallOptions,
-    getServiceMeta,
     getMethodsMeta,
 } from '@actuallab/rpc';
 import {
@@ -90,6 +88,20 @@ class FusionSystemCallHandler extends RpcSystemCallHandler {
     }
 }
 
+/** Sends the Fusion $sys-c.Invalidate system call — mirrors .NET's RpcComputeSystemCallSender. */
+class FusionSystemCallSender extends RpcSystemCallSender {
+    invalidate(
+        conn: RpcConnection,
+        format: RpcSerializationFormat,
+        relatedId: number
+    ): void {
+        this._send(conn, format, {
+            Method: FUSION_INVALIDATE_METHOD,
+            RelatedId: relatedId,
+        });
+    }
+}
+
 /** Creates a compute service definition — all methods default to FUSION_CALL_TYPE_ID. */
 export function defineComputeService(
     name: string,
@@ -107,13 +119,19 @@ export function defineComputeService(
 
 /** Central coordinator for Fusion + RPC — manages compute services, invalidation wiring. */
 export class FusionHub extends RpcHub {
+    declare readonly systemCallSender: FusionSystemCallSender;
+
     constructor(hubId?: string) {
         super(hubId);
         this.systemCallHandler = new FusionSystemCallHandler();
         // Register Fusion-specific system call for compact format hash resolution
         this.registry.register(FUSION_INVALIDATE_METHOD);
     }
 
+    protected override _createSystemCallSender(): FusionSystemCallSender {
+        return new FusionSystemCallSender();
+    }
+
     /** Accept an incoming WebSocket and create a server peer. */
     acceptConnection(ws: WebSocketLike): RpcServerPeer {
         const ref = `server://${crypto.randomUUID()}`;
@@ -131,36 +149,28 @@ export class FusionHub extends RpcHub {
         return peer;
     }
 
-    /** Override to apply FUSION_CALL_TYPE_ID for compute methods. */
+    /** Delegate to the base builder, then patch callTypeId for compute methods —
+     *  keeps the base's noWait / remoteExecutionMode handling instead of drifting. */
     protected override _buildServiceDef(
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         cls: abstract new (...args: any[]) => any
     ): RpcServiceDef {
-        const svcMeta = getServiceMeta(cls);
-        if (svcMeta === undefined)
-            throw new Error('Contract class missing @rpcService metadata');
-
+        const def = super._buildServiceDef(cls);
         const methodsMeta = getMethodsMeta(cls) ?? {};
         const methods = new Map<string, RpcMethodDef>();
-
-        for (const [name, meta] of Object.entries(methodsMeta)) {
-            const wireArgCount = meta.argCount + 1;
-            const mapKey = `${name}:${wireArgCount}`;
-            methods.set(mapKey, {
-                name,
-                serviceName: svcMeta.name,
-                argCount: meta.argCount,
-                wireArgCount,
-                callTypeId:
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
-                    (meta as any).compute === true ? FUSION_CALL_TYPE_ID : 0,
-                stream: meta.returns === RpcType.stream,
-                noWait: meta.returns === RpcType.noWait,
-                remoteExecutionMode: RpcRemoteExecutionMode.Default,
-            });
+        for (const [mapKey, methodDef] of def.methods) {
+            const isCompute =
+                (methodsMeta[methodDef.name] as { compute?: boolean } | undefined)
+                    ?.compute === true;
+            methods.set(
+                mapKey,
+                isCompute
+                    ? { ...methodDef, callTypeId: FUSION_CALL_TYPE_ID }
+                    : methodDef
+            );
         }
 
-        return { name: svcMeta.name, methods };
+        return { name: def.name, methods };
     }
 
     protected override _wrapServerMethod(
@@ -181,14 +191,27 @@ export class FusionHub extends RpcHub {
 
             const computed = await cf.invoke(impl, cleanArgs);
 
-            // Wire invalidation → send $sys-c.Invalidate to the client
-            if (context !== undefined) {
-                computed.onInvalidated(() => {
-                    const msg = serializeMessage({
-                        Method: FUSION_INVALIDATE_METHOD,
-                        RelatedId: context.callId,
-                    });
-                    context.connection.send(msg);
+            // IsRegularCall parity (F7): a Regular call to a compute method returns
+            // the result immediately, with no invalidation tracking.
+            if (context?.callType === FUSION_CALL_TYPE_ID) {
+                const { peer, callId } = context;
+                // ProcessStage2 parity (F1): whenInvalidated() resolves immediately
+                // for an already-invalidated computed, so an invalidation landing
+                // during computation still produces the send.
+                void computed.whenInvalidated().then(() => {
+                    // C# sends the result (ProcessStage1Plus) before the
+                    // invalidation (ProcessStage2). Here the dispatch loop sends
+                    // $sys.Ok after this wrapper returns, so defer past that turn —
+                    // a client drops an Invalidate that precedes its result.
+                    setTimeout(() => {
+                        const conn = peer.connection;
+                        if (conn !== undefined)
+                            this.systemCallSender.invalidate(
+                                conn,
+                                peer.serializationFormat,
+                                callId
+                            );
+                    }, 0);
                 });
             }