@actuallab/rpc 14.3.32 → 14.3.34

package/dist/index.cjs

@@ -56,6 +56,7 @@ __export(index_exports, {
   RpcOutboundCall: () => RpcOutboundCall,
   RpcOutboundCallTracker: () => RpcOutboundCallTracker,
   RpcPeer: () => RpcPeer,
+  RpcPeerChangeKind: () => RpcPeerChangeKind,
   RpcPeerStateKind: () => RpcPeerStateKind,
   RpcPeerStateMonitor: () => RpcPeerStateMonitor,
   RpcRefBuilder: () => RpcRefBuilder,
@@ -864,6 +865,16 @@ var RpcOutboundCallTracker = class {
   activeCallIds() {
     return [...this._calls.keys()];
   }
+  /** Calls handed to the transport at least once. Must be snapshotted BEFORE the
+   *  peer enters `Connected` — that flushes every queued call, making queued and
+   *  in-flight calls indistinguishable. Mirrors .NET's `GetSentCalls`. */
+  getSentCalls() {
+    const calls = [];
+    for (const call of this._calls.values())
+      if (call.sentAt !== 0)
+        calls.push(call);
+    return calls;
+  }
   /** Reject all pending calls with the given error.
    *  Stage-3 compute calls (result resolved, awaiting invalidation) are kept in the tracker. */
   rejectAll(error) {
@@ -3178,6 +3189,13 @@ var RpcConnectionState = /* @__PURE__ */ ((RpcConnectionState2) => {
   RpcConnectionState2[RpcConnectionState2["Connected"] = 3] = "Connected";
   return RpcConnectionState2;
 })(RpcConnectionState || {});
+var RpcPeerChangeKind = /* @__PURE__ */ ((RpcPeerChangeKind2) => {
+  RpcPeerChangeKind2[RpcPeerChangeKind2["Unchanged"] = 0] = "Unchanged";
+  RpcPeerChangeKind2[RpcPeerChangeKind2["ChangedToVeryFirst"] = 1] = "ChangedToVeryFirst";
+  RpcPeerChangeKind2[RpcPeerChangeKind2["Changed"] = 2] = "Changed";
+  return RpcPeerChangeKind2;
+})(RpcPeerChangeKind || {});
+var peerChangeKindNames = ["Unchanged", "ChangedToVeryFirst", "Changed"];
 var RpcClientPeer = class extends RpcPeer {
   _disposed = false;
   /** Aborted when the peer is stopped/disposed — threaded into the reconnect
@@ -3190,7 +3208,10 @@ var RpcClientPeer = class extends RpcPeer {
    *  `connectionState.Handshake.Index` path in
    *  `RpcOutboundCallTracker.TryReconnect`. */
   _remoteHandshakeIndex = 0;
-  _lastRemotePeerId;
+  /** Mirrors .NET's `lastHandshake` local in `RpcPeer.OnRun`: first-ness is keyed
+   *  off "was there a previous handshake", not off `RemotePeerId` — a legacy server
+   *  sends none, so every one of its handshakes would look like the first. */
+  _lastHandshake;
   _pendingHandshake;
   _reconnectsAt = 0;
   /** Server-issued reconnect secret, from the most recent handshake that
@@ -3271,10 +3292,11 @@ var RpcClientPeer = class extends RpcPeer {
    *  self-invalidate and remote/shared objects are disposed). Pass `false`
    *  to simulate a same-peer reconnect in tests. */
   connectWith(conn, isPeerChanged = true) {
+    const sentCalls = this.outboundCalls.getSentCalls();
     this.setupConnection(conn);
     this._isConnected = true;
     this.connectionStateChanged.trigger(3 /* Connected */);
-    void this._reconnect(isPeerChanged);
+    void this._reconnect(sentCalls, isPeerChanged);
   }
   /** Kick off the reconnect loop. Idempotent — subsequent calls are
    *  no-ops; await `peer.whenRunning` if you need the loop's completion
@@ -3405,11 +3427,19 @@ var RpcClientPeer = class extends RpcPeer {
           this._remoteHandshakeIndex = remoteHandshake.Index ?? 0;
           if (remoteHandshake.Secret)
             this._reconnectSecret = remoteHandshake.Secret;
-          const isPeerChanged = this._detectPeerChange(remoteHandshake);
-          infoLog?.log(`'${this.ref}': Handshake succeeded, peerChanged=${isPeerChanged}`);
+          const peerChangeKind = this._detectPeerChange(remoteHandshake);
+          infoLog?.log(
+            `'${this.ref}': Handshake succeeded, peerChangeKind=${peerChangeKindNames[peerChangeKind]}`
+          );
+          const sentCalls = this.outboundCalls.getSentCalls();
           this._setConnectionState(3 /* Connected */);
           connectedAt = Date.now();
-          await this._reconnect(isPeerChanged, closedController.signal);
+          if (peerChangeKind !== 1 /* ChangedToVeryFirst */)
+            await this._reconnect(
+              sentCalls,
+              peerChangeKind === 2 /* Changed */,
+              closedController.signal
+            );
           await whenClosed;
         } catch (e) {
           debugLog2?.log(`'${this.ref}': run() iteration failed:`, e);
@@ -3431,7 +3461,10 @@ var RpcClientPeer = class extends RpcPeer {
     }
   }
   /**
-   * Reconcile outbound calls after reconnection, then flush pending sends.
+   * Reconcile the calls that were in flight on the connection that just died
+   * (`sentCalls`), then resend the survivors. Calls still waiting for a
+   * connection are deliberately NOT passed in — `AllowReconnect`/`AllowResend`
+   * don't apply to them, and entering `Connected` already sends them.
    *
    * On peer change (different server hubId) or with binary wire format —
    * we blind-resend every eligible call.
@@ -3449,7 +3482,7 @@ var RpcClientPeer = class extends RpcPeer {
    * 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, closedSignal) {
+  async _reconnect(sentCalls, isPeerChanged, closedSignal) {
     if (this._connection === void 0) return;
     if (isPeerChanged) {
       this.remoteObjects.disconnectAll();
@@ -3458,7 +3491,7 @@ var RpcClientPeer = class extends RpcPeer {
       this.remoteObjects.reconnectAll();
     }
     const eligible = [];
-    for (const call of [...this.outboundCalls.values()]) {
+    for (const call of sentCalls) {
       const mode = call.remoteExecutionMode;
       if (!(mode & 2)) {
         if (!call.result.isCompleted)
@@ -3479,8 +3512,7 @@ var RpcClientPeer = class extends RpcPeer {
         continue;
       }
       eligible.push(call);
-      if (call.sentAt !== 0)
-        call.sentAt = Date.now();
+      call.sentAt = Date.now();
     }
     let unknownIds = null;
     if (!isPeerChanged && eligible.length > 0) {
@@ -3568,19 +3600,18 @@ var RpcClientPeer = class extends RpcPeer {
    *  `RpcHandshake.GetPeerChangeKind` keys off `RemotePeerId`, not
    *  `RemoteHubId` (an idle server peer can be replaced while keeping the
    *  same hub id). On a change it clears the inbound tracker and fires
-   *  `peerChanged`; the very first handshake is never a change. */
+   *  `peerChanged`; the very first handshake is `ChangedToVeryFirst`. */
   _detectPeerChange(handshake) {
-    const remotePeerId = handshake.RemotePeerId;
-    if (remotePeerId === void 0)
-      return false;
-    const isPeerChanged = this._lastRemotePeerId !== void 0 && this._lastRemotePeerId !== remotePeerId;
-    this._lastRemotePeerId = remotePeerId;
-    if (isPeerChanged) {
-      this.inboundCalls.clear();
-      infoLog?.log(`'${this.ref}': Peer changed`);
-      this.peerChanged.trigger();
-    }
-    return isPeerChanged;
+    const lastHandshake = this._lastHandshake;
+    this._lastHandshake = handshake;
+    if (lastHandshake === void 0)
+      return 1 /* ChangedToVeryFirst */;
+    if (handshake.RemotePeerId === lastHandshake.RemotePeerId)
+      return 0 /* Unchanged */;
+    this.inboundCalls.clear();
+    infoLog?.log(`'${this.ref}': Peer changed`);
+    this.peerChanged.trigger();
+    return 2 /* Changed */;
   }
   _onHandshakeReceived(handshake) {
     this._pendingHandshake?.resolve(handshake);
@@ -4880,6 +4911,7 @@ var RpcPeerStateMonitor = class {
   RpcOutboundCall,
   RpcOutboundCallTracker,
   RpcPeer,
+  RpcPeerChangeKind,
   RpcPeerStateKind,
   RpcPeerStateMonitor,
   RpcRefBuilder,