@actuallab/rpc 14.3.32 → 14.4.3

package/dist/index.d.cts

@@ -409,7 +409,8 @@ declare class RpcCallTimeouts {
     static readonly None: RpcCallTimeouts;
     /** Command default: 1.5 s connect / 10 s run (.NET `RpcCallTimeouts.Default.Command`). */
     static readonly Command: RpcCallTimeouts;
-    /** 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. */
     readonly connectTimeoutMs: number;
     /** Max time a sent call may stay unanswered before it is failed. */
     readonly runTimeoutMs: number;
@@ -522,6 +523,10 @@ declare class RpcOutboundCallTracker {
     remove(callId: number): RpcOutboundCall | undefined;
     values(): IterableIterator<RpcOutboundCall>;
     activeCallIds(): number[];
+    /** 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(): RpcOutboundCall[];
     /** Reject all pending calls with the given error.
      *  Stage-3 compute calls (result resolved, awaiting invalidation) are kept in the tracker. */
     rejectAll(error: Error): void;
@@ -999,6 +1004,8 @@ declare abstract class RpcPeer {
     /** Wall-clock time of the last inbound `$sys.KeepAlive`, or 0 if none yet
      *  for the current connection. Useful for diagnostics. */
     private _lastKeepAliveAt;
+    /** When the current outage began; 0 until the peer has been connected at least once. */
+    private _disconnectedAt;
     /** Outbound keep-alive send period. Initialized from `hub.limits` at
      *  construction; set directly to override on a single peer. */
     keepAlivePeriodMs: number;
@@ -1008,9 +1015,10 @@ declare abstract class RpcPeer {
     protected constructor(hub: RpcHub, ref: string);
     /** 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. */
     private _maintainOutboundCalls;
     get connection(): RpcConnection | undefined;
     get connectionState(): RpcConnectionState;
@@ -1071,6 +1079,14 @@ declare const enum RpcConnectionState {
     Handshaking = 2,
     Connected = 3
 }
+/** Outcome of comparing an incoming handshake with the previous one. Mirrors
+ *  .NET `RpcPeerChangeKind` — `ChangedToVeryFirst` lets the first handshake skip
+ *  reconnect processing, since there's no prior connection to reconcile with. */
+declare const enum RpcPeerChangeKind {
+    Unchanged = 0,
+    ChangedToVeryFirst = 1,
+    Changed = 2
+}
 /** Client-side RPC peer — initiates WebSocket connection. ref = URL. */
 declare class RpcClientPeer extends RpcPeer {
     private _disposed;
@@ -1084,7 +1100,10 @@ declare class RpcClientPeer extends RpcPeer {
      *  `connectionState.Handshake.Index` path in
      *  `RpcOutboundCallTracker.TryReconnect`. */
     private _remoteHandshakeIndex;
-    private _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. */
+    private _lastHandshake;
     private _pendingHandshake;
     private _reconnectsAt;
     /** Server-issued reconnect secret, from the most recent handshake that
@@ -1166,7 +1185,10 @@ declare class RpcClientPeer extends RpcPeer {
     protected run(): Promise<void>;
     private _runImpl;
     /**
-     * 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.
@@ -1204,7 +1226,7 @@ declare class RpcClientPeer 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`. */
     private _detectPeerChange;
     protected _onHandshakeReceived(handshake: RemoteHandshake): void;
     close(): void;
@@ -1620,4 +1642,4 @@ declare function xxh3_64str(input: string, seed?: bigint): bigint;
  */
 declare function computeMethodHash(methodName: string): number;
 
-export { ARG_DELIMITER, ENVELOPE_DELIMITER, FRAME_DELIMITER, type IRpcObject, IncreasingSeqCompressor, type MethodMeta, REMOTE_EXCEPTION_TYPE_REF, RPC_CLOSE_CODE_UNSUPPORTED_FORMAT, type RemoteHandshake, type RpcCallOptions, RpcCallStage, RpcCallTimeouts, RpcCallTypeId, RpcClientPeer, RpcClientPeerReconnectDelayer, type RpcConnection, RpcConnectionState, type RpcConnectionUrlResolver, type RpcDeserializedMessage, type RpcDispatchContext, RpcError, type RpcErrorFilter, type RpcExceptionInfo, RpcHub, RpcInboundCall, RpcInboundCallTracker, RpcJsonSerializationFormat, RpcLimits, type RpcLogScope, type RpcMessage, RpcMessageChannelConnection, RpcMessagePackCompactSerializationFormat, RpcMessagePackSerializationFormat, type RpcMethodDef, type RpcMethodDefInput, RpcMethodRegistry, type RpcObjectId, RpcObjectKind, RpcOutboundCall, RpcOutboundCallTracker, RpcPeer, type RpcPeerFactory, type RpcPeerState, RpcPeerStateKind, RpcPeerStateMonitor, type RpcReceivedMessage, type RpcReconnectProofParameters, RpcRefBuilder, RpcRemoteExecutionMode, RpcRemoteObjectTracker, RpcSerializationFormat, RpcSerializationFormatResolver, RpcServerPeer, type RpcServiceDef, RpcServiceHost, type RpcServiceImpl, RpcSharedObjectTracker, RpcStream, type RpcStreamOptions, type RpcStreamRef, RpcStreamSender, type RpcStreamSource, RpcSystemCallHandler, RpcSystemCallSender, RpcSystemCalls, RpcType, RpcWebSocketConnection, type RpcWireData, type ServiceMeta, type WebSocketLike, type WebSocketServer, WebSocketState, computeMethodHash, computeReconnectProof, createBinaryEncoder, createMessageChannelPair, createRpcClient, defaultBinaryDecoder, defaultBinaryEncoder, defaultConnectionUrlResolver, defineRpcService, deserializeBinaryMessage, deserializeCompactBinaryMessage, deserializeMessage, genericErrorFilter, getLogs, getMethodsMeta, getServiceMeta, getStateDescription, isConnected, isReconnectProofSupported, likelyConnected, parseStreamRef, readPolymorphismMarker, rpcMethod, rpcService, serializeBinaryFrame, serializeBinaryMessage, serializeCompactBinaryMessage, serializeFrame, serializeMessage, splitBinaryFrame, splitCompactBinaryFrame, splitFrame, toExceptionInfo, toRpcStream, wireMethodName, xxh3_64, xxh3_64str };
+export { ARG_DELIMITER, ENVELOPE_DELIMITER, FRAME_DELIMITER, type IRpcObject, IncreasingSeqCompressor, type MethodMeta, REMOTE_EXCEPTION_TYPE_REF, RPC_CLOSE_CODE_UNSUPPORTED_FORMAT, type RemoteHandshake, type RpcCallOptions, RpcCallStage, RpcCallTimeouts, RpcCallTypeId, RpcClientPeer, RpcClientPeerReconnectDelayer, type RpcConnection, RpcConnectionState, type RpcConnectionUrlResolver, type RpcDeserializedMessage, type RpcDispatchContext, RpcError, type RpcErrorFilter, type RpcExceptionInfo, RpcHub, RpcInboundCall, RpcInboundCallTracker, RpcJsonSerializationFormat, RpcLimits, type RpcLogScope, type RpcMessage, RpcMessageChannelConnection, RpcMessagePackCompactSerializationFormat, RpcMessagePackSerializationFormat, type RpcMethodDef, type RpcMethodDefInput, RpcMethodRegistry, type RpcObjectId, RpcObjectKind, RpcOutboundCall, RpcOutboundCallTracker, RpcPeer, RpcPeerChangeKind, type RpcPeerFactory, type RpcPeerState, RpcPeerStateKind, RpcPeerStateMonitor, type RpcReceivedMessage, type RpcReconnectProofParameters, RpcRefBuilder, RpcRemoteExecutionMode, RpcRemoteObjectTracker, RpcSerializationFormat, RpcSerializationFormatResolver, RpcServerPeer, type RpcServiceDef, RpcServiceHost, type RpcServiceImpl, RpcSharedObjectTracker, RpcStream, type RpcStreamOptions, type RpcStreamRef, RpcStreamSender, type RpcStreamSource, RpcSystemCallHandler, RpcSystemCallSender, RpcSystemCalls, RpcType, RpcWebSocketConnection, type RpcWireData, type ServiceMeta, type WebSocketLike, type WebSocketServer, WebSocketState, computeMethodHash, computeReconnectProof, createBinaryEncoder, createMessageChannelPair, createRpcClient, defaultBinaryDecoder, defaultBinaryEncoder, defaultConnectionUrlResolver, defineRpcService, deserializeBinaryMessage, deserializeCompactBinaryMessage, deserializeMessage, genericErrorFilter, getLogs, getMethodsMeta, getServiceMeta, getStateDescription, isConnected, isReconnectProofSupported, likelyConnected, parseStreamRef, readPolymorphismMarker, rpcMethod, rpcService, serializeBinaryFrame, serializeBinaryMessage, serializeCompactBinaryMessage, serializeFrame, serializeMessage, splitBinaryFrame, splitCompactBinaryFrame, splitFrame, toExceptionInfo, toRpcStream, wireMethodName, xxh3_64, xxh3_64str };

package/dist/index.d.ts

@@ -409,7 +409,8 @@ declare class RpcCallTimeouts {
     static readonly None: RpcCallTimeouts;
     /** Command default: 1.5 s connect / 10 s run (.NET `RpcCallTimeouts.Default.Command`). */
     static readonly Command: RpcCallTimeouts;
-    /** 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. */
     readonly connectTimeoutMs: number;
     /** Max time a sent call may stay unanswered before it is failed. */
     readonly runTimeoutMs: number;
@@ -522,6 +523,10 @@ declare class RpcOutboundCallTracker {
     remove(callId: number): RpcOutboundCall | undefined;
     values(): IterableIterator<RpcOutboundCall>;
     activeCallIds(): number[];
+    /** 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(): RpcOutboundCall[];
     /** Reject all pending calls with the given error.
      *  Stage-3 compute calls (result resolved, awaiting invalidation) are kept in the tracker. */
     rejectAll(error: Error): void;
@@ -999,6 +1004,8 @@ declare abstract class RpcPeer {
     /** Wall-clock time of the last inbound `$sys.KeepAlive`, or 0 if none yet
      *  for the current connection. Useful for diagnostics. */
     private _lastKeepAliveAt;
+    /** When the current outage began; 0 until the peer has been connected at least once. */
+    private _disconnectedAt;
     /** Outbound keep-alive send period. Initialized from `hub.limits` at
      *  construction; set directly to override on a single peer. */
     keepAlivePeriodMs: number;
@@ -1008,9 +1015,10 @@ declare abstract class RpcPeer {
     protected constructor(hub: RpcHub, ref: string);
     /** 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. */
     private _maintainOutboundCalls;
     get connection(): RpcConnection | undefined;
     get connectionState(): RpcConnectionState;
@@ -1071,6 +1079,14 @@ declare const enum RpcConnectionState {
     Handshaking = 2,
     Connected = 3
 }
+/** Outcome of comparing an incoming handshake with the previous one. Mirrors
+ *  .NET `RpcPeerChangeKind` — `ChangedToVeryFirst` lets the first handshake skip
+ *  reconnect processing, since there's no prior connection to reconcile with. */
+declare const enum RpcPeerChangeKind {
+    Unchanged = 0,
+    ChangedToVeryFirst = 1,
+    Changed = 2
+}
 /** Client-side RPC peer — initiates WebSocket connection. ref = URL. */
 declare class RpcClientPeer extends RpcPeer {
     private _disposed;
@@ -1084,7 +1100,10 @@ declare class RpcClientPeer extends RpcPeer {
      *  `connectionState.Handshake.Index` path in
      *  `RpcOutboundCallTracker.TryReconnect`. */
     private _remoteHandshakeIndex;
-    private _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. */
+    private _lastHandshake;
     private _pendingHandshake;
     private _reconnectsAt;
     /** Server-issued reconnect secret, from the most recent handshake that
@@ -1166,7 +1185,10 @@ declare class RpcClientPeer extends RpcPeer {
     protected run(): Promise<void>;
     private _runImpl;
     /**
-     * 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.
@@ -1204,7 +1226,7 @@ declare class RpcClientPeer 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`. */
     private _detectPeerChange;
     protected _onHandshakeReceived(handshake: RemoteHandshake): void;
     close(): void;
@@ -1620,4 +1642,4 @@ declare function xxh3_64str(input: string, seed?: bigint): bigint;
  */
 declare function computeMethodHash(methodName: string): number;
 
-export { ARG_DELIMITER, ENVELOPE_DELIMITER, FRAME_DELIMITER, type IRpcObject, IncreasingSeqCompressor, type MethodMeta, REMOTE_EXCEPTION_TYPE_REF, RPC_CLOSE_CODE_UNSUPPORTED_FORMAT, type RemoteHandshake, type RpcCallOptions, RpcCallStage, RpcCallTimeouts, RpcCallTypeId, RpcClientPeer, RpcClientPeerReconnectDelayer, type RpcConnection, RpcConnectionState, type RpcConnectionUrlResolver, type RpcDeserializedMessage, type RpcDispatchContext, RpcError, type RpcErrorFilter, type RpcExceptionInfo, RpcHub, RpcInboundCall, RpcInboundCallTracker, RpcJsonSerializationFormat, RpcLimits, type RpcLogScope, type RpcMessage, RpcMessageChannelConnection, RpcMessagePackCompactSerializationFormat, RpcMessagePackSerializationFormat, type RpcMethodDef, type RpcMethodDefInput, RpcMethodRegistry, type RpcObjectId, RpcObjectKind, RpcOutboundCall, RpcOutboundCallTracker, RpcPeer, type RpcPeerFactory, type RpcPeerState, RpcPeerStateKind, RpcPeerStateMonitor, type RpcReceivedMessage, type RpcReconnectProofParameters, RpcRefBuilder, RpcRemoteExecutionMode, RpcRemoteObjectTracker, RpcSerializationFormat, RpcSerializationFormatResolver, RpcServerPeer, type RpcServiceDef, RpcServiceHost, type RpcServiceImpl, RpcSharedObjectTracker, RpcStream, type RpcStreamOptions, type RpcStreamRef, RpcStreamSender, type RpcStreamSource, RpcSystemCallHandler, RpcSystemCallSender, RpcSystemCalls, RpcType, RpcWebSocketConnection, type RpcWireData, type ServiceMeta, type WebSocketLike, type WebSocketServer, WebSocketState, computeMethodHash, computeReconnectProof, createBinaryEncoder, createMessageChannelPair, createRpcClient, defaultBinaryDecoder, defaultBinaryEncoder, defaultConnectionUrlResolver, defineRpcService, deserializeBinaryMessage, deserializeCompactBinaryMessage, deserializeMessage, genericErrorFilter, getLogs, getMethodsMeta, getServiceMeta, getStateDescription, isConnected, isReconnectProofSupported, likelyConnected, parseStreamRef, readPolymorphismMarker, rpcMethod, rpcService, serializeBinaryFrame, serializeBinaryMessage, serializeCompactBinaryMessage, serializeFrame, serializeMessage, splitBinaryFrame, splitCompactBinaryFrame, splitFrame, toExceptionInfo, toRpcStream, wireMethodName, xxh3_64, xxh3_64str };
+export { ARG_DELIMITER, ENVELOPE_DELIMITER, FRAME_DELIMITER, type IRpcObject, IncreasingSeqCompressor, type MethodMeta, REMOTE_EXCEPTION_TYPE_REF, RPC_CLOSE_CODE_UNSUPPORTED_FORMAT, type RemoteHandshake, type RpcCallOptions, RpcCallStage, RpcCallTimeouts, RpcCallTypeId, RpcClientPeer, RpcClientPeerReconnectDelayer, type RpcConnection, RpcConnectionState, type RpcConnectionUrlResolver, type RpcDeserializedMessage, type RpcDispatchContext, RpcError, type RpcErrorFilter, type RpcExceptionInfo, RpcHub, RpcInboundCall, RpcInboundCallTracker, RpcJsonSerializationFormat, RpcLimits, type RpcLogScope, type RpcMessage, RpcMessageChannelConnection, RpcMessagePackCompactSerializationFormat, RpcMessagePackSerializationFormat, type RpcMethodDef, type RpcMethodDefInput, RpcMethodRegistry, type RpcObjectId, RpcObjectKind, RpcOutboundCall, RpcOutboundCallTracker, RpcPeer, RpcPeerChangeKind, type RpcPeerFactory, type RpcPeerState, RpcPeerStateKind, RpcPeerStateMonitor, type RpcReceivedMessage, type RpcReconnectProofParameters, RpcRefBuilder, RpcRemoteExecutionMode, RpcRemoteObjectTracker, RpcSerializationFormat, RpcSerializationFormatResolver, RpcServerPeer, type RpcServiceDef, RpcServiceHost, type RpcServiceImpl, RpcSharedObjectTracker, RpcStream, type RpcStreamOptions, type RpcStreamRef, RpcStreamSender, type RpcStreamSource, RpcSystemCallHandler, RpcSystemCallSender, RpcSystemCalls, RpcType, RpcWebSocketConnection, type RpcWireData, type ServiceMeta, type WebSocketLike, type WebSocketServer, WebSocketState, computeMethodHash, computeReconnectProof, createBinaryEncoder, createMessageChannelPair, createRpcClient, defaultBinaryDecoder, defaultBinaryEncoder, defaultConnectionUrlResolver, defineRpcService, deserializeBinaryMessage, deserializeCompactBinaryMessage, deserializeMessage, genericErrorFilter, getLogs, getMethodsMeta, getServiceMeta, getStateDescription, isConnected, isReconnectProofSupported, likelyConnected, parseStreamRef, readPolymorphismMarker, rpcMethod, rpcService, serializeBinaryFrame, serializeBinaryMessage, serializeCompactBinaryMessage, serializeFrame, serializeMessage, splitBinaryFrame, splitCompactBinaryFrame, splitFrame, toExceptionInfo, toRpcStream, wireMethodName, xxh3_64, xxh3_64str };

package/dist/index.js

@@ -751,6 +751,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) {
@@ -869,7 +879,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;
@@ -2663,6 +2674,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;
@@ -2683,9 +2696,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);
@@ -2694,7 +2708,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)
@@ -2737,10 +2755,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);
@@ -2765,6 +2786,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})`);
@@ -3065,6 +3088,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
@@ -3077,7 +3107,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
@@ -3158,10 +3191,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
@@ -3292,11 +3326,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);
@@ -3318,7 +3360,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.
@@ -3336,7 +3381,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();
@@ -3345,7 +3390,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)
@@ -3366,8 +3411,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) {
@@ -3455,19 +3499,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);
@@ -4766,6 +4809,7 @@ export {
   RpcOutboundCall,
   RpcOutboundCallTracker,
   RpcPeer,
+  RpcPeerChangeKind,
   RpcPeerStateKind,
   RpcPeerStateMonitor,
   RpcRefBuilder,