@actuallab/rpc 12.3.14 → 12.3.29

package/dist/index.js

@@ -23,9 +23,45 @@ var FRAME_DELIMITER = "\n";
 
 // src/rpc-serialization.ts
 import {
-  Encoder,
+  Encoder as Encoder2,
   Decoder
 } from "@msgpack/msgpack";
+
+// src/msgpack-map-patch.ts
+import { Encoder } from "@msgpack/msgpack";
+function patchMsgpackEncoderForMaps() {
+  const proto = 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
 function serializeMessage(message, args) {
   const envelope = JSON.stringify(message);
   if (args === void 0 || args.length === 0) {
@@ -66,7 +102,7 @@ function deserializeMessage(raw) {
 var textEncoder = new TextEncoder();
 var textDecoder = new TextDecoder();
 var INITIAL_ENCODER_BUFFER_SIZE = 32 * 1024;
-var defaultBinaryEncoder = new Encoder(
+var defaultBinaryEncoder = new Encoder2(
   void 0,
   void 0,
   void 0,
@@ -74,7 +110,7 @@ var defaultBinaryEncoder = new Encoder(
 );
 var defaultBinaryDecoder = new Decoder();
 function createBinaryEncoder() {
-  return new Encoder(
+  return new Encoder2(
     void 0,
     void 0,
     void 0,
@@ -560,6 +596,21 @@ function defineRpcService(name, methods) {
 
 // src/rpc-call-tracker.ts
 import { PromiseSource as PromiseSource2 } from "@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;
@@ -571,11 +622,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() {
   }
@@ -597,7 +672,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() {
@@ -660,6 +738,97 @@ 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
 import Denque from "denque";
 import { PromiseSource as PromiseSource4 } from "@actuallab/core";
@@ -668,7 +837,7 @@ import { PromiseSource as PromiseSource4 } from "@actuallab/core";
 var RpcObjectKind = { Local: 0, Remote: 1 };
 
 // src/rpc-stream-sender.ts
-import { PromiseSource as PromiseSource3 } from "@actuallab/core";
+import { PromiseSource as PromiseSource3, RingBuffer } from "@actuallab/core";
 var DEFAULT_ACK_PERIOD = 256;
 var DEFAULT_ACK_ADVANCE = 128;
 var RpcStreamSender = class _RpcStreamSender {
@@ -681,15 +850,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 PromiseSource3();
+  /** 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;
@@ -698,6 +881,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() {
@@ -707,56 +891,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. */
@@ -776,76 +965,270 @@ 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 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) {
+          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 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) 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 PromiseSource3();
-      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 PromiseSource3();
+    await this._whenAckReady.promise;
+    this._whenAckReady = null;
   }
   // -- IRpcObject --
   reconnect() {
@@ -857,17 +1240,38 @@ 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 DEFAULT_ACK_PERIOD2 = 30;
@@ -903,6 +1307,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;
@@ -980,17 +1393,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],
@@ -1200,6 +1615,25 @@ 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 RpcSystemCallHandler = class {
   handle(message, args, peer) {
@@ -1209,6 +1643,7 @@ var RpcSystemCallHandler = class {
       case RpcSystemCalls.ok: {
         const call = peer.outbound.get(relatedId);
         if (call !== void 0) {
+          call.completedStage |= RpcCallStage.ResultReady;
           if (call.removeOnOk) {
             peer.outbound.remove(relatedId);
           }
@@ -1216,6 +1651,10 @@ 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) {
@@ -1304,7 +1743,54 @@ 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 RpcSystemCallSender = class _RpcSystemCallSender {
@@ -1695,9 +2181,17 @@ var RpcPeer = class {
       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();
@@ -1806,8 +2300,16 @@ var RpcPeer = class {
     }
     const method = message.Method ?? "";
     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")) {
@@ -1897,6 +2399,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;
@@ -1923,24 +2431,24 @@ 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) {
@@ -1984,6 +2492,7 @@ var RpcClientPeer = class extends RpcPeer {
           closedRejection
         ]);
         this._pendingHandshake = void 0;
+        this._remoteHandshakeIndex = remoteHandshake.Index ?? 0;
         const remoteHubId = remoteHandshake.RemoteHubId;
         let isPeerChanged = false;
         if (remoteHubId !== void 0) {
@@ -1997,7 +2506,7 @@ var RpcClientPeer = class extends RpcPeer {
         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 {
       }
@@ -2022,42 +2531,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);
   }
@@ -2105,6 +2701,17 @@ 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 RpcServiceHost = class {
@@ -3107,7 +3714,9 @@ export {
   ARG_DELIMITER,
   ENVELOPE_DELIMITER,
   FRAME_DELIMITER,
+  IncreasingSeqCompressor,
   RPC_CLOSE_CODE_UNSUPPORTED_FORMAT,
+  RpcCallStage,
   RpcCallTypeId,
   RpcClientPeer,
   RpcClientPeerReconnectDelayer,