@actuallab/rpc 12.3.50 → 12.3.64

package/dist/index.cjs

@@ -2310,6 +2310,14 @@ var RpcPeer = class {
    *  entered only after the handshake has succeeded. */
   connectionStateChanged = new import_core7.EventHandlerSet();
   _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;
@@ -2332,15 +2340,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
@@ -2362,6 +2375,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
@@ -2398,7 +2412,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 {
@@ -2431,16 +2445,24 @@ 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);
   }
+  /** Close the current WS connection without disposing the peer. The
+   *  `conn.closed` handler flips state to `Disconnected`; for
+   *  `RpcClientPeer` the run loop then iterates and reopens. The peer
+   *  stays in the hub and all client proxies bound to it remain valid. */
+  disconnect() {
+    this._connection?.close();
+  }
   close() {
     infoLog?.log(`'${this.ref}': Stopping`);
     this.remoteObjects.disconnectAll();
@@ -2693,6 +2715,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
@@ -2753,7 +2776,6 @@ var RpcClientPeer = class extends RpcPeer {
           });
           this._pendingHandshake = new import_core7.PromiseSource();
           this.setupConnection(conn);
-          this._connection = void 0;
           await Promise.race([conn.whenConnected, closedRejection]);
           try {
             this.hub.systemCallSender.handshake(
@@ -2806,7 +2828,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);