@actuallab/rpc 12.3.49 → 12.3.60

package/dist/index.d.cts

@@ -782,6 +782,14 @@ declare abstract class RpcPeer {
      *  entered only after the handshake has succeeded. */
     readonly connectionStateChanged: EventHandlerSet<RpcConnectionState>;
     protected _connection: RpcConnection | undefined;
+    /** Mirror of `_connectionState === Connected` — true only after the
+     *  handshake round-trip completes. Kept as its own field (rather than
+     *  derived from `_connection`) so outbound calls can be gated on
+     *  handshake completion, not merely WS-open: previously the run loop
+     *  nulled `_connection` during the handshake window to suppress calls,
+     *  which made `close()` a silent no-op and left a zombie peer when the
+     *  hub removed it mid-handshake. */
+    protected _isConnected: boolean;
     protected _connectionState: RpcConnectionState;
     protected _pendingSends: RpcOutboundCall[];
     private _keepAliveTimer;

package/dist/index.d.ts

@@ -782,6 +782,14 @@ declare abstract class RpcPeer {
      *  entered only after the handshake has succeeded. */
     readonly connectionStateChanged: EventHandlerSet<RpcConnectionState>;
     protected _connection: RpcConnection | undefined;
+    /** Mirror of `_connectionState === Connected` — true only after the
+     *  handshake round-trip completes. Kept as its own field (rather than
+     *  derived from `_connection`) so outbound calls can be gated on
+     *  handshake completion, not merely WS-open: previously the run loop
+     *  nulled `_connection` during the handshake window to suppress calls,
+     *  which made `close()` a silent no-op and left a zombie peer when the
+     *  hub removed it mid-handshake. */
+    protected _isConnected: boolean;
     protected _connectionState: RpcConnectionState;
     protected _pendingSends: RpcOutboundCall[];
     private _keepAliveTimer;

package/dist/index.js

@@ -2205,6 +2205,14 @@ var RpcPeer = class {
    *  entered only after the handshake has succeeded. */
   connectionStateChanged = new EventHandlerSet3();
   _connection;
+  /** Mirror of `_connectionState === Connected` — true only after the
+   *  handshake round-trip completes. Kept as its own field (rather than
+   *  derived from `_connection`) so outbound calls can be gated on
+   *  handshake completion, not merely WS-open: previously the run loop
+   *  nulled `_connection` during the handshake window to suppress calls,
+   *  which made `close()` a silent no-op and left a zombie peer when the
+   *  hub removed it mid-handshake. */
+  _isConnected = false;
   _connectionState = 0 /* Disconnected */;
   _pendingSends = [];
   _keepAliveTimer;
@@ -2227,15 +2235,20 @@ var RpcPeer = class {
     return this._connectionState;
   }
   get isConnected() {
-    return this._connection?.isOpen ?? false;
+    return this._isConnected;
   }
   _setConnectionState(value) {
     if (this._connectionState === value) return;
+    const previousState = this._connectionState;
     this._connectionState = value;
-    if (value === 2 /* Connected */)
+    if (value === 2 /* Connected */) {
+      this._isConnected = true;
       this._armKeepAliveWatchdog();
-    else if (value === 0 /* Disconnected */)
+    } else if (value === 0 /* Disconnected */) {
+      if (previousState === 2 /* Connected */)
+        this._isConnected = false;
       this._disarmKeepAliveWatchdog();
+    }
     this.connectionStateChanged.trigger(value);
   }
   /** Resolves on the next transition into `Connected` — or immediately if
@@ -2257,6 +2270,7 @@ var RpcPeer = class {
     conn.messageReceived.add((raw) => this._handleMessage(raw));
     conn.closed.add((ev) => {
       this._connection = void 0;
+      this._isConnected = false;
       if (ev.reason)
         infoLog?.log(`'${this.ref}': Disconnected: ${ev.reason} (code=${ev.code})`);
       else
@@ -2293,7 +2307,7 @@ var RpcPeer = class {
       this._connection?.encoder,
       this.hub.registry
     );
-    if (this._connection !== void 0) {
+    if (this._isConnected) {
       this.outboundCalls.register(outboundCall);
       this._sendWireData(outboundCall.serializedWireData);
     } else {
@@ -2326,12 +2340,13 @@ var RpcPeer = class {
     return outboundCall;
   }
   callNoWait(method, args) {
-    if (this._connection === void 0) return;
+    if (!this._isConnected) return;
+    const conn = this._connection;
     const envelope = { Method: method, RelatedId: 0 };
     const wireData = this.serializationFormat.serializeMessage(
       envelope,
       args,
-      this._connection.encoder,
+      conn.encoder,
       this.hub.registry
     );
     this._sendWireData(wireData);
@@ -2588,6 +2603,7 @@ var RpcClientPeer = class extends RpcPeer {
    *  to simulate a same-peer reconnect in tests. */
   connectWith(conn, isPeerChanged = true) {
     this.setupConnection(conn);
+    this._isConnected = true;
     void this._reconnect(isPeerChanged);
   }
   /** Kick off the reconnect loop. Idempotent — subsequent calls are
@@ -2648,7 +2664,6 @@ var RpcClientPeer = class extends RpcPeer {
           });
           this._pendingHandshake = new PromiseSource5();
           this.setupConnection(conn);
-          this._connection = void 0;
           await Promise.race([conn.whenConnected, closedRejection]);
           try {
             this.hub.systemCallSender.handshake(
@@ -2701,7 +2716,6 @@ var RpcClientPeer = class extends RpcPeer {
             this._lastRemoteHubId = remoteHubId;
           }
           infoLog?.log(`'${this.ref}': Handshake succeeded, peerChanged=${isPeerChanged}`);
-          this._connection = conn;
           this._setConnectionState(2 /* Connected */);
           this._tryIndex = 0;
           await this._reconnect(isPeerChanged, closedController.signal);