fix(ts/rpc): correct dispatch receiver, decorator metadata isolation, and wire arity

R18: RpcServiceHost now stores the implementation receiver beside each method
entry and dispatches via entry.fn.call(receiver, ...), so regular, no-wait, and
stream methods read the correct `this` (including #private state). addService
passes the original impl as the receiver; the unbound function is preserved so
FusionHub's server-method wrapper keeps working.

R19: stage-3 decorator metadata is no longer mutated through the prototype
chain. New shared helper ownMetadata (@actuallab/core) clones an inherited
metadata record into an own property before writing, so base contracts keep
their name/method set and sibling derived contracts no longer contaminate each
other. Used by rpcService, rpcMethod, and computeMethod.

R20: rpcMethod and computeMethod accept an explicit argCount option; when
absent, resolveArgCount (@actuallab/core) scans the parameter list for default
(`=`) / rest (`...`) parameters and throws a clear declaration-time error rather
than trusting the unreliable Function.length.

Tests: end-to-end receiver tests (regular/no-wait/stream, ordinary and #private
state) plus base/derived/sibling metadata and arity tests in both the rpc and
fusion decorator packages. Full suite: 572 passed.

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

@@ -564,6 +564,8 @@ Confidence: confirmed (documented omission). TS removes the tracker entry only (
 
 ### R18. Regular service dispatch loses the implementation receiver
 
+Status: **closed** — fixed 2026-07-15 (batch rpcdeco).
+
 Confidence: confirmed and executable-probe verified. (Second-pass finding.)
 
 - TS stores only the extracted function (`rpc-service-host.ts:54-61`), then calls `entry.fn(...args)`
@@ -584,6 +586,8 @@ Confidence: confirmed and executable-probe verified. (Second-pass finding.)
 
 ### R19. Decorator metadata is shared and mutated across base and derived classes
 
+Status: **closed** — fixed 2026-07-15 (batch rpcdeco; shared `ownMetadata` helper in `@actuallab/core`).
+
 Confidence: confirmed and executable-probe verified. (Second-pass finding.)
 
 - Stage-3 decorator metadata for a derived class inherits from the base metadata object. Both `rpcService` and
@@ -609,6 +613,8 @@ Confidence: confirmed and executable-probe verified. (Second-pass finding.)
 
 ### R20. Decorator wire arity is wrong after a default parameter and for rest parameters
 
+Status: **closed** — fixed 2026-07-15 (batch rpcdeco; explicit `argCount` option, ambiguity throws at declaration time; `computeMethod` became dual-mode — bare or `@computeMethod({ argCount })`).
+
 Confidence: confirmed and executable-probe verified. (Second-pass finding.)
 
 - `rpcMethod` records `target.length` (`rpc-decorators.ts:90-95`); `computeMethod` does the same

ts/packages/core/src/decorators.ts

@@ -0,0 +1,67 @@
+// Helpers shared by the stage-3 decorators of @actuallab/rpc and @actuallab/fusion.
+
+// Returns the record stored under `key` in `metadata`, guaranteeing it is an OWN
+// property. Stage-3 decorator metadata of a derived class inherits from the base
+// class's metadata via the prototype chain, so writing through an inherited record
+// would silently mutate the base contract. When the record is inherited (or missing)
+// it is shallow-cloned into an own property first — base entries stay visible on the
+// derived contract while derived writes stay local to it.
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- callers pick the record shape
+export function ownMetadata<T extends object>(metadata: object, key: symbol): T {
+    const bag = metadata as Record<symbol, T>;
+    if (!Object.hasOwn(metadata, key))
+        bag[key] = { ...bag[key] };
+
+    return bag[key];
+}
+
+// Resolves the fixed argument count of a decorated method for the RPC wire name.
+// Function.length silently stops at the first default parameter and ignores rest
+// parameters, so an inferred count would be wrong; when the parameter list is
+// ambiguous the caller must pass an explicit `argCount` or this throws at declaration
+// time (the erased count cannot be recovered reliably at runtime).
+export function resolveArgCount(
+    fn: (...args: never[]) => unknown,
+    explicit: number | undefined,
+    methodName: string,
+): number {
+    if (explicit !== undefined)
+        return explicit;
+    if (hasAmbiguousArity(fn))
+        throw new Error(
+            `Cannot infer the argument count of "${methodName}": its parameter list uses ` +
+            `default and/or rest parameters, for which Function.length is unreliable. ` +
+            `Pass an explicit argCount to the decorator.`,
+        );
+
+    return fn.length;
+}
+
+// Private methods
+
+function hasAmbiguousArity(fn: (...args: never[]) => unknown): boolean {
+    const params = parameterListText(fn);
+    return params !== undefined && (params.includes('=') || params.includes('...'));
+}
+
+function parameterListText(fn: (...args: never[]) => unknown): string | undefined {
+    const src = Function.prototype.toString.call(fn);
+    const open = src.indexOf('(');
+    const arrow = src.indexOf('=>');
+    // A parenless single-identifier arrow (`x => ...`) has no default/rest parameters.
+    if (open < 0 || (arrow >= 0 && arrow < open))
+        return undefined;
+
+    let depth = 0;
+    for (let i = open; i < src.length; i++) {
+        const ch = src[i];
+        if (ch === '(')
+            depth++;
+        else if (ch === ')') {
+            depth--;
+            if (depth === 0)
+                return src.slice(open + 1, i);
+        }
+    }
+    return undefined;
+}

ts/packages/core/src/index.ts

@@ -55,3 +55,6 @@ export {
 } from './retry-delayer.js';
 export type { RetryDelaySchedule } from './retry.js';
 export { retry, catchErrors } from './retry.js';
+
+// Decorator helpers
+export { ownMetadata, resolveArgCount } from './decorators.js';

ts/packages/fusion/src/compute-method.ts

@@ -1,4 +1,5 @@
-/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-this-alias */
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-this-alias */
+import { ownMetadata, resolveArgCount } from '@actuallab/core';
 import { ComputeFunction } from './compute-function.js';
 import { ComputedRegistry } from './computed-registry.js';
 
@@ -17,24 +18,53 @@ export function getMethodsMeta(
     return (cls as any)[Symbol.metadata]?.[METHODS_META];
 }
 
-/** Method decorator — wraps a method to route through ComputeFunction for caching and dependency tracking. */
+export interface ComputeMethodOptions {
+    argCount?: number;
+}
+
+type ComputeMethodDecorator<This, Args extends unknown[], Return> = (
+    target: (this: This, ...args: Args) => Return,
+    context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>
+) => (this: This, ...args: Args) => Return;
+
+/**
+ * Method decorator — routes a method through ComputeFunction for caching and dependency
+ * tracking. Usable bare (`@computeMethod`) or with options (`@computeMethod({ argCount })`).
+ */
+export function computeMethod<This, Args extends unknown[], Return>(
+    target: (this: This, ...args: Args) => Return,
+    context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>
+): (this: This, ...args: Args) => Return;
+export function computeMethod<This, Args extends unknown[], Return>(
+    options?: ComputeMethodOptions
+): ComputeMethodDecorator<This, Args, Return>;
 export function computeMethod<This, Args extends unknown[], Return>(
+    targetOrOptions?: ((this: This, ...args: Args) => Return) | ComputeMethodOptions,
+    context?: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>
+): unknown {
+    if (typeof targetOrOptions === 'function')
+        return computeMethodImpl(targetOrOptions, context!, {});
+
+    const options = targetOrOptions ?? {};
+    return (target: (this: This, ...args: Args) => Return, ctx: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>) =>
+        computeMethodImpl(target, ctx, options);
+}
+
+function computeMethodImpl<This, Args extends unknown[], Return>(
     target: (this: This, ...args: Args) => Return,
     context: ClassMethodDecoratorContext<
         This,
         (this: This, ...args: Args) => Return
-    >
+    >,
+    options: ComputeMethodOptions
 ): (this: This, ...args: Args) => Return {
     const methodName = String(context.name);
 
-    // Store metadata
-    const methods: Record<string, MethodMeta> = ((context.metadata as any)[
-        METHODS_META
-    ] ??= {});
+    const methods = ownMetadata<Record<string, MethodMeta>>(context.metadata, METHODS_META);
     methods[methodName] = {
         ...methods[methodName],
         compute: true,
-        argCount: target.length,
+        argCount: resolveArgCount(target, options.argCount, methodName),
     };
 
     // ONE ComputeFunction per class×method — created at decoration time

ts/packages/fusion/tests/compute-method-inheritance.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect } from 'vitest';
+import { computeMethod, getMethodsMeta } from '../src/index.js';
+
+describe('computeMethod metadata isolation across inheritance (R19)', () => {
+    it('derived methods do not leak into the base contract', () => {
+        class Base {
+            @computeMethod
+            base(_a: string): number { return 0; }
+        }
+        class Derived extends Base {
+            @computeMethod
+            derived(_a: string): number { return 0; }
+        }
+
+        expect(Object.keys(getMethodsMeta(Base) ?? {})).toEqual(['base']);
+        expect(Object.keys(getMethodsMeta(Derived) ?? {}).sort()).toEqual(['base', 'derived']);
+    });
+
+    it('sibling derived contracts do not contaminate one another', () => {
+        class Base {
+            @computeMethod
+            base(_a: string): number { return 0; }
+        }
+        class DerivedA extends Base {
+            @computeMethod
+            a(_a: string): number { return 0; }
+        }
+        class DerivedB extends Base {
+            @computeMethod
+            b(_a: string): number { return 0; }
+        }
+
+        expect(Object.keys(getMethodsMeta(Base) ?? {})).toEqual(['base']);
+        expect(Object.keys(getMethodsMeta(DerivedA) ?? {}).sort()).toEqual(['a', 'base']);
+        expect(Object.keys(getMethodsMeta(DerivedB) ?? {}).sort()).toEqual(['b', 'base']);
+    });
+});
+
+describe('computeMethod wire arity (R20)', () => {
+    it('infers argCount for a plain parameter list', () => {
+        class Svc {
+            @computeMethod
+            m(_a: string, _b: number): number { return 0; }
+        }
+        expect(getMethodsMeta(Svc)!['m'].argCount).toBe(2);
+    });
+
+    it('throws for a default parameter without an explicit argCount', () => {
+        expect(() => {
+            class Svc {
+                @computeMethod
+                m(_a: string, _b = 1): number { return 0; }
+            }
+            return Svc;
+        }).toThrow(/argCount/);
+    });
+
+    it('throws for a rest parameter without an explicit argCount', () => {
+        expect(() => {
+            class Svc {
+                @computeMethod
+                m(..._args: unknown[]): number { return 0; }
+            }
+            return Svc;
+        }).toThrow(/argCount/);
+    });
+
+    it('uses the explicit argCount for a default parameter', () => {
+        class Svc {
+            @computeMethod({ argCount: 2 })
+            m(_a: string, _b = 1): number { return 0; }
+        }
+        expect(getMethodsMeta(Svc)!['m'].argCount).toBe(2);
+    });
+});

ts/packages/rpc/src/rpc-decorators.ts

@@ -25,6 +25,8 @@
 //     RpcServiceDef.  .NET determines this via the service interface hierarchy
 //     (IComputeService marker interface).
 
+import { ownMetadata, resolveArgCount } from '@actuallab/core';
+
 const METHODS_META = Symbol.for('actuallab.methods');
 const SERVICE_META = Symbol.for('actuallab.service');
 
@@ -65,15 +67,17 @@ export function rpcService(serviceName: string) {
         _target: T,
         context: ClassDecoratorContext<T>,
     ): void {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any -- decorator metadata requires untyped access
-        const meta: ServiceMeta = ((context.metadata as any)[SERVICE_META] ??=
-            {} as ServiceMeta);
+        const meta = ownMetadata<ServiceMeta>(context.metadata, SERVICE_META);
         meta.name = serviceName;
     };
 }
 
 /** Method decorator — stores RPC method metadata (argCount, returns, remoteExecutionMode). Does NOT wrap the method. */
-export function rpcMethod(options?: { returns?: symbol; remoteExecutionMode?: number }) {
+export function rpcMethod(options?: {
+    returns?: symbol;
+    remoteExecutionMode?: number;
+    argCount?: number;
+}) {
     return function <This, Args extends unknown[], Return>(
         target: (this: This, ...args: Args) => Return,
         context: ClassMethodDecoratorContext<
@@ -82,14 +86,10 @@ export function rpcMethod(options?: { returns?: symbol; remoteExecutionMode?: nu
         >,
     ): (this: This, ...args: Args) => Return {
         const methodName = String(context.name);
-        /* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any -- decorator metadata requires untyped access */
-        const methods: Record<string, MethodMeta> = ((context.metadata as any)[
-            METHODS_META
-        ] ??= {});
-        /* eslint-enable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any */
+        const methods = ownMetadata<Record<string, MethodMeta>>(context.metadata, METHODS_META);
         methods[methodName] = {
             ...methods[methodName],
-            argCount: target.length,
+            argCount: resolveArgCount(target, options?.argCount, methodName),
             returns: options?.returns,
             remoteExecutionMode: options?.remoteExecutionMode,
         };

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

@@ -172,7 +172,7 @@ export class RpcHub {
                     ? this._wrapServerMethod(methodDef, fn, impl as object)
                     : fn;
         }
-        this.serviceHost.register(def, wrappedImpl);
+        this.serviceHost.register(def, wrappedImpl, impl as object);
         this.registry.registerService(def.name, def.methods);
     }
 

ts/packages/rpc/src/rpc-service-host.ts

@@ -48,16 +48,17 @@ export interface RpcDispatchContext {
 export class RpcServiceHost {
     private _methods = new Map<
         string,
-        { def: RpcMethodDef; fn: (...args: unknown[]) => unknown }
+        { def: RpcMethodDef; fn: (...args: unknown[]) => unknown; receiver: object }
     >();
 
-    register(def: RpcServiceDef, impl: RpcServiceImpl): void {
+    register(def: RpcServiceDef, impl: RpcServiceImpl, receiver: object = impl): void {
         for (const methodDef of def.methods.values()) {
             const fn = impl[methodDef.name];
             if (!fn) continue;
             this._methods.set(wireMethodName(methodDef), {
                 def: methodDef,
                 fn,
+                receiver,
             });
         }
     }
@@ -77,9 +78,9 @@ export class RpcServiceHost {
         // Pass context as the last arg only for custom call types (e.g., compute) — their
         // wrapped functions use it; regular methods should not see it to avoid polluting ...args.
         if (context !== undefined && entry.def.callTypeId !== 0) {
-            return await entry.fn(...args, context);
+            return await entry.fn.call(entry.receiver, ...args, context);
         }
-        return await entry.fn(...args);
+        return await entry.fn.call(entry.receiver, ...args);
     }
 
     getMethodDef(wireMethod: string): RpcMethodDef | undefined {