@actuallab/rpc 14.3.5 → 14.3.26

package/dist/index.d.cts

@@ -981,6 +981,9 @@ declare abstract class RpcPeer {
      *  stale `$sys.Reconnect` that references an older connection generation
      *  (C# `RpcSystemCalls.Reconnect`'s `ownHandshake.Index` check). */
     protected _ownHandshakeIndex: number;
+    /** Whether the current connection generation has already used its single
+     *  `$sys.Reconnect`. Mirrors C# `RpcPeerConnectionState.TryClaimReconnect`. */
+    protected _isReconnectClaimed: boolean;
     protected _connection: RpcConnection | undefined;
     /** Mirror of `_connectionState === Connected`. True only after the
      *  handshake round-trip completes; outbound `call()` checks this to
@@ -1013,6 +1016,8 @@ declare abstract class RpcPeer {
     get connectionState(): RpcConnectionState;
     get isConnected(): boolean;
     get ownHandshakeIndex(): number;
+    tryClaimReconnect(): boolean;
+    protected nextOwnHandshakeIndex(): number;
     protected _setConnectionState(value: RpcConnectionState): void;
     /** Resolves on the next transition into `Connected` — or immediately if
      *  already in that state. */
@@ -1516,6 +1521,7 @@ declare class RpcStream<T> implements AsyncIterable<T>, IRpcObject {
     private _complete;
     private _failProtocol;
     private _isBeyondAckWindow;
+    private _ackWindowSize;
     private _ackWindowError;
     private _gapError;
     private _notifyConsumer;

package/dist/index.d.ts

@@ -981,6 +981,9 @@ declare abstract class RpcPeer {
      *  stale `$sys.Reconnect` that references an older connection generation
      *  (C# `RpcSystemCalls.Reconnect`'s `ownHandshake.Index` check). */
     protected _ownHandshakeIndex: number;
+    /** Whether the current connection generation has already used its single
+     *  `$sys.Reconnect`. Mirrors C# `RpcPeerConnectionState.TryClaimReconnect`. */
+    protected _isReconnectClaimed: boolean;
     protected _connection: RpcConnection | undefined;
     /** Mirror of `_connectionState === Connected`. True only after the
      *  handshake round-trip completes; outbound `call()` checks this to
@@ -1013,6 +1016,8 @@ declare abstract class RpcPeer {
     get connectionState(): RpcConnectionState;
     get isConnected(): boolean;
     get ownHandshakeIndex(): number;
+    tryClaimReconnect(): boolean;
+    protected nextOwnHandshakeIndex(): number;
     protected _setConnectionState(value: RpcConnectionState): void;
     /** Resolves on the next transition into `Connected` — or immediately if
      *  already in that state. */
@@ -1516,6 +1521,7 @@ declare class RpcStream<T> implements AsyncIterable<T>, IRpcObject {
     private _complete;
     private _failProtocol;
     private _isBeyondAckWindow;
+    private _ackWindowSize;
     private _ackWindowError;
     private _gapError;
     private _notifyConsumer;

package/dist/index.js

@@ -1172,6 +1172,15 @@ var RpcSystemCallHandler = class {
       );
       return;
     }
+    if (!peer.tryClaimReconnect()) {
+      peer.hub.systemCallSender.error(
+        peer.connection,
+        peer.serializationFormat,
+        relatedId,
+        new Error("TooLateToReconnect: this connection was already reconnected")
+      );
+      return;
+    }
     let unknownIds = [];
     try {
       const stagesRaw = args[1];
@@ -1912,6 +1921,7 @@ function _compactBufferedUnsentSuffix(buffer, firstUnsentIndex, canSkipTo) {
 var { warnLog: warnLog6 } = getLogs("RpcStream");
 var DEFAULT_ACK_PERIOD2 = 30;
 var DEFAULT_ACK_ADVANCE2 = 61;
+var MAX_BATCH_SIZE = 1024;
 function parseStreamRef(value) {
   if (typeof value === "string") {
     const parts = value.split(",");
@@ -2099,6 +2109,10 @@ var RpcStream = class _RpcStream {
       this._failProtocol(`invalid $sys.B index/length: ${String(index)}/${String(items.length)}`);
       return;
     }
+    if (items.length > MAX_BATCH_SIZE) {
+      this._failProtocol(`$sys.B batch is too large: ${items.length} > ${MAX_BATCH_SIZE}`);
+      return;
+    }
     if (index > this._nextExpectedIndex) {
       warnLog6?.log(`batch index gap: localId=${this.id.localId}, expected=${this._nextExpectedIndex}, received=${index}`);
       if (!this.allowReconnect) {
@@ -2233,11 +2247,23 @@ var RpcStream = class _RpcStream {
   // last acknowledged index. The sending side is the only place that window
   // was ever enforced, which left a flooding remote free to grow our buffer
   // without bound (I6) — so we enforce our half of the contract here.
+  //
+  // The window is credited by consumption, never by `_ackSentUpTo`: a reset ack
+  // re-bases to what we've *received*, so crediting it would let a peer ratchet
+  // its own limit up by alternating "fill the window" with a forced gap.
+  // Twice ackAdvance is what a conforming sender can leave buffered (ackAdvance
+  // in steady state, plus ackAdvance more after a reset re-bases it), and
+  // ackPeriod covers the lag of acks behind consumption.
   _isBeyondAckWindow(nextExpectedIndex) {
-    return this.ackAdvance > 0 && nextExpectedIndex > this._ackSentUpTo + this.ackAdvance;
+    if (this.ackAdvance <= 0)
+      return false;
+    return nextExpectedIndex > this._nextConsumedIndex + this._ackWindowSize();
+  }
+  _ackWindowSize() {
+    return 2 * this.ackAdvance + this.ackPeriod;
   }
   _ackWindowError(nextExpectedIndex) {
-    return `Stream ran past its ack window: reached ${nextExpectedIndex}, acked ${this._ackSentUpTo}, ackAdvance ${this.ackAdvance}`;
+    return `Stream ran past its ack window: reached ${nextExpectedIndex}, consumed ${this._nextConsumedIndex}, ackAdvance ${this.ackAdvance}`;
   }
   _gapError(index) {
     return new Error(
@@ -2619,6 +2645,9 @@ var RpcPeer = class {
    *  stale `$sys.Reconnect` that references an older connection generation
    *  (C# `RpcSystemCalls.Reconnect`'s `ownHandshake.Index` check). */
   _ownHandshakeIndex = 0;
+  /** Whether the current connection generation has already used its single
+   *  `$sys.Reconnect`. Mirrors C# `RpcPeerConnectionState.TryClaimReconnect`. */
+  _isReconnectClaimed = false;
   _connection;
   /** Mirror of `_connectionState === Connected`. True only after the
    *  handshake round-trip completes; outbound `call()` checks this to
@@ -2689,6 +2718,19 @@ var RpcPeer = class {
   get ownHandshakeIndex() {
     return this._ownHandshakeIndex;
   }
+  // A conforming peer sends `$sys.Reconnect` at most once per connection, so anything
+  // beyond that is a replay - and the reconciliation it performs is proportional to the
+  // call ids it carries, with nothing else capping how often it can arrive.
+  tryClaimReconnect() {
+    if (this._isReconnectClaimed)
+      return false;
+    this._isReconnectClaimed = true;
+    return true;
+  }
+  nextOwnHandshakeIndex() {
+    this._isReconnectClaimed = false;
+    return ++this._ownHandshakeIndex;
+  }
   _setConnectionState(value) {
     if (this._connectionState === value) return;
     const previousState = this._connectionState;
@@ -3224,7 +3266,7 @@ var RpcClientPeer = class extends RpcPeer {
               this.serializationFormat,
               this.id,
               this.hub.hubId,
-              ++this._ownHandshakeIndex
+              this.nextOwnHandshakeIndex()
             );
           } catch (e) {
             warnLog7?.log(`'${this.ref}': Failed to send handshake`, e);
@@ -3489,7 +3531,7 @@ var RpcServerPeer = class extends RpcPeer {
         this.serializationFormat,
         this.id,
         this.hub.hubId,
-        ++this._ownHandshakeIndex
+        this.nextOwnHandshakeIndex()
       );
       this._setConnectionState(3 /* Connected */);
     }