@actuallab/rpc 14.3.5 → 14.3.26

package/dist/index.cjs

@@ -1285,6 +1285,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];
@@ -2025,6 +2034,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(",");
@@ -2212,6 +2222,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) {
@@ -2346,11 +2360,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(
@@ -2732,6 +2758,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
@@ -2802,6 +2831,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;
@@ -3337,7 +3379,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);
@@ -3602,7 +3644,7 @@ var RpcServerPeer = class extends RpcPeer {
         this.serializationFormat,
         this.id,
         this.hub.hubId,
-        ++this._ownHandshakeIndex
+        this.nextOwnHandshakeIndex()
       );
       this._setConnectionState(3 /* Connected */);
     }