@actuallab/rpc 14.4.14 → 15.0.17

package/dist/index.cjs

@@ -2479,6 +2479,7 @@ function toRpcStream(value, peer) {
 }
 
 // src/rpc-remote-object-tracker.ts
+var { warnLog: warnLog7 } = getLogs("RpcRemoteObjectTracker");
 var RpcRemoteObjectTracker = class {
   _objects = /* @__PURE__ */ new Map();
   register(obj) {
@@ -2509,8 +2510,17 @@ var RpcRemoteObjectTracker = class {
   }
   reconnectAll() {
     for (const obj of this._objects.values()) {
-      if (obj.allowReconnect) obj.reconnect();
-      else obj.disconnect();
+      try {
+        if (obj.allowReconnect) obj.reconnect();
+        else obj.disconnect();
+      } catch (e) {
+        warnLog7?.log(`Failed to reconnect ${obj.id.localId}, disconnecting it`, e);
+        try {
+          obj.disconnect();
+        } catch (e2) {
+          warnLog7?.log(`Failed to disconnect ${obj.id.localId}`, e2);
+        }
+      }
     }
   }
 };
@@ -2735,7 +2745,7 @@ function yieldToEventLoop() {
   return new Promise((resolve) => setTimeout(resolve, 0));
 }
 var RPC_CLOSE_CODE_UNSUPPORTED_FORMAT = 4001;
-var { debugLog: debugLog2, infoLog, warnLog: warnLog7, errorLog: errorLog2 } = getLogs("RpcPeer");
+var { debugLog: debugLog2, infoLog, warnLog: warnLog8, errorLog: errorLog2 } = getLogs("RpcPeer");
 var defaultConnectionUrlResolver = async (peer) => {
   const formatKey = peer.serializationFormat.key;
   const proof = await peer.computeReconnectProof();
@@ -3207,9 +3217,13 @@ var RpcPeer = class {
     this._keepAliveTimer ??= setInterval(() => {
       const conn = this.wireConnection;
       if (conn !== void 0) {
-        this.hub.systemCallSender.keepAlive(conn, this.serializationFormat, [
-          ...this.remoteObjects.keys()
-        ]);
+        try {
+          this.hub.systemCallSender.keepAlive(conn, this.serializationFormat, [
+            ...this.remoteObjects.keys()
+          ]);
+        } catch (e) {
+          warnLog8?.log(`'${this.ref}': Failed to send keep-alive`, e);
+        }
       }
     }, this.keepAlivePeriodMs);
     if (this._keepAliveWatchdog !== void 0)
@@ -3217,7 +3231,7 @@ var RpcPeer = class {
     this._keepAliveWatchdog = setTimeout(() => {
       this._keepAliveWatchdog = void 0;
       if (this._connection === void 0) return;
-      warnLog7?.log(
+      warnLog8?.log(
         `'${this.ref}': no keep-alive for ${this.keepAliveTimeoutMs}ms \u2014 force-closing connection`
       );
       this._connection.close();
@@ -3418,7 +3432,7 @@ var RpcClientPeer = class extends RpcPeer {
         this._setConnectionState(1 /* Connecting */);
         const retryDelay = this.hub.reconnectDelayer.getDelay(this._tryIndex, this._stopController.signal);
         if (retryDelay.isLimitExceeded) {
-          warnLog7?.log(`'${this.ref}': Reconnect limit exceeded - shutting down`);
+          warnLog8?.log(`'${this.ref}': Reconnect limit exceeded - shutting down`);
           this._disposed = true;
           break;
         }
@@ -3467,7 +3481,7 @@ var RpcClientPeer = class extends RpcPeer {
             );
           } catch (e) {
             if (e instanceof import_core7.TimeoutError) {
-              warnLog7?.log(`'${this.ref}': Connect timed out after ${connectTimeoutMs}ms`);
+              warnLog8?.log(`'${this.ref}': Connect timed out after ${connectTimeoutMs}ms`);
               conn.close();
             }
             throw e;
@@ -3482,7 +3496,7 @@ var RpcClientPeer = class extends RpcPeer {
               this.nextOwnHandshakeIndex()
             );
           } catch (e) {
-            warnLog7?.log(`'${this.ref}': Failed to send handshake`, e);
+            warnLog8?.log(`'${this.ref}': Failed to send handshake`, e);
             throw e;
           }
           const handshakeTimeoutMs = this.handshakeTimeoutMs;
@@ -3495,7 +3509,7 @@ var RpcClientPeer = class extends RpcPeer {
             );
           } catch (e) {
             if (e instanceof import_core7.TimeoutError) {
-              warnLog7?.log(`'${this.ref}': Handshake timed out after ${handshakeTimeoutMs}ms`);
+              warnLog8?.log(`'${this.ref}': Handshake timed out after ${handshakeTimeoutMs}ms`);
               conn.close();
             }
             throw e;
@@ -3525,7 +3539,7 @@ var RpcClientPeer = class extends RpcPeer {
         this._setConnectionState(0 /* Disconnected */);
         if (this._disposed) break;
         if (lastCloseCode === RPC_CLOSE_CODE_UNSUPPORTED_FORMAT) {
-          warnLog7?.log(`'${this.ref}': Unsupported serialization format - shutting down`);
+          warnLog8?.log(`'${this.ref}': Unsupported serialization format - shutting down`);
           this.unsupportedFormat.trigger({ reason: lastCloseReason });
           this._disposed = true;
           break;
@@ -3780,7 +3794,7 @@ function warnReconnectProofUnavailable(ref, reason) {
   if (isReconnectProofUnavailableWarned)
     return;
   isReconnectProofUnavailableWarned = true;
-  warnLog7?.log(
+  warnLog8?.log(
     `'${ref}': ${reason} - connecting without a reconnect proof. This fails if the server requires one (RequireReconnectProof).`
   );
 }
@@ -3861,7 +3875,7 @@ var RpcClientPeerReconnectDelayer = class extends import_core8.RetryDelayer {
 };
 
 // src/rpc-service-host.ts
-var { warnLog: warnLog8 } = getLogs("RpcServiceHost");
+var { warnLog: warnLog9 } = getLogs("RpcServiceHost");
 var RpcServiceHost = class {
   _methods = /* @__PURE__ */ new Map();
   register(def, impl, receiver = impl) {
@@ -3878,7 +3892,7 @@ var RpcServiceHost = class {
   async dispatch(wireMethod, args, context) {
     const entry = this._methods.get(wireMethod);
     if (entry === void 0) {
-      warnLog8?.log(`Method not found: ${wireMethod}`);
+      warnLog9?.log(`Method not found: ${wireMethod}`);
       throw new Error(`Method not found: ${wireMethod}`);
     }
     if (context !== void 0 && entry.def.callTypeId !== 0) {
@@ -4411,7 +4425,7 @@ function computeMethodHash(methodName) {
 }
 
 // src/rpc-method-registry.ts
-var { warnLog: warnLog9 } = getLogs("RpcMethodRegistry");
+var { warnLog: warnLog10 } = getLogs("RpcMethodRegistry");
 var RpcMethodRegistry = class {
   _nameToHash = /* @__PURE__ */ new Map();
   _hashToName = /* @__PURE__ */ new Map();
@@ -4421,7 +4435,7 @@ var RpcMethodRegistry = class {
     const hash = computeMethodHash(methodName);
     const existing = this._hashToName.get(hash);
     if (existing !== void 0 && existing !== methodName) {
-      warnLog9?.log(`hash collision: "${methodName}" and "${existing}" both hash to ${hash}`);
+      warnLog10?.log(`hash collision: "${methodName}" and "${existing}" both hash to ${hash}`);
       return;
     }
     this._nameToHash.set(methodName, hash);
@@ -4454,7 +4468,7 @@ var RpcMethodRegistry = class {
 };
 
 // src/rpc-hub.ts
-var { warnLog: warnLog10 } = getLogs("RpcHub");
+var { warnLog: warnLog11 } = getLogs("RpcHub");
 var RpcHub = class {
   hubId;
   peers = /* @__PURE__ */ new Map();
@@ -4519,7 +4533,7 @@ var RpcHub = class {
     if (peer !== void 0) {
       peer.close();
       this.peers.delete(ref);
-      warnLog10?.log(`'${ref}': peer is removed from RpcHub`);
+      warnLog11?.log(`'${ref}': peer is removed from RpcHub`);
     }
   }
   /** Get or create a peer by ref. If the peer does not exist: