@actuallab/rpc 14.3.26 → 14.3.34

package/dist/index.d.cts

@@ -522,6 +522,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;
@@ -1071,6 +1075,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 +1096,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 +1181,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 +1222,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 +1638,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

@@ -522,6 +522,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;
@@ -1071,6 +1075,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 +1096,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 +1181,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 +1222,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 +1638,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) {
@@ -3065,6 +3075,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 +3094,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 +3178,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 +3313,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 +3347,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 +3368,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 +3377,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 +3398,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 +3486,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 +4796,7 @@ export {
   RpcOutboundCall,
   RpcOutboundCallTracker,
   RpcPeer,
+  RpcPeerChangeKind,
   RpcPeerStateKind,
   RpcPeerStateMonitor,
   RpcRefBuilder,