@vrtmrz/livesync-commonlib 0.1.19 → 0.1.21

package/dist/replication/trystero/types.js

@@ -14,6 +14,9 @@ var DeviceDecisions = /* @__PURE__ */ ((DeviceDecisions2) => {
   return DeviceDecisions2;
 })(DeviceDecisions || {});
 const ID_P2PKnownDevices = "_local/P2PKnownDevices";
+function resolveCurrentP2PSettings(env) {
+  return env.currentSettings?.() ?? env.settings;
+}
 const KEY_DEVICE_DECISIONS = "p2p-device-decisions";
 export {
   BULK_GET_RPC_TIMEOUT,
@@ -23,5 +26,6 @@ export {
   DeviceDecisions,
   ID_P2PKnownDevices,
   KEY_DEVICE_DECISIONS,
-  ResponsePreventedError
+  ResponsePreventedError,
+  resolveCurrentP2PSettings
 };

package/dist/replication/trystero/useP2PReplicatorCommands.d.ts

@@ -1,7 +1,7 @@
 import type { NecessaryServices } from "../../interfaces/ServiceModule.js";
-import type { UseP2PReplicatorResult } from "./UseP2PReplicatorResult.js";
+import type { P2PServiceViews } from "../../p2p/P2PService.js";
 /**
- * ServiceFeature: Registers event handlers for P2P replication and manages the lifecycle of a LiveSyncTrysteroReplicator instance.
+ * Register manual transport commands against the focused lifecycle view.
  * @param host
  */
-export declare function useP2PReplicatorCommands(host: NecessaryServices<"API" | "setting", never>, result: UseP2PReplicatorResult): void;
+export declare function useP2PReplicatorCommands(host: NecessaryServices<"API" | "setting", never>, result: Pick<P2PServiceViews, "transportLifecycle">): void;

package/dist/replication/trystero/useP2PReplicatorCommands.js

@@ -4,21 +4,19 @@ function useP2PReplicatorCommands(host, result) {
     id: "p2p-establish-connection",
     name: "P2P Sync : Connect to the Signalling Server",
     checkCallback: (isChecking) => {
-      const replicator = result.replicator;
-      if (!replicator) return false;
-      if (isChecking) return !(replicator.server?.isServing ?? false);
-      void replicator.open();
+      const lifecycle = result.transportLifecycle;
+      if (isChecking) return !lifecycle.isConnected;
+      void lifecycle.connect();
     }
   });
   host.services.API.addCommand({
     id: "p2p-close-connection",
     name: "P2P Sync : Disconnect from the Signalling Server",
     checkCallback: (isChecking) => {
-      const replicator = result.replicator;
-      if (!replicator) return false;
-      if (isChecking) return replicator.server?.isServing ?? false;
+      const lifecycle = result.transportLifecycle;
+      if (isChecking) return lifecycle.isConnected;
       Logger("Closing P2P Connection", LOG_LEVEL_NOTICE);
-      void replicator.close();
+      void lifecycle.disconnect();
     }
   });
 }

package/dist/replication/trystero/useP2PReplicatorFeature.d.ts

@@ -1,17 +1,26 @@
 import type { NecessaryServices } from "../../interfaces/ServiceModule.js";
-import { LiveSyncTrysteroReplicator } from "./LiveSyncTrysteroReplicator.js";
+import type { LiveSyncTrysteroReplicator } from "./LiveSyncTrysteroReplicator.js";
 import { type UseP2PReplicatorResult } from "./UseP2PReplicatorResult.js";
+import { type P2PServiceViews } from "../../p2p/P2PService.js";
 /**
- * Factory type: given a replicator instance, returns the openReplicationUI callback for that instance.
- * Injected by the host platform (e.g. Obsidian). CLI/headless environments omit this.
+ * Factory type: given the compatibility Replicator and the stable service
+ * views, returns the openReplicationUI callback for that instance.
+ *
+ * The Replicator remains available for rebuild-specific compatibility work;
+ * modal lifecycle, status, and ordinary actions should use the narrow views.
+ * Injected by the host platform (for example, Obsidian). CLI and headless
+ * environments omit this.
  */
-export type OpenReplicationUIFactory = (replicator: LiveSyncTrysteroReplicator) => (showResult: boolean) => Promise<boolean | void>;
+export type OpenReplicationUIFactory = (replicator: LiveSyncTrysteroReplicator, p2p: P2PServiceViews) => (showResult: boolean) => Promise<boolean | void>;
 /** Same shape as OpenReplicationUIFactory, used for the rebuild/replicateAllFromServer flow. */
 export type OpenRebuildUIFactory = OpenReplicationUIFactory;
 /**
- * ServiceFeature: P2P Replicator integration and lifecycle management.
- * Registers a LiveSyncTrysteroReplicator instance as the active replicator when P2P is enabled in settings,
- * and binds it to lifecycle events for proper initialization and cleanup.
+ * Compose one private P2P service context and register non-owning active
+ * provider adapters over it.
+ *
+ * The returned views remain valid for the host composition lifetime. The
+ * compatibility facade is retained only for consumers which have not yet
+ * migrated to those views.
  * @param host
  */
 export declare function useP2PReplicatorFeature(host: NecessaryServices<"API" | "appLifecycle" | "setting" | "vault" | "database" | "databaseEvents" | "keyValueDB" | "replication" | "config" | "UI" | "replicator" | "remote", never>, openReplicationUIFactory?: OpenReplicationUIFactory, openRebuildUIFactory?: OpenRebuildUIFactory): UseP2PReplicatorResult;

package/dist/replication/trystero/useP2PReplicatorFeature.js

@@ -1,76 +1,94 @@
-import { Logger, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
 import { AutoAccepting, REMOTE_P2P } from "../../common/types.js";
-import { LiveSyncTrysteroReplicator } from "./LiveSyncTrysteroReplicator.js";
 import {} from "./UseP2PReplicatorResult.js";
 import { addP2PEventHandlers } from "./addP2PEventHandlers.js";
-import { compatGlobal } from "../../common/coreEnvFunctions.js";
+import { createP2PService } from "../../p2p/P2PService.js";
+import {
+  CAPABILITY_NOT_APPLICABLE,
+  NO_REMOTE_RESOURCE_CAPABILITIES,
+  PEER_REPLICATION_READINESS,
+  REPLICATION_PROGRESS_PRESENTATIONS,
+  defineReplicatorProviderDefinitions,
+  outcomeFromFiniteOpenReplication,
+  replicationBlocked,
+  replicationFailed,
+  supportedCapability,
+  supportedStopActiveTransfer
+} from "../index.js";
+import { getP2PReplicatorConfigurationIdentity } from "./p2pReplicatorConfigurationIdentity.js";
 function useP2PReplicatorFeature(host, openReplicationUIFactory, openRebuildUIFactory) {
-  let replicator = new LiveSyncTrysteroReplicator({
+  const service = createP2PService({
     services: host.services
   });
-  let replacementPromise;
-  if (openReplicationUIFactory) {
-    replicator.env.openReplicationUI = openReplicationUIFactory(replicator);
-  }
-  if (openRebuildUIFactory) {
-    replicator.env.openRebuildUI = openRebuildUIFactory(replicator);
-  }
-  const activeReplicator = {
-    get replicator() {
-      return replicator;
+  const replicator = service.compatibilityReplicator;
+  const { views, lifecycle } = service;
+  const configureReplicator = (instance) => {
+    if (openReplicationUIFactory) {
+      instance.env.openReplicationUI = openReplicationUIFactory(instance, views);
+    }
+    if (openRebuildUIFactory) {
+      instance.env.openRebuildUI = openRebuildUIFactory(instance, views);
     }
   };
-  addP2PEventHandlers(() => activeReplicator.replicator, host.services.context.events);
-  host.services.replicator.getNewReplicator.addHandler(
-    async (settingOverride = {}) => {
-      const settings = { ...host.services.setting.currentSettings(), ...settingOverride };
-      if (settings.remoteType == REMOTE_P2P) {
-        if (replacementPromise) return await replacementPromise;
-        const operation = (async () => {
-          const existingReplicator = replicator;
-          try {
-            await existingReplicator?.close();
-          } catch (e) {
-            Logger(`Error closing existing p2p replicator`);
-            Logger(e, LOG_LEVEL_VERBOSE);
-          }
-          const newReplicator = new LiveSyncTrysteroReplicator({ services: host.services });
-          if (openReplicationUIFactory) {
-            newReplicator.env.openReplicationUI = openReplicationUIFactory(newReplicator);
-          }
-          if (openRebuildUIFactory) {
-            newReplicator.env.openRebuildUI = openRebuildUIFactory(newReplicator);
-          }
-          replicator = newReplicator;
-          return replicator;
-        })();
-        replacementPromise = operation;
-        try {
-          return await operation;
-        } finally {
-          if (replacementPromise === operation) replacementPromise = void 0;
-        }
-      }
-      return void 0;
+  configureReplicator(replicator);
+  const createP2PReplicator = async () => service.createActiveReplicator();
+  const userInitiatedOneShot = async (instance, setting, request) => {
+    if (request.interaction.kind !== "permitted" || !request.interaction.permissions.peerSelection) {
+      return replicationBlocked("interaction-required");
+    }
+    try {
+      const result = await instance.openReplication(
+        setting,
+        false,
+        request.progressPresentation === REPLICATION_PROGRESS_PRESENTATIONS.NOTICE,
+        false
+      );
+      return outcomeFromFiniteOpenReplication(result);
+    } catch (error) {
+      return replicationFailed(error);
+    }
+  };
+  const unattendedOneShot = async (_instance, _setting, request) => {
+    if (request.interaction.kind !== "forbidden") {
+      return replicationBlocked("interaction-required");
     }
+    return await views.targetedTransfer.synchroniseConfiguredTargets();
+  };
+  host.services.replicator.registerReplicatorProviderDefinitions(
+    defineReplicatorProviderDefinitions([REMOTE_P2P], {
+      [REMOTE_P2P]: {
+        kind: REMOTE_P2P,
+        diagnosticName: "P2P",
+        readiness: PEER_REPLICATION_READINESS,
+        isConfigured: (settings) => settings.remoteType === REMOTE_P2P && settings.P2P_Enabled,
+        configurationIdentity: getP2PReplicatorConfigurationIdentity,
+        create: createP2PReplicator,
+        remoteResources: NO_REMOTE_RESOURCE_CAPABILITIES,
+        userInitiatedOneShot: supportedCapability(userInitiatedOneShot),
+        unattendedOneShot: supportedCapability(unattendedOneShot),
+        continuous: CAPABILITY_NOT_APPLICABLE,
+        stopActiveTransfer: supportedStopActiveTransfer()
+      }
+    })
   );
+  const activeReplicator = { replicator, ...views };
+  addP2PEventHandlers(lifecycle, host.services.context.events);
   host.services.appLifecycle.onUnload.addHandler(async () => {
-    await replicator?.close();
+    await lifecycle.closeForLifecycle();
     return true;
   });
   host.services.appLifecycle.onSuspending.addHandler(async () => {
-    await replicator?.close();
+    await lifecycle.closeForLifecycle();
     return true;
   });
-  host.services.databaseEvents.onDatabaseInitialisation.addHandler(async () => {
-    await replicator?.close();
+  const closeForDatabaseLifecycle = async () => {
+    await lifecycle.closeForLifecycle();
     return true;
-  });
+  };
+  host.services.databaseEvents.onResetDatabase.addHandler(closeForDatabaseLifecycle);
+  host.services.databaseEvents.onCloseDatabase.addHandler(closeForDatabaseLifecycle);
+  host.services.databaseEvents.onDatabaseInitialisation.addHandler(closeForDatabaseLifecycle);
   host.services.appLifecycle.onResumed.addHandler(() => {
-    const settings = host.services.setting.currentSettings();
-    if (settings.P2P_Enabled && settings.P2P_AutoStart) {
-      compatGlobal.setTimeout(() => void replicator?.open(), 100);
-    }
+    lifecycle.scheduleAutoStart();
     return Promise.resolve(true);
   });
   host.services.setting.suspendExtraSync.addHandler(() => {

package/dist/rpc/RpcRoom.d.ts

@@ -1,5 +1,5 @@
 import { RpcSession } from "./RpcSession.js";
-import { type JsonLike, type RpcMethodHandler, type RpcRegisterOptions, type RpcRoomOptions } from "./types.js";
+import { type JsonLike, type RpcCallOptions, type RpcCancellationAwareMethodHandler, type RpcMethodHandler, type RpcRegisterOptions, type RpcRoomOptions } from "./types.js";
 export declare class RpcRoom {
     private options;
     private pending;
@@ -11,12 +11,26 @@ export declare class RpcRoom {
     private incomingChunkTimers;
     private peerVersion;
     private disposers;
+    private closed;
     constructor(options: RpcRoomOptions);
     close(): void;
     session(peerId: string): RpcSession;
     register<T extends JsonLike[], U>(method: string, handler: RpcMethodHandler<T, U>, options?: RpcRegisterOptions): void;
+    /**
+     * Register a handler which receives an AbortSignal for cooperative
+     * cancellation. The original `register` API deliberately remains
+     * unchanged for handlers which do not need request context.
+     */
+    registerCancellable<T extends JsonLike[], U>(method: string, handler: RpcCancellationAwareMethodHandler<T, U>, options?: RpcRegisterOptions): void;
+    private registerMethod;
     invoke(peerId: string, method: string, args: JsonLike[], timeoutMs?: number): Promise<JsonLike>;
+    invoke(peerId: string, method: string, args: JsonLike[], options?: RpcCallOptions): Promise<JsonLike>;
+    invoke(peerId: string, method: string, args: JsonLike[], timeoutOrOptions?: number | RpcCallOptions): Promise<JsonLike>;
     cancel(peerId: string, requestId: string): Promise<void>;
+    private removePending;
+    private rejectPending;
+    private notifyRemoteCancellation;
+    private abortInboundCall;
     private sendEnvelope;
     private scheduleMissingAck;
     private onWireMessage;

package/dist/rpc/RpcRoom.js

@@ -24,6 +24,7 @@ class RpcRoom {
   incomingChunkTimers = /* @__PURE__ */ new Map();
   peerVersion = /* @__PURE__ */ new Map();
   disposers = [];
+  closed = false;
   constructor(options) {
     this.options = {
       maxWirePayloadBytes: options.maxWirePayloadBytes ?? 32 * 1024,
@@ -49,6 +50,18 @@ class RpcRoom {
     if (this.options.transport.onPeerLeave) {
       this.disposers.push(
         this.options.transport.onPeerLeave((peerId) => {
+          this.pending.forEach((pending, requestId) => {
+            if (pending.peerId !== peerId) return;
+            this.rejectPending(requestId, new RpcError("NOT_CONNECTED", "Peer disconnected"));
+          });
+          this.inboundCalls.forEach((context, requestId) => {
+            if (context.peerId !== peerId) return;
+            this.abortInboundCall(requestId, context);
+            this.inboundCalls.delete(requestId);
+          });
+          this.outgoingChunkMap.forEach((state, streamId) => {
+            if (state.peerId === peerId) this.outgoingChunkMap.delete(streamId);
+          });
           this.sessions.delete(peerId);
           this.peerVersion.delete(peerId);
         })
@@ -56,9 +69,15 @@ class RpcRoom {
     }
   }
   close() {
+    if (this.closed) return;
+    this.closed = true;
     this.disposers.splice(0).forEach((dispose) => dispose());
-    this.pending.forEach((pending) => pending.reject(new RpcError("NOT_CONNECTED", "Room closed")));
-    this.pending.clear();
+    this.pending.forEach((_pending, requestId) => {
+      this.rejectPending(requestId, new RpcError("NOT_CONNECTED", "Room closed"), true);
+    });
+    this.inboundCalls.forEach((context, requestId) => {
+      this.abortInboundCall(requestId, context);
+    });
     this.inboundCalls.clear();
     this.methods.clear();
     this.sessions.clear();
@@ -75,44 +94,131 @@ class RpcRoom {
     return s;
   }
   register(method, handler, options = {}) {
+    this.registerMethod(method, handler, false, options);
+  }
+  registerCancellable(method, handler, options = {}) {
+    this.registerMethod(method, handler, true, options);
+  }
+  registerMethod(method, handler, cancellationAware, options) {
     if (!validNamespacedMethod(method)) {
       throw new RpcError("PROTOCOL_ERROR", `Method must be namespaced: ${method}`);
     }
     this.methods.set(method, {
       handler,
+      cancellationAware,
       serial: options.serial ?? false,
       queue: Promise.resolve()
     });
   }
-  async invoke(peerId, method, args, timeoutMs = 3e4) {
+  async invoke(peerId, method, args, timeoutOrOptions = 3e4) {
     if (!validNamespacedMethod(method)) {
       throw new RpcError("PROTOCOL_ERROR", `Method must be namespaced: ${method}`);
     }
+    if (this.closed) {
+      throw new RpcError("NOT_CONNECTED", "Room is closed");
+    }
+    const options = typeof timeoutOrOptions === "number" ? { timeoutMs: timeoutOrOptions } : timeoutOrOptions ?? {};
+    const timeoutMs = options.timeoutMs ?? 3e4;
+    if (options.signal?.aborted) {
+      throw new RpcError("CANCELLED", `RPC cancelled: ${method}`);
+    }
     const requestId = newId("req");
+    let pending;
     const p = new Promise((resolve, reject) => {
-      const pending = { resolve, reject };
+      pending = {
+        peerId,
+        method,
+        resolve,
+        reject,
+        signal: options.signal,
+        requestSent: false,
+        cancelRequested: false
+      };
       if (timeoutMs > 0) {
         pending.timeoutHandle = compatGlobal.setTimeout(() => {
-          this.pending.delete(requestId);
-          reject(new RpcError("TIMEOUT", `RPC timed out: ${method}`));
+          this.rejectPending(requestId, new RpcError("TIMEOUT", `RPC timed out: ${method}`), true);
         }, timeoutMs);
       }
       this.pending.set(requestId, pending);
+      if (options.signal) {
+        const onAbort = () => {
+          const current = this.pending.get(requestId);
+          if (!current) return;
+          this.rejectPending(requestId, new RpcError("CANCELLED", `RPC cancelled: ${method}`), true);
+        };
+        pending.abortListener = onAbort;
+        options.signal.addEventListener("abort", onAbort, { once: true });
+        if (options.signal.aborted) onAbort();
+      }
     });
-    await this.sendEnvelope(peerId, {
+    const sendTask = this.sendEnvelope(peerId, {
       kind: "request",
       requestId,
       method,
       args
     });
+    void sendTask.then(
+      () => {
+        const current = this.pending.get(requestId);
+        pending.requestSent = true;
+        if (!current && pending.cancelRequested) {
+          this.notifyRemoteCancellation(peerId, requestId);
+        }
+      },
+      (ex) => {
+        const current = this.pending.get(requestId);
+        if (!current) return;
+        const failed = this.removePending(requestId);
+        if (failed) failed.reject(ex);
+      }
+    );
     return await p;
   }
   async cancel(peerId, requestId) {
+    const pending = this.pending.get(requestId);
+    if (pending?.peerId === peerId) {
+      const requestSent = pending.requestSent;
+      pending.cancelRequested = true;
+      this.rejectPending(requestId, new RpcError("CANCELLED", "Invocation cancelled"));
+      if (!requestSent) return;
+    }
     await this.sendEnvelope(peerId, {
       kind: "cancel",
       requestId
     });
   }
+  removePending(requestId) {
+    const pending = this.pending.get(requestId);
+    if (!pending) return void 0;
+    this.pending.delete(requestId);
+    if (pending.timeoutHandle !== void 0) {
+      compatGlobal.clearTimeout(pending.timeoutHandle);
+    }
+    if (pending.signal && pending.abortListener) {
+      pending.signal.removeEventListener("abort", pending.abortListener);
+    }
+    return pending;
+  }
+  rejectPending(requestId, error, notifyRemote = false) {
+    const pending = this.pending.get(requestId);
+    if (!pending) return;
+    if (notifyRemote) pending.cancelRequested = true;
+    const removed = this.removePending(requestId);
+    if (!removed) return;
+    removed.reject(error);
+    if (notifyRemote && removed.requestSent) this.notifyRemoteCancellation(removed.peerId, requestId);
+  }
+  notifyRemoteCancellation(peerId, requestId) {
+    void this.sendEnvelope(peerId, { kind: "cancel", requestId }).catch((error) => {
+      this.options.onProtocolWarning?.(`Failed to send RPC cancellation: ${String(error)}`, peerId);
+    });
+  }
+  abortInboundCall(requestId, context) {
+    if (this.inboundCalls.get(requestId) !== context) return;
+    if (!context.signal.aborted) {
+      context.controller.abort(new RpcError("CANCELLED", "Invocation cancelled"));
+    }
+  }
   async sendEnvelope(peerId, envelope) {
     const serialized = JSON.stringify(envelope);
     if (estimateBytes(serialized) <= this.options.maxWirePayloadBytes) {
@@ -214,36 +320,61 @@ class RpcRoom {
     }
     if (envelope.kind === "cancel") {
       const ctx2 = this.inboundCalls.get(envelope.requestId);
-      if (ctx2) ctx2.cancelled = true;
+      if (ctx2 && ctx2.peerId === peerId) this.abortInboundCall(envelope.requestId, ctx2);
       return;
     }
     if (envelope.kind === "response") {
       const pending = this.pending.get(envelope.requestId);
       if (!pending) return;
-      this.pending.delete(envelope.requestId);
-      if (pending.timeoutHandle) compatGlobal.clearTimeout(pending.timeoutHandle);
+      const settled = this.removePending(envelope.requestId);
+      if (!settled) return;
       if (envelope.ok === true) {
-        pending.resolve(envelope.data);
+        settled.resolve(envelope.data);
       } else {
-        pending.reject(new RpcError(envelope.error.code, envelope.error.message, envelope.error.details));
+        settled.reject(new RpcError(envelope.error.code, envelope.error.message, envelope.error.details));
+      }
+      return;
+    }
+    const controller = new AbortController();
+    const ctx = { controller, signal: controller.signal, peerId };
+    this.inboundCalls.set(envelope.requestId, ctx);
+    let accepted;
+    try {
+      accepted = await this.options.canAcceptRequest?.(peerId, envelope.method, ctx);
+    } catch (ex) {
+      this.inboundCalls.delete(envelope.requestId);
+      if (!ctx.signal.aborted && !this.closed) {
+        await this.sendEnvelope(peerId, {
+          kind: "response",
+          requestId: envelope.requestId,
+          ok: false,
+          error: asRpcErrorShape(ex)
+        });
       }
       return;
     }
-    const accepted = await this.options.canAcceptRequest?.(peerId, envelope.method);
     if (accepted === false) {
+      this.inboundCalls.delete(envelope.requestId);
+      return;
+    }
+    if (ctx.signal.aborted || this.closed) {
+      this.inboundCalls.delete(envelope.requestId);
       return;
     }
     const version = this.peerVersion.get(peerId);
     if (version && version.major !== RPC_VERSION_MAJOR) {
-      await this.sendEnvelope(peerId, {
-        kind: "response",
-        requestId: envelope.requestId,
-        ok: false,
-        error: {
-          code: "REMOTE_ERROR",
-          message: `RPC major mismatch: local=${RPC_VERSION_MAJOR}, remote=${version.major}`
-        }
-      });
+      if (!ctx.signal.aborted && !this.closed) {
+        await this.sendEnvelope(peerId, {
+          kind: "response",
+          requestId: envelope.requestId,
+          ok: false,
+          error: {
+            code: "REMOTE_ERROR",
+            message: `RPC major mismatch: local=${RPC_VERSION_MAJOR}, remote=${version.major}`
+          }
+        });
+      }
+      this.inboundCalls.delete(envelope.requestId);
       return;
     }
     if (version && version.minor !== RPC_VERSION_MINOR) {
@@ -254,28 +385,29 @@ class RpcRoom {
     }
     const method = this.methods.get(envelope.method);
     if (!method) {
-      await this.sendEnvelope(peerId, {
-        kind: "response",
-        requestId: envelope.requestId,
-        ok: false,
-        error: {
-          code: "REMOTE_ERROR",
-          message: `Method not found: ${envelope.method}`
-        }
-      });
+      if (!ctx.signal.aborted && !this.closed) {
+        await this.sendEnvelope(peerId, {
+          kind: "response",
+          requestId: envelope.requestId,
+          ok: false,
+          error: {
+            code: "REMOTE_ERROR",
+            message: `Method not found: ${envelope.method}`
+          }
+        });
+      }
+      this.inboundCalls.delete(envelope.requestId);
       return;
     }
-    const ctx = { cancelled: false };
-    this.inboundCalls.set(envelope.requestId, ctx);
     const runner = async () => {
       try {
-        if (ctx.cancelled) {
-          throw new RpcError("CANCELLED", "Invocation cancelled");
-        }
-        const data = await method.handler(peerId, ...envelope.args);
-        if (ctx.cancelled) {
-          throw new RpcError("CANCELLED", "Invocation cancelled");
-        }
+        if (ctx.signal.aborted || this.closed) return;
+        const data = method.cancellationAware ? await method.handler(
+          ctx,
+          peerId,
+          ...envelope.args
+        ) : await method.handler(peerId, ...envelope.args);
+        if (ctx.signal.aborted || this.closed) return;
         await this.sendEnvelope(peerId, {
           kind: "response",
           requestId: envelope.requestId,
@@ -283,6 +415,7 @@ class RpcRoom {
           data
         });
       } catch (ex) {
+        if (ctx.signal.aborted || this.closed) return;
         await this.sendEnvelope(peerId, {
           kind: "response",
           requestId: envelope.requestId,
@@ -290,7 +423,9 @@ class RpcRoom {
           error: asRpcErrorShape(ex)
         });
       } finally {
-        this.inboundCalls.delete(envelope.requestId);
+        if (this.inboundCalls.get(envelope.requestId) === ctx) {
+          this.inboundCalls.delete(envelope.requestId);
+        }
       }
     };
     if (method.serial) {

package/dist/rpc/RpcSession.d.ts

@@ -1,9 +1,11 @@
-import type { JsonLike } from "./types.js";
+import type { JsonLike, RpcCallOptions } from "./types.js";
 import type { RpcRoom } from "./RpcRoom.js";
 export declare class RpcSession {
     readonly peerId: string;
     private room;
     constructor(room: RpcRoom, peerId: string);
     call<T = JsonLike>(method: string, args?: JsonLike[], timeoutMs?: number): Promise<T>;
+    call<T = JsonLike>(method: string, args?: JsonLike[], options?: RpcCallOptions): Promise<T>;
+    call<T = JsonLike>(method: string, args: JsonLike[] | undefined, timeoutOrOptions?: number | RpcCallOptions): Promise<T>;
     createProxy<T extends object>(namespace: string): T;
 }

package/dist/rpc/RpcSession.js

@@ -6,11 +6,11 @@ class RpcSession {
     this.room = room;
     this.peerId = peerId;
   }
-  async call(method, args = [], timeoutMs) {
+  async call(method, args = [], timeoutOrOptions) {
     if (!this.peerId) {
       throw new RpcError("NOT_CONNECTED", "Peer is not connected");
     }
-    return await this.room.invoke(this.peerId, method, args, timeoutMs);
+    return await this.room.invoke(this.peerId, method, args, timeoutOrOptions);
   }
   createProxy(namespace) {
     const session = this;

package/dist/rpc/index.d.ts

@@ -3,4 +3,4 @@ export { RpcSession } from "./RpcSession.js";
 export { RpcError } from "./errors.js";
 export { exposeDB } from "./pouchdb/RpcPouchDBServer.js";
 export { RpcPouchDBProxy } from "./pouchdb/RpcPouchDBProxy.js";
-export type { JsonLike, RpcEnvelope, RpcErrorCode, RpcErrorShape, RpcMethodHandler, RpcRegisterOptions, RpcRoomOptions, RpcWireMessage, TransportAdapter, } from "./types.js";
+export type { JsonLike, RpcEnvelope, RpcErrorCode, RpcErrorShape, RpcCallOptions, RpcCancellationAwareMethodHandler, RpcMethodHandler, RpcRegisterOptions, RpcRequestContext, RpcRoomOptions, RpcWireMessage, TransportAdapter, } from "./types.js";

package/dist/rpc/transports/trysteroUtils.js

@@ -2,6 +2,7 @@ import { P2PConnectionPaths } from "../../common/models/setting.const.js";
 import {
   hasValidP2PTurnServerUrl,
   normaliseP2PConnectionPath,
+  splitP2PRelayUrls,
   splitP2PTurnServerUrls
 } from "../../common/models/setting.p2p.js";
 import { mixedHash } from "octagonal-wheels/hash/purejs";
@@ -10,7 +11,7 @@ import { createDiagRTCPeerConnectionConstructor } from "./DiagRTCPeerConnections
 function generateJoinRoomOptions(settings) {
   const passphraseNumbers = mixedHash(settings.P2P_passphrase, 0);
   const passphrase = passphraseNumbers[0].toString(36) + passphraseNumbers[1].toString(36);
-  const relays = settings.P2P_relays.split(",").map((e) => e.trim()).filter((e) => e.length > 0);
+  const relays = splitP2PRelayUrls(settings.P2P_relays);
   const turnServers = splitP2PTurnServerUrls(settings.P2P_turnServers);
   const relayConfig = {
     manualReconnection: true,