@actuallab/rpc 12.3.14 → 12.3.31

package/dist/index.cjs

@@ -33,7 +33,9 @@ __export(index_exports, {
   ARG_DELIMITER: () => ARG_DELIMITER,
   ENVELOPE_DELIMITER: () => ENVELOPE_DELIMITER,
   FRAME_DELIMITER: () => FRAME_DELIMITER,
+  IncreasingSeqCompressor: () => IncreasingSeqCompressor,
   RPC_CLOSE_CODE_UNSUPPORTED_FORMAT: () => RPC_CLOSE_CODE_UNSUPPORTED_FORMAT,
+  RpcCallStage: () => RpcCallStage,
   RpcCallTypeId: () => RpcCallTypeId,
   RpcClientPeer: () => RpcClientPeer,
   RpcClientPeerReconnectDelayer: () => RpcClientPeerReconnectDelayer,
@@ -78,6 +80,7 @@ __export(index_exports, {
   deserializeBinaryMessage: () => deserializeBinaryMessage,
   deserializeCompactBinaryMessage: () => deserializeCompactBinaryMessage,
   deserializeMessage: () => deserializeMessage,
+  getLogs: () => getLogs,
   getMethodsMeta: () => getMethodsMeta,
   getServiceMeta: () => getServiceMeta,
   getStateDescription: () => getStateDescription,
@@ -101,6 +104,33 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/logging.ts
+var import_core = require("@actuallab/core");
+var scopeDefaults = {
+  RpcCallTracker: import_core.LogLevel.Warn,
+  RpcClient: import_core.LogLevel.Warn,
+  RpcClientPeerReconnectDelayer: import_core.LogLevel.Warn,
+  RpcConnection: import_core.LogLevel.Warn,
+  RpcHub: import_core.LogLevel.Warn,
+  RpcInterceptor: import_core.LogLevel.Warn,
+  RpcMessageChannelConnection: import_core.LogLevel.Warn,
+  RpcMethodRegistry: import_core.LogLevel.Warn,
+  RpcOutboundCall: import_core.LogLevel.Warn,
+  RpcPeer: import_core.LogLevel.Info,
+  RpcPeerStateMonitor: import_core.LogLevel.Warn,
+  RpcRemoteObjectTracker: import_core.LogLevel.Warn,
+  RpcSerialization: import_core.LogLevel.Warn,
+  RpcServiceHost: import_core.LogLevel.Warn,
+  RpcSharedObjectTracker: import_core.LogLevel.Warn,
+  RpcSharedStream: import_core.LogLevel.Warn,
+  RpcStream: import_core.LogLevel.Warn,
+  RpcStreamSender: import_core.LogLevel.Warn,
+  RpcSystemCallHandler: import_core.LogLevel.Warn,
+  RpcSystemCallSender: import_core.LogLevel.Warn,
+  RpcWebSocketClient: import_core.LogLevel.Warn
+};
+var getLogs = (0, import_core.createLogProvider)("rpc.", scopeDefaults);
+
 // src/rpc-message.ts
 var RpcCallTypeId = /* @__PURE__ */ ((RpcCallTypeId2) => {
   RpcCallTypeId2[RpcCallTypeId2["Regular"] = 0] = "Regular";
@@ -125,7 +155,44 @@ var ARG_DELIMITER = "";
 var FRAME_DELIMITER = "\n";
 
 // src/rpc-serialization.ts
+var import_msgpack2 = require("@msgpack/msgpack");
+
+// src/msgpack-map-patch.ts
 var import_msgpack = require("@msgpack/msgpack");
+function patchMsgpackEncoderForMaps() {
+  const proto = import_msgpack.Encoder.prototype;
+  if (proto._hasMapPatch) return;
+  proto._hasMapPatch = true;
+  const originalDoEncode = proto.doEncode;
+  proto.doEncode = function(object, depth) {
+    if (object instanceof Map) {
+      _encodeMapInstance.call(this, object, depth);
+      return;
+    }
+    originalDoEncode.call(this, object, depth);
+  };
+  function _encodeMapInstance(m, depth) {
+    const self = this;
+    const size = m.size;
+    if (size < 16) {
+      self.writeU8(128 + size);
+    } else if (size < 65536) {
+      self.writeU8(222);
+      self.writeU16(size);
+    } else {
+      self.writeU8(223);
+      self.writeU32(size);
+    }
+    for (const [key, value] of m) {
+      self.doEncode(key, depth + 1);
+      self.doEncode(value, depth + 1);
+    }
+  }
+}
+patchMsgpackEncoderForMaps();
+
+// src/rpc-serialization.ts
+var { warnLog } = getLogs("RpcSerialization");
 function serializeMessage(message, args) {
   const envelope = JSON.stringify(message);
   if (args === void 0 || args.length === 0) {
@@ -155,9 +222,7 @@ function deserializeMessage(raw) {
     try {
       return JSON.parse(s);
     } catch {
-      console.warn(
-        `[RpcSerialization] failed to parse arg as JSON: ${s.substring(0, 100)}`
-      );
+      warnLog?.log(`failed to parse arg as JSON: ${s.substring(0, 100)}`);
       return s;
     }
   });
@@ -166,15 +231,15 @@ function deserializeMessage(raw) {
 var textEncoder = new TextEncoder();
 var textDecoder = new TextDecoder();
 var INITIAL_ENCODER_BUFFER_SIZE = 32 * 1024;
-var defaultBinaryEncoder = new import_msgpack.Encoder(
+var defaultBinaryEncoder = new import_msgpack2.Encoder(
   void 0,
   void 0,
   void 0,
   INITIAL_ENCODER_BUFFER_SIZE
 );
-var defaultBinaryDecoder = new import_msgpack.Decoder();
+var defaultBinaryDecoder = new import_msgpack2.Decoder();
 function createBinaryEncoder() {
-  return new import_msgpack.Encoder(
+  return new import_msgpack2.Encoder(
     void 0,
     void 0,
     void 0,
@@ -411,8 +476,9 @@ function splitCompactBinaryFrame(frame, registry, decoder = defaultBinaryDecoder
 }
 
 // src/rpc-connection.ts
-var import_msgpack2 = require("@msgpack/msgpack");
-var import_core = require("@actuallab/core");
+var import_msgpack3 = require("@msgpack/msgpack");
+var import_core2 = require("@actuallab/core");
+var { warnLog: warnLog2 } = getLogs("RpcConnection");
 var WebSocketState = {
   CONNECTING: 0,
   OPEN: 1,
@@ -422,7 +488,7 @@ var WebSocketState = {
 var RpcWebSocketConnection = class {
   _ws;
   _sendBuffer = [];
-  _connected = new import_core.PromiseSource();
+  _connected = new import_core2.PromiseSource();
   /** Per-connection msgpack encoder — reused across outbound messages to
    *  amortise construction cost and to keep the internal write buffer at
    *  its largest observed size (avoids repeated `resizeBuffer` growth on
@@ -430,7 +496,7 @@ var RpcWebSocketConnection = class {
   _encoder = createBinaryEncoder();
   /** Per-connection msgpack decoder — reused across inbound messages
    *  rather than reconstructing one for every `decodeMulti` call. */
-  _decoder = new import_msgpack2.Decoder();
+  _decoder = new import_msgpack3.Decoder();
   /** Exposed for callers who need to encode outbound binary messages
    *  through this connection (e.g. `serializeBinaryMessage`). Safe to
    *  pass to synchronous encode calls on the same event-loop turn. */
@@ -443,9 +509,9 @@ var RpcWebSocketConnection = class {
   _format;
   _methodRegistry;
   binaryMode;
-  messageReceived = new import_core.EventHandlerSet();
-  closed = new import_core.EventHandlerSet();
-  error = new import_core.EventHandlerSet();
+  messageReceived = new import_core2.EventHandlerSet();
+  closed = new import_core2.EventHandlerSet();
+  error = new import_core2.EventHandlerSet();
   constructor(ws, binaryMode = false, format, methodRegistry) {
     this._ws = ws;
     this.binaryMode = binaryMode;
@@ -474,6 +540,7 @@ var RpcWebSocketConnection = class {
             });
           }
         } catch (e) {
+          warnLog2?.log("Failed to split binary frame:", e);
           this.error.trigger(e);
         }
       } else if (typeof Blob !== "undefined" && ev.data instanceof Blob && this.binaryMode) {
@@ -489,6 +556,7 @@ var RpcWebSocketConnection = class {
               });
             }
           } catch (e) {
+            warnLog2?.log("Failed to split binary blob frame:", e);
             this.error.trigger(e);
           }
         });
@@ -564,13 +632,13 @@ var RpcWebSocketConnection = class {
 };
 
 // src/rpc-message-channel-connection.ts
-var import_core2 = require("@actuallab/core");
+var import_core3 = require("@actuallab/core");
 var RpcMessageChannelConnection = class {
   _port;
   _open = true;
   binaryMode = false;
-  messageReceived = new import_core2.EventHandlerSet();
-  closed = new import_core2.EventHandlerSet();
+  messageReceived = new import_core3.EventHandlerSet();
+  closed = new import_core3.EventHandlerSet();
   whenConnected = Promise.resolve();
   // immediately connected
   constructor(port) {
@@ -659,11 +727,26 @@ function defineRpcService(name, methods) {
 }
 
 // src/rpc-call-tracker.ts
-var import_core3 = require("@actuallab/core");
+var import_core4 = require("@actuallab/core");
+
+// src/rpc-call-stage.ts
+var RpcCallStage = {
+  /** The call's result has been received from the peer. */
+  ResultReady: 1,
+  /** The compute call's result has been invalidated (compute-call specific). */
+  Invalidated: 3,
+  /**
+   * Bit flag added on top of ResultReady/Invalidated when the outbound
+   * call has been removed from the tracker (unregistered).
+   */
+  Unregistered: 4096
+};
+
+// src/rpc-call-tracker.ts
 var RpcOutboundCall = class {
   callId;
   method;
-  result = new import_core3.PromiseSource();
+  result = new import_core4.PromiseSource();
   /** Bitfield of RpcRemoteExecutionMode flags controlling reconnect/resend behavior. */
   remoteExecutionMode;
   /** Whether to remove this call from the tracker on $sys.Ok. Default: true.
@@ -671,11 +754,35 @@ var RpcOutboundCall = class {
   removeOnOk = true;
   /** The serialized wire data — stored for re-sending on reconnect. */
   serializedWireData = "";
+  /**
+   * Bitfield of {@link RpcCallStage} flags indicating how far this call
+   * has progressed. Used by the `$sys.Reconnect` protocol to tell the
+   * remote peer which calls are still pending its attention.
+   *
+   * - 0: brand new, no result yet (the peer is expected to be actively processing).
+   * - `ResultReady` (1): `$sys.Ok` received for this call.
+   * - `Invalidated` (3): result was invalidated (compute calls only).
+   * - `Unregistered` (0x1000): removed from the tracker.
+   */
+  completedStage = 0;
   constructor(callId, method, remoteExecutionMode = 7) {
     this.callId = callId;
     this.method = method;
     this.remoteExecutionMode = remoteExecutionMode;
   }
+  /**
+   * Returns the stage to report to the remote peer via `$sys.Reconnect`,
+   * or `null` if this call should not be reconciled and must be aborted.
+   *
+   * Mirrors .NET `RpcOutboundCall.GetReconnectStage` at
+   * src/ActualLab.Rpc/Infrastructure/RpcOutboundCall.cs.
+   */
+  getReconnectStage(isPeerChanged) {
+    const mode = this.remoteExecutionMode;
+    if (!(mode & RpcRemoteExecutionMode.AllowReconnect)) return null;
+    if (isPeerChanged && !(mode & RpcRemoteExecutionMode.AllowResend)) return null;
+    return this.completedStage;
+  }
   /** Called when the connection is lost. Subclasses can override to resolve invalidation promises. */
   onDisconnect() {
   }
@@ -697,7 +804,10 @@ var RpcOutboundCallTracker = class {
   }
   remove(callId) {
     const call = this._calls.get(callId);
-    if (call !== void 0) this._calls.delete(callId);
+    if (call !== void 0) {
+      this._calls.delete(callId);
+      call.completedStage |= RpcCallStage.Unregistered;
+    }
     return call;
   }
   values() {
@@ -760,15 +870,107 @@ var RpcInboundCallTracker = class {
   }
 };
 
+// src/increasing-seq-compressor.ts
+var IncreasingSeqCompressor = {
+  /**
+   * Serialize a non-decreasing sequence of non-negative integers as
+   * LEB128-encoded deltas.
+   *
+   * Throws `RangeError` if the input is not monotonically non-decreasing,
+   * or if a value exceeds `Number.MAX_SAFE_INTEGER`.
+   */
+  serialize(values) {
+    const deltas = [];
+    let last = 0;
+    let totalBytes = 0;
+    for (const value of values) {
+      if (!Number.isSafeInteger(value) || value < 0)
+        throw new RangeError(
+          `IncreasingSeqCompressor: value must be a non-negative safe integer (got ${value}).`
+        );
+      const delta = value - last;
+      if (delta < 0)
+        throw new RangeError(
+          `IncreasingSeqCompressor: sequence must be non-decreasing (saw ${value} after ${last}).`
+        );
+      deltas.push(delta);
+      last = value;
+      totalBytes += _varUintByteLength(delta);
+    }
+    const out = new Uint8Array(totalBytes);
+    let offset = 0;
+    for (const delta of deltas) {
+      offset = _writeVarUint(out, delta, offset);
+    }
+    return out;
+  },
+  /**
+   * Decode bytes produced by {@link serialize} back into the original
+   * sorted sequence of non-negative integers.
+   */
+  deserialize(data) {
+    const result = [];
+    let last = 0;
+    let offset = 0;
+    while (offset < data.length) {
+      const [delta, next] = _readVarUint(data, offset);
+      offset = next;
+      last += delta;
+      result.push(last);
+    }
+    return result;
+  }
+};
+var LOW_BITS = 127;
+var HIGH_BIT = 128;
+function _varUintByteLength(value) {
+  let n = 0;
+  let v = value;
+  while (v >= HIGH_BIT) {
+    n++;
+    v = Math.floor(v / 128);
+  }
+  return n + 1;
+}
+function _writeVarUint(out, value, offset) {
+  let v = value;
+  while (v >= HIGH_BIT) {
+    out[offset++] = (HIGH_BIT | v & LOW_BITS) & 255;
+    v = Math.floor(v / 128);
+  }
+  out[offset++] = v & 255;
+  return offset;
+}
+function _readVarUint(data, offset) {
+  let value = 0;
+  let shift = 0;
+  while (shift < 63) {
+    if (offset >= data.length)
+      throw new RangeError("IncreasingSeqCompressor: truncated VarUInt.");
+    const b2 = data[offset++];
+    value += (b2 & LOW_BITS) * Math.pow(2, shift);
+    if (b2 <= LOW_BITS) return [value, offset];
+    shift += 7;
+  }
+  if (offset >= data.length)
+    throw new RangeError("IncreasingSeqCompressor: truncated VarUInt.");
+  const b = data[offset++];
+  if (b > 1)
+    throw new RangeError("IncreasingSeqCompressor: VarUInt value exceeds 64 bits.");
+  value += b * Math.pow(2, 63);
+  return [value, offset];
+}
+
 // src/rpc-stream.ts
 var import_denque = __toESM(require("denque"), 1);
-var import_core5 = require("@actuallab/core");
+var import_core6 = require("@actuallab/core");
 
 // src/rpc-object.ts
 var RpcObjectKind = { Local: 0, Remote: 1 };
 
 // src/rpc-stream-sender.ts
-var import_core4 = require("@actuallab/core");
+var import_core5 = require("@actuallab/core");
+var { warnLog: warnLog3 } = getLogs("RpcSharedStream");
 var DEFAULT_ACK_PERIOD = 256;
 var DEFAULT_ACK_ADVANCE = 128;
 var RpcStreamSender = class _RpcStreamSender {
@@ -781,15 +983,29 @@ var RpcStreamSender = class _RpcStreamSender {
   peer;
   ackPeriod;
   ackAdvance;
+  /**
+   * If true, the source was produced by a factory `(abortSignal) => AsyncIterable<T>`
+   * and may honor the AbortSignal to exit gracefully. `disconnect()` first aborts
+   * the signal and gives the source up to `RpcStream.disconnectGracePeriodMs` ms
+   * before force-closing via `iterator.return()`.
+   *
+   * If false, the source is a plain AsyncIterable that cannot observe the signal,
+   * so `disconnect()` force-closes immediately.
+   */
+  sourceUsesAbortSignal;
+  // -- Pump state --
+  /** Next stream index that will be sent (matches .NET's `index`). */
   _nextIndex = 0;
   _ended = false;
-  _started = new import_core4.PromiseSource();
+  _started = new import_core5.PromiseSource();
+  /** Highest `nextIndex` observed in an ACK so far (matches .NET's `lastAckNextIndex` idiom). */
   _lastAckedIndex = 0;
-  _ackWaiting = null;
-  _resetRequested = false;
   _abortController = new AbortController();
   _iterator = null;
-  constructor(peer, ackPeriod = DEFAULT_ACK_PERIOD, ackAdvance = DEFAULT_ACK_ADVANCE, allowReconnect = true, isRealTime = false, canSkipTo = () => true) {
+  // -- ACK queue (analog of .NET's Channel<(long, bool)>) --
+  _acks = [];
+  _whenAckReady = null;
+  constructor(peer, ackPeriod = DEFAULT_ACK_PERIOD, ackAdvance = DEFAULT_ACK_ADVANCE, allowReconnect = true, isRealTime = false, canSkipTo = () => true, sourceUsesAbortSignal = false) {
     const localId = peer.sharedObjects.nextId();
     this.id = { hostId: peer.hub.hubId, localId };
     this.allowReconnect = allowReconnect;
@@ -798,6 +1014,7 @@ var RpcStreamSender = class _RpcStreamSender {
     this.peer = peer;
     this.ackPeriod = ackPeriod;
     this.ackAdvance = ackAdvance;
+    this.sourceUsesAbortSignal = sourceUsesAbortSignal;
   }
   /** AbortSignal that is aborted when the sender is disconnected. */
   get abortSignal() {
@@ -807,56 +1024,61 @@ var RpcStreamSender = class _RpcStreamSender {
   toRef() {
     return `${this.id.hostId},${this.id.localId},${this.ackPeriod},${this.ackAdvance},${this.allowReconnect ? "1" : "0"},${this.isRealTime ? "1" : "0"}`;
   }
-  /** Called by system call handler when $sys.Ack is received from the client. */
+  /**
+   * Called by system call handler when $sys.Ack is received from the client.
+   *
+   * Mirrors .NET `RpcSharedStream<T>.OnAck` at
+   * src/ActualLab.Rpc/Infrastructure/RpcSharedStream.cs:68-101.
+   */
   onAck(nextIndex, hostId) {
     const mustReset = hostId !== "" && hostId !== _RpcStreamSender._emptyGuid;
-    if (!this._started.isCompleted) {
-      this._started.resolve();
-    }
-    if (mustReset && this.isRealTime) {
-      this._nextIndex = nextIndex;
-      this._lastAckedIndex = nextIndex;
-      this._resetRequested = true;
-    } else {
-      if (mustReset || nextIndex > this._lastAckedIndex) {
-        this._lastAckedIndex = nextIndex;
-      }
-    }
-    if (this._ackWaiting) {
-      this._ackWaiting.resolve();
-      this._ackWaiting = null;
+    if (!this._started.isCompleted) this._started.resolve();
+    this._acks.push({ nextIndex, mustReset });
+    if (this._whenAckReady) {
+      this._whenAckReady.resolve();
+      this._whenAckReady = null;
     }
   }
   /** Called by system call handler when $sys.AckEnd is received from the client. */
   onAckEnd(_hostId) {
     this.disconnect();
   }
-  /** Send a single item to the client. */
+  /**
+   * Send a single item to the client at the current `_nextIndex`.
+   *
+   * Advances `_nextIndex` unconditionally — even if the peer is disconnected
+   * the item is considered "sent" from the pump's perspective so the replay
+   * buffer indexing stays consistent. If a connection is absent, the wire
+   * message is dropped; the item will be resent from the replay buffer
+   * after a reconnect (client sends `Ack(N, mustReset=true)`).
+   */
   sendItem(item) {
     if (this._ended) return;
     const conn = this.peer.connection;
-    if (!conn) return;
-    this.peer.hub.systemCallSender.item(
-      conn,
-      this.peer.format,
-      this.id.localId,
-      this._nextIndex,
-      item
-    );
+    if (conn) {
+      this.peer.hub.systemCallSender.item(
+        conn,
+        this.peer.format,
+        this.id.localId,
+        this._nextIndex,
+        item
+      );
+    }
     this._nextIndex++;
   }
-  /** Send a batch of items to the client. */
+  /** Send a batch of items to the client. See {@link sendItem} for disconnect semantics. */
   sendBatch(items) {
     if (this._ended || items.length === 0) return;
     const conn = this.peer.connection;
-    if (!conn) return;
-    this.peer.hub.systemCallSender.batch(
-      conn,
-      this.peer.format,
-      this.id.localId,
-      this._nextIndex,
-      items
-    );
+    if (conn) {
+      this.peer.hub.systemCallSender.batch(
+        conn,
+        this.peer.format,
+        this.id.localId,
+        this._nextIndex,
+        items
+      );
+    }
     this._nextIndex += items.length;
   }
   /** Signal stream completion to the client. */
@@ -876,76 +1098,274 @@ var RpcStreamSender = class _RpcStreamSender {
   }
   /**
    * Consume an AsyncIterable and send all items to the client.
-   * Waits for the client's initial Ack before starting to pump items.
    *
-   * When `isRealTime` is true, applies flow control based on `ackAdvance`:
-   * if the sender is `ackAdvance` items ahead of the last ACK, it enters
-   * skip mode — draining the source and discarding items until it finds
-   * one where `canSkipTo` returns true.
+   * Dispatches to the non-real-time or real-time pump, matching .NET
+   * `RpcSharedStream<T>.OnRun` at
+   * src/ActualLab.Rpc/Infrastructure/RpcSharedStream.cs:105-108.
    */
   async writeFrom(source) {
     await this._started.promise;
+    if (this._ended) return;
     const iterator = source[Symbol.asyncIterator]();
     this._iterator = iterator;
+    const state = { iteratorDone: false };
     try {
-      for (; ; ) {
-        const next = await iterator.next();
-        if (next.done || this._ended) break;
-        const item = next.value;
-        if (this._resetRequested) {
-          if (!this.canSkipTo(item)) continue;
-          this._resetRequested = false;
-          this.sendItem(item);
-          continue;
+      if (this.isRealTime) {
+        await this._runRealTime(iterator, state);
+      } else {
+        await this._runNonRealTime(iterator, state);
+      }
+    } finally {
+      if (state.iteratorDone && this._iterator === iterator) {
+        this._iterator = null;
+      }
+    }
+  }
+  /**
+   * Non-real-time pump — back-pressure through buffered ACKs.
+   *
+   * Direct port of .NET `OnRunNonRealTime` at
+   * src/ActualLab.Rpc/Infrastructure/RpcSharedStream.cs:110-217.
+   */
+  /* eslint-disable @typescript-eslint/no-unnecessary-condition -- _ended changes across awaits */
+  async _runNonRealTime(iterator, state) {
+    const buffer = new import_core5.RingBuffer(this.ackAdvance + 1);
+    let bufferStart = 0;
+    let isFullyBuffered = false;
+    while (true) {
+      let ack = this._tryProcessAcks();
+      if (!ack) {
+        await this._waitAckReady();
+        if (this._ended) return;
+        ack = this._tryProcessAcks();
+        if (!ack) {
+          warnLog3?.log("Something is off: couldn't read an acknowledgement");
+          return;
         }
-        if (this._nextIndex < this._lastAckedIndex + this.ackAdvance) {
-          this.sendItem(item);
+      }
+      this._lastAckedIndex = ack.nextIndex;
+      const shift = _clamp(ack.nextIndex - bufferStart, 0, buffer.count);
+      if (shift > 0) {
+        buffer.moveHead(shift);
+        bufferStart += shift;
+      }
+      if (this._nextIndex < bufferStart) {
+        if (!this._ended)
+          this.sendEnd(new Error("Stream position unavailable."));
+        return;
+      }
+      let bufferIndex = this._nextIndex - bufferStart;
+      const maxIndex = ack.nextIndex + this.ackAdvance;
+      while (this._nextIndex < maxIndex) {
+        if (this._ended) return;
+        if (bufferIndex < buffer.count) {
+          const item = buffer.get(bufferIndex++);
+          if (item.kind === "value") {
+            this.sendItem(item.value);
+          } else if (item.kind === "end") {
+            if (!this._ended) this.sendEnd();
+            return;
+          } else {
+            if (!this._ended) this.sendEnd(item.error);
+            return;
+          }
           continue;
         }
-        if (!this.isRealTime) {
-          await this._waitForAckBudget();
+        if (isFullyBuffered) break;
+        if (!buffer.hasRemainingCapacity) break;
+        let pulled;
+        try {
+          const r = await iterator.next();
           if (this._ended) return;
-          this.sendItem(item);
-          continue;
+          if (r.done) {
+            pulled = _endItem;
+            isFullyBuffered = true;
+            state.iteratorDone = true;
+          } else {
+            pulled = { kind: "value", value: r.value };
+          }
+        } catch (e) {
+          state.iteratorDone = true;
+          isFullyBuffered = true;
+          pulled = {
+            kind: "error",
+            error: e instanceof Error ? e : new Error(String(e))
+          };
         }
-        let latestSkipTarget = this.canSkipTo(item) ? item : void 0;
-        let sourceExhausted = false;
-        while (this._nextIndex >= this._lastAckedIndex + this.ackAdvance) {
+        buffer.pushTail(pulled);
+      }
+    }
+  }
+  /**
+   * Real-time pump — drops stale items to stay close to the source's head.
+   *
+   * Direct port of .NET `OnRunRealTime` at
+   * src/ActualLab.Rpc/Infrastructure/RpcSharedStream.cs:219-420.
+   */
+  async _runRealTime(iterator, state) {
+    const buffer = new import_core5.RingBuffer(this.ackAdvance + 1);
+    let bufferStart = 0;
+    let isFullyBuffered = false;
+    while (true) {
+      let ack = this._tryProcessAcks();
+      if (!ack) {
+        await this._waitAckReady();
+        if (this._ended) return;
+        ack = this._tryProcessAcks();
+        if (!ack) {
+          warnLog3?.log("Something is off: couldn't read an acknowledgement");
+          return;
+        }
+      }
+      this._lastAckedIndex = ack.nextIndex;
+      if (ack.mustReset && !isFullyBuffered) {
+        buffer.clear();
+        bufferStart = this._nextIndex;
+        while (true) {
           if (this._ended) return;
-          const n = await iterator.next();
-          if (n.done) {
-            sourceExhausted = true;
-            break;
-          }
-          if (this.canSkipTo(n.value)) {
-            latestSkipTarget = n.value;
+          let item;
+          let accepted = false;
+          try {
+            const r = await iterator.next();
+            if (this._ended) return;
+            if (r.done) {
+              item = _endItem;
+              isFullyBuffered = true;
+              state.iteratorDone = true;
+            } else if (this.canSkipTo(r.value)) {
+              item = { kind: "value", value: r.value };
+              accepted = true;
+            } else {
+              continue;
+            }
+          } catch (e) {
+            state.iteratorDone = true;
+            isFullyBuffered = true;
+            item = {
+              kind: "error",
+              error: e instanceof Error ? e : new Error(String(e))
+            };
           }
+          buffer.pushTail(item);
+          if (accepted || isFullyBuffered) break;
         }
+      }
+      const shift = _clamp(ack.nextIndex - bufferStart, 0, buffer.count);
+      if (shift > 0) {
+        buffer.moveHead(shift);
+        bufferStart += shift;
+      }
+      if (this._nextIndex < bufferStart) {
+        if (!this._ended)
+          this.sendEnd(new Error("Stream position unavailable."));
+        return;
+      }
+      let bufferIndex = this._nextIndex - bufferStart;
+      const maxIndex = ack.nextIndex + this.ackAdvance;
+      while (this._nextIndex < maxIndex) {
         if (this._ended) return;
-        if (latestSkipTarget !== void 0) {
-          this.sendItem(latestSkipTarget);
+        if (this._acks.length > 0) break;
+        if (bufferIndex < buffer.count) {
+          const item = buffer.get(bufferIndex++);
+          if (item.kind === "value") {
+            this.sendItem(item.value);
+          } else if (item.kind === "end") {
+            if (!this._ended) this.sendEnd();
+            return;
+          } else {
+            if (!this._ended) this.sendEnd(item.error);
+            return;
+          }
+          continue;
         }
-        if (sourceExhausted) {
-          if (!this._ended) this.sendEnd();
-          return;
+        if (isFullyBuffered) break;
+        if (!buffer.hasRemainingCapacity) break;
+        let pulled;
+        try {
+          const r = await iterator.next();
+          if (this._ended) return;
+          if (r.done) {
+            pulled = _endItem;
+            isFullyBuffered = true;
+            state.iteratorDone = true;
+          } else {
+            pulled = { kind: "value", value: r.value };
+          }
+        } catch (e) {
+          state.iteratorDone = true;
+          isFullyBuffered = true;
+          pulled = {
+            kind: "error",
+            error: e instanceof Error ? e : new Error(String(e))
+          };
         }
+        buffer.pushTail(pulled);
       }
-      if (!this._ended) {
-        this.sendEnd();
-      }
-    } catch (e) {
-      if (!this._ended) {
-        this.sendEnd(e instanceof Error ? e : new Error(String(e)));
+      if (this._nextIndex >= maxIndex && !isFullyBuffered && !this._ended) {
+        let latestValue;
+        let haveLatest = false;
+        let exitReason = "ack";
+        let exitError = null;
+        drain: while (!this._ended) {
+          if (this._acks.length > 0) {
+            exitReason = "ack";
+            break drain;
+          }
+          let r;
+          try {
+            r = await iterator.next();
+          } catch (e) {
+            state.iteratorDone = true;
+            isFullyBuffered = true;
+            exitReason = "error";
+            exitError = e instanceof Error ? e : new Error(String(e));
+            break drain;
+          }
+          if (this._ended) return;
+          if (r.done) {
+            state.iteratorDone = true;
+            isFullyBuffered = true;
+            exitReason = "end";
+            break drain;
+          }
+          if (this.canSkipTo(r.value)) {
+            latestValue = r.value;
+            haveLatest = true;
+          }
+        }
+        if (exitReason === "end" || exitReason === "error") {
+          if (haveLatest && !this._ended) this.sendItem(latestValue);
+          if (!this._ended) this.sendEnd(exitError);
+          return;
+        }
+        if (haveLatest) {
+          const wasFull = buffer.isFull;
+          buffer.pushTailAndMoveHeadIfFull({ kind: "value", value: latestValue });
+          if (wasFull) bufferStart++;
+        }
       }
     }
   }
-  /** Wait until _nextIndex < _lastAckedIndex + ackAdvance. */
-  async _waitForAckBudget() {
-    while (this._nextIndex >= this._lastAckedIndex + this.ackAdvance) {
-      if (this._ended) return;
-      this._ackWaiting = new import_core4.PromiseSource();
-      await this._ackWaiting.promise;
+  /* eslint-enable @typescript-eslint/no-unnecessary-condition */
+  /** Drain all queued ACKs, returning the most recent one (or null if none). */
+  _tryProcessAcks() {
+    if (this._acks.length === 0) return null;
+    let last = null;
+    while (this._acks.length > 0) {
+      const a = this._acks.shift();
+      last = a;
+      if (a.mustReset || this._nextIndex < a.nextIndex) {
+        this._nextIndex = a.nextIndex;
+      }
     }
+    return last;
+  }
+  /** Wait for the ACK queue to have at least one entry (or `_ended`). */
+  async _waitAckReady() {
+    if (this._acks.length > 0 || this._ended) return;
+    this._whenAckReady = new import_core5.PromiseSource();
+    await this._whenAckReady.promise;
+    this._whenAckReady = null;
   }
   // -- IRpcObject --
   reconnect() {
@@ -957,19 +1377,41 @@ var RpcStreamSender = class _RpcStreamSender {
     if (!this._started.isCompleted) {
       this._started.resolve();
     }
-    if (this._ackWaiting) {
-      this._ackWaiting.resolve();
-      this._ackWaiting = null;
+    if (this._whenAckReady) {
+      this._whenAckReady.resolve();
+      this._whenAckReady = null;
     }
-    if (this._iterator) {
-      void this._iterator.return?.(void 0);
+    this.peer.sharedObjects.unregister(this);
+    const iterator = this._iterator;
+    if (!iterator) return;
+    if (!this.sourceUsesAbortSignal) {
       this._iterator = null;
+      this._forceCloseIterator(iterator);
+      return;
+    }
+    setTimeout(() => {
+      if (this._iterator === iterator) {
+        this._iterator = null;
+        this._forceCloseIterator(iterator);
+      }
+    }, RpcStream.disconnectGracePeriodMs);
+  }
+  _forceCloseIterator(iterator) {
+    try {
+      const ret = iterator.return?.(void 0);
+      if (ret) void ret.catch(() => {
+      });
+    } catch {
     }
-    this.peer.sharedObjects.unregister(this);
   }
 };
+var _endItem = { kind: "end" };
+function _clamp(value, min, max) {
+  return value < min ? min : value > max ? max : value;
+}
 
 // src/rpc-stream.ts
+var { warnLog: warnLog4 } = getLogs("RpcStream");
 var DEFAULT_ACK_PERIOD2 = 30;
 var DEFAULT_ACK_ADVANCE2 = 61;
 function parseStreamRef(value) {
@@ -1003,6 +1445,15 @@ function parseStreamRef(value) {
   return null;
 }
 var RpcStream = class _RpcStream {
+  /**
+   * Grace period (ms) given to a factory-form local source to honor its
+   * AbortSignal and exit naturally before the sender force-closes the
+   * iterator via `iterator.return()`.
+   *
+   * Only applies to sources provided as `(abortSignal) => AsyncIterable<T>`.
+   * Plain `AsyncIterable<T>` sources are force-closed immediately on disconnect.
+   */
+  static disconnectGracePeriodMs = 100;
   id;
   kind;
   allowReconnect;
@@ -1080,17 +1531,19 @@ var RpcStream = class _RpcStream {
         throw new Error("toRef() was already called with a different peer.");
       return this._toRefValue;
     }
+    const isFactory = typeof this.localSource === "function";
     const sender = new RpcStreamSender(
       peer,
       this.ackPeriod,
       this.ackAdvance,
       this.allowReconnect,
       this.isRealTime,
-      this.canSkipTo
+      this.canSkipTo,
+      isFactory
     );
     peer.sharedObjects.register(sender);
     this._sender = sender;
-    const source = typeof this.localSource === "function" ? this.localSource(sender.abortSignal) : this.localSource;
+    const source = isFactory ? this.localSource(sender.abortSignal) : this.localSource;
     this._whenSent = sender.writeFrom(source);
     this._toRefValue = peer.format.isBinary ? {
       SerializedId: [sender.id.hostId, sender.id.localId],
@@ -1104,9 +1557,7 @@ var RpcStream = class _RpcStream {
   onItem(index, item) {
     if (this._disposed || this._completed) return;
     if (index > this._nextExpectedIndex) {
-      console.warn(
-        `[RpcStream] item index gap: localId=${this.id.localId}, expected=${this._nextExpectedIndex}, received=${index}`
-      );
+      warnLog4?.log(`item index gap: localId=${this.id.localId}, expected=${this._nextExpectedIndex}, received=${index}`);
       if (!this.allowReconnect) {
         this._completed = true;
         this._completionError = new Error(
@@ -1131,9 +1582,7 @@ var RpcStream = class _RpcStream {
   onBatch(index, items) {
     if (this._disposed || this._completed) return;
     if (index > this._nextExpectedIndex) {
-      console.warn(
-        `[RpcStream] batch index gap: localId=${this.id.localId}, expected=${this._nextExpectedIndex}, received=${index}`
-      );
+      warnLog4?.log(`batch index gap: localId=${this.id.localId}, expected=${this._nextExpectedIndex}, received=${index}`);
       if (!this.allowReconnect) {
         this._completed = true;
         this._completionError = new Error(
@@ -1204,7 +1653,7 @@ var RpcStream = class _RpcStream {
             if (this._completionError) throw this._completionError;
             return { value: void 0, done: true };
           }
-          this._consumerWaiting = new import_core5.PromiseSource();
+          this._consumerWaiting = new import_core6.PromiseSource();
           await this._consumerWaiting.promise;
         }
       },
@@ -1300,15 +1749,37 @@ function resolveStreamRefs(value, peer) {
   return value;
 }
 
+// src/base64.ts
+function base64Encode(bytes) {
+  const chunkSize = 32768;
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += chunkSize) {
+    binary += String.fromCharCode.apply(
+      null,
+      bytes.subarray(i, Math.min(bytes.length, i + chunkSize))
+    );
+  }
+  return btoa(binary);
+}
+function base64Decode(encoded) {
+  const binary = atob(encoded);
+  const out = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);
+  return out;
+}
+
 // src/rpc-system-call-handler.ts
+var { debugLog, warnLog: warnLog5 } = getLogs("RpcSystemCallHandler");
 var RpcSystemCallHandler = class {
   handle(message, args, peer) {
     const method = message.Method;
     const relatedId = message.RelatedId ?? 0;
+    debugLog?.log(`'${peer.ref}': handle ${method}#${relatedId}`);
     switch (method) {
       case RpcSystemCalls.ok: {
         const call = peer.outbound.get(relatedId);
         if (call !== void 0) {
+          call.completedStage |= RpcCallStage.ResultReady;
           if (call.removeOnOk) {
             peer.outbound.remove(relatedId);
           }
@@ -1316,11 +1787,21 @@ var RpcSystemCallHandler = class {
         }
         break;
       }
+      case RpcSystemCalls.reconnect: {
+        this._handleReconnect(relatedId, args, peer);
+        break;
+      }
       case RpcSystemCalls.error: {
         const call = peer.outbound.remove(relatedId);
         if (call !== void 0) {
           const errorInfo = args[0];
           const msg = errorInfo?.Message ?? errorInfo?.message ?? "RPC error";
+          const errorType = errorInfo?.TypeRef ?? errorInfo?.typeRef;
+          if (errorType !== null && typeof errorType === "object") {
+            const t = errorType;
+            if (t.TypeName === "RpcRerouteException" || t.typeName === "RpcRerouteException")
+              warnLog5?.log("Got RpcRerouteException from remote peer:", msg);
+          }
           call.result.reject(new Error(msg));
         }
         break;
@@ -1334,25 +1815,20 @@ var RpcSystemCallHandler = class {
       }
       case RpcSystemCalls.item: {
         const stream = peer.remoteObjects.get(relatedId);
-        if (!stream) {
-          console.warn(
-            `[RpcSysHandler] $sys.I: no stream for relatedId=${relatedId}`
-          );
-        } else {
+        if (!stream)
+          debugLog?.log(`$sys.I: no stream for relatedId=${relatedId}`);
+        else
           stream.onItem(
             args[0],
             resolveStreamRefs(args[1], peer)
           );
-        }
         break;
       }
       case RpcSystemCalls.batch: {
         const stream = peer.remoteObjects.get(relatedId);
-        if (!stream) {
-          console.warn(
-            `[RpcSysHandler] $sys.B: no stream for relatedId=${relatedId}`
-          );
-        } else if (Array.isArray(args[1])) {
+        if (!stream)
+          debugLog?.log(`$sys.B: no stream for relatedId=${relatedId}`);
+        else if (Array.isArray(args[1])) {
           const items = args[1];
           for (let i = 0; i < items.length; i++)
             items[i] = resolveStreamRefs(items[i], peer);
@@ -1363,9 +1839,7 @@ var RpcSystemCallHandler = class {
       case RpcSystemCalls.end: {
         const stream = peer.remoteObjects.get(relatedId);
         if (!stream) {
-          console.warn(
-            `[RpcSysHandler] $sys.End: no stream for relatedId=${relatedId}`
-          );
+          debugLog?.log(`$sys.End: no stream for relatedId=${relatedId}`);
         } else {
           const errorInfo = args[1];
           const msg = errorInfo?.Message ?? errorInfo?.message;
@@ -1404,9 +1878,57 @@ var RpcSystemCallHandler = class {
       }
     }
   }
+  /**
+   * Server-side handler for the `$sys.Reconnect` call. Parses the peer's
+   * report of in-flight call IDs (grouped by stage, IncreasingSeqCompressor-
+   * encoded, base64-wrapped for JSON transport), computes the subset this
+   * peer does not recognize, and replies with a compressed byte[] of the
+   * unknown IDs wrapped in `$sys.Ok`.
+   *
+   * @param relatedId The outbound call ID the client used for this
+   *                  `$sys.Reconnect` invocation — we send `$sys.Ok` back
+   *                  with the same `RelatedId`.
+   */
+  _handleReconnect(relatedId, args, peer) {
+    if (peer.connection === void 0) 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)) {
+          const bytes = _toBytes(rawValue);
+          if (bytes === null) continue;
+          const callIds = IncreasingSeqCompressor.deserialize(bytes);
+          for (const callId of callIds) {
+            if (peer.inbound.get(callId) === void 0) {
+              unknownSet.add(callId);
+            }
+          }
+        }
+        unknownIds = [...unknownSet].sort((a, b) => a - b);
+      }
+    } catch {
+    }
+    const responseBytes = IncreasingSeqCompressor.serialize(unknownIds);
+    const responseValue = peer.format.isBinary ? responseBytes : base64Encode(responseBytes);
+    peer.hub.systemCallSender.ok(peer.connection, peer.format, relatedId, responseValue);
+  }
 };
+function _toBytes(value) {
+  if (value instanceof Uint8Array) return value;
+  if (typeof value === "string") {
+    try {
+      return base64Decode(value);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
 
 // src/rpc-system-call-sender.ts
+var { errorLog } = getLogs("RpcSystemCallSender");
 var RpcSystemCallSender = class _RpcSystemCallSender {
   // Reusable envelopes — one per hot-path method.
   _itemEnv = {
@@ -1463,12 +1985,17 @@ var RpcSystemCallSender = class _RpcSystemCallSender {
     ]);
   }
   ok(conn, format, relatedId, result) {
-    this._send(
-      conn,
-      format,
-      { Method: RpcSystemCalls.ok, RelatedId: relatedId },
-      [result]
-    );
+    try {
+      this._send(
+        conn,
+        format,
+        { Method: RpcSystemCalls.ok, RelatedId: relatedId },
+        [result]
+      );
+    } catch (e) {
+      errorLog?.log(`Failed to send Ok response for call #${relatedId}`, e);
+      this.error(conn, format, relatedId, e);
+    }
   }
   error(conn, format, relatedId, error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -1580,19 +2107,19 @@ var RpcSharedObjectTracker = class {
 };
 
 // src/rpc-peer.ts
-var import_core7 = require("@actuallab/core");
+var import_core8 = require("@actuallab/core");
 
 // src/rpc-client-peer-reconnect-delayer.ts
-var import_core6 = require("@actuallab/core");
-var RpcClientPeerReconnectDelayer = class extends import_core6.RetryDelayer {
+var import_core7 = require("@actuallab/core");
+var RpcClientPeerReconnectDelayer = class extends import_core7.RetryDelayer {
   constructor() {
     super();
-    this.delays = import_core6.RetryDelaySeq.exp(1e3, 6e4);
+    this.delays = import_core7.RetryDelaySeq.exp(1e3, 6e4);
   }
 };
 
 // src/rpc-serialization-format.ts
-var import_msgpack3 = require("@msgpack/msgpack");
+var import_msgpack4 = require("@msgpack/msgpack");
 var RpcSerializationFormat = class {
   /** Create a reusable binary encoder for this format. Returns undefined for text formats. */
   createEncoder() {
@@ -1666,7 +2193,7 @@ var RpcMessagePackSerializationFormat = class extends RpcSerializationFormat {
     return createBinaryEncoder();
   }
   createDecoder() {
-    return new import_msgpack3.Decoder();
+    return new import_msgpack4.Decoder();
   }
 };
 var RpcMessagePackCompactSerializationFormat = class extends RpcSerializationFormat {
@@ -1698,7 +2225,7 @@ var RpcMessagePackCompactSerializationFormat = class extends RpcSerializationFor
     return createBinaryEncoder();
   }
   createDecoder() {
-    return new import_msgpack3.Decoder();
+    return new import_msgpack4.Decoder();
   }
 };
 RpcSerializationFormat.SystemJsonV5 = new RpcJsonSerializationFormat("json5");
@@ -1750,6 +2277,7 @@ var RpcSerializationFormatResolver = class _RpcSerializationFormatResolver {
 
 // src/rpc-peer.ts
 var RPC_CLOSE_CODE_UNSUPPORTED_FORMAT = 4001;
+var { debugLog: debugLog2, infoLog, warnLog: warnLog6, errorLog: errorLog2 } = getLogs("RpcPeer");
 var defaultConnectionUrlResolver = (peer) => {
   const sep = peer.ref.includes("?") ? "&" : "?";
   return peer.ref + sep + `clientId=${peer.clientId}&f=${peer.serializationFormat}`;
@@ -1765,8 +2293,8 @@ var RpcPeer = class {
   inbound = new RpcInboundCallTracker();
   remoteObjects = new RpcRemoteObjectTracker();
   sharedObjects = new RpcSharedObjectTracker();
-  connected = new import_core7.EventHandlerSet();
-  disconnected = new import_core7.EventHandlerSet();
+  connected = new import_core8.EventHandlerSet();
+  disconnected = new import_core8.EventHandlerSet();
   _pendingSends = [];
   _keepAliveTimer;
   constructor(ref, hub) {
@@ -1788,16 +2316,29 @@ var RpcPeer = class {
     conn.closed.add((ev) => {
       this._connection = void 0;
       this._stopKeepAlive();
+      if (ev.reason)
+        infoLog?.log(`'${this.ref}': Disconnected: ${ev.reason} (code=${ev.code})`);
+      else
+        infoLog?.log(`'${this.ref}': Disconnected`);
       this.disconnected.trigger(ev);
     });
     void conn.whenConnected.then(() => {
+      infoLog?.log(`'${this.ref}': Connected`);
       this.connected.trigger();
       this._startKeepAlive();
     });
   }
-  /** The serialization format used by this peer. Override in subclasses. */
+  /**
+   * The serialization format used by this peer for outgoing messages.
+   * If not set explicitly, defaults to the resolver's default (JSON /
+   * json5np). Subclasses can pre-assign in their constructor.
+   */
+  _format;
   get format() {
-    return RpcSerializationFormatResolver.Default.defaultFormat;
+    return this._format ?? RpcSerializationFormatResolver.Default.defaultFormat;
+  }
+  set format(value) {
+    this._format = value;
   }
   call(method, args, options) {
     const callId = this.outbound.nextId();
@@ -1857,6 +2398,7 @@ var RpcPeer = class {
     this._sendWireData(wireData);
   }
   close() {
+    infoLog?.log(`'${this.ref}': Stopping`);
     this._stopKeepAlive();
     this.remoteObjects.disconnectAll();
     this.sharedObjects.disconnectAll();
@@ -1870,6 +2412,7 @@ var RpcPeer = class {
     this.outbound.invalidateAll();
     this._connection?.close();
     this._hub.peers.delete(this.ref);
+    infoLog?.log(`'${this.ref}': Stopped`);
   }
   /** Send any messages buffered while disconnected. Call after connection + handshake are ready. */
   _flushPendingSends() {
@@ -1896,18 +2439,32 @@ var RpcPeer = class {
   _handleMessage(received) {
     let message;
     let args;
-    if (received.kind === "binary") {
-      message = received.message;
-      args = received.args;
-    } else {
-      const parsed = deserializeMessage(received.raw);
-      message = parsed.message;
-      args = parsed.args;
+    try {
+      if (received.kind === "binary") {
+        message = received.message;
+        args = received.args;
+      } else {
+        const parsed = deserializeMessage(received.raw);
+        message = parsed.message;
+        args = parsed.args;
+      }
+    } catch (e) {
+      errorLog2?.log(`'${this.ref}': Failed to process inbound message:`, received, e);
+      return;
     }
     const method = message.Method ?? "";
+    debugLog2?.log(`'${this.ref}': <- ${method}#${message.RelatedId ?? 0}`);
     if (method === RpcSystemCalls.handshake) {
-      const handshake = args[0];
-      if (handshake !== void 0) this._onHandshakeReceived(handshake);
+      const raw = args[0];
+      if (raw !== void 0) {
+        const handshake = Array.isArray(raw) ? {
+          RemotePeerId: raw[0],
+          RemoteHubId: raw[2],
+          ProtocolVersion: raw[3],
+          Index: raw[4]
+        } : raw;
+        this._onHandshakeReceived(handshake);
+      }
       return;
     }
     if (method.startsWith("$sys")) {
@@ -1963,6 +2520,7 @@ var RpcPeer = class {
             e
           );
         }
+        debugLog2?.log(`'${this.ref}': Inbound call failed: ${method}#${relatedId}`, e);
       } finally {
         if (!isNoWait) {
           this.inbound.remove(relatedId);
@@ -1997,6 +2555,12 @@ var RpcClientPeer = class extends RpcPeer {
   _connectionKind = 0 /* Disconnected */;
   _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;
   _pendingHandshake;
   _reconnectsAt = 0;
@@ -2010,11 +2574,11 @@ var RpcClientPeer = class extends RpcPeer {
   serializationFormat;
   /** Builds the WebSocket URL for this peer. Replace to customize URL construction. */
   connectionUrlResolver = defaultConnectionUrlResolver;
-  peerChanged = new import_core7.EventHandlerSet();
+  peerChanged = new import_core8.EventHandlerSet();
   /** Fired when the server rejects the connection due to an unsupported serialization format (close code 4010). */
-  unsupportedFormat = new import_core7.EventHandlerSet();
+  unsupportedFormat = new import_core8.EventHandlerSet();
   reconnectDelayer = new RpcClientPeerReconnectDelayer();
-  reconnectsAtChanged = new import_core7.EventHandlerSet();
+  reconnectsAtChanged = new import_core8.EventHandlerSet();
   get reconnectsAt() {
     return this._reconnectsAt;
   }
@@ -2023,32 +2587,34 @@ var RpcClientPeer = class extends RpcPeer {
     this._reconnectsAt = value;
     this.reconnectsAtChanged.trigger();
   }
-  _format;
   constructor(hub, url, serializationFormat) {
     super(url, hub);
     this.clientId = guidToBase64Url(this.id);
     const resolver = RpcSerializationFormatResolver.Default;
     this.serializationFormat = serializationFormat ?? resolver.defaultFormatKey;
-    this._format = resolver.get(this.serializationFormat);
-  }
-  get format() {
-    return this._format;
+    this.format = resolver.get(this.serializationFormat);
   }
   get connectionKind() {
     return this._connectionKind;
   }
-  /** One-shot connection for tests — no reconnection loop, no handshake. */
-  connectWith(conn) {
+  /** One-shot connection for tests — no reconnection loop, no handshake.
+   *  @param isPeerChanged Whether to treat this as a peer-identity change
+   *  (default `true` — no handshake was exchanged, so stage-3 compute calls
+   *  self-invalidate and remote/shared objects are disposed). Pass `false`
+   *  to simulate a same-peer reconnect in tests. */
+  connectWith(conn, isPeerChanged = true) {
     this.setupConnection(conn);
-    this._reconnect(true);
+    void this._reconnect(isPeerChanged);
   }
   /** Start the reconnection loop — runs until disposed. */
   async run(wsFactory) {
     const connUrl = this.connectionUrlResolver(this);
+    infoLog?.log(`'${this.ref}': Started (Client)`);
     while (!this._disposed) {
       let lastCloseCode = 0;
       let lastCloseReason = "";
       try {
+        infoLog?.log(`'${this.ref}': Connecting to ${connUrl}`);
         const ws = wsFactory?.(connUrl) ?? new WebSocket(connUrl);
         const conn = new RpcWebSocketConnection(
           ws,
@@ -2061,7 +2627,7 @@ var RpcClientPeer = class extends RpcPeer {
           lastCloseCode = ev.code;
           lastCloseReason = ev.reason;
         });
-        this._pendingHandshake = new import_core7.PromiseSource();
+        this._pendingHandshake = new import_core8.PromiseSource();
         this.setupConnection(conn);
         this._connection = void 0;
         const closedRejection = new Promise(
@@ -2072,38 +2638,48 @@ var RpcClientPeer = class extends RpcPeer {
         closedRejection.catch(() => {
         });
         await Promise.race([conn.whenConnected, closedRejection]);
-        this._hub.systemCallSender.handshake(
-          conn,
-          this.format,
-          this.id,
-          this._hub.hubId,
-          ++this._handshakeIndex
-        );
+        try {
+          this._hub.systemCallSender.handshake(
+            conn,
+            this.format,
+            this.id,
+            this._hub.hubId,
+            ++this._handshakeIndex
+          );
+        } catch (e) {
+          warnLog6?.log(`'${this.ref}': Failed to send handshake`, e);
+          throw e;
+        }
         const remoteHandshake = await Promise.race([
           this._pendingHandshake.promise,
           closedRejection
         ]);
         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.inbound.clear();
+            infoLog?.log(`'${this.ref}': Peer changed`);
             this.peerChanged.trigger();
           }
           this._lastRemoteHubId = remoteHubId;
         }
+        infoLog?.log(`'${this.ref}': Handshake succeeded, peerChanged=${isPeerChanged}`);
         this._connection = conn;
         this._connectionKind = 2 /* Connected */;
         this._tryIndex = 0;
-        this._reconnect(isPeerChanged);
+        await this._reconnect(isPeerChanged);
         await new Promise((r) => conn.closed.add(() => r()));
-      } catch {
+      } catch (e) {
+        debugLog2?.log(`'${this.ref}': run() iteration failed:`, e);
       }
       this._connectionKind = 0 /* Disconnected */;
       if (this._disposed) break;
       if (lastCloseCode === RPC_CLOSE_CODE_UNSUPPORTED_FORMAT) {
+        warnLog6?.log(`'${this.ref}': Unsupported serialization format - shutting down`);
         this.unsupportedFormat.trigger({ reason: lastCloseReason });
         this._disposed = true;
         break;
@@ -2111,6 +2687,7 @@ var RpcClientPeer = class extends RpcPeer {
       this._tryIndex++;
       const delay = this.reconnectDelayer.getDelay(this._tryIndex);
       if (delay.isLimitExceeded) {
+        warnLog6?.log(`'${this.ref}': Reconnect limit exceeded - shutting down`);
         this._disposed = true;
         break;
       }
@@ -2122,42 +2699,129 @@ var RpcClientPeer = class extends RpcPeer {
       }
     }
   }
-  /** Re-send outbound calls after reconnection + flush pending sends.
-   *  Stage-3 compute calls are always self-invalidated: without $sys.Reconnect
-   *  protocol, the server's invalidation tracking is lost on disconnect, and
-   *  re-sending would get a duplicate $sys.Ok that is ignored (PromiseSource
-   *  already resolved). Self-invalidation forces a fresh recompute that
-   *  establishes new invalidation tracking on the new connection.
-   *  Regular in-flight calls are re-sent transparently. */
-  _reconnect(_isPeerChanged) {
+  /**
+   * Reconcile outbound calls after reconnection, then flush pending sends.
+   *
+   * On peer change (different server hubId) or with binary wire format —
+   * we blind-resend every eligible call.
+   *
+   * On a same-peer reconnect with JSON transport, first call
+   * `$sys.Reconnect` to ask the server which call IDs it no longer
+   * recognizes (e.g. inbound tracker was cleared, or the call never
+   * reached the server). Only those get resent; the rest stay in the
+   * tracker awaiting their $sys.Ok. This prevents duplicate server-side
+   * invocation of in-flight streaming calls on every transient
+   * reconnect — mirrors .NET `RpcOutboundCallTracker.Reconnect` at
+   * src/ActualLab.Rpc/Infrastructure/RpcCallTrackers.cs:209-279.
+   *
+   * Stage-3 compute calls (result already resolved, awaiting invalidation)
+   * are always self-invalidated — TS doesn't track compute-call stages
+   * across reconnect, so the safest behavior is to force a fresh compute.
+   */
+  async _reconnect(isPeerChanged) {
     if (this._connection === void 0) return;
-    if (_isPeerChanged) {
+    if (isPeerChanged) {
       this.remoteObjects.disconnectAll();
+      this.sharedObjects.disconnectAll();
     } else {
       this.remoteObjects.reconnectAll();
     }
-    const trackerCalls = [...this.outbound.values()];
-    for (const call of trackerCalls) {
+    const eligible = [];
+    for (const call of [...this.outbound.values()]) {
       const mode = call.remoteExecutionMode;
       if (!(mode & 2)) {
         if (!call.result.isCompleted)
-          call.result.reject(new Error("Outbound call failed: disconnected and AllowReconnect is not set."));
+          call.result.reject(new Error(
+            "Outbound call failed: disconnected and AllowReconnect is not set."
+          ));
         call.onDisconnect();
         this.outbound.remove(call.callId);
-      } else if (_isPeerChanged && !(mode & 4)) {
+        continue;
+      }
+      if (isPeerChanged && !(mode & 4)) {
         if (!call.result.isCompleted)
-          call.result.reject(new Error("Outbound call failed: reconnected to a different peer and AllowResend is not set."));
+          call.result.reject(new Error(
+            "Outbound call failed: reconnected to a different peer and AllowResend is not set."
+          ));
         call.onDisconnect();
         this.outbound.remove(call.callId);
-      } else if (!call.removeOnOk && call.result.isCompleted) {
+        continue;
+      }
+      eligible.push(call);
+    }
+    let unknownIds = null;
+    if (!isPeerChanged && eligible.length > 0) {
+      unknownIds = await this._reconcileReconnect(eligible);
+    }
+    for (const call of eligible) {
+      if (!call.removeOnOk && call.result.isCompleted) {
         call.onDisconnect();
         this.outbound.remove(call.callId);
-      } else {
-        this._sendWireData(call.serializedWireData);
+        continue;
+      }
+      if (unknownIds !== null && !unknownIds.has(call.callId)) {
+        continue;
       }
+      this._sendWireData(call.serializedWireData);
     }
     this._flushPendingSends();
   }
+  /**
+   * Ask the server which call IDs in `eligible` it no longer recognizes
+   * via `$sys.Reconnect:3`. Returns the set of call IDs that need to be
+   * resent. On any failure, falls back to "resend everything".
+   *
+   * Wire format of the `completedStages` argument is chosen per wire format:
+   *   - JSON (json5np): plain object `{"<stage>": "<base64-of-bytes>"}` —
+   *     matches .NET `System.Text.Json`'s default for `Dictionary<int, byte[]>`.
+   *   - MessagePack (msgpack6/msgpack6c): `Map<number, Uint8Array>` —
+   *     the patched encoder (see `./msgpack-map-patch.ts`) writes this as a
+   *     native msgpack `map<int, bin>`, matching .NET MessagePack-CSharp's
+   *     default for `Dictionary<int, byte[]>`.
+   */
+  async _reconcileReconnect(eligible) {
+    try {
+      const byStage = /* @__PURE__ */ new Map();
+      for (const call of eligible) {
+        const stage = call.getReconnectStage(false);
+        if (stage === null) continue;
+        let arr = byStage.get(stage);
+        if (!arr) {
+          arr = [];
+          byStage.set(stage, arr);
+        }
+        arr.push(call.callId);
+      }
+      if (byStage.size === 0) {
+        return new Set(eligible.map((c) => c.callId));
+      }
+      const isBinary = this.format.isBinary;
+      const stagesArg = isBinary ? /* @__PURE__ */ new Map() : {};
+      for (const [stage, ids] of byStage) {
+        ids.sort((a, b) => a - b);
+        const bytes2 = IncreasingSeqCompressor.serialize(ids);
+        if (isBinary) {
+          stagesArg.set(stage, bytes2);
+        } else {
+          stagesArg[String(stage)] = base64Encode(bytes2);
+        }
+      }
+      const reconnectCall = this.call(
+        RpcSystemCalls.reconnect,
+        [this._remoteHandshakeIndex, stagesArg],
+        {
+          remoteExecutionMode: 1
+          /* AwaitForConnection only; must not itself reconnect */
+        }
+      );
+      const result = await reconnectCall.result.promise;
+      const bytes = _toBytes2(result);
+      if (bytes === null) return new Set(eligible.map((c) => c.callId));
+      return new Set(IncreasingSeqCompressor.deserialize(bytes));
+    } catch {
+      return new Set(eligible.map((c) => c.callId));
+    }
+  }
   _onHandshakeReceived(handshake) {
     this._pendingHandshake?.resolve(handshake);
   }
@@ -2205,8 +2869,20 @@ function guidToBase64Url(uuid) {
   const binary = String.fromCharCode(...bytes);
   return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 }
+function _toBytes2(value) {
+  if (value instanceof Uint8Array) return value;
+  if (typeof value === "string") {
+    try {
+      return base64Decode(value);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
 
 // src/rpc-service-host.ts
+var { warnLog: warnLog7 } = getLogs("RpcServiceHost");
 var RpcServiceHost = class {
   _methods = /* @__PURE__ */ new Map();
   register(def, impl) {
@@ -2221,8 +2897,10 @@ var RpcServiceHost = class {
   }
   async dispatch(wireMethod, args, context) {
     const entry = this._methods.get(wireMethod);
-    if (entry === void 0)
+    if (entry === void 0) {
+      warnLog7?.log(`Method not found: ${wireMethod}`);
       throw new Error(`Method not found: ${wireMethod}`);
+    }
     if (context !== void 0 && entry.def.callTypeId !== 0) {
       return await entry.fn(...args, context);
     }
@@ -2752,6 +3430,7 @@ function computeMethodHash(methodName) {
 }
 
 // src/rpc-method-registry.ts
+var { warnLog: warnLog8 } = getLogs("RpcMethodRegistry");
 var RpcMethodRegistry = class {
   _nameToHash = /* @__PURE__ */ new Map();
   _hashToName = /* @__PURE__ */ new Map();
@@ -2761,9 +3440,7 @@ var RpcMethodRegistry = class {
     const hash = computeMethodHash(methodName);
     const existing = this._hashToName.get(hash);
     if (existing !== void 0 && existing !== methodName) {
-      console.warn(
-        `[RpcMethodRegistry] hash collision: "${methodName}" and "${existing}" both hash to ${hash}`
-      );
+      warnLog8?.log(`hash collision: "${methodName}" and "${existing}" both hash to ${hash}`);
       return;
     }
     this._nameToHash.set(methodName, hash);
@@ -2796,6 +3473,7 @@ var RpcMethodRegistry = class {
 };
 
 // src/rpc-hub.ts
+var { warnLog: warnLog9 } = getLogs("RpcHub");
 var RpcHub = class {
   hubId;
   peers = /* @__PURE__ */ new Map();
@@ -2821,6 +3499,7 @@ var RpcHub = class {
     if (peer !== void 0) {
       peer.close();
       this.peers.delete(ref);
+      warnLog9?.log(`'${ref}': peer is removed from RpcHub`);
     }
   }
   /** Get or create a peer by ref. Server peers have "server://" prefix, everything else is a client peer. */
@@ -3052,13 +3731,14 @@ function getStateDescription(state, useLastError = false) {
 }
 
 // src/rpc-peer-state-monitor.ts
-var import_core8 = require("@actuallab/core");
+var import_core9 = require("@actuallab/core");
+var { infoLog: infoLog2 } = getLogs("RpcPeerStateMonitor");
 var JustConnectedPeriodMs = 1500;
 var JustDisconnectedPeriodMs = 3e3;
 var MinReconnectsInMs = 1e3;
 var RpcPeerStateMonitor = class {
   peer;
-  stateChanged = new import_core8.EventHandlerSet();
+  stateChanged = new import_core9.EventHandlerSet();
   _rawConnected;
   _connectedAt = 0;
   _disconnectedAt = 0;
@@ -3114,6 +3794,7 @@ var RpcPeerStateMonitor = class {
     this._scheduleRecompute(
       this._rawConnected ? JustConnectedPeriodMs : JustDisconnectedPeriodMs
     );
+    infoLog2?.log(`'${peer.ref}': monitor started`);
   }
   get state() {
     return this._state;
@@ -3129,6 +3810,7 @@ var RpcPeerStateMonitor = class {
     this.peer.reconnectDelayer.cancelDelaysChanged.remove(
       this._onCancelDelaysChanged
     );
+    infoLog2?.log(`'${this.peer.ref}': monitor stopped`);
   }
   _recompute() {
     if (this._timer !== void 0) {
@@ -3208,7 +3890,9 @@ var RpcPeerStateMonitor = class {
   ARG_DELIMITER,
   ENVELOPE_DELIMITER,
   FRAME_DELIMITER,
+  IncreasingSeqCompressor,
   RPC_CLOSE_CODE_UNSUPPORTED_FORMAT,
+  RpcCallStage,
   RpcCallTypeId,
   RpcClientPeer,
   RpcClientPeerReconnectDelayer,
@@ -3253,6 +3937,7 @@ var RpcPeerStateMonitor = class {
   deserializeBinaryMessage,
   deserializeCompactBinaryMessage,
   deserializeMessage,
+  getLogs,
   getMethodsMeta,
   getServiceMeta,
   getStateDescription,