fix(rpc): addClient extends the shared proxy instead of dropping methods (F8)

The F8 client-proxy cache in RpcHub.addClient was keyed by (peer, service
name) only, so a second addClient for the same service name returned the
first proxy verbatim. When two call sites register different defs under one
name — as ts/e2e/ts-dotnet-perf.ts does, splitting ITypeScriptTestComputeService
into a call-methods def (Add/GetValue) and a stream def (StreamInt32) — the
later def's methods were silently missing from the returned proxy, failing
the .NET-driven StreamPerformance test with "svc.StreamInt32 is not a function".

addClient now merges each def into a single shared proxy per (peer, name):
methods absent from the proxy are added (superset extends it), preserving F8's
singleton-proxy guarantee (same proxy object, one ComputeFunction per method,
one shared computed/invalidation stream). A genuinely conflicting re-registration
(same method name + argCount, different wire signature) throws a clear error,
matching C#'s ServiceNameConflict/MethodNameConflict spirit — the API fails
loudly rather than serving a method-less proxy silently.

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

@@ -905,7 +905,7 @@ Confidence: confirmed.
 
 ### F8. No deduplication of remote computeds across proxies — each `addClient` mints a fresh key space
 
-Status: **closed** — fixed 2026-07-15 (batch fusionrpc3; proxy cached per `(peer, service name)` in the base `RpcHub.addClient`).
+Status: **closed** — fixed 2026-07-15 (batch fusionrpc3; proxy cached per `(peer, service name)` in the base `RpcHub.addClient`). Refined same day (batch e2efix) after the .NET-driven e2e caught a regression: the cache silently dropped methods when a second, different def used the same service name (`ts-dotnet-perf.ts` registers disjoint defs) — `addClient` now merges defs into one shared proxy (existing methods and their `ComputeFunction`s preserved; different arities coexist as overloads, wire-name parity) and throws on genuinely conflicting signatures, validate-first so a rejected def changes nothing.
 
 Confidence: confirmed.
 

ts/packages/fusion-rpc/tests/fusion-rpc-glue-fixes.test.ts

@@ -176,6 +176,64 @@ describe('Fusion-over-RPC glue fixes', () => {
         clientConn.close();
     });
 
+    // F8 — a later def registered under the same service name must extend the
+    // shared proxy, not silently return the first (method-less-for-the-caller)
+    // one. Mirrors ts-dotnet-perf.ts splitting ITypeScriptTestComputeService
+    // into a call-methods def and a stream def.
+    it('extends the shared proxy when a later def adds methods under the same service name', () => {
+        const clientPeer = new RpcClientPeer(clientHub, 'ws://test');
+        clientHub.addPeer(clientPeer);
+
+        const callsDef = defineComputeService('SplitService', {
+            Add: { args: [0, 0], callTypeId: 0 },
+            GetValue: { args: [0] },
+        });
+        const streamDef = defineRpcService('SplitService', {
+            StreamInt32: { args: [0], returns: RpcType.stream, wireArgCount: 1 },
+        });
+
+        const svc = clientHub.addClient<Record<string, unknown>>(clientPeer, callsDef);
+        const streamSvc = clientHub.addClient<Record<string, unknown>>(clientPeer, streamDef);
+
+        expect(streamSvc).toBe(svc);
+        expect(typeof svc['Add']).toBe('function');
+        expect(typeof svc['GetValue']).toBe('function');
+        expect(typeof svc['StreamInt32']).toBe('function');
+        expect(typeof streamSvc['StreamInt32']).toBe('function');
+    });
+
+    it('throws on a conflicting re-registration of a method under the same service name', () => {
+        const clientPeer = new RpcClientPeer(clientHub, 'ws://test');
+        clientHub.addPeer(clientPeer);
+
+        const computeDef = defineComputeService('ConflictService', { Value: { args: [0] } });
+        const rpcDef = defineRpcService('ConflictService', { Value: { args: [0] } });
+
+        clientHub.addClient(clientPeer, computeDef);
+        expect(() => clientHub.addClient(clientPeer, rpcDef)).toThrow(/conflicting definition/);
+    });
+
+    it('leaves the shared proxy unchanged when a partially conflicting def is rejected', () => {
+        const clientPeer = new RpcClientPeer(clientHub, 'ws://test');
+        clientHub.addPeer(clientPeer);
+
+        const baseDef = defineComputeService('PartialService', { Value: { args: [0] } });
+        const badDef = defineRpcService('PartialService', {
+            Extra: { args: [0] },
+            Value: { args: [0] },
+        });
+        const goodDef = defineRpcService('PartialService', { Extra: { args: [0] } });
+
+        const svc = clientHub.addClient<Record<string, unknown>>(clientPeer, baseDef);
+        expect(() => clientHub.addClient(clientPeer, badDef)).toThrow(/conflicting definition/);
+        expect(svc['Extra']).toBeUndefined();
+
+        const extended = clientHub.addClient<Record<string, unknown>>(clientPeer, goodDef);
+        expect(extended).toBe(svc);
+        expect(typeof svc['Extra']).toBe('function');
+        expect(typeof svc['Value']).toBe('function');
+    });
+
     it('mints distinct proxies for different peers', async () => {
         const [clientConnA, serverConnA] = createMessageChannelPair();
         const [clientConnB, serverConnB] = createMessageChannelPair();

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

@@ -57,6 +57,18 @@ const { warnLog } = getLogs('RpcHub');
  *  `getServerPeer` cast the result, so the factory returns RpcPeer. */
 export type RpcPeerFactory = (hub: RpcHub, ref: string) => RpcPeer;
 
+type RpcClientFn = (...args: unknown[]) => unknown;
+
+/** A live client proxy plus the mutable maps it reads from, so a later def can
+ *  add methods to the already-handed-out proxy. `methods` is the map the Proxy's
+ *  get-trap resolves against; `overloads` tracks each method's per-argCount defs
+ *  and functions for overload resolution and conflict detection. */
+interface RpcClientProxy {
+    readonly proxy: object;
+    readonly methods: Map<string, RpcClientFn>;
+    readonly overloads: Map<string, Map<number, { def: RpcMethodDef; fn: RpcClientFn }>>;
+}
+
 /** Central RPC coordinator — manages peers, services, and configuration. */
 export class RpcHub {
     readonly hubId: string;
@@ -76,8 +88,11 @@ export class RpcHub {
     /** Cache of client proxies keyed by peer, then by service name — so
      *  repeated {@link addClient} calls for the same service+peer return one
      *  proxy. All consumers then share a single computed/call/invalidation
-     *  stream per logical value, matching .NET's singleton client proxies (F8). */
-    private readonly _clientProxies = new WeakMap<RpcPeer, Map<string, object>>();
+     *  stream per logical value, matching .NET's singleton client proxies (F8).
+     *  A later def registered under the same name extends the existing proxy
+     *  with its extra methods (superset), so no consumer ever receives a proxy
+     *  missing methods the def declares. */
+    private readonly _clientProxies = new WeakMap<RpcPeer, Map<string, RpcClientProxy>>();
 
     /** Connection-lifecycle timing limits. Peers constructed against this hub
      *  read their initial `*Ms` field values from this instance; later
@@ -183,65 +198,29 @@ export class RpcHub {
         this.registry.registerService(def.name, def.methods);
     }
 
-    /** Create a typed client proxy for a service on a remote peer. */
+    /** Create a typed client proxy for a service on a remote peer. Repeated calls
+     *  for the same (peer, service name) return one shared proxy; a def carrying
+     *  extra methods extends it (F8). */
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- T is used for caller-specified proxy type
     addClient<T extends object>(
         peer: RpcPeer,
         defOrContract: RpcServiceDef | (AnyConstructor)
     ): T {
         const def = this._resolveServiceDef(defOrContract);
+        this.registry.registerService(def.name, def.methods);
 
         let byService = this._clientProxies.get(peer);
         if (byService === undefined) {
-            byService = new Map<string, object>();
+            byService = new Map<string, RpcClientProxy>();
             this._clientProxies.set(peer, byService);
         }
-        const cached = byService.get(def.name);
-        if (cached !== undefined)
-            return cached as T;
-
-        this.registry.registerService(def.name, def.methods);
-
-        type RpcClientFn = (...args: unknown[]) => unknown;
-
-        // Group methods by clean name, indexed by argCount for overload resolution
-        const overloads = new Map<string, Map<number, RpcClientFn>>();
-        for (const methodDef of def.methods.values()) {
-            let byArgCount = overloads.get(methodDef.name);
-            if (!byArgCount) {
-                byArgCount = new Map<number, RpcClientFn>();
-                overloads.set(methodDef.name, byArgCount);
-            }
-            byArgCount.set(
-                methodDef.argCount,
-                this._createClientMethod(peer, methodDef)
-            );
-        }
-
-        // Build final proxy methods — single overload: use directly; multiple: resolve by args.length
-        const methods = new Map<string, RpcClientFn>();
-        for (const [name, byArgCount] of overloads) {
-            if (byArgCount.size === 1) {
-                const [[, singleFn]] = byArgCount;
-                methods.set(name, singleFn);
-            } else {
-                methods.set(name, (...args: unknown[]) => {
-                    const fn = byArgCount.get(args.length);
-                    if (!fn)
-                        throw new Error(
-                            `No overload of ${name} accepts ${args.length} arguments`
-                        );
-                    return fn(...args);
-                });
-            }
+        let entry = byService.get(def.name);
+        if (entry === undefined) {
+            entry = this._createClientProxy();
+            byService.set(def.name, entry);
         }
-
-        const proxy = new Proxy({} as T, {
-            get: (_target, prop) =>
-                typeof prop === 'string' ? methods.get(prop) : undefined,
-        });
-        byService.set(def.name, proxy);
-        return proxy;
+        this._extendClientProxy(peer, entry, def);
+        return entry.proxy as T;
     }
 
     close(): void {
@@ -357,4 +336,72 @@ export class RpcHub {
             return resolveStreamRefs(result, peer);
         };
     }
+
+    // Private methods
+
+    private _createClientProxy(): RpcClientProxy {
+        const methods = new Map<string, RpcClientFn>();
+        const proxy = new Proxy({}, {
+            get: (_target, prop) =>
+                typeof prop === 'string' ? methods.get(prop) : undefined,
+        });
+        return { proxy, methods, overloads: new Map() };
+    }
+
+    private _extendClientProxy(peer: RpcPeer, entry: RpcClientProxy, def: RpcServiceDef): void {
+        // Validate the whole def before mutating anything, so a conflict
+        // leaves the shared proxy exactly as it was.
+        for (const methodDef of def.methods.values()) {
+            const existing = entry.overloads.get(methodDef.name)?.get(methodDef.argCount);
+            if (existing !== undefined && !isSameWireMethod(existing.def, methodDef))
+                throw new Error(
+                    `RpcHub.addClient: conflicting definition of '${wireMethodName(methodDef)}' ` +
+                    `under service '${def.name}' — a different signature is already registered.`);
+        }
+
+        const changed = new Set<string>();
+        for (const methodDef of def.methods.values()) {
+            let byArgCount = entry.overloads.get(methodDef.name);
+            if (byArgCount === undefined) {
+                byArgCount = new Map();
+                entry.overloads.set(methodDef.name, byArgCount);
+            }
+            if (byArgCount.has(methodDef.argCount))
+                continue;
+
+            byArgCount.set(methodDef.argCount, {
+                def: methodDef,
+                fn: this._createClientMethod(peer, methodDef),
+            });
+            changed.add(methodDef.name);
+        }
+        for (const name of changed) {
+            const byArgCount = entry.overloads.get(name)!;
+            entry.methods.set(name, buildOverloadFn(name, byArgCount));
+        }
+    }
+}
+
+function buildOverloadFn(
+    name: string,
+    byArgCount: Map<number, { def: RpcMethodDef; fn: RpcClientFn }>
+): RpcClientFn {
+    if (byArgCount.size === 1) {
+        const [[, only]] = byArgCount;
+        return only.fn;
+    }
+    return (...args: unknown[]) => {
+        const overload = byArgCount.get(args.length);
+        if (overload === undefined)
+            throw new Error(`No overload of ${name} accepts ${args.length} arguments`);
+        return overload.fn(...args);
+    };
+}
+
+function isSameWireMethod(a: RpcMethodDef, b: RpcMethodDef): boolean {
+    return a.wireArgCount === b.wireArgCount
+        && a.callTypeId === b.callTypeId
+        && a.stream === b.stream
+        && a.noWait === b.noWait
+        && a.remoteExecutionMode === b.remoteExecutionMode;
 }