@actuallab/rpc 12.3.4 → 12.3.14

package/dist/index.cjs

@@ -52,6 +52,7 @@ __export(index_exports, {
   RpcPeerConnectionKind: () => RpcPeerConnectionKind,
   RpcPeerStateKind: () => RpcPeerStateKind,
   RpcPeerStateMonitor: () => RpcPeerStateMonitor,
+  RpcRemoteExecutionMode: () => RpcRemoteExecutionMode,
   RpcRemoteObjectTracker: () => RpcRemoteObjectTracker,
   RpcSerializationFormat: () => RpcSerializationFormat,
   RpcSerializationFormatResolver: () => RpcSerializationFormatResolver,
@@ -614,6 +615,18 @@ function createMessageChannelPair() {
 }
 
 // src/rpc-service-def.ts
+var RpcRemoteExecutionMode = {
+  /** Wait for connection if disconnected when the call is made. */
+  AwaitForConnection: 1,
+  /** Resend on reconnection to the same peer. */
+  AllowReconnect: 2,
+  /** Resend on reconnection to a different peer (implies AllowReconnect). */
+  AllowResend: 6,
+  // 4 | AllowReconnect
+  /** Default: wait + reconnect + resend. */
+  Default: 7
+  // AwaitForConnection | AllowResend
+};
 var RpcType = {
   object: /* @__PURE__ */ Symbol("object"),
   stream: /* @__PURE__ */ Symbol("stream"),
@@ -630,6 +643,7 @@ function defineRpcService(name, methods) {
     const cleanName = colonIndex >= 0 ? key.substring(0, colonIndex) : key;
     const wireArgCount = input.wireArgCount ?? input.args.length + 1;
     const mapKey = `${cleanName}:${wireArgCount}`;
+    const isNoWait = input.returns === RpcType.noWait;
     map.set(mapKey, {
       name: cleanName,
       serviceName: name,
@@ -637,7 +651,8 @@ function defineRpcService(name, methods) {
       wireArgCount,
       callTypeId: input.callTypeId ?? 0,
       stream: input.returns === RpcType.stream,
-      noWait: input.returns === RpcType.noWait
+      noWait: isNoWait,
+      remoteExecutionMode: isNoWait ? 0 : input.remoteExecutionMode ?? RpcRemoteExecutionMode.Default
     });
   }
   return { name, methods: map };
@@ -649,14 +664,17 @@ var RpcOutboundCall = class {
   callId;
   method;
   result = new import_core3.PromiseSource();
+  /** Bitfield of RpcRemoteExecutionMode flags controlling reconnect/resend behavior. */
+  remoteExecutionMode;
   /** Whether to remove this call from the tracker on $sys.Ok. Default: true.
    *  Subclasses (e.g. compute calls) override to false to stay in tracker for invalidation. */
   removeOnOk = true;
   /** The serialized wire data — stored for re-sending on reconnect. */
   serializedWireData = "";
-  constructor(callId, method) {
+  constructor(callId, method, remoteExecutionMode = 7) {
     this.callId = callId;
     this.method = method;
+    this.remoteExecutionMode = remoteExecutionMode;
   }
   /** Called when the connection is lost. Subclasses can override to resolve invalidation promises. */
   onDisconnect() {
@@ -769,6 +787,8 @@ var RpcStreamSender = class _RpcStreamSender {
   _lastAckedIndex = 0;
   _ackWaiting = null;
   _resetRequested = false;
+  _abortController = new AbortController();
+  _iterator = null;
   constructor(peer, ackPeriod = DEFAULT_ACK_PERIOD, ackAdvance = DEFAULT_ACK_ADVANCE, allowReconnect = true, isRealTime = false, canSkipTo = () => true) {
     const localId = peer.sharedObjects.nextId();
     this.id = { hostId: peer.hub.hubId, localId };
@@ -779,6 +799,10 @@ var RpcStreamSender = class _RpcStreamSender {
     this.ackPeriod = ackPeriod;
     this.ackAdvance = ackAdvance;
   }
+  /** AbortSignal that is aborted when the sender is disconnected. */
+  get abortSignal() {
+    return this._abortController.signal;
+  }
   /** Returns the stream reference string for the $sys.Ok response. */
   toRef() {
     return `${this.id.hostId},${this.id.localId},${this.ackPeriod},${this.ackAdvance},${this.allowReconnect ? "1" : "0"},${this.isRealTime ? "1" : "0"}`;
@@ -805,8 +829,7 @@ var RpcStreamSender = class _RpcStreamSender {
   }
   /** Called by system call handler when $sys.AckEnd is received from the client. */
   onAckEnd(_hostId) {
-    this._ended = true;
-    this.peer.sharedObjects.unregister(this);
+    this.disconnect();
   }
   /** Send a single item to the client. */
   sendItem(item) {
@@ -863,6 +886,7 @@ var RpcStreamSender = class _RpcStreamSender {
   async writeFrom(source) {
     await this._started.promise;
     const iterator = source[Symbol.asyncIterator]();
+    this._iterator = iterator;
     try {
       for (; ; ) {
         const next = await iterator.next();
@@ -927,10 +951,20 @@ var RpcStreamSender = class _RpcStreamSender {
   reconnect() {
   }
   disconnect() {
+    if (this._ended) return;
     this._ended = true;
+    this._abortController.abort();
     if (!this._started.isCompleted) {
       this._started.resolve();
     }
+    if (this._ackWaiting) {
+      this._ackWaiting.resolve();
+      this._ackWaiting = null;
+    }
+    if (this._iterator) {
+      void this._iterator.return?.(void 0);
+      this._iterator = null;
+    }
     this.peer.sharedObjects.unregister(this);
   }
 };
@@ -995,7 +1029,7 @@ var RpcStream = class _RpcStream {
   _iterating = false;
   _ackSentUpTo = 0;
   constructor(sourceOrRef, optionsOrPeer) {
-    if (_isAsyncIterable(sourceOrRef)) {
+    if (_isStreamSource(sourceOrRef)) {
       const options = optionsOrPeer ?? {};
       this.kind = RpcObjectKind.Local;
       this.localSource = sourceOrRef;
@@ -1056,7 +1090,8 @@ var RpcStream = class _RpcStream {
     );
     peer.sharedObjects.register(sender);
     this._sender = sender;
-    this._whenSent = sender.writeFrom(this.localSource);
+    const source = typeof this.localSource === "function" ? this.localSource(sender.abortSignal) : this.localSource;
+    this._whenSent = sender.writeFrom(source);
     this._toRefValue = peer.format.isBinary ? {
       SerializedId: [sender.id.hostId, sender.id.localId],
       AckPeriod: sender.ackPeriod,
@@ -1136,7 +1171,10 @@ var RpcStream = class _RpcStream {
     }
   }
   disconnect() {
-    if (this.kind === RpcObjectKind.Local) return;
+    if (this.kind === RpcObjectKind.Local) {
+      this._sender?.disconnect();
+      return;
+    }
     if (this._completed) return;
     this._completed = true;
     this._completionError = new Error("Peer disconnected.");
@@ -1145,7 +1183,8 @@ var RpcStream = class _RpcStream {
   // -- AsyncIterable --
   [Symbol.asyncIterator]() {
     if (this.kind === RpcObjectKind.Local) {
-      return this.localSource[Symbol.asyncIterator]();
+      const source = typeof this.localSource === "function" ? this.localSource(new AbortController().signal) : this.localSource;
+      return source[Symbol.asyncIterator]();
     }
     if (this._iterating)
       throw new Error("RpcStream can only be iterated once.");
@@ -1226,7 +1265,8 @@ var RpcStream = class _RpcStream {
     }
   }
 };
-function _isAsyncIterable(value) {
+function _isStreamSource(value) {
+  if (typeof value === "function") return true;
   return value !== null && typeof value === "object" && Symbol.asyncIterator in value;
 }
 function resolveStreamRefs(value, peer) {
@@ -1761,7 +1801,7 @@ var RpcPeer = class {
   }
   call(method, args, options) {
     const callId = this.outbound.nextId();
-    const outboundCall = options?.outboundCallFactory ? options.outboundCallFactory(callId, method) : new RpcOutboundCall(callId, method);
+    const outboundCall = options?.outboundCallFactory ? options.outboundCallFactory(callId, method) : new RpcOutboundCall(callId, method, options?.remoteExecutionMode ?? 7);
     const envelope = {
       Method: method,
       RelatedId: callId,
@@ -2098,7 +2138,18 @@ var RpcClientPeer = class extends RpcPeer {
     }
     const trackerCalls = [...this.outbound.values()];
     for (const call of trackerCalls) {
-      if (!call.removeOnOk && call.result.isCompleted) {
+      const mode = call.remoteExecutionMode;
+      if (!(mode & 2)) {
+        if (!call.result.isCompleted)
+          call.result.reject(new Error("Outbound call failed: disconnected and AllowReconnect is not set."));
+        call.onDisconnect();
+        this.outbound.remove(call.callId);
+      } else if (_isPeerChanged && !(mode & 4)) {
+        if (!call.result.isCompleted)
+          call.result.reject(new Error("Outbound call failed: reconnected to a different peer and AllowResend is not set."));
+        call.onDisconnect();
+        this.outbound.remove(call.callId);
+      } else if (!call.removeOnOk && call.result.isCompleted) {
         call.onDisconnect();
         this.outbound.remove(call.callId);
       } else {
@@ -2122,6 +2173,9 @@ var RpcServerPeer = class extends RpcPeer {
   /** Accept an incoming connection — sets up message handling and handshake response. */
   accept(conn) {
     this.setupConnection(conn);
+    conn.closed.add(() => {
+      this.sharedObjects.disconnectAll();
+    });
   }
   _onHandshakeReceived(_handshake) {
     if (this._connection !== void 0) {
@@ -2201,7 +2255,8 @@ function rpcMethod(options) {
     methods[methodName] = {
       ...methods[methodName],
       argCount: target.length,
-      returns: options?.returns
+      returns: options?.returns,
+      remoteExecutionMode: options?.remoteExecutionMode
     };
     return target;
   };
@@ -2816,7 +2871,8 @@ var RpcHub = class {
     const methods = /* @__PURE__ */ new Map();
     for (const [name, byArgCount] of overloads) {
       if (byArgCount.size === 1) {
-        methods.set(name, byArgCount.values().next().value);
+        const [[, singleFn]] = byArgCount;
+        methods.set(name, singleFn);
       } else {
         methods.set(name, (...args) => {
           const fn = byArgCount.get(args.length);
@@ -2846,6 +2902,7 @@ var RpcHub = class {
     for (const [name, meta] of Object.entries(methodsMeta)) {
       const wireArgCount = meta.argCount + 1;
       const mapKey = `${name}:${wireArgCount}`;
+      const isNoWait = meta.returns === RpcType.noWait;
       methods.set(mapKey, {
         name,
         serviceName: svcMeta.name,
@@ -2853,7 +2910,8 @@ var RpcHub = class {
         wireArgCount,
         callTypeId: 0,
         stream: meta.returns === RpcType.stream,
-        noWait: meta.returns === RpcType.noWait
+        noWait: isNoWait,
+        remoteExecutionMode: isNoWait ? 0 : meta.remoteExecutionMode ?? RpcRemoteExecutionMode.Default
       });
     }
     return { name: svcMeta.name, methods };
@@ -2871,6 +2929,8 @@ var RpcHub = class {
   /** Create a client method for the given methodDef. Override in FusionHub for custom call types. */
   _createClientMethod(peer, methodDef) {
     const wireName = wireMethodName(methodDef);
+    const mode = methodDef.remoteExecutionMode;
+    const mustCheckConnection = !(mode & RpcRemoteExecutionMode.AwaitForConnection);
     if (methodDef.noWait) {
       return (...args) => {
         const callArgs = args.slice(0, methodDef.argCount);
@@ -2879,6 +2939,8 @@ var RpcHub = class {
     }
     if (methodDef.stream) {
       return async (...args) => {
+        if (mustCheckConnection && !peer.isConnected)
+          throw new Error("Outbound call failed: not connected and AwaitForConnection is not set.");
         const callArgs = args.slice(0, methodDef.argCount);
         const outboundCall = peer.call(wireName, callArgs);
         const result = await outboundCall.result.promise;
@@ -2892,8 +2954,10 @@ var RpcHub = class {
         return stream;
       };
     }
-    const callOptions = methodDef.callTypeId !== 0 ? { callTypeId: methodDef.callTypeId } : void 0;
+    const callOptions = methodDef.callTypeId !== 0 || mode !== RpcRemoteExecutionMode.Default ? { callTypeId: methodDef.callTypeId, remoteExecutionMode: mode } : void 0;
     return async (...args) => {
+      if (mustCheckConnection && !peer.isConnected)
+        throw new Error("Outbound call failed: not connected and AwaitForConnection is not set.");
       const callArgs = args.slice(0, methodDef.argCount);
       const outboundCall = peer.call(wireName, callArgs, callOptions);
       const result = await outboundCall.result.promise;
@@ -2916,7 +2980,7 @@ function createRpcClient(peer, serviceDef) {
   const methods = /* @__PURE__ */ new Map();
   for (const [name, byArgCount] of overloads) {
     if (byArgCount.size === 1) {
-      const methodDef = byArgCount.values().next().value;
+      const [[, methodDef]] = byArgCount;
       methods.set(name, createMethod(peer, methodDef));
     } else {
       const fns = /* @__PURE__ */ new Map();
@@ -2941,10 +3005,14 @@ function createRpcClient(peer, serviceDef) {
   });
 }
 function createMethod(peer, methodDef) {
+  const mode = methodDef.remoteExecutionMode;
+  const mustCheckConnection = !(mode & RpcRemoteExecutionMode.AwaitForConnection);
   return async (...args) => {
+    if (mustCheckConnection && !peer.isConnected)
+      throw new Error("Outbound call failed: not connected and AwaitForConnection is not set.");
     const callArgs = args.slice(0, methodDef.argCount);
     const wireName = wireMethodName(methodDef);
-    const options = methodDef.callTypeId !== 0 ? { callTypeId: methodDef.callTypeId } : void 0;
+    const options = methodDef.callTypeId !== 0 || mode !== RpcRemoteExecutionMode.Default ? { callTypeId: methodDef.callTypeId, remoteExecutionMode: mode } : void 0;
     const outboundCall = peer.call(wireName, callArgs, options);
     return outboundCall.result.promise;
   };
@@ -3159,6 +3227,7 @@ var RpcPeerStateMonitor = class {
   RpcPeerConnectionKind,
   RpcPeerStateKind,
   RpcPeerStateMonitor,
+  RpcRemoteExecutionMode,
   RpcRemoteObjectTracker,
   RpcSerializationFormat,
   RpcSerializationFormatResolver,