@actuallab/rpc 14.3.32 → 14.4.3

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) {
@@ -982,7 +993,8 @@ var RpcCallTimeouts = class _RpcCallTimeouts {
   static None = new _RpcCallTimeouts(Infinity, Infinity);
   /** Command default: 1.5 s connect / 10 s run (.NET `RpcCallTimeouts.Default.Command`). */
   static Command = new _RpcCallTimeouts(1500, 1e4);
-  /** Max time a call may wait for the connection before it is sent. */
+  /** Max time a call may wait for a connection - before it is sent, and again for the
+   *  duration of any outage it is still pending through. */
   connectTimeoutMs;
   /** Max time a sent call may stay unanswered before it is failed. */
   runTimeoutMs;
@@ -2776,6 +2788,8 @@ var RpcPeer = class {
   /** Wall-clock time of the last inbound `$sys.KeepAlive`, or 0 if none yet
    *  for the current connection. Useful for diagnostics. */
   _lastKeepAliveAt = 0;
+  /** When the current outage began; 0 until the peer has been connected at least once. */
+  _disconnectedAt = 0;
   /** Outbound keep-alive send period. Initialized from `hub.limits` at
    *  construction; set directly to override on a single peer. */
   keepAlivePeriodMs;
@@ -2796,9 +2810,10 @@ var RpcPeer = class {
   }
   /** Fail outbound calls whose per-call {@link RpcCallTimeouts} elapsed —
    *  the connect timeout while a call still awaits the wire, the run timeout
-   *  once it has been sent. Mirrors .NET `RpcOutboundCallTracker.Maintain`
-   *  (RpcCallTrackers.cs:108-207). Calls without timeouts (queries) never
-   *  time out here. */
+   *  once it has been sent, and the connect timeout again for any pending call while the
+   *  peer is away. Mirrors .NET `RpcOutboundCallTracker.HandleDisconnect` (ConnectTimeout,
+   *  per outage) plus `Maintain` (RunTimeout, per connection). Calls without timeouts
+   *  (queries) never time out here. */
   _maintainOutboundCalls() {
     const now = Date.now();
     const canRunTimeout = this._isConnected && (this._lastKeepAliveAt === 0 || now - this._lastKeepAliveAt <= this.keepAliveTimeoutMs);
@@ -2807,7 +2822,11 @@ var RpcPeer = class {
       if (timeouts === void 0 || call.result.isCompleted)
         continue;
       let timedOut;
-      if (call.sentAt === 0) {
+      if (!this._isConnected) {
+        const since = Math.max(this._disconnectedAt, call.startedAt);
+        if (now - since >= timeouts.connectTimeoutMs)
+          timedOut = `connect timeout (${timeouts.connectTimeoutMs}ms)`;
+      } else if (call.sentAt === 0) {
         if (now - call.startedAt >= timeouts.connectTimeoutMs)
           timedOut = `connect timeout (${timeouts.connectTimeoutMs}ms)`;
       } else if (canRunTimeout && now - call.sentAt >= timeouts.runTimeoutMs)
@@ -2850,10 +2869,13 @@ var RpcPeer = class {
     this._connectionState = value;
     if (value === 3 /* Connected */) {
       this._isConnected = true;
+      this._disconnectedAt = 0;
       this._armKeepAliveWatchdog();
     } else if (value === 0 /* Disconnected */) {
-      if (previousState === 3 /* Connected */)
+      if (previousState === 3 /* Connected */) {
         this._isConnected = false;
+        this._disconnectedAt = Date.now();
+      }
       this._disarmKeepAliveWatchdog();
     }
     this.connectionStateChanged.trigger(value);
@@ -2878,6 +2900,8 @@ var RpcPeer = class {
     conn.closed.add((ev) => {
       if (this._connection !== conn) return;
       this._connection = void 0;
+      if (this._isConnected)
+        this._disconnectedAt = Date.now();
       this._isConnected = false;
       if (ev.reason)
         infoLog?.log(`'${this.ref}': Disconnected: ${ev.reason} (code=${ev.code})`);
@@ -3178,6 +3202,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 +3221,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 +3305,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 +3440,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 +3474,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 +3495,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 +3504,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 +3525,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 +3613,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 +4924,7 @@ var RpcPeerStateMonitor = class {
   RpcOutboundCall,
   RpcOutboundCallTracker,
   RpcPeer,
+  RpcPeerChangeKind,
   RpcPeerStateKind,
   RpcPeerStateMonitor,
   RpcRefBuilder,