@actuallab/rpc 13.0.25 → 13.0.167

package/dist/index.js

@@ -165,6 +165,24 @@ function readVarUint(data, offset) {
   } while (shift < 35);
   return { value: value >>> 0, bytesRead };
 }
+function skipHeaders(data, pos, headerCount) {
+  for (let h = 0; h < headerCount; h++) {
+    const keyLen = data[pos++];
+    pos += keyLen;
+    const valLen = readVarUint(data, pos);
+    pos += valLen.bytesRead + valLen.value;
+  }
+  return pos;
+}
+function readPolymorphismMarker(data, offset) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const length = view.getUint16(offset, true);
+  if (length === 0)
+    return { bytesRead: 2, isNull: false };
+  if (length === 1)
+    return { bytesRead: 2, isNull: true };
+  throw new Error("polymorphic payloads are not supported by the TS client");
+}
 function concatUint8Arrays(arrays) {
   let totalLength = 0;
   for (const arr of arrays) totalLength += arr.length;
@@ -228,14 +246,6 @@ function deserializeBinaryMessage(data, offset, decoder = defaultBinaryDecoder)
   pos += methodLen.value;
   const argDataLen = view.getInt32(pos, true);
   pos += 4;
-  if (headerCount > 0) {
-    for (let h = 0; h < headerCount; h++) {
-      const keyLen = data[pos++];
-      pos += keyLen;
-      const valLen = readVarUint(data, pos);
-      pos += valLen.bytesRead + valLen.value;
-    }
-  }
   const args = [];
   const argEnd = pos + argDataLen;
   if (argDataLen > 0) {
@@ -243,8 +253,10 @@ function deserializeBinaryMessage(data, offset, decoder = defaultBinaryDecoder)
     for (const decoded of decoder.decodeMulti(argSlice)) {
       args.push(decoded);
     }
-    pos = argEnd;
   }
+  pos = argEnd;
+  if (headerCount > 0)
+    pos = skipHeaders(data, pos, headerCount);
   const message = {
     Method: method,
     RelatedId: relId.value,
@@ -322,14 +334,6 @@ function deserializeCompactBinaryMessage(data, offset, registry, decoder = defau
   const method = registry?.getName(methodHash | 0) ?? `<hash:0x${methodHash.toString(16).padStart(8, "0")}>`;
   const argDataLen = view.getInt32(pos, true);
   pos += 4;
-  if (headerCount > 0) {
-    for (let h = 0; h < headerCount; h++) {
-      const keyLen = data[pos++];
-      pos += keyLen;
-      const valLen = readVarUint(data, pos);
-      pos += valLen.bytesRead + valLen.value;
-    }
-  }
   const args = [];
   const argEnd = pos + argDataLen;
   if (argDataLen > 0) {
@@ -337,8 +341,10 @@ function deserializeCompactBinaryMessage(data, offset, registry, decoder = defau
     for (const decoded of decoder.decodeMulti(argSlice)) {
       args.push(decoded);
     }
-    pos = argEnd;
   }
+  pos = argEnd;
+  if (headerCount > 0)
+    pos = skipHeaders(data, pos, headerCount);
   const message = {
     Method: method,
     RelatedId: relId.value,
@@ -608,7 +614,8 @@ function defineRpcService(name, methods) {
       callTypeId: input.callTypeId ?? 0,
       stream: input.returns === RpcType.stream,
       noWait: isNoWait,
-      remoteExecutionMode: isNoWait ? 0 : input.remoteExecutionMode ?? RpcRemoteExecutionMode.Default
+      remoteExecutionMode: isNoWait ? 0 : input.remoteExecutionMode ?? RpcRemoteExecutionMode.Default,
+      timeouts: input.timeouts
     });
   }
   return { name, methods: map };
@@ -642,6 +649,14 @@ var RpcOutboundCall = class {
   removeOnOk = true;
   /** The serialized wire data — stored for re-sending on reconnect. */
   serializedWireData = "";
+  /** Per-call connect/run timeouts enforced by the peer's maintenance loop
+   *  (R12). `undefined` means unbounded (the query default). */
+  timeouts;
+  /** `Date.now()` when this call was created (used for the connect timeout). */
+  startedAt = Date.now();
+  /** `Date.now()` when this call was last put on the wire, or 0 if it hasn't
+   *  been sent yet (used for the run timeout). */
+  sentAt = 0;
   /**
    * Bitfield of {@link RpcCallStage} flags indicating how far this call
    * has progressed. Used by the `$sys.Reconnect` protocol to tell the
@@ -731,20 +746,77 @@ var RpcInboundCall = class {
   callId;
   method;
   args;
+  /** 0 = still processing, 1 = result computed and sent at least once. */
+  completedStage = 0;
+  _resend;
+  _abortController = new AbortController();
   constructor(callId, method, args) {
     this.callId = callId;
     this.method = method;
     this.args = args;
   }
+  /** Aborted when the remote peer cancels this call via `$sys.Cancel` (R17).
+   *  Threaded into the service handler so it can abort in-flight work. */
+  get signal() {
+    return this._abortController.signal;
+  }
+  /** True once the remote peer cancelled this call — the response is then
+   *  suppressed even though the call may still be registered (R9 dedup). */
+  get isCancelled() {
+    return this._abortController.signal.aborted;
+  }
+  cancel() {
+    this._abortController.abort();
+  }
+  // Records the closure that re-sends this call's already-computed result;
+  // marks the call as completed. Mirrors .NET's post-`ProcessStage1Plus` state.
+  setResult(resend) {
+    this._resend = resend;
+    this.completedStage = 1;
+  }
+  // Re-sends the result to the remote peer if it was already computed.
+  // A resent frame for an in-flight call is a no-op — the original dispatch
+  // will send the result when it completes. Mirrors .NET
+  // `RpcInboundCall.TryReprocess`.
+  resendResult() {
+    if (this.completedStage >= 1)
+      this._resend?.();
+  }
 };
 var RpcInboundCallTracker = class {
   _calls = /* @__PURE__ */ new Map();
+  _completedIds = [];
+  /** Cap on retained completed calls — see `RpcLimits.completedInboundCallsLimit`. */
+  completedCallsLimit = 1e3;
   get size() {
     return this._calls.size;
   }
   register(call) {
     this._calls.set(call.callId, call);
   }
+  // Registers `call` unless its id is already tracked, in which case the
+  // existing call is returned. Mirrors .NET `RpcInboundCallTracker.GetOrRegister`.
+  getOrRegister(call) {
+    const existing = this._calls.get(call.callId);
+    if (existing !== void 0)
+      return existing;
+    this._calls.set(call.callId, call);
+    return call;
+  }
+  // Keeps the completed `call` registered for duplicate-frame dedup, evicting
+  // the oldest completed calls beyond `completedCallsLimit`. Deviation from
+  // .NET (which unregisters a call once its result is sent): TS peers
+  // blind-resend after reconnect, so a completed call must stay resolvable
+  // to avoid re-executing the handler — but only within a bounded window.
+  markCompleted(call) {
+    if (this._calls.get(call.callId) !== call)
+      return;
+    this._completedIds.push(call.callId);
+    while (this._completedIds.length > this.completedCallsLimit) {
+      const id = this._completedIds.shift();
+      this._calls.delete(id);
+    }
+  }
   get(callId) {
     return this._calls.get(callId);
   }
@@ -755,6 +827,23 @@ var RpcInboundCallTracker = class {
   }
   clear() {
     this._calls.clear();
+    this._completedIds.length = 0;
+  }
+};
+
+// src/rpc-call-timeouts.ts
+var RpcCallTimeouts = class _RpcCallTimeouts {
+  /** Both timeouts unbounded — the query default (.NET `RpcCallTimeouts.None`). */
+  static None = new _RpcCallTimeouts(Infinity, Infinity);
+  /** Command default: 1.5 s connect / 10 s run (.NET `RpcCallTimeouts.Default.Command`). */
+  static Command = new _RpcCallTimeouts(1500, 1e4);
+  /** Max time a call may wait for the connection before it is sent. */
+  connectTimeoutMs;
+  /** Max time a sent call may stay unanswered before it is failed. */
+  runTimeoutMs;
+  constructor(connectTimeoutMs = Infinity, runTimeoutMs = Infinity) {
+    this.connectTimeoutMs = connectTimeoutMs;
+    this.runTimeoutMs = runTimeoutMs;
   }
 };
 
@@ -768,6 +857,12 @@ var RpcError = class extends Error {
       this.typeName = typeName;
   }
 };
+var REMOTE_EXCEPTION_TYPE_REF = "ActualLab.Serialization.RemoteException, ActualLab.Core";
+function toExceptionInfo(error) {
+  const name = error instanceof Error ? error.name : "Error";
+  const message = error instanceof Error ? error.message : String(error);
+  return { TypeRef: REMOTE_EXCEPTION_TYPE_REF, Message: `${name}: ${message}` };
+}
 
 // src/increasing-seq-compressor.ts
 var IncreasingSeqCompressor = {
@@ -872,6 +967,7 @@ import { PromiseSource as PromiseSource3, RingBuffer } from "@actuallab/core";
 var { warnLog: warnLog3 } = getLogs("RpcSharedStream");
 var DEFAULT_ACK_PERIOD = 256;
 var DEFAULT_ACK_ADVANCE = 128;
+var RTT_WINDOW_MS = 2e4;
 var RpcStreamSender = class _RpcStreamSender {
   static _emptyGuid = "00000000-0000-0000-0000-000000000000";
   id;
@@ -913,6 +1009,9 @@ var RpcStreamSender = class _RpcStreamSender {
   _lastAckedIndex = 0;
   _abortController = new AbortController();
   _iterator = null;
+  // -- RTT sampling (send → matching ack round trips, windowed minimum) --
+  _pendingSendTimes = [];
+  _rttSamples = [];
   // -- Recorder-controller metrics (Step 9.1) --
   /** Total items skipped via real-time `canSkipTo` compaction. */
   _skipCount = 0;
@@ -937,6 +1036,21 @@ var RpcStreamSender = class _RpcStreamSender {
   get skipCount() {
     return this._skipCount;
   }
+  // Windowed-MIN ack round trip (ms, -1 until sampled): converges on propagation
+  // RTT — unlike a mean/EMA it is not inflated by self-induced queuing.
+  get minRttMs() {
+    const cutoffMs = Date.now() - RTT_WINDOW_MS;
+    while (this._rttSamples.length > 0 && this._rttSamples[0].atMs < cutoffMs)
+      this._rttSamples.shift();
+    if (this._rttSamples.length === 0)
+      return -1;
+    let min = this._rttSamples[0].rttMs;
+    for (const s of this._rttSamples) {
+      if (s.rttMs < min)
+        min = s.rttMs;
+    }
+    return min;
+  }
   // -- ACK queue (analog of .NET's Channel<(long, bool)>) --
   _acks = [];
   _whenAckReady = null;
@@ -972,13 +1086,39 @@ var RpcStreamSender = class _RpcStreamSender {
    */
   onAck(nextIndex, hostId) {
     const mustReset = hostId !== "" && hostId !== _RpcStreamSender._emptyGuid;
-    if (!this._started.isCompleted) this._started.resolve();
+    if (mustReset && hostId !== this.id.hostId) {
+      this._sendDisconnect();
+      return;
+    }
+    if (!this._started.isCompleted) {
+      if (mustReset && nextIndex === 0)
+        this._started.resolve();
+      else {
+        this._sendDisconnect();
+        return;
+      }
+    } else if (this._ended) {
+      this._sendDisconnect();
+      return;
+    } else if (mustReset && !this.allowReconnect) {
+      this._sendDisconnect();
+      return;
+    }
+    this._sampleRtt(nextIndex, mustReset);
     this._acks.push({ nextIndex, mustReset });
     if (this._whenAckReady) {
       this._whenAckReady.resolve();
       this._whenAckReady = null;
     }
   }
+  // Tells the consumer this shared stream is gone, then disposes it —
+  // mirrors RpcSharedStream.SendDisconnect (RpcSharedStream.cs:284-289).
+  _sendDisconnect() {
+    const conn = this.peer.connection;
+    if (conn)
+      this.peer.hub.systemCallSender.disconnect(conn, this.peer.serializationFormat, [this.id.localId]);
+    this.disconnect();
+  }
   /** Called by system call handler when $sys.AckEnd is received from the client. */
   onAckEnd(_hostId) {
     this.disconnect();
@@ -1003,6 +1143,7 @@ var RpcStreamSender = class _RpcStreamSender {
         this._nextIndex,
         item
       );
+      this._pendingSendTimes.push({ index: this._nextIndex, sentAtMs: Date.now() });
     }
     this._nextIndex++;
   }
@@ -1027,7 +1168,7 @@ var RpcStreamSender = class _RpcStreamSender {
     this._ended = true;
     const conn = this.peer.connection;
     if (!conn) return;
-    const errorInfo = error ? { TypeRef: "System.Exception", Message: error.message } : { TypeRef: "", Message: "" };
+    const errorInfo = error ? toExceptionInfo(error) : { TypeRef: "", Message: "" };
     this.peer.hub.systemCallSender.end(
       conn,
       this.peer.serializationFormat,
@@ -1245,6 +1386,26 @@ var RpcStreamSender = class _RpcStreamSender {
     await this._whenAckReady;
     this._whenAckReady = null;
   }
+  // One RTT sample per ack: time from sending the newest acked item to the
+  // ack's arrival (a slight upper bound — includes the server's ack cadence).
+  _sampleRtt(ackNextIndex, mustReset) {
+    if (mustReset) {
+      this._pendingSendTimes.length = 0;
+      return;
+    }
+    let sentAtMs = -1;
+    while (this._pendingSendTimes.length > 0 && this._pendingSendTimes[0].index < ackNextIndex) {
+      sentAtMs = this._pendingSendTimes[0].sentAtMs;
+      this._pendingSendTimes.shift();
+    }
+    if (sentAtMs < 0)
+      return;
+    const nowMs = Date.now();
+    const cutoffMs = nowMs - RTT_WINDOW_MS;
+    while (this._rttSamples.length > 0 && this._rttSamples[0].atMs < cutoffMs)
+      this._rttSamples.shift();
+    this._rttSamples.push({ atMs: nowMs, rttMs: nowMs - sentAtMs });
+  }
   // -- IRpcObject --
   reconnect() {
   }
@@ -1469,11 +1630,7 @@ var RpcStream = class _RpcStream {
     if (index > this._nextExpectedIndex) {
       warnLog4?.log(`item index gap: localId=${this.id.localId}, expected=${this._nextExpectedIndex}, received=${index}`);
       if (!this.allowReconnect) {
-        this._completed = true;
-        this._completionError = new Error(
-          `Stream gap at index ${index} (expected ${this._nextExpectedIndex}); reconnect not allowed`
-        );
-        this._notifyConsumer();
+        this._complete(this._gapError(index));
         return;
       }
       this._sendAck(this._nextExpectedIndex, true);
@@ -1493,11 +1650,7 @@ var RpcStream = class _RpcStream {
     if (index > this._nextExpectedIndex) {
       warnLog4?.log(`batch index gap: localId=${this.id.localId}, expected=${this._nextExpectedIndex}, received=${index}`);
       if (!this.allowReconnect) {
-        this._completed = true;
-        this._completionError = new Error(
-          `Stream gap at index ${index} (expected ${this._nextExpectedIndex}); reconnect not allowed`
-        );
-        this._notifyConsumer();
+        this._complete(this._gapError(index));
         return;
       }
       this._sendAck(this._nextExpectedIndex, true);
@@ -1514,9 +1667,20 @@ var RpcStream = class _RpcStream {
   /** Called by system call handler when the stream ends ($sys.End). */
   onEnd(index, error) {
     if (this._disposed || this._completed) return;
-    this._completed = true;
-    this._completionError = error;
-    this._notifyConsumer();
+    if (index > this._nextExpectedIndex) {
+      warnLog4?.log(`end index gap: localId=${this.id.localId}, expected=${this._nextExpectedIndex}, received=${index}`);
+      if (!this.allowReconnect) {
+        this._complete(this._gapError(index));
+        return;
+      }
+      this._sendAck(this._nextExpectedIndex, true);
+      return;
+    }
+    if (index < this._nextExpectedIndex) {
+      this._maybeSendAck(Math.min(index, this._nextConsumedIndex));
+      return;
+    }
+    this._complete(error);
   }
   // -- IRpcObject --
   reconnect() {
@@ -1550,6 +1714,7 @@ var RpcStream = class _RpcStream {
       next: async () => {
         if (!this._started) {
           this._started = true;
+          this.peer.remoteObjects.register(this);
           this._sendAck(0, true);
         }
         this._maybeSendAck(this._nextConsumedIndex);
@@ -1560,6 +1725,7 @@ var RpcStream = class _RpcStream {
             return { value, done: false };
           }
           if (this._completed) {
+            this.dispose();
             if (this._completionError) throw this._completionError;
             return { value: void 0, done: true };
           }
@@ -1568,7 +1734,8 @@ var RpcStream = class _RpcStream {
         }
       },
       return: () => {
-        this._sendAckEnd();
+        if (this._started && !this._completed)
+          this._sendAckEnd();
         this.dispose();
         return Promise.resolve({ value: void 0, done: true });
       }
@@ -1584,6 +1751,22 @@ var RpcStream = class _RpcStream {
     this._notifyConsumer();
   }
   // -- Private --
+  // Mirrors .NET RpcStream.CloseFromLock: acknowledge the end to the sender
+  // (so its RpcSharedStream is released) and unregister immediately.
+  _complete(error) {
+    if (this._completed) return;
+    this._completed = true;
+    this._completionError = error;
+    this._sendAckEnd();
+    if (this.kind === RpcObjectKind.Remote)
+      this.peer.remoteObjects.unregister(this);
+    this._notifyConsumer();
+  }
+  _gapError(index) {
+    return new Error(
+      `Stream gap at index ${index} (expected ${this._nextExpectedIndex}); reconnect not allowed`
+    );
+  }
   _notifyConsumer() {
     if (this._consumerWaiting !== null) {
       this._consumerWaiting.resolve();
@@ -1600,7 +1783,7 @@ var RpcStream = class _RpcStream {
   static _emptyGuid = "00000000-0000-0000-0000-000000000000";
   _sendAck(nextIndex, mustReset) {
     this._ackSentUpTo = nextIndex;
-    const conn = this.peer.connection;
+    const conn = this.peer.isConnected ? this.peer.connection : void 0;
     if (conn) {
       const hostId = mustReset ? this.id.hostId : _RpcStream._emptyGuid;
       this.peer.hub.systemCallSender.ack(
@@ -1613,7 +1796,7 @@ var RpcStream = class _RpcStream {
     }
   }
   _sendAckEnd() {
-    const conn = this.peer.connection;
+    const conn = this.peer.isConnected ? this.peer.connection : void 0;
     if (conn) {
       this.peer.hub.systemCallSender.ackEnd(
         conn,
@@ -1633,9 +1816,7 @@ function resolveStreamRefs(value, peer) {
   if (typeof value === "string") {
     const ref = parseStreamRef(value);
     if (ref !== null) {
-      const stream = new RpcStream(ref, peer);
-      peer.remoteObjects.register(stream);
-      return stream;
+      return new RpcStream(ref, peer);
     }
     return value;
   }
@@ -1688,6 +1869,11 @@ var RpcSystemCallHandler = class {
       case RpcSystemCalls.ok: {
         const call = peer.outboundCalls.get(relatedId);
         if (call !== void 0) {
+          if (args.length > 1) {
+            peer.outboundCalls.remove(relatedId);
+            call.result.reject(polymorphicPayloadError(method, args.length, 1));
+            break;
+          }
           call.completedStage |= RpcCallStage.ResultReady;
           if (call.removeOnOk) {
             peer.outboundCalls.remove(relatedId);
@@ -1701,19 +1887,15 @@ var RpcSystemCallHandler = class {
         break;
       }
       case RpcSystemCalls.error: {
-        const call = peer.outboundCalls.remove(relatedId);
+        const call = peer.outboundCalls.get(relatedId);
         if (call !== void 0) {
+          call.completedStage |= RpcCallStage.ResultReady;
+          if (call.removeOnOk) {
+            peer.outboundCalls.remove(relatedId);
+          }
           const errorInfo = args[0];
           const msg = errorInfo?.Message ?? errorInfo?.message ?? "RPC error";
-          const errorType = errorInfo?.TypeRef ?? errorInfo?.typeRef;
-          let typeName;
-          if (typeof errorType === "string") {
-            const commaIdx = errorType.indexOf(",");
-            typeName = commaIdx >= 0 ? errorType.slice(0, commaIdx) : errorType;
-          } else if (errorType !== null && typeof errorType === "object") {
-            const t = errorType;
-            typeName = t.TypeName ?? t.typeName;
-          }
+          const typeName = extractTypeName(errorInfo?.TypeRef ?? errorInfo?.typeRef);
           if (typeName === "ActualLab.Rpc.RpcRerouteException")
             warnLog5?.log("Got RpcRerouteException from remote peer:", msg);
           call.result.reject(new RpcError(msg, typeName));
@@ -1721,17 +1903,29 @@ var RpcSystemCallHandler = class {
         break;
       }
       case RpcSystemCalls.cancel: {
-        peer.inboundCalls.remove(relatedId);
+        const call = peer.inboundCalls.remove(relatedId);
+        call?.cancel();
         break;
       }
       case RpcSystemCalls.keepAlive: {
         peer.notifyKeepAliveReceived();
+        const keepAliveIds = args[0];
+        if (Array.isArray(keepAliveIds) && keepAliveIds.length > 0 && peer.connection !== void 0) {
+          const unknownIds = [];
+          for (const id of keepAliveIds)
+            if (peer.sharedObjects.get(id) === void 0)
+              unknownIds.push(id);
+          if (unknownIds.length > 0)
+            peer.hub.systemCallSender.disconnect(peer.connection, peer.serializationFormat, unknownIds);
+        }
         break;
       }
       case RpcSystemCalls.item: {
         const stream = peer.remoteObjects.get(relatedId);
         if (!stream)
           debugLog?.log(`$sys.I: no stream for relatedId=${relatedId}`);
+        else if (args.length > 2)
+          stream.onEnd(args[0], polymorphicPayloadError(method, args.length, 2));
         else
           stream.onItem(
             args[0],
@@ -1743,6 +1937,8 @@ var RpcSystemCallHandler = class {
         const stream = peer.remoteObjects.get(relatedId);
         if (!stream)
           debugLog?.log(`$sys.B: no stream for relatedId=${relatedId}`);
+        else if (args.length > 2)
+          stream.onEnd(args[0], polymorphicPayloadError(method, args.length, 2));
         else if (Array.isArray(args[1])) {
           const items = args[1];
           for (let i = 0; i < items.length; i++)
@@ -1757,20 +1953,32 @@ var RpcSystemCallHandler = class {
           debugLog?.log(`$sys.End: no stream for relatedId=${relatedId}`);
         } else {
           const errorInfo = args[1];
+          const typeName = extractTypeName(errorInfo?.TypeRef ?? errorInfo?.typeRef);
           const msg = errorInfo?.Message ?? errorInfo?.message;
-          const error = msg ? new Error(msg) : null;
+          let error = null;
+          if (typeName || msg) {
+            error = new Error(msg ?? typeName ?? "RPC stream error");
+            if (typeName)
+              error.name = typeName;
+          }
           stream.onEnd(args[0], error);
         }
         break;
       }
       case RpcSystemCalls.ack: {
         const sender = peer.sharedObjects.get(relatedId);
-        sender?.onAck(args[0], args[1]);
+        if (sender)
+          sender.onAck(args[0], args[1]);
+        else if (peer.connection !== void 0)
+          peer.hub.systemCallSender.disconnect(peer.connection, peer.serializationFormat, [relatedId]);
         break;
       }
       case RpcSystemCalls.ackEnd: {
         const sender = peer.sharedObjects.get(relatedId);
-        sender?.onAckEnd(args[0]);
+        if (sender)
+          sender.onAckEnd(args[0]);
+        else if (peer.connection !== void 0)
+          peer.hub.systemCallSender.disconnect(peer.connection, peer.serializationFormat, [relatedId]);
         break;
       }
       case RpcSystemCalls.disconnect: {
@@ -1804,19 +2012,34 @@ var RpcSystemCallHandler = class {
    */
   _handleReconnect(relatedId, args, peer) {
     if (peer.connection === void 0) return;
+    const handshakeIndex = args[0];
+    if (typeof handshakeIndex === "number" && handshakeIndex !== peer.ownHandshakeIndex) {
+      peer.hub.systemCallSender.error(
+        peer.connection,
+        peer.serializationFormat,
+        relatedId,
+        new Error(
+          `TooLateToReconnect: own handshake index ${peer.ownHandshakeIndex} != ${handshakeIndex}`
+        )
+      );
+      return;
+    }
     let unknownIds = [];
     try {
       const stagesRaw = args[1];
       if (stagesRaw && typeof stagesRaw === "object" && !Array.isArray(stagesRaw)) {
         const unknownSet = /* @__PURE__ */ new Set();
-        for (const [, rawValue] of Object.entries(stagesRaw)) {
+        for (const [stageKey, rawValue] of Object.entries(stagesRaw)) {
           const bytes = _toBytes(rawValue);
           if (bytes === null) continue;
+          const completedStage = parseInt(stageKey, 10) || 0;
           const callIds = IncreasingSeqCompressor.deserialize(bytes);
           for (const callId of callIds) {
-            if (peer.inboundCalls.get(callId) === void 0) {
+            const call = peer.inboundCalls.get(callId);
+            if (call === void 0)
               unknownSet.add(callId);
-            }
+            else if (completedStage < 1)
+              call.resendResult();
           }
         }
         unknownIds = [...unknownSet].sort((a, b) => a - b);
@@ -1828,6 +2051,29 @@ var RpcSystemCallHandler = class {
     peer.hub.systemCallSender.ok(peer.connection, peer.serializationFormat, relatedId, responseValue);
   }
 };
+function polymorphicPayloadError(method, got, expected) {
+  return new Error(
+    `${method}: expected ${expected} value(s), got ${got} \u2014 polymorphic payloads are not supported by the TS client`
+  );
+}
+function extractTypeName(typeRef) {
+  if (typeof typeRef === "string") {
+    if (typeRef.length === 0)
+      return void 0;
+    const commaIdx = typeRef.indexOf(",");
+    return commaIdx >= 0 ? typeRef.slice(0, commaIdx) : typeRef;
+  }
+  if (typeRef !== null && typeof typeRef === "object") {
+    const t = typeRef;
+    const aqn = t.AssemblyQualifiedName ?? t.assemblyQualifiedName;
+    if (typeof aqn === "string" && aqn.length > 0) {
+      const commaIdx = aqn.indexOf(",");
+      return commaIdx >= 0 ? aqn.slice(0, commaIdx) : aqn;
+    }
+    return t.TypeName ?? t.typeName;
+  }
+  return void 0;
+}
 function _toBytes(value) {
   if (value instanceof Uint8Array) return value;
   if (typeof value === "string") {
@@ -1911,12 +2157,11 @@ var RpcSystemCallSender = class _RpcSystemCallSender {
     }
   }
   error(conn, format, relatedId, error) {
-    const message = error instanceof Error ? error.message : String(error);
     this._send(
       conn,
       format,
       { Method: RpcSystemCalls.error, RelatedId: relatedId },
-      [{ Message: message }]
+      [toExceptionInfo(error)]
     );
   }
   cancel(conn, format, relatedId) {
@@ -1930,6 +2175,14 @@ var RpcSystemCallSender = class _RpcSystemCallSender {
       activeCallIds
     ]);
   }
+  // Tells the remote peer the listed shared-object ids are gone on our side,
+  // so its matching remote objects (e.g. RpcStream consumers) fail fast
+  // instead of hanging. Mirrors .NET RpcSystemCallSender.Disconnect.
+  disconnect(conn, format, localIds) {
+    this._send(conn, format, { Method: RpcSystemCalls.disconnect }, [
+      localIds
+    ]);
+  }
   item(conn, format, localId, index, item) {
     this._itemEnv.RelatedId = localId;
     this._itemArgs[0] = index;
@@ -1967,7 +2220,13 @@ var RpcSystemCallSender = class _RpcSystemCallSender {
 var RpcRemoteObjectTracker = class {
   _objects = /* @__PURE__ */ new Map();
   register(obj) {
-    this._objects.set(obj.id.localId, obj);
+    const localId = obj.id.localId;
+    const existing = this._objects.get(localId);
+    if (existing === obj)
+      return;
+    if (existing !== void 0)
+      existing.disconnect();
+    this._objects.set(localId, obj);
   }
   get(localId) {
     return this._objects.get(localId);
@@ -1976,7 +2235,9 @@ var RpcRemoteObjectTracker = class {
     return this._objects.keys();
   }
   unregister(obj) {
-    this._objects.delete(obj.id.localId);
+    const localId = obj.id.localId;
+    if (this._objects.get(localId) === obj)
+      this._objects.delete(localId);
   }
   disconnectAll() {
     for (const obj of this._objects.values()) {
@@ -2000,7 +2261,10 @@ var RpcSharedObjectTracker = class {
     return this._nextId++;
   }
   register(obj) {
-    this._objects.set(obj.id.localId, obj);
+    const localId = obj.id.localId;
+    if (this._objects.has(localId))
+      throw new Error(`RPC shared object with localId ${localId} is already registered.`);
+    this._objects.set(localId, obj);
   }
   get(localId) {
     return this._objects.get(localId);
@@ -2009,7 +2273,9 @@ var RpcSharedObjectTracker = class {
     return this._objects.keys();
   }
   unregister(obj) {
-    this._objects.delete(obj.id.localId);
+    const localId = obj.id.localId;
+    if (this._objects.get(localId) === obj)
+      this._objects.delete(localId);
   }
   disconnectAll() {
     for (const obj of this._objects.values()) {
@@ -2020,7 +2286,7 @@ var RpcSharedObjectTracker = class {
 };
 
 // src/rpc-peer.ts
-import { EventHandlerSet as EventHandlerSet3, PromiseSource as PromiseSource5, TimeoutError, withTimeout } from "@actuallab/core";
+import { EventHandlerSet as EventHandlerSet3, PromiseSource as PromiseSource5, TimeoutError, cancellationError, withTimeout } from "@actuallab/core";
 
 // src/rpc-serialization-format.ts
 import { Decoder as Decoder3 } from "@msgpack/msgpack";
@@ -2039,9 +2305,7 @@ var RpcSerializationFormat = class {
   static NewtonsoftJsonV5;
   static NewtonsoftJsonV5NP;
   static MessagePackV6;
-  static MemoryPackV6;
   static MessagePackV6C;
-  static MemoryPackV6C;
   static All;
   /** Convenience shortcut for RpcSerializationFormatResolver.Default.get(key). */
   static get(key) {
@@ -2137,18 +2401,14 @@ RpcSerializationFormat.SystemJsonV5NP = new RpcJsonSerializationFormat("json5np"
 RpcSerializationFormat.NewtonsoftJsonV5 = new RpcJsonSerializationFormat("njson5");
 RpcSerializationFormat.NewtonsoftJsonV5NP = new RpcJsonSerializationFormat("njson5np");
 RpcSerializationFormat.MessagePackV6 = new RpcMessagePackSerializationFormat("msgpack6");
-RpcSerializationFormat.MemoryPackV6 = new RpcMessagePackSerializationFormat("mempack6");
 RpcSerializationFormat.MessagePackV6C = new RpcMessagePackCompactSerializationFormat("msgpack6c");
-RpcSerializationFormat.MemoryPackV6C = new RpcMessagePackCompactSerializationFormat("mempack6c");
 RpcSerializationFormat.All = [
   RpcSerializationFormat.SystemJsonV5,
   RpcSerializationFormat.SystemJsonV5NP,
   RpcSerializationFormat.NewtonsoftJsonV5,
   RpcSerializationFormat.NewtonsoftJsonV5NP,
   RpcSerializationFormat.MessagePackV6,
-  RpcSerializationFormat.MemoryPackV6,
-  RpcSerializationFormat.MessagePackV6C,
-  RpcSerializationFormat.MemoryPackV6C
+  RpcSerializationFormat.MessagePackV6C
 ];
 var RpcSerializationFormatResolver = class _RpcSerializationFormatResolver {
   static DefaultFormats = RpcSerializationFormat.All;
@@ -2168,6 +2428,8 @@ var RpcSerializationFormatResolver = class _RpcSerializationFormatResolver {
     this.formats = map;
   }
   get(key) {
+    if (isMemoryPackKey(key))
+      throw new Error(`Serialization format '${key}': MemoryPack formats are not supported by the TS client.`);
     const format = this.tryGet(key);
     if (!format)
       throw new Error(`No format with key '${key}'.`);
@@ -2175,9 +2437,14 @@ var RpcSerializationFormatResolver = class _RpcSerializationFormatResolver {
   }
   tryGet(key) {
     if (!key) key = this.defaultFormatKey;
+    if (isMemoryPackKey(key))
+      throw new Error(`Serialization format '${key}': MemoryPack formats are not supported by the TS client.`);
     return this.formats.get(key);
   }
 };
+function isMemoryPackKey(key) {
+  return key.startsWith("mempack");
+}
 
 // src/rpc-peer.ts
 function yieldToEventLoop() {
@@ -2231,6 +2498,10 @@ var RpcPeer = class {
    *  attempt (the reconnect delay is part of this phase); `Connected` is
    *  entered only after the handshake has succeeded. */
   connectionStateChanged = new EventHandlerSet3();
+  /** Index of the handshake THIS peer most recently sent. Used to reject a
+   *  stale `$sys.Reconnect` that references an older connection generation
+   *  (C# `RpcSystemCalls.Reconnect`'s `ownHandshake.Index` check). */
+  _ownHandshakeIndex = 0;
   _connection;
   /** Mirror of `_connectionState === Connected`. True only after the
    *  handshake round-trip completes; outbound `call()` checks this to
@@ -2242,6 +2513,7 @@ var RpcPeer = class {
   _connectionState = 0 /* Disconnected */;
   _keepAliveTimer;
   _keepAliveWatchdog;
+  _maintainTimer;
   /** Wall-clock time of the last inbound `$sys.KeepAlive`, or 0 if none yet
    *  for the current connection. Useful for diagnostics. */
   _lastKeepAliveAt = 0;
@@ -2256,6 +2528,37 @@ var RpcPeer = class {
     this.ref = ref;
     this.keepAlivePeriodMs = hub.limits.keepAlivePeriodMs;
     this.keepAliveTimeoutMs = hub.limits.keepAliveTimeoutMs;
+    this.inboundCalls.completedCallsLimit = hub.limits.completedInboundCallsLimit;
+    const checkPeriod = hub.limits.callTimeoutCheckPeriodMs;
+    if (checkPeriod > 0 && Number.isFinite(checkPeriod)) {
+      this._maintainTimer = setInterval(() => this._maintainOutboundCalls(), checkPeriod);
+      this._maintainTimer.unref?.();
+    }
+  }
+  /** Fail outbound calls whose per-call {@link RpcCallTimeouts} elapsed —
+   *  the connect timeout while a call still awaits the wire, the run timeout
+   *  once it has been sent. Mirrors .NET `RpcOutboundCallTracker.Maintain`
+   *  (RpcCallTrackers.cs:108-207). Calls without timeouts (queries) never
+   *  time out here. */
+  _maintainOutboundCalls() {
+    const now = Date.now();
+    const canRunTimeout = this._isConnected && (this._lastKeepAliveAt === 0 || now - this._lastKeepAliveAt <= this.keepAliveTimeoutMs);
+    for (const call of [...this.outboundCalls.values()]) {
+      const timeouts = call.timeouts;
+      if (timeouts === void 0 || call.result.isCompleted)
+        continue;
+      let timedOut;
+      if (call.sentAt === 0) {
+        if (now - call.startedAt >= timeouts.connectTimeoutMs)
+          timedOut = `connect timeout (${timeouts.connectTimeoutMs}ms)`;
+      } else if (canRunTimeout && now - call.sentAt >= timeouts.runTimeoutMs)
+        timedOut = `run timeout (${timeouts.runTimeoutMs}ms)`;
+      if (timedOut === void 0)
+        continue;
+      this.outboundCalls.remove(call.callId);
+      call.result.reject(new TimeoutError(`'${this.ref}': call ${call.method}#${call.callId} timed out \u2014 ${timedOut}`));
+      call.onDisconnect();
+    }
   }
   get connection() {
     return this._connection;
@@ -2266,6 +2569,9 @@ var RpcPeer = class {
   get isConnected() {
     return this._isConnected;
   }
+  get ownHandshakeIndex() {
+    return this._ownHandshakeIndex;
+  }
   _setConnectionState(value) {
     if (this._connectionState === value) return;
     const previousState = this._connectionState;
@@ -2337,14 +2643,17 @@ var RpcPeer = class {
       this._connection?.encoder,
       this.hub.registry
     );
+    outboundCall.timeouts = options?.timeouts;
     this.outboundCalls.register(outboundCall);
     if (this._isConnected) {
+      outboundCall.sentAt = Date.now();
       this._sendWireData(outboundCall.serializedWireData);
     } else {
       const stateHandler = (state) => {
         if (state !== 3 /* Connected */) return;
         this.connectionStateChanged.remove(stateHandler);
         if (outboundCall.result.isCompleted) return;
+        outboundCall.sentAt = Date.now();
         this._sendWireData(outboundCall.serializedWireData);
       };
       this.connectionStateChanged.add(stateHandler);
@@ -2354,9 +2663,9 @@ var RpcPeer = class {
     if (signal !== void 0) {
       const onAbort = () => {
         if (this.outboundCalls.remove(callId) !== void 0) {
-          outboundCall.result.reject(new Error("Call cancelled."));
+          outboundCall.result.reject(cancellationError("Call cancelled."));
           outboundCall.onDisconnect();
-          if (this._connection !== void 0)
+          if (this._isConnected && this._connection !== void 0)
             this.hub.systemCallSender.cancel(this._connection, this.serializationFormat, callId);
         }
       };
@@ -2386,10 +2695,15 @@ var RpcPeer = class {
   }
   close() {
     infoLog?.log(`'${this.ref}': Stopping`);
+    if (this._maintainTimer !== void 0) {
+      clearInterval(this._maintainTimer);
+      this._maintainTimer = void 0;
+    }
     this.remoteObjects.disconnectAll();
     this.sharedObjects.disconnectAll();
-    this.outboundCalls.rejectAll(new Error("Peer closed."));
+    this.outboundCalls.rejectAll(cancellationError("Peer closed."));
     this.outboundCalls.invalidateAll();
+    this.inboundCalls.clear();
     this._connection?.close();
     this.hub.peers.delete(this.ref);
     this._setConnectionState(0 /* Disconnected */);
@@ -2453,57 +2767,85 @@ var RpcPeer = class {
   _handleInbound(message, args) {
     const method = message.Method ?? "";
     const relatedId = message.RelatedId ?? 0;
-    const call = new RpcInboundCall(relatedId, method, args);
     const methodDef = this.hub.serviceHost.getMethodDef(method);
     const isNoWait = methodDef?.noWait === true;
-    if (!isNoWait) {
-      this.inboundCalls.register(call);
-    }
     const serviceHost = this.hub.serviceHost;
-    void (async () => {
+    const dispatch = async (call2) => {
       try {
         const context = this._connection !== void 0 ? {
           __rpcDispatch: true,
           callId: relatedId,
-          connection: this._connection
+          callType: message.CallType ?? 0,
+          connection: this._connection,
+          signal: call2?.signal,
+          peer: this
         } : void 0;
-        const result = await serviceHost.dispatch(
-          method,
-          args,
-          context
-        );
-        if (methodDef?.stream === true && this._connection !== void 0) {
-          const stream = result instanceof RpcStream ? result : new RpcStream(result);
-          this.hub.systemCallSender.ok(
-            this._connection,
-            this.serializationFormat,
-            relatedId,
-            stream.toRef(this)
-          );
-        } else if (!isNoWait && this._connection !== void 0) {
-          this.hub.systemCallSender.ok(
-            this._connection,
-            this.serializationFormat,
-            relatedId,
-            result
-          );
+        const result = await serviceHost.dispatch(method, args, context);
+        if (methodDef?.stream === true) {
+          if (this._connection !== void 0) {
+            const stream = result instanceof RpcStream ? result : new RpcStream(result);
+            const ref = stream.toRef(this);
+            const send = () => {
+              if (call2?.isCancelled === true) return;
+              if (this._connection !== void 0)
+                this.hub.systemCallSender.ok(
+                  this._connection,
+                  this.serializationFormat,
+                  relatedId,
+                  ref
+                );
+            };
+            if (call2 !== void 0) {
+              call2.setResult(send);
+              this.inboundCalls.markCompleted(call2);
+            }
+            send();
+          }
+        } else if (call2 !== void 0) {
+          const send = () => {
+            if (call2.isCancelled) return;
+            if (this._connection !== void 0)
+              this.hub.systemCallSender.ok(
+                this._connection,
+                this.serializationFormat,
+                relatedId,
+                result
+              );
+          };
+          call2.setResult(send);
+          this.inboundCalls.markCompleted(call2);
+          send();
         }
       } catch (e) {
-        if (!isNoWait && this._connection !== void 0) {
-          this.hub.systemCallSender.error(
-            this._connection,
-            this.serializationFormat,
-            relatedId,
-            e
-          );
+        if (call2 !== void 0) {
+          const send = () => {
+            if (call2.isCancelled) return;
+            if (this._connection !== void 0)
+              this.hub.systemCallSender.error(
+                this._connection,
+                this.serializationFormat,
+                relatedId,
+                e
+              );
+          };
+          call2.setResult(send);
+          this.inboundCalls.markCompleted(call2);
+          send();
         }
         debugLog2?.log(`'${this.ref}': Inbound call failed: ${method}#${relatedId}`, e);
-      } finally {
-        if (!isNoWait) {
-          this.inboundCalls.remove(relatedId);
-        }
       }
-    })();
+    };
+    if (isNoWait) {
+      void dispatch(void 0);
+      return;
+    }
+    const call = new RpcInboundCall(relatedId, method, args);
+    const existing = this.inboundCalls.getOrRegister(call);
+    if (existing !== call) {
+      existing.resendResult();
+      return;
+    }
+    void dispatch(call);
   }
   /** Start sending `$sys.KeepAlive` pings and arm the silence watchdog.
    *  Called when the peer transitions into `Connected` (after handshake).
@@ -2559,15 +2901,17 @@ var RpcConnectionState = /* @__PURE__ */ ((RpcConnectionState2) => {
 })(RpcConnectionState || {});
 var RpcClientPeer = class extends RpcPeer {
   _disposed = false;
+  /** Aborted when the peer is stopped/disposed — threaded into the reconnect
+   *  delay so a pending delay rejects promptly instead of parking. */
+  _stopController = new AbortController();
   _tryIndex = 0;
-  _handshakeIndex = 0;
   /** Index from the MOST RECENTLY RECEIVED server handshake — sent back
    *  to the server in `$sys.Reconnect:3` so the server can verify we're
    *  talking about the current connection. Mirrors .NET's
    *  `connectionState.Handshake.Index` path in
    *  `RpcOutboundCallTracker.TryReconnect`. */
   _remoteHandshakeIndex = 0;
-  _lastRemoteHubId;
+  _lastRemotePeerId;
   _pendingHandshake;
   _reconnectsAt = 0;
   /** Base64url-encoded peer ID — matches .NET's RpcClientPeer.ClientId (Guid.ToBase64Url). */
@@ -2588,6 +2932,10 @@ var RpcClientPeer = class extends RpcPeer {
    *  the connection attempt. Initialized from `hub.limits` at construction;
    *  set directly to override on a single peer. */
   handshakeTimeoutMs;
+  /** A connection that lived less than this before dropping does NOT reset
+   *  `_tryIndex`, so a crash-looping server sees growing reconnect delays.
+   *  Initialized from `hub.limits` at construction; override per peer. */
+  prematureDisconnectTimeoutMs;
   peerChanged = new EventHandlerSet3();
   /** Fired when the server rejects the connection due to an unsupported serialization format (close code 4010). */
   unsupportedFormat = new EventHandlerSet3();
@@ -2620,6 +2968,7 @@ var RpcClientPeer = class extends RpcPeer {
     super(hub, url);
     this.connectTimeoutMs = hub.limits.connectTimeoutMs;
     this.handshakeTimeoutMs = hub.limits.handshakeTimeoutMs;
+    this.prematureDisconnectTimeoutMs = hub.limits.prematureDisconnectTimeoutMs;
     this.clientId = guidToBase64Url(this.id);
     const resolver = RpcSerializationFormatResolver.Default;
     this.serializationFormat = resolver.get(parseFormatFromUrl(url) ?? resolver.defaultFormatKey);
@@ -2656,7 +3005,7 @@ var RpcClientPeer = class extends RpcPeer {
     try {
       while (!this._disposed) {
         this._setConnectionState(1 /* Connecting */);
-        const retryDelay = this.hub.reconnectDelayer.getDelay(this._tryIndex);
+        const retryDelay = this.hub.reconnectDelayer.getDelay(this._tryIndex, this._stopController.signal);
         if (retryDelay.isLimitExceeded) {
           warnLog6?.log(`'${this.ref}': Reconnect limit exceeded - shutting down`);
           this._disposed = true;
@@ -2665,12 +3014,14 @@ var RpcClientPeer = class extends RpcPeer {
         this._setReconnectsAt(retryDelay.endsAt);
         try {
           await retryDelay.promise;
+        } catch {
         } finally {
           this._setReconnectsAt(0);
         }
         if (this._disposed) break;
         let lastCloseCode = 0;
         let lastCloseReason = "";
+        let connectedAt = 0;
         try {
           const connUrl = await this.connectionUrlResolver(this);
           infoLog?.log(`'${this.ref}': Connecting to ${sanitizeUrl(connUrl)}`);
@@ -2717,7 +3068,7 @@ var RpcClientPeer = class extends RpcPeer {
               this.serializationFormat,
               this.id,
               this.hub.hubId,
-              ++this._handshakeIndex
+              ++this._ownHandshakeIndex
             );
           } catch (e) {
             warnLog6?.log(`'${this.ref}': Failed to send handshake`, e);
@@ -2741,20 +3092,10 @@ var RpcClientPeer = class extends RpcPeer {
             this._pendingHandshake = void 0;
           }
           this._remoteHandshakeIndex = remoteHandshake.Index ?? 0;
-          const remoteHubId = remoteHandshake.RemoteHubId;
-          let isPeerChanged = false;
-          if (remoteHubId !== void 0) {
-            isPeerChanged = this._lastRemoteHubId !== void 0 && this._lastRemoteHubId !== remoteHubId;
-            if (isPeerChanged) {
-              this.inboundCalls.clear();
-              infoLog?.log(`'${this.ref}': Peer changed`);
-              this.peerChanged.trigger();
-            }
-            this._lastRemoteHubId = remoteHubId;
-          }
+          const isPeerChanged = this._detectPeerChange(remoteHandshake);
           infoLog?.log(`'${this.ref}': Handshake succeeded, peerChanged=${isPeerChanged}`);
           this._setConnectionState(3 /* Connected */);
-          this._tryIndex = 0;
+          connectedAt = Date.now();
           await this._reconnect(isPeerChanged, closedController.signal);
           await whenClosed;
         } catch (e) {
@@ -2768,6 +3109,8 @@ var RpcClientPeer = class extends RpcPeer {
           this._disposed = true;
           break;
         }
+        if (connectedAt !== 0 && Date.now() - connectedAt >= this.prematureDisconnectTimeoutMs)
+          this._tryIndex = 0;
         this._tryIndex++;
       }
     } finally {
@@ -2823,6 +3166,8 @@ var RpcClientPeer = class extends RpcPeer {
         continue;
       }
       eligible.push(call);
+      if (call.sentAt !== 0)
+        call.sentAt = Date.now();
     }
     let unknownIds = null;
     if (!isPeerChanged && eligible.length > 0) {
@@ -2839,6 +3184,7 @@ var RpcClientPeer = class extends RpcPeer {
       if (unknownIds !== null && !unknownIds.has(call.callId)) {
         continue;
       }
+      call.sentAt = Date.now();
       this._sendWireData(call.serializedWireData);
       resentSinceYield++;
       if (resentSinceYield >= YIELD_BATCH) {
@@ -2904,30 +3250,80 @@ var RpcClientPeer = class extends RpcPeer {
       return new Set(eligible.map((c) => c.callId));
     }
   }
+  /** Detects a server-peer identity change by comparing the incoming
+   *  handshake's `RemotePeerId` with the last one — C#
+   *  `RpcHandshake.GetPeerChangeKind` keys off `RemotePeerId`, not
+   *  `RemoteHubId` (an idle server peer can be replaced while keeping the
+   *  same hub id). On a change it clears the inbound tracker and fires
+   *  `peerChanged`; the very first handshake is never a change. */
+  _detectPeerChange(handshake) {
+    const remotePeerId = handshake.RemotePeerId;
+    if (remotePeerId === void 0)
+      return false;
+    const isPeerChanged = this._lastRemotePeerId !== void 0 && this._lastRemotePeerId !== remotePeerId;
+    this._lastRemotePeerId = remotePeerId;
+    if (isPeerChanged) {
+      this.inboundCalls.clear();
+      infoLog?.log(`'${this.ref}': Peer changed`);
+      this.peerChanged.trigger();
+    }
+    return isPeerChanged;
+  }
   _onHandshakeReceived(handshake) {
     this._pendingHandshake?.resolve(handshake);
   }
   close() {
     this._disposed = true;
+    this._stopController.abort();
     super.close();
   }
 };
 var RpcServerPeer = class extends RpcPeer {
-  // Needed to widen the base `protected constructor` to public.
-  // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+  /** Grace period before an idle (disconnected) server peer is stopped and
+   *  removed from `hub.peers`; a re-`accept()` within it cancels removal.
+   *  Snapshotted from `hub.limits` at construction (F11). */
+  serverPeerCloseTimeoutMs;
+  _closeTimer;
+  _isClosed = false;
   constructor(hub, ref) {
     super(hub, ref);
+    this.serverPeerCloseTimeoutMs = hub.limits.serverPeerCloseTimeoutMs;
   }
   /** Accept an incoming connection — sets up message handling and handshake response. */
   accept(conn) {
+    this._clearCloseTimer();
     this._setConnectionState(1 /* Connecting */);
     this.setupConnection(conn);
     this._setConnectionState(2 /* Handshaking */);
     conn.closed.add(() => {
       if (this._connection !== conn && this._connection !== void 0) return;
       this.sharedObjects.disconnectAll();
+      this._armCloseTimer();
     });
   }
+  close() {
+    this._isClosed = true;
+    this._clearCloseTimer();
+    super.close();
+  }
+  _armCloseTimer() {
+    this._clearCloseTimer();
+    if (this._isClosed) return;
+    const timeout = this.serverPeerCloseTimeoutMs;
+    if (!(timeout > 0) || !Number.isFinite(timeout)) return;
+    this._closeTimer = setTimeout(() => {
+      this._closeTimer = void 0;
+      if (this._connection === void 0)
+        this.close();
+    }, timeout);
+    this._closeTimer.unref?.();
+  }
+  _clearCloseTimer() {
+    if (this._closeTimer !== void 0) {
+      clearTimeout(this._closeTimer);
+      this._closeTimer = void 0;
+    }
+  }
   _onHandshakeReceived(_handshake) {
     if (this._connection !== void 0) {
       this.hub.systemCallSender.handshake(
@@ -2935,7 +3331,7 @@ var RpcServerPeer = class extends RpcPeer {
         this.serializationFormat,
         this.id,
         this.hub.hubId,
-        0
+        ++this._ownHandshakeIndex
       );
       this._setConnectionState(3 /* Connected */);
     }
@@ -2974,6 +3370,12 @@ var RpcLimits = class _RpcLimits {
   /** Process-wide default. Hubs read from this when they're constructed
    *  unless caller assigns a custom instance to `hub.limits`. */
   static Default = new _RpcLimits();
+  /** Dev preset with a relaxed keep-alive timeout (5 min), matching .NET's
+   *  debugger-attached `KeepAlivePeriod` (RpcLimits.cs:46-54). Activate
+   *  explicitly — e.g. `RpcLimits.Default = RpcLimits.Debug` or per-hub
+   *  `hub.limits = RpcLimits.Debug`. Never switched on automatically: the
+   *  TS side can't detect a debugger on the server (decision D4). */
+  static Debug = new _RpcLimits({ keepAliveTimeoutMs: 3e5 });
   /** Max time to wait for the WebSocket to enter the OPEN state. On a
    *  hung connect (mobile after network change, half-open after sleep)
    *  the browser can take ~2 min to emit `onerror`/`onclose`; without
@@ -2981,6 +3383,22 @@ var RpcLimits = class _RpcLimits {
   connectTimeoutMs = 1e4;
   /** Max time to wait for the server's handshake response after WS opens. */
   handshakeTimeoutMs = 1e4;
+  /** If a connection lived less than this before dropping, a graceful close
+   *  still counts as a failed attempt — the client keeps its growing
+   *  `_tryIndex` instead of resetting it, so a crash-looping server sees
+   *  increasing reconnect delays via `RetryDelaySeq`. Mirrors .NET
+   *  `RpcLimits.PrematureDisconnectTimeout` (RpcLimits.cs:18). */
+  prematureDisconnectTimeoutMs = 15e3;
+  /** Max completed inbound calls retained for duplicate-frame dedup
+   *  (a resent call id re-sends the computed result instead of
+   *  re-executing the handler). Deviation from .NET, which unregisters a
+   *  call once its result is sent: TS clients blind-resend on reconnect,
+   *  so completed calls are retained — bounded by this limit (oldest
+   *  evicted first) to cap memory on long-lived connections. */
+  completedInboundCallsLimit = 1e3;
+  /** How often each peer's maintenance loop scans outbound calls for
+   *  timeouts (R12). Mirrors .NET `RpcLimits.CallTimeoutCheckPeriod`. */
+  callTimeoutCheckPeriodMs = 1e3;
   /** Outbound `$sys.KeepAlive` send period. */
   keepAlivePeriodMs = 1e4;
   /** Reaper threshold — connection is force-closed (and the reconnect
@@ -2990,6 +3408,13 @@ var RpcLimits = class _RpcLimits {
    *  `keepAlivePeriodMs + stall_duration`, so with these defaults the
    *  tolerated stall is ~15 s. */
   keepAliveTimeoutMs = 25e3;
+  /** How long a server peer stays in `hub.peers` after its connection closes
+   *  before it's stopped and removed. A same-peer reconnect (`accept()`)
+   *  within this window cancels the pending removal, so brief drops don't
+   *  discard the peer's trackers. Mirrors .NET's server-peer shutdown timeout
+   *  (`RpcPeerOptions.ServerPeerShutdownTimeoutProvider`, 3-15 min); the TS
+   *  port uses a fixed floor-matching default. */
+  serverPeerCloseTimeoutMs = 18e4;
   constructor(overrides) {
     if (overrides) Object.assign(this, overrides);
   }
@@ -3000,7 +3425,7 @@ import { RetryDelaySeq, RetryDelayer } from "@actuallab/core";
 var RpcClientPeerReconnectDelayer = class extends RetryDelayer {
   constructor() {
     super();
-    this.delays = RetryDelaySeq.fixed(100);
+    this.delays = RetryDelaySeq.exp(100, 1e4);
   }
 };
 
@@ -3008,13 +3433,14 @@ var RpcClientPeerReconnectDelayer = class extends RetryDelayer {
 var { warnLog: warnLog7 } = getLogs("RpcServiceHost");
 var RpcServiceHost = class {
   _methods = /* @__PURE__ */ new Map();
-  register(def, impl) {
+  register(def, impl, receiver = impl) {
     for (const methodDef of def.methods.values()) {
       const fn = impl[methodDef.name];
       if (!fn) continue;
       this._methods.set(wireMethodName(methodDef), {
         def: methodDef,
-        fn
+        fn,
+        receiver
       });
     }
   }
@@ -3025,9 +3451,9 @@ var RpcServiceHost = class {
       throw new Error(`Method not found: ${wireMethod}`);
     }
     if (context !== void 0 && 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) {
     return this._methods.get(wireMethod)?.def;
@@ -3035,6 +3461,7 @@ var RpcServiceHost = class {
 };
 
 // src/rpc-decorators.ts
+import { ownMetadata, resolveArgCount } from "@actuallab/core";
 var METHODS_META = /* @__PURE__ */ Symbol.for("actuallab.methods");
 var SERVICE_META = /* @__PURE__ */ Symbol.for("actuallab.service");
 function getMethodsMeta(cls) {
@@ -3045,17 +3472,17 @@ function getServiceMeta(cls) {
 }
 function rpcService(serviceName) {
   return function(_target, context) {
-    const meta = context.metadata[SERVICE_META] ??= {};
+    const meta = ownMetadata(context.metadata, SERVICE_META);
     meta.name = serviceName;
   };
 }
 function rpcMethod(options) {
   return function(target, context) {
     const methodName = String(context.name);
-    const methods = context.metadata[METHODS_META] ??= {};
+    const methods = ownMetadata(context.metadata, METHODS_META);
     methods[methodName] = {
       ...methods[methodName],
-      argCount: target.length,
+      argCount: resolveArgCount(target, options?.argCount, methodName),
       returns: options?.returns,
       remoteExecutionMode: options?.remoteExecutionMode
     };
@@ -3601,7 +4028,7 @@ var RpcHub = class {
   hubId;
   peers = /* @__PURE__ */ new Map();
   serviceHost;
-  systemCallSender = new RpcSystemCallSender();
+  systemCallSender;
   systemCallHandler = new RpcSystemCallHandler();
   /** Method registry for compact format hash ↔ name resolution.
    *  Created lazily, populated by addService/addClient. */
@@ -3609,6 +4036,14 @@ var RpcHub = class {
   /** Shared reconnect delayer used by every client peer in this hub. Swap in
    *  a custom subclass (e.g. app-level signal-gated) before peers start. */
   reconnectDelayer = new RpcClientPeerReconnectDelayer();
+  /** 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).
+   *  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. */
+  _clientProxies = /* @__PURE__ */ new WeakMap();
   /** Connection-lifecycle timing limits. Peers constructed against this hub
    *  read their initial `*Ms` field values from this instance; later
    *  mutations affect only peers built afterward (existing peers can be
@@ -3626,6 +4061,7 @@ var RpcHub = class {
   constructor(hubId) {
     this.hubId = hubId ?? crypto.randomUUID();
     this.serviceHost = new RpcServiceHost();
+    this.systemCallSender = this._createSystemCallSender();
     this.systemCallSender.registry = this.registry;
     for (const methodName of Object.values(RpcSystemCalls)) {
       this.registry.register(methodName);
@@ -3686,50 +4122,38 @@ var RpcHub = class {
       if (!fn) continue;
       wrappedImpl[methodDef.name] = methodDef.callTypeId !== 0 ? this._wrapServerMethod(methodDef, fn, impl) : fn;
     }
-    this.serviceHost.register(def, wrappedImpl);
+    this.serviceHost.register(def, wrappedImpl, impl);
     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(peer, defOrContract) {
     const def = this._resolveServiceDef(defOrContract);
     this.registry.registerService(def.name, def.methods);
-    const overloads = /* @__PURE__ */ new Map();
-    for (const methodDef of def.methods.values()) {
-      let byArgCount = overloads.get(methodDef.name);
-      if (!byArgCount) {
-        byArgCount = /* @__PURE__ */ new Map();
-        overloads.set(methodDef.name, byArgCount);
-      }
-      byArgCount.set(
-        methodDef.argCount,
-        this._createClientMethod(peer, methodDef)
-      );
+    let byService = this._clientProxies.get(peer);
+    if (byService === void 0) {
+      byService = /* @__PURE__ */ new Map();
+      this._clientProxies.set(peer, byService);
     }
-    const methods = /* @__PURE__ */ new Map();
-    for (const [name, byArgCount] of overloads) {
-      if (byArgCount.size === 1) {
-        const [[, singleFn]] = byArgCount;
-        methods.set(name, singleFn);
-      } else {
-        methods.set(name, (...args) => {
-          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 === void 0) {
+      entry = this._createClientProxy();
+      byService.set(def.name, entry);
     }
-    return new Proxy({}, {
-      get: (_target, prop) => typeof prop === "string" ? methods.get(prop) : void 0
-    });
+    this._extendClientProxy(peer, entry, def);
+    return entry.proxy;
   }
   close() {
     for (const peer of this.peers.values()) peer.close();
     this.peers.clear();
   }
+  /** Create the hub's system-call sender. Override in FusionHub to add
+   *  Fusion-specific system calls (e.g. $sys-c.Invalidate). */
+  _createSystemCallSender() {
+    return new RpcSystemCallSender();
+  }
   /** Build an RpcServiceDef from decorator metadata on a contract class. Override in FusionHub for compute support. */
   _buildServiceDef(cls) {
     const svcMeta = getServiceMeta(cls);
@@ -3787,12 +4211,10 @@ var RpcHub = class {
           throw new Error(
             `Expected stream reference, got: ${JSON.stringify(result)}`
           );
-        const stream = new RpcStream(ref, peer);
-        peer.remoteObjects.register(stream);
-        return stream;
+        return new RpcStream(ref, peer);
       };
     }
-    const callOptions = methodDef.callTypeId !== 0 || mode !== RpcRemoteExecutionMode.Default ? { callTypeId: methodDef.callTypeId, remoteExecutionMode: mode } : void 0;
+    const callOptions = methodDef.callTypeId !== 0 || mode !== RpcRemoteExecutionMode.Default || methodDef.timeouts !== void 0 ? { callTypeId: methodDef.callTypeId, remoteExecutionMode: mode, timeouts: methodDef.timeouts } : void 0;
     return async (...args) => {
       if (mustCheckConnection && !peer.isConnected)
         throw new Error("Outbound call failed: not connected and AwaitForConnection is not set.");
@@ -3802,7 +4224,58 @@ var RpcHub = class {
       return resolveStreamRefs(result, peer);
     };
   }
+  // Private methods
+  _createClientProxy() {
+    const methods = /* @__PURE__ */ new Map();
+    const proxy = new Proxy({}, {
+      get: (_target, prop) => typeof prop === "string" ? methods.get(prop) : void 0
+    });
+    return { proxy, methods, overloads: /* @__PURE__ */ new Map() };
+  }
+  _extendClientProxy(peer, entry, def) {
+    for (const methodDef of def.methods.values()) {
+      const existing = entry.overloads.get(methodDef.name)?.get(methodDef.argCount);
+      if (existing !== void 0 && !isSameWireMethod(existing.def, methodDef))
+        throw new Error(
+          `RpcHub.addClient: conflicting definition of '${wireMethodName(methodDef)}' under service '${def.name}' \u2014 a different signature is already registered.`
+        );
+    }
+    const changed = /* @__PURE__ */ new Set();
+    for (const methodDef of def.methods.values()) {
+      let byArgCount = entry.overloads.get(methodDef.name);
+      if (byArgCount === void 0) {
+        byArgCount = /* @__PURE__ */ 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, byArgCount) {
+  if (byArgCount.size === 1) {
+    const [[, only]] = byArgCount;
+    return only.fn;
+  }
+  return (...args) => {
+    const overload = byArgCount.get(args.length);
+    if (overload === void 0)
+      throw new Error(`No overload of ${name} accepts ${args.length} arguments`);
+    return overload.fn(...args);
+  };
+}
+function isSameWireMethod(a, b) {
+  return a.wireArgCount === b.wireArgCount && a.callTypeId === b.callTypeId && a.stream === b.stream && a.noWait === b.noWait && a.remoteExecutionMode === b.remoteExecutionMode;
+}
 
 // src/rpc-peer-ref-builder.ts
 var RpcPeerRefBuilder = class {
@@ -3869,7 +4342,7 @@ function createMethod(peer, methodDef) {
       throw new Error("Outbound call failed: not connected and AwaitForConnection is not set.");
     const callArgs = args.slice(0, methodDef.argCount);
     const wireName = wireMethodName(methodDef);
-    const options = methodDef.callTypeId !== 0 || mode !== RpcRemoteExecutionMode.Default ? { callTypeId: methodDef.callTypeId, remoteExecutionMode: mode } : void 0;
+    const options = methodDef.callTypeId !== 0 || mode !== RpcRemoteExecutionMode.Default || methodDef.timeouts !== void 0 ? { callTypeId: methodDef.callTypeId, remoteExecutionMode: mode, timeouts: methodDef.timeouts } : void 0;
     const outboundCall = peer.call(wireName, callArgs, options);
     return outboundCall.result.promise;
   };
@@ -4064,8 +4537,10 @@ export {
   ENVELOPE_DELIMITER,
   FRAME_DELIMITER,
   IncreasingSeqCompressor,
+  REMOTE_EXCEPTION_TYPE_REF,
   RPC_CLOSE_CODE_UNSUPPORTED_FORMAT,
   RpcCallStage,
+  RpcCallTimeouts,
   RpcCallTypeId,
   RpcClientPeer,
   RpcClientPeerReconnectDelayer,
@@ -4120,6 +4595,7 @@ export {
   isConnected,
   likelyConnected,
   parseStreamRef,
+  readPolymorphismMarker,
   resolveStreamRefs,
   rpcMethod,
   rpcService,
@@ -4131,6 +4607,7 @@ export {
   splitBinaryFrame,
   splitCompactBinaryFrame,
   splitFrame,
+  toExceptionInfo,
   wireMethodName,
   xxh3_64,
   xxh3_64str