@vrtmrz/livesync-commonlib 0.1.19 → 0.1.20

package/dist/replication/trystero/LiveSyncTrysteroReplicator.js

@@ -3,8 +3,7 @@ import {
   RemotePreferredTweakStatuses,
   LOG_LEVEL_NOTICE,
   LOG_LEVEL_INFO,
-  LOG_LEVEL_VERBOSE,
-  SETTING_KEY_P2P_DEVICE_NAME
+  LOG_LEVEL_VERBOSE
 } from "../../common/types.js";
 import {
   LiveSyncAbstractReplicator
@@ -12,175 +11,75 @@ import {
 import { TrysteroReplicator } from "./TrysteroReplicator.js";
 import {
   EVENT_ADVERTISEMENT_RECEIVED,
-  EVENT_P2P_CONNECTED,
-  P2PHost
+  EVENT_P2P_CONNECTED
 } from "./TrysteroReplicatorP2PServer.js";
 import { delay } from "octagonal-wheels/promises";
-import {
-  hasValidP2PTurnServerUrl,
-  normaliseP2PConnectionPath,
-  normaliseP2PMaxWirePayloadBytes
-} from "../../common/models/setting.p2p.js";
-import { P2PConnectionPaths } from "../../common/models/setting.const.js";
+import { P2PRoomSessionOwner } from "./P2PRoomSessionOwner.js";
 class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
-  _p2pHost;
-  _replicator;
-  _lifecycleOperation = Promise.resolve();
-  _shouldBeOpen = false;
-  _activeTransportCompatibilitySignature;
+  constructor(env, sessionOwner = new P2PRoomSessionOwner(env)) {
+    super(env);
+    this.sessionOwner = sessionOwner;
+    this.env = env;
+  }
+  sessionOwner;
+  /** Peer lifecycle is fenced inside the room session rather than this facade. */
+  handlesPeerEventsWithinSession = true;
   get openReplicationUI() {
     return this.env.openReplicationUI;
   }
   get rawReplicator() {
-    return this._replicator;
+    return this.sessionOwner.currentSession?.replicator;
   }
   get rawHost() {
-    return this._p2pHost;
+    return this.sessionOwner.currentSession?.host;
   }
   getReplicationPBKDF2Salt(_setting, _refresh) {
     return Promise.resolve(new Uint8Array(32));
   }
   terminateSync() {
-  }
-  _buildEnv() {
-    const services = this.env.services;
-    return {
-      events: services.context.events,
-      translate: services.context.translate,
-      get settings() {
-        return services.setting.currentSettings();
-      },
-      get db() {
-        return services.database.localDatabase.localDatabase;
-      },
-      get simpleStore() {
-        return services.keyValueDB.openSimpleStore("p2p-sync");
-      },
-      get deviceName() {
-        return services.config.getSmallConfig(SETTING_KEY_P2P_DEVICE_NAME) || services.vault.getVaultName();
-      },
-      get platform() {
-        return services.API.getPlatform();
-      },
-      get confirm() {
-        return services.API.confirm;
-      },
-      runFiniteReplicationActivity: (task, options) => services.replicator.runFiniteReplicationActivity(task, options),
-      canStartOrdinaryReplication: (showMessage = false) => services.replication.onCheckReplicationReady(showMessage),
-      processReplicatedDocs: async (docs) => {
-        const settings = services.setting.currentSettings();
-        if (settings.suspendParseReplicationResult) {
-          const docLength = docs.length;
-          if (docLength > 0) {
-            Logger(
-              `P2P sync, but parseReplicationResult is suspended. Ignoring ${docLength} documents.`,
-              LOG_LEVEL_VERBOSE
-            );
-          }
-          return;
-        }
-        await services.replication.parseSynchroniseResult(docs);
-      }
-    };
-  }
-  _enqueueLifecycleOperation(operation) {
-    const queued = this._lifecycleOperation.catch(() => void 0).then(operation);
-    this._lifecycleOperation = queued.catch(() => void 0);
-    return queued;
-  }
-  /**
-   * Capture settings which are fixed when the active P2P transport joins its room.
-   * A later open request can remain idempotent only while these effective values match.
-   */
-  _getTransportCompatibilitySignature() {
-    const settings = this.env.services.setting.currentSettings();
-    const configuredPath = normaliseP2PConnectionPath(settings.P2P_connectionPath);
-    const effectivePath = configuredPath === P2PConnectionPaths.Relay && hasValidP2PTurnServerUrl(settings.P2P_turnServers ?? "") ? P2PConnectionPaths.Relay : P2PConnectionPaths.Automatic;
-    return `${normaliseP2PMaxWirePayloadBytes(settings.P2P_maxWirePayloadBytes)}:${effectivePath}`;
-  }
-  /** Close and forget the transport without changing the requested lifecycle state. */
-  async _closeTransport() {
-    if (this._replicator) {
-      this._replicator.disableBroadcastChanges();
-      await this._replicator.close();
-      this._replicator = void 0;
-    }
-    this._p2pHost = void 0;
-    this._activeTransportCompatibilitySignature = void 0;
+    this.sessionOwner.cancelActiveTransfers();
   }
   async open() {
-    if (!this.env.services.setting.currentSettings().P2P_Enabled) {
-      Logger(this.translate("P2P.NotEnabled"), LOG_LEVEL_NOTICE);
-      return;
-    }
-    this._shouldBeOpen = true;
-    await this._enqueueLifecycleOperation(async () => {
-      if (!this._shouldBeOpen) return;
-      const compatibilitySignature = this._getTransportCompatibilitySignature();
-      if (this._replicator && this._p2pHost?.isServing) {
-        if (this._activeTransportCompatibilitySignature === compatibilitySignature) {
-          Logger("P2P replicator is already open.");
-          return;
-        }
-        await this._closeTransport();
-      }
-      try {
-        const env = this._buildEnv();
-        const host = new P2PHost(env);
-        const replicator = new TrysteroReplicator(env, host);
-        this._p2pHost = host;
-        this._replicator = replicator;
-        await replicator.open();
-        this._activeTransportCompatibilitySignature = compatibilitySignature;
-      } catch (e) {
-        Logger(e instanceof Error ? e.message : "Error while opening P2P connection", LOG_LEVEL_NOTICE);
-        Logger(e, LOG_LEVEL_VERBOSE);
-        this._p2pHost = void 0;
-        this._replicator = void 0;
-        this._activeTransportCompatibilitySignature = void 0;
-      }
-    });
+    await this.sessionOwner.open();
   }
   async close() {
-    this._shouldBeOpen = false;
-    await this._enqueueLifecycleOperation(async () => {
-      await this._closeTransport();
-    });
+    await this.sessionOwner.close();
   }
   closeReplication() {
-    this._replicator?.disconnectFromServer();
+    this.sessionOwner.currentSession?.replicator.disconnectFromServer();
   }
   get server() {
-    return this._replicator?.server;
+    return this.sessionOwner.currentSession?.replicator.server;
   }
   get knownAdvertisements() {
-    return this._replicator?.knownAdvertisements ?? [];
+    return this.sessionOwner.currentSession?.replicator.knownAdvertisements ?? [];
   }
   enableBroadcastChanges() {
-    this._replicator?.enableBroadcastChanges();
+    this.sessionOwner.currentSession?.replicator.enableBroadcastChanges();
   }
   disableBroadcastChanges() {
-    this._replicator?.disableBroadcastChanges();
+    this.sessionOwner.currentSession?.replicator.disableBroadcastChanges();
   }
   requestStatus() {
-    this._replicator?.requestStatus();
+    this.sessionOwner.currentSession?.replicator.requestStatus();
   }
   onNewPeer(peer) {
-    return this._replicator?.onNewPeer(peer);
+    return this.sessionOwner.currentSession?.replicator.onNewPeer(peer);
   }
   onPeerLeaved(peerId) {
-    this._replicator?.onPeerLeaved(peerId);
+    this.sessionOwner.currentSession?.replicator.onPeerLeaved(peerId);
   }
   async replicateFromCommand(showResult = false) {
-    const replicator = this._replicator;
-    if (!replicator) return;
-    await this.env.services.replicator.runFiniteReplicationActivity(
+    const replicator = this.sessionOwner.currentSession?.replicator;
+    if (!replicator) return false;
+    const result = await this.env.services.replicator.runFiniteReplicationActivity(
       () => replicator.replicateFromCommand(showResult),
       { label: "replication" }
     );
+    return result.status === "completed";
   }
   async replicateFrom(peerId, showNotice = false, skipOrdinaryReplicationPolicy = false) {
-    const replicator = this._replicator;
+    const replicator = this.sessionOwner.currentSession?.replicator;
     if (!replicator) throw new Error("P2P replicator is not open");
     return await this.env.services.replicator.runFiniteReplicationActivity(
       () => skipOrdinaryReplicationPolicy ? replicator.replicateFrom(peerId, showNotice, false, true) : replicator.replicateFrom(peerId, showNotice),
@@ -188,7 +87,7 @@ class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
     );
   }
   async requestSynchroniseToPeer(peerId) {
-    const replicator = this._replicator;
+    const replicator = this.sessionOwner.currentSession?.replicator;
     if (!replicator) throw new Error("P2P replicator is not open");
     return await this.env.services.replicator.runBoundedRemoteActivity(
       () => replicator.requestSynchroniseToPeer(peerId),
@@ -196,33 +95,35 @@ class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
     );
   }
   async getRemoteConfig(peerId) {
-    if (!this._replicator) throw new Error("P2P replicator is not open");
-    return await this._replicator.getRemoteConfig(peerId);
+    const replicator = this.sessionOwner.currentSession?.replicator;
+    if (!replicator) throw new Error("P2P replicator is not open");
+    return await replicator.getRemoteConfig(peerId);
   }
   watchPeer(peerId) {
-    this._replicator?.watchPeer(peerId);
+    this.sessionOwner.currentSession?.replicator.watchPeer(peerId);
   }
   unwatchPeer(peerId) {
-    this._replicator?.unwatchPeer(peerId);
+    this.sessionOwner.currentSession?.replicator.unwatchPeer(peerId);
   }
   async sync(peerId, showNotice = false) {
-    if (!this._replicator) throw new Error("P2P replicator is not open");
-    return await this._replicator.sync(peerId, showNotice);
+    const replicator = this.sessionOwner.currentSession?.replicator;
+    if (!replicator) throw new Error("P2P replicator is not open");
+    return await replicator.sync(peerId, showNotice);
   }
   setOnSetup() {
-    this._replicator?.setOnSetup();
+    this.sessionOwner.currentSession?.replicator.setOnSetup();
   }
   clearOnSetup() {
-    this._replicator?.clearOnSetup();
+    this.sessionOwner.currentSession?.replicator.clearOnSetup();
   }
   async makeDecision(decision) {
-    await this._replicator?.server?.makeDecision(decision);
+    await this.sessionOwner.currentSession?.replicator.server?.makeDecision(decision);
   }
   async revokeDecision(decision) {
-    await this._replicator?.server?.revokeDecision(decision);
+    await this.sessionOwner.currentSession?.replicator.server?.revokeDecision(decision);
   }
   async makeSureOpened() {
-    if (!this._replicator || !this._p2pHost?.isServing) {
+    if (!this.sessionOwner.isConnected) {
       await this.open();
     }
   }
@@ -232,11 +133,13 @@ class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
     }
     const logLevel = showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO;
     await this.makeSureOpened();
-    if (!this._replicator) {
+    const replicator = this.sessionOwner.currentSession?.replicator;
+    if (!replicator) {
       Logger(this.translate("P2P.ReplicatorInstanceMissing"), logLevel);
       return false;
     }
-    await this._replicator.replicateFromCommand(showResult);
+    const result = await replicator.replicateFromCommand(showResult);
+    return result.status === "completed";
   }
   tryConnectRemote(_setting, _showResult) {
     return Promise.resolve(false);
@@ -314,7 +217,8 @@ class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
       return this.replicateAllFromServer(setting, showingNotice);
     }
     await this.open();
-    if (!this._replicator) {
+    const replicator = this.sessionOwner.currentSession?.replicator;
+    if (!replicator) {
       Logger("Failed to get replicator instance.", logLevel);
       return false;
     }
@@ -323,12 +227,12 @@ class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
     }
     await this.env.services.context.events.waitFor(EVENT_P2P_CONNECTED);
     const peerFrom = setting.P2P_RebuildFrom;
-    this._replicator.setOnSetup();
+    replicator.setOnSetup();
     try {
       const r = await this.tryUntilSuccess(
         async () => {
           await this.makeSureOpened();
-          return this._replicator ?? false;
+          return this.sessionOwner.currentSession?.replicator ?? false;
         },
         10,
         logLevel
@@ -354,7 +258,7 @@ class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
         return false;
       }
     } finally {
-      this._replicator?.clearOnSetup();
+      this.sessionOwner.currentSession?.replicator.clearOnSetup();
     }
   }
   tryResetRemoteDatabase(_setting) {
@@ -411,10 +315,6 @@ class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
     );
     return Promise.resolve(false);
   }
-  constructor(env) {
-    super(env);
-    this.env = env;
-  }
 }
 export {
   LiveSyncTrysteroReplicator

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

@@ -0,0 +1,20 @@
+import type { P2PReplicationResult } from "./TrysteroReplicator.js";
+/**
+ * Stable de-duplication state for automatic baseline transfers.
+ *
+ * The service owner keeps this object across transport-only room replacement.
+ * Completed baselines are reset only for a new application lifecycle or a
+ * changed logical peer namespace/local database identity. In-flight work from
+ * an older generation may still settle, but cannot publish completion into the
+ * current generation.
+ */
+export declare class P2PAutomationCoordinator {
+    private generation;
+    private identity;
+    private readonly completedPeers;
+    private readonly inFlightPeers;
+    beginLifecycle(): void;
+    reconcileIdentity(namespace: string, database: object): void;
+    runBaseline(peerName: string, task: () => Promise<P2PReplicationResult>): Promise<P2PReplicationResult>;
+    private normalisePeerName;
+}

package/dist/replication/trystero/P2PAutomationCoordinator.js

@@ -0,0 +1,43 @@
+class P2PAutomationCoordinator {
+  generation = 0;
+  identity;
+  completedPeers = /* @__PURE__ */ new Set();
+  inFlightPeers = /* @__PURE__ */ new Map();
+  beginLifecycle() {
+    this.generation += 1;
+    this.completedPeers.clear();
+  }
+  reconcileIdentity(namespace, database) {
+    if (this.identity?.namespace === namespace && this.identity.database === database) return;
+    this.identity = { namespace, database };
+    this.generation += 1;
+    this.completedPeers.clear();
+  }
+  runBaseline(peerName, task) {
+    const key = this.normalisePeerName(peerName);
+    if (this.completedPeers.has(key)) {
+      return Promise.resolve({ status: "completed", ok: true });
+    }
+    const current = this.inFlightPeers.get(key);
+    if (current) return current;
+    const generation = this.generation;
+    const operation = task().then((result) => {
+      if (result.status === "completed" && generation === this.generation) {
+        this.completedPeers.add(key);
+      }
+      return result;
+    }).finally(() => {
+      if (this.inFlightPeers.get(key) === operation) {
+        this.inFlightPeers.delete(key);
+      }
+    });
+    this.inFlightPeers.set(key, operation);
+    return operation;
+  }
+  normalisePeerName(peerName) {
+    return peerName.trim().toLocaleLowerCase("en-US");
+  }
+}
+export {
+  P2PAutomationCoordinator
+};

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

@@ -0,0 +1,32 @@
+import type { ObsidianLiveSyncSettings } from "../../common/types.js";
+/** Stable decision code for a trial which would extend an active relay binding. */
+export declare const ACTIVE_P2P_RELAY_BINDING_CONFLICT: "active-p2p-relay-binding-conflict";
+/** Settings needed to arbitrate a signalling-only P2P connection probe. */
+export type P2PConnectionProbeSettings = Pick<ObsidianLiveSyncSettings, "P2P_relays">;
+/** Owner settlement for one P2P connection-probe request. */
+export type P2PConnectionProbeAdmissionResult<T> = {
+    readonly status: "observed-active";
+} | {
+    readonly status: "trial";
+    readonly result: T;
+} | {
+    readonly status: "blocked";
+    readonly reason: typeof ACTIVE_P2P_RELAY_BINDING_CONFLICT;
+};
+/**
+ * Arbitrates a complete short-lived probe against the stable P2P room owner.
+ *
+ * The continuation owns construction and disposal of its trial resources. It
+ * must not await another lifecycle operation on the same P2P service because
+ * the owner holds that lifecycle serialisation boundary until it settles.
+ */
+export interface P2PConnectionProbeAdmission {
+    run<T>(trialSettings: P2PConnectionProbeSettings, runOwnedTrial: () => Promise<T>): Promise<P2PConnectionProbeAdmissionResult<T>>;
+}
+/**
+ * Return whether an active relay set already covers every requested relay.
+ *
+ * Relay strings are split, trimmed, and de-duplicated. Broader URI
+ * canonicalisation would diverge from the key used by the Trystero transport.
+ */
+export declare function activeP2PRelayBindingCovers(activeSettings: P2PConnectionProbeSettings, trialSettings: P2PConnectionProbeSettings): boolean;

package/dist/replication/trystero/P2PConnectionProbeAdmission.js

@@ -0,0 +1,10 @@
+import { splitP2PRelayUrls } from "../../common/models/setting.p2p.js";
+const ACTIVE_P2P_RELAY_BINDING_CONFLICT = "active-p2p-relay-binding-conflict";
+function activeP2PRelayBindingCovers(activeSettings, trialSettings) {
+  const activeRelays = new Set(splitP2PRelayUrls(activeSettings.P2P_relays));
+  return splitP2PRelayUrls(trialSettings.P2P_relays).every((relay) => activeRelays.has(relay));
+}
+export {
+  ACTIVE_P2P_RELAY_BINDING_CONFLICT,
+  activeP2PRelayBindingCovers
+};

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

@@ -0,0 +1,31 @@
+import { type RpcErrorShape } from "../../rpc/index.js";
+import type { P2PReplicationResult } from "./TrysteroReplicator.js";
+/** JSON-safe representation used only while a replication result crosses RPC. */
+export type P2PReplicationWireResult = {
+    readonly status: "completed";
+    readonly ok: true;
+    readonly error?: never;
+} | {
+    readonly status: "cancelled";
+    readonly ok?: false;
+    readonly error?: never;
+} | {
+    readonly status: "failed";
+    readonly ok?: false;
+    readonly error: RpcErrorShape;
+};
+/**
+ * Decompose a local result before it enters an `RpcRoom` success envelope.
+ *
+ * `Error` properties are not enumerable, so JSON would otherwise reduce the
+ * failure to `{}` even though the surrounding result reaches the caller.
+ */
+export declare function toP2PReplicationWireResult(result: P2PReplicationResult): P2PReplicationWireResult;
+/**
+ * Restore the local `Error` contract after a JSON-safe result leaves RPC.
+ * Malformed results from an older or incompatible peer remain explicit errors
+ * instead of leaking an untyped object into local result handling.
+ */
+export declare function fromP2PReplicationWireResult(result: P2PReplicationWireResult): P2PReplicationResult;
+/** Decompose an auxiliary command failure which remains inside successful RPC data. */
+export declare function toP2PWireError(error: unknown): RpcErrorShape;

package/dist/replication/trystero/P2PReplicationWire.js

@@ -0,0 +1,50 @@
+import { RpcError } from "../../rpc/index.js";
+import { asRpcErrorShape } from "../../rpc/errors.js";
+const RPC_ERROR_CODES = /* @__PURE__ */ new Set([
+  "TIMEOUT",
+  "NOT_CONNECTED",
+  "REMOTE_ERROR",
+  "CANCELLED",
+  "PROTOCOL_ERROR"
+]);
+function isRpcErrorCode(value) {
+  return typeof value === "string" && RPC_ERROR_CODES.has(value);
+}
+function toP2PReplicationWireResult(result) {
+  if (result.status !== "failed") return result;
+  return { status: "failed", error: asRpcErrorShape(result.error) };
+}
+function fromP2PReplicationWireResult(result) {
+  if (result.status !== "failed") return result;
+  const wireError = result.error;
+  if (!wireError || typeof wireError !== "object" || !("message" in wireError)) {
+    return {
+      status: "failed",
+      error: new RpcError(
+        "REMOTE_ERROR",
+        "The remote peer reported a replication failure without a usable reason."
+      )
+    };
+  }
+  const record = wireError;
+  if (typeof record.message !== "string") {
+    return {
+      status: "failed",
+      error: new RpcError(
+        "REMOTE_ERROR",
+        "The remote peer reported a replication failure without a usable reason."
+      )
+    };
+  }
+  const code = isRpcErrorCode(record.code) ? record.code : "REMOTE_ERROR";
+  const { message, details } = record;
+  return { status: "failed", error: new RpcError(code, message, details) };
+}
+function toP2PWireError(error) {
+  return asRpcErrorShape(error);
+}
+export {
+  fromP2PReplicationWireResult,
+  toP2PReplicationWireResult,
+  toP2PWireError
+};

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

@@ -0,0 +1,32 @@
+import type { ReplicatorHostEnv } from "./types.js";
+import { TrysteroReplicator } from "./TrysteroReplicator.js";
+import { P2PHost } from "./TrysteroReplicatorP2PServer.js";
+/**
+ * Narrow operation boundary owned by one P2P room session.
+ *
+ * A manual stop aborts only current finite operations. Retiring the session
+ * aborts the session lifetime, waits for cooperative operations to settle,
+ * and then releases the room transport.
+ */
+export interface P2PFiniteOperationOwner {
+    runFiniteOperation<T>(task: (signal: AbortSignal) => T | PromiseLike<T>, callerSignal?: AbortSignal): Promise<T>;
+}
+/** Owns one P2P room membership and every finite operation bound to it. */
+export declare class P2PRoomSession implements P2PFiniteOperationOwner {
+    readonly host: P2PHost;
+    readonly replicator: TrysteroReplicator;
+    private readonly sessionController;
+    private readonly activeFiniteOperations;
+    private readonly detachPeerHandlers;
+    private acceptingOperations;
+    private retirement?;
+    constructor(env: ReplicatorHostEnv);
+    /** Open the room owned by this session. */
+    open(): Promise<void>;
+    runFiniteOperation<T>(task: (signal: AbortSignal) => T | PromiseLike<T>, callerSignal?: AbortSignal): Promise<T>;
+    /** Request cooperative cancellation of current transfers without leaving the room. */
+    cancelActiveTransfers(reason?: unknown): void;
+    /** Fence this session, settle its current operations, and release its room. */
+    retire(reason?: unknown): Promise<void>;
+    private linkOperationController;
+}

package/dist/replication/trystero/P2PRoomSession.js

@@ -0,0 +1,101 @@
+import { TrysteroReplicator } from "./TrysteroReplicator.js";
+import { P2PHost } from "./TrysteroReplicatorP2PServer.js";
+class P2PRoomSession {
+  host;
+  replicator;
+  sessionController = new AbortController();
+  activeFiniteOperations = /* @__PURE__ */ new Set();
+  detachPeerHandlers;
+  acceptingOperations = true;
+  retirement;
+  constructor(env) {
+    this.host = new P2PHost(env);
+    this.replicator = new TrysteroReplicator(env, this.host, this);
+    this.detachPeerHandlers = this.host.setSessionPeerHandlers({
+      onAdvertisement: async (peer) => {
+        if (!this.acceptingOperations) return;
+        await this.replicator.onNewPeer(peer);
+      },
+      onPeerLeft: (peerId) => {
+        if (!this.acceptingOperations) return;
+        this.replicator.onPeerLeaved(peerId);
+      }
+    });
+  }
+  /** Open the room owned by this session. */
+  async open() {
+    if (!this.acceptingOperations) {
+      throw new Error("The P2P room session is retiring.");
+    }
+    await this.replicator.open();
+  }
+  async runFiniteOperation(task, callerSignal) {
+    if (!this.acceptingOperations) {
+      throw new Error("The P2P room session is retiring.");
+    }
+    const controller = new AbortController();
+    const detachSignals = this.linkOperationController(controller, callerSignal);
+    const operation = { controller, detachSignals };
+    this.activeFiniteOperations.add(operation);
+    const settlement = Promise.resolve().then(() => task(controller.signal)).finally(() => {
+      detachSignals();
+      this.activeFiniteOperations.delete(operation);
+    });
+    operation.settlement = settlement;
+    return await settlement;
+  }
+  /** Request cooperative cancellation of current transfers without leaving the room. */
+  cancelActiveTransfers(reason = new Error("P2P transfer cancelled.")) {
+    for (const operation of this.activeFiniteOperations) {
+      if (!operation.controller.signal.aborted) {
+        operation.controller.abort(reason);
+      }
+    }
+  }
+  /** Fence this session, settle its current operations, and release its room. */
+  retire(reason = new Error("P2P room session retired.")) {
+    this.retirement ??= (async () => {
+      this.acceptingOperations = false;
+      this.detachPeerHandlers();
+      if (!this.sessionController.signal.aborted) {
+        this.sessionController.abort(reason);
+      }
+      this.cancelActiveTransfers(reason);
+      await Promise.allSettled(
+        [...this.activeFiniteOperations].map((operation) => operation.settlement).filter((settlement) => settlement !== void 0)
+      );
+      this.replicator.disableBroadcastChanges();
+      await this.replicator.dispose();
+    })();
+    return this.retirement;
+  }
+  linkOperationController(controller, callerSignal) {
+    const listeners = /* @__PURE__ */ new Map();
+    const detach = () => {
+      for (const [signal, listener] of listeners) {
+        signal.removeEventListener("abort", listener);
+      }
+      listeners.clear();
+    };
+    const abortFrom = (signal) => {
+      detach();
+      if (!controller.signal.aborted) {
+        controller.abort(signal.reason);
+      }
+    };
+    for (const signal of [this.sessionController.signal, callerSignal]) {
+      if (!signal) continue;
+      if (signal.aborted) {
+        abortFrom(signal);
+        break;
+      }
+      const listener = () => abortFrom(signal);
+      listeners.set(signal, listener);
+      signal.addEventListener("abort", listener, { once: true });
+    }
+    return detach;
+  }
+}
+export {
+  P2PRoomSession
+};