@actuallab/rpc 14.4.14 → 15.0.21

package/dist/index.cjs

@@ -1014,6 +1014,14 @@ var RpcError = class extends Error {
       this.typeName = typeName;
   }
 };
+var CANCELLATION_TYPE_NAMES = /* @__PURE__ */ new Set([
+  "System.OperationCanceledException",
+  "System.Threading.Tasks.TaskCanceledException",
+  "ActualLab.Rpc.RpcRerouteException"
+]);
+function isCancellationTypeName(typeName) {
+  return typeName !== void 0 && CANCELLATION_TYPE_NAMES.has(typeName);
+}
 var REMOTE_EXCEPTION_TYPE_REF = "ActualLab.Serialization.RemoteException, ActualLab.Core";
 var genericErrorFilter = () => ({
   TypeRef: REMOTE_EXCEPTION_TYPE_REF,
@@ -1173,15 +1181,21 @@ var RpcSystemCallHandler = class {
         const call = peer.outboundCalls.get(relatedId);
         if (call !== void 0) {
           call.completedStage |= RpcCallStage.ResultReady;
-          if (call.removeOnOk) {
+          const errorInfo = args[0];
+          const typeName = extractTypeName(errorInfo?.TypeRef ?? errorInfo?.typeRef);
+          const isCancelled = !call.removeOnOk && isCancellationTypeName(typeName);
+          if (call.removeOnOk || isCancelled) {
             peer.outboundCalls.remove(relatedId);
           }
-          const errorInfo = args[0];
           const msg = errorInfo?.Message ?? errorInfo?.message ?? "RPC error";
-          const typeName = extractTypeName(errorInfo?.TypeRef ?? errorInfo?.typeRef);
           if (typeName === "ActualLab.Rpc.RpcRerouteException")
             warnLog4?.log("Got RpcRerouteException from remote peer:", msg);
-          call.result.reject(new RpcError(msg, typeName));
+          const error = new RpcError(msg, typeName);
+          if (isCancelled)
+            error.name = "AbortError";
+          call.result.reject(error);
+          if (isCancelled)
+            call.onDisconnect();
         }
         break;
       }
@@ -2479,6 +2493,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 +2524,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 +2759,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 +3231,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 +3245,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 +3446,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 +3495,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 +3510,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 +3523,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 +3553,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;
@@ -3593,8 +3621,10 @@ var RpcClientPeer = class extends RpcPeer {
       call.sentAt = Date.now();
     }
     let unknownIds = null;
+    let isReconciled = false;
     if (!isPeerChanged && eligible.length > 0) {
       unknownIds = await this._reconcileReconnect(eligible, closedSignal);
+      isReconciled = unknownIds !== null;
     }
     const YIELD_BATCH = 20;
     let resentSinceYield = 0;
@@ -3607,6 +3637,17 @@ var RpcClientPeer = class extends RpcPeer {
       if (unknownIds !== null && !unknownIds.has(call.callId)) {
         continue;
       }
+      if (!(call.remoteExecutionMode & 4)) {
+        if (!isReconciled)
+          continue;
+        if (!call.result.isCompleted)
+          call.result.reject(new Error(
+            "Outbound call failed: the peer does not know the call after reconnect and AllowResend is not set."
+          ));
+        call.onDisconnect();
+        this.outboundCalls.remove(call.callId);
+        continue;
+      }
       call.sentAt = Date.now();
       this._sendWireData(call.serializedWireData);
       resentSinceYield++;
@@ -3619,7 +3660,8 @@ var RpcClientPeer = class extends RpcPeer {
   /**
    * Ask the server which call IDs in `eligible` it no longer recognizes
    * via `$sys.Reconnect:3`. Returns the set of call IDs that need to be
-   * resent. On any failure, falls back to "resend everything".
+   * resent, or `null` if the reconciliation failed: the caller then
+   * resends everything that allows it.
    *
    * Wire format of the `completedStages` argument is chosen per wire format:
    *   - JSON (json5np): plain object `{"<stage>": "<base64-of-bytes>"}` —
@@ -3643,7 +3685,7 @@ var RpcClientPeer = class extends RpcPeer {
         arr.push(call.callId);
       }
       if (byStage.size === 0) {
-        return new Set(eligible.map((c) => c.callId));
+        return null;
       }
       const isBinary = this.serializationFormat.isBinary;
       const stagesArg = isBinary ? /* @__PURE__ */ new Map() : {};
@@ -3667,10 +3709,10 @@ var RpcClientPeer = class extends RpcPeer {
       );
       const result = await reconnectCall.result;
       const bytes = _toBytes2(result);
-      if (bytes === null) return new Set(eligible.map((c) => c.callId));
+      if (bytes === null) return null;
       return new Set(IncreasingSeqCompressor.deserialize(bytes));
     } catch {
-      return new Set(eligible.map((c) => c.callId));
+      return null;
     }
   }
   /** Detects a server-peer identity change by comparing the incoming
@@ -3780,7 +3822,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 +3903,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 +3920,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 +4453,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 +4463,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 +4496,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 +4561,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: