@vrtmrz/livesync-commonlib 0.1.19 → 0.1.21

package/dist/replication/trystero/TrysteroReplicatorP2PClient.js

@@ -10,22 +10,29 @@ class TrysteroReplicatorP2PClient {
   get remoteDB() {
     return this._remoteDB;
   }
+  /** Bind the reverse database RPC calls to one finite-operation signal. */
+  getRemoteDB(signal) {
+    return signal ? this._bindRemoteDB(signal) : this._remoteDB;
+  }
   constructor(server, connectedPeerId) {
     this._server = server;
     this._connectedPeerId = connectedPeerId;
     this._remoteDB = this._bindRemoteDB();
   }
-  _bindRemoteDB() {
+  _bindRemoteDB(signal) {
     return {
-      info: this.bindRemoteFunction("info"),
-      changes: this.bindRemoteFunction("changes"),
-      revsDiff: this.bindRemoteFunction("revsDiff"),
-      bulkDocs: this.bindRemoteFunction("bulkDocs"),
-      bulkGet: this.bindRemoteFunction("bulkGet", BULK_GET_RPC_TIMEOUT),
-      put: this.bindRemoteFunction("put"),
-      get: this.bindRemoteFunction("get")
+      info: this.bindRemoteFunction("info", DEFAULT_RPC_TIMEOUT, signal),
+      changes: this.bindRemoteFunction("changes", DEFAULT_RPC_TIMEOUT, signal),
+      revsDiff: this.bindRemoteFunction("revsDiff", DEFAULT_RPC_TIMEOUT, signal),
+      bulkDocs: this.bindRemoteFunction("bulkDocs", DEFAULT_RPC_TIMEOUT, signal),
+      bulkGet: this.bindRemoteFunction("bulkGet", BULK_GET_RPC_TIMEOUT, signal),
+      put: this.bindRemoteFunction("put", DEFAULT_RPC_TIMEOUT, signal),
+      get: this.bindRemoteFunction("get", DEFAULT_RPC_TIMEOUT, signal)
     };
   }
+  getCallOptions(timeout, signal) {
+    return { timeoutMs: timeout, signal };
+  }
   _sendRPC(type, args, timeout = DEFAULT_RPC_TIMEOUT) {
     const room = this._server?.rpcRoom;
     if (!room) {
@@ -36,21 +43,21 @@ class TrysteroReplicatorP2PClient {
   }
   __onResponse(_data) {
   }
-  bindRemoteFunction(type, timeout = DEFAULT_RPC_TIMEOUT) {
+  bindRemoteFunction(type, timeout = DEFAULT_RPC_TIMEOUT, signal) {
     return async (...args) => {
       const room = this._server?.rpcRoom;
       if (!room) {
         throw new Error("Not connected to any room");
       }
-      return await room.session(this._connectedPeerId).call(toRpcMethodName(type), args, timeout);
+      return await room.session(this._connectedPeerId).call(toRpcMethodName(type), args, this.getCallOptions(timeout, signal));
     };
   }
-  async invokeRemoteFunction(type, args, timeout = DEFAULT_RPC_TIMEOUT) {
+  async invokeRemoteFunction(type, args, timeout = DEFAULT_RPC_TIMEOUT, signal) {
     const room = this._server?.rpcRoom;
     if (!room) {
       throw new Error("Not connected to any room");
     }
-    return await room.session(this._connectedPeerId).call(toRpcMethodName(type), args, timeout);
+    return await room.session(this._connectedPeerId).call(toRpcMethodName(type), args, this.getCallOptions(timeout, signal));
   }
   // eslint-disable-next-line @typescript-eslint/no-explicit-any -- This is a generic function binder, so we can't be more specific about the types here.
   bindRemoteObjectFunctions(key, timeout = DEFAULT_RPC_TIMEOUT) {
@@ -63,12 +70,12 @@ class TrysteroReplicatorP2PClient {
     };
   }
   // eslint-disable-next-line @typescript-eslint/no-explicit-any -- This is a generic function binder, so we can't be more specific about the types here.
-  async invokeRemoteObjectFunction(key, args, timeout = DEFAULT_RPC_TIMEOUT) {
+  async invokeRemoteObjectFunction(key, args, timeout = DEFAULT_RPC_TIMEOUT, signal) {
     const room = this._server?.rpcRoom;
     if (!room) {
       throw new Error("Not connected to any room");
     }
-    return await room.session(this._connectedPeerId).call(toRpcMethodName(key.toString()), args, timeout);
+    return await room.session(this._connectedPeerId).call(toRpcMethodName(key.toString()), args, this.getCallOptions(timeout, signal));
   }
   close() {
     this._remoteDB = void 0;

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

@@ -4,7 +4,7 @@ import { type ReplicatorHostEnv, type FullFilledDeviceInfo, type Request, type R
 import { StoredMapLike } from "../../dataobject/StoredMap.js";
 import { TrysteroReplicatorP2PClient } from "./TrysteroReplicatorP2PClient.js";
 import { Computed } from "octagonal-wheels/dataobject/Computed";
-import { RpcRoom, type JsonLike } from "../../rpc/index.js";
+import { RpcRoom, type JsonLike, type RpcRequestContext } from "../../rpc/index.js";
 import { type DiagRTCStats } from "../../rpc/transports/DiagRTCPeerConnections.types.js";
 export type PeerInfo = Advertisement & {
     isAccepted: boolean | undefined;
@@ -20,6 +20,8 @@ export type RevokeAcceptanceDecision = {
     peerId: string;
     name: string;
 };
+/** Non-interactive result of evaluating the persisted and automatic peer policy. */
+export type P2PPeerAcceptance = "accepted" | "rejected" | "undecided" | "unknown";
 export type P2PServerInfo = {
     isConnected: boolean;
     knownAdvertisements: PeerInfo[];
@@ -27,6 +29,11 @@ export type P2PServerInfo = {
     roomId: string;
     diag: DiagRTCStats;
 };
+/** Peer callbacks bound to one room session rather than the global event hub. */
+export interface P2PSessionPeerHandlers {
+    onAdvertisement(peer: Advertisement): void | Promise<void>;
+    onPeerLeft(peerId: string): void;
+}
 export declare const EVENT_SERVER_STATUS = "p2p-server-status";
 export declare const EVENT_MAKE_DECISION = "make-decision-p2p-peer";
 export declare const EVENT_REVOKE_DECISION = "revoke-decision-p2p-peer";
@@ -63,6 +70,9 @@ export declare class TrysteroReplicatorP2PServer {
     _rpcRoom?: RpcRoom;
     protected _peerStatusEventCleanup: (() => void) | undefined;
     protected _peerFailureAnalysisCleanup: (() => void) | undefined;
+    private _platformUnloadCleanup;
+    private _sessionPeerHandlers;
+    private _hostLifetimeEnded;
     protected _peerConnectionEventCleanup(): void;
     _diagStats: DiagRTCStats;
     get isDisposed(): boolean;
@@ -70,8 +80,12 @@ export declare class TrysteroReplicatorP2PServer {
     ensureLeaved(): Promise<void>;
     setRoom(room: Room): Promise<void>;
     shutdown(): Promise<void>;
+    /** Release subscriptions whose lifetime is the host object rather than one transport join. */
+    dispose(): void;
     dispatchConnectionStatus(): Promise<void>;
     constructor(env: ReplicatorHostEnv, _serverPeerId?: string);
+    /** Attach callbacks owned by the current room session and return their disposer. */
+    setSessionPeerHandlers(handlers: P2PSessionPeerHandlers): () => void;
     makeDecision(decision: AcceptanceDecision): Promise<void>;
     revokeDecision(decision: RevokeAcceptanceDecision): Promise<void>;
     get room(): Room;
@@ -79,6 +93,8 @@ export declare class TrysteroReplicatorP2PServer {
     get db(): PouchDB.Database<import("../../common/types.js").EntryDoc>;
     get confirm(): import("../../interfaces/Confirm.js").Confirm;
     get settings(): P2PSyncSetting;
+    /** Latest admission and enablement policy for this room. */
+    get currentSettings(): P2PSyncSetting;
     get isEnabled(): boolean;
     get deviceInfo(): FullFilledDeviceInfo;
     _sendAdvertisement?: (data: Advertisement, peerId?: string) => Promise<void>;
@@ -92,20 +108,27 @@ export declare class TrysteroReplicatorP2PServer {
     _confirmUserToAccept(peerId: string): Promise<boolean>;
     _acceptablePeers: Computed<[settings: P2PSyncSetting], RegExp[]>;
     _shouldDenyPeers: Computed<[settings: P2PSyncSetting], RegExp[]>;
+    /**
+     * Evaluate peer admission without opening a dialogue or changing a stored
+     * decision. Unattended automation uses this boundary before starting RPC.
+     */
+    evaluatePeerAcceptance(peerId: string): Promise<P2PPeerAcceptance>;
     isAcceptablePeer(peerId: string): Promise<boolean>;
     __send(data: Payload, peerId: string): Promise<void>;
     processArrivedRPC(data: Payload, peerId: string): Promise<void>;
     private _onPeerJoin;
     private _onPeerLeave;
     onAfterJoinRoom(): void;
-    startService(bindings?: BindableObject[]): Promise<void>;
-    start(bindings?: BindableObject[]): Promise<void>;
+    startService(bindings?: BindableObject[], beforeAdvertisement?: () => void): Promise<void>;
+    start(bindings?: BindableObject[], beforeAdvertisement?: () => void): Promise<void>;
     /**
      * @deprecated Use serveFunction or serveObject instead. This is only for backward compatibility and may be removed in the future.
      * @param type
      * @param func
      */
     serveFunction<T extends JsonLike[], U>(type: string, func: (peerId: string, ...args: T) => U | Promise<U>): void;
+    /** Serve one function whose finite work can observe caller cancellation. */
+    serveCancellationAwareFunction<T extends JsonLike[], U>(type: string, func: (context: RpcRequestContext, peerId: string, ...args: T) => U | Promise<U>): void;
     serveObject<T>(obj: BindableObject<T>): void;
     __onResponse(data: Response, peerId: string): void;
     __onRequest(data: Request, peerId: string): Promise<void>;

package/dist/replication/trystero/TrysteroReplicatorP2PServer.js

@@ -1,8 +1,9 @@
 import { selfId, joinRoom } from "@trystero-p2p/nostr";
-import { LOG_LEVEL_INFO, LOG_LEVEL_NOTICE } from "../../common/types.js";
+import { AutoAccepting, LOG_LEVEL_INFO, LOG_LEVEL_NOTICE } from "../../common/types.js";
 import { LOG_LEVEL_VERBOSE, Logger } from "../../common/logger.js";
 import {
   DIRECTION_RESPONSE,
+  resolveCurrentP2PSettings,
   ResponsePreventedError,
   DIRECTION_REQUEST
 } from "./types.js";
@@ -19,6 +20,7 @@ import { toRpcMethodName } from "./rpcCompat.js";
 import { generateJoinRoomOptions } from "../../rpc/transports/trysteroUtils.js";
 import { subscribeConnectionStatus, subscribeFailureDiagnosis } from "../../rpc/transports/DiagRTCPeerConnections.js";
 import {} from "../../rpc/transports/DiagRTCPeerConnections.types.js";
+import { asRpcErrorShape } from "../../rpc/errors.js";
 const EVENT_SERVER_STATUS = "p2p-server-status";
 const EVENT_MAKE_DECISION = "make-decision-p2p-peer";
 const EVENT_REVOKE_DECISION = "revoke-decision-p2p-peer";
@@ -42,6 +44,9 @@ class TrysteroReplicatorP2PServer {
   _rpcRoom;
   _peerStatusEventCleanup = void 0;
   _peerFailureAnalysisCleanup = void 0;
+  _platformUnloadCleanup;
+  _sessionPeerHandlers;
+  _hostLifetimeEnded = false;
   _peerConnectionEventCleanup() {
     if (this._peerStatusEventCleanup) {
       this._peerStatusEventCleanup();
@@ -95,7 +100,15 @@ class TrysteroReplicatorP2PServer {
       Logger(ex, LOG_LEVEL_VERBOSE);
     }
   }
+  /** Release subscriptions whose lifetime is the host object rather than one transport join. */
+  dispose() {
+    this._hostLifetimeEnded = true;
+    this._platformUnloadCleanup?.();
+    this._platformUnloadCleanup = void 0;
+    this._sessionPeerHandlers = void 0;
+  }
   async dispatchConnectionStatus() {
+    if (this._hostLifetimeEnded) return;
     const adsTasks = [...this.knownAdvertisements].map(async (e) => {
       const isAccepted = await this.acceptedPeers.get(e.name);
       const isTemporaryAccepted = this.temporaryAcceptedPeers.get(e.peerId);
@@ -106,6 +119,7 @@ class TrysteroReplicatorP2PServer {
       };
     });
     const ads = await Promise.all(adsTasks);
+    if (this._hostLifetimeEnded) return;
     this._env.events.emitEvent(EVENT_SERVER_STATUS, {
       isConnected: this.isServing,
       knownAdvertisements: ads,
@@ -117,7 +131,7 @@ class TrysteroReplicatorP2PServer {
   constructor(env, _serverPeerId = selfId) {
     this._env = env;
     this._serverPeerId = _serverPeerId;
-    this._env.events.onEvent(EVENT_PLATFORM_UNLOADED, () => {
+    this._platformUnloadCleanup = this._env.events.onEvent(EVENT_PLATFORM_UNLOADED, () => {
       void this.shutdown();
     });
     this.acceptedPeers = new StoredMapLike(
@@ -125,6 +139,15 @@ class TrysteroReplicatorP2PServer {
       "p2p-device-decisions"
     );
   }
+  /** Attach callbacks owned by the current room session and return their disposer. */
+  setSessionPeerHandlers(handlers) {
+    this._sessionPeerHandlers = handlers;
+    return () => {
+      if (this._sessionPeerHandlers === handlers) {
+        this._sessionPeerHandlers = void 0;
+      }
+    };
+  }
   async makeDecision(decision) {
     if (decision.decision) {
       if (decision.isTemporary) {
@@ -161,8 +184,12 @@ class TrysteroReplicatorP2PServer {
   get settings() {
     return this._env.settings;
   }
+  /** Latest admission and enablement policy for this room. */
+  get currentSettings() {
+    return resolveCurrentP2PSettings(this._env);
+  }
   get isEnabled() {
-    return this.settings.P2P_Enabled;
+    return this.currentSettings.P2P_Enabled;
   }
   get deviceInfo() {
     return {
@@ -173,7 +200,6 @@ class TrysteroReplicatorP2PServer {
     };
   }
   _sendAdvertisement;
-  // _advertisementTimer?: ReturnType<typeof setInterval>;
   sendAdvertisement(peerId) {
     if (!this.isEnabled) return;
     const devInfo = this.deviceInfo;
@@ -187,28 +213,12 @@ class TrysteroReplicatorP2PServer {
       void this._sendAdvertisement(data, peerId);
     }
   }
-  // startAdvertisementBroadcast() {
-  //     if (this._advertisementTimer) {
-  //         clearInterval(this._advertisementTimer);
-  //     }
-  //     this._advertisementTimer = setInterval(() => {
-  //         if (!this.isServing || !this.isEnabled) {
-  //             return;
-  //         }
-  //         this.sendAdvertisement();
-  //     }, ADVERTISEMENT_REBROADCAST_INTERVAL_MS);
-  // }
-  // stopAdvertisementBroadcast() {
-  //     if (this._advertisementTimer) {
-  //         clearInterval(this._advertisementTimer);
-  //         this._advertisementTimer = undefined;
-  //     }
-  // }
   _knownAdvertisements = /* @__PURE__ */ new Map();
   get knownAdvertisements() {
     return [...this._knownAdvertisements.values()];
   }
   onAdvertisement(data, peerId) {
+    if (this._hostLifetimeEnded) return;
     if (!this.isEnabled) return;
     Logger(`Advertisement from ${peerId}`, LOG_LEVEL_VERBOSE);
     if (peerId === this.serverPeerId) return;
@@ -216,6 +226,7 @@ class TrysteroReplicatorP2PServer {
     if (data.peerId !== peerId) return;
     this._knownAdvertisements.set(peerId, data);
     void this.dispatchConnectionStatus();
+    void Promise.resolve().then(() => this._sessionPeerHandlers?.onAdvertisement(data)).catch((error) => Logger(error, LOG_LEVEL_VERBOSE));
     void this._env.events.emitEvent(EVENT_ADVERTISEMENT_RECEIVED, data);
   }
   acceptedPeers;
@@ -278,25 +289,40 @@ You can chose as follows:
       return `${settings?.P2P_AutoDenyingPeers ?? ""}`.split(",").map((e) => e.trim()).filter((e) => !!e).map((e) => e.startsWith("~") ? new RegExp(e.substring(1), "i") : new RegExp(`^${e}$`, "i"));
     }
   });
-  async isAcceptablePeer(peerId) {
-    if (!this.isEnabled) return void 0;
+  /**
+   * Evaluate peer admission without opening a dialogue or changing a stored
+   * decision. Unattended automation uses this boundary before starting RPC.
+   */
+  async evaluatePeerAcceptance(peerId) {
+    if (!this.isEnabled) return "unknown";
     const peerInfo = this._knownAdvertisements.get(peerId);
-    if (!peerInfo) return false;
+    if (!peerInfo) return "unknown";
     const peerName = peerInfo.name;
-    if (this.temporaryAcceptedPeers.has(peerId)) return this.temporaryAcceptedPeers.get(peerId);
+    if (this.temporaryAcceptedPeers.has(peerId)) {
+      return this.temporaryAcceptedPeers.get(peerId) ? "accepted" : "rejected";
+    }
     const accepted = await this.acceptedPeers.get(peerName);
-    if (accepted !== void 0 && accepted !== null) return accepted;
-    const isAcceptable = (await this._acceptablePeers.update(this.settings)).value.some((e) => e.test(peerName));
-    const isDeny = (await this._shouldDenyPeers.update(this.settings)).value.some((e) => e.test(peerName));
-    if (isAcceptable) {
-      if (isDeny) return false;
-      this.temporaryAcceptedPeers.set(peerId, true);
-      void this.dispatchConnectionStatus();
+    if (accepted !== void 0 && accepted !== null) return accepted ? "accepted" : "rejected";
+    const currentSettings = { ...this.currentSettings };
+    const isAcceptable = (await this._acceptablePeers.update(currentSettings)).value.some((e) => e.test(peerName));
+    const isDeny = (await this._shouldDenyPeers.update(currentSettings)).value.some((e) => e.test(peerName));
+    if (isDeny) return "rejected";
+    if (isAcceptable || currentSettings.P2P_AutoAccepting === AutoAccepting.ALL) return "accepted";
+    return "undecided";
+  }
+  async isAcceptablePeer(peerId) {
+    const acceptance = await this.evaluatePeerAcceptance(peerId);
+    if (acceptance === "accepted") {
+      const peerName = this._knownAdvertisements.get(peerId)?.name;
+      const persisted = peerName ? await this.acceptedPeers.get(peerName) : void 0;
+      if (!this.temporaryAcceptedPeers.has(peerId) && persisted == null) {
+        this.temporaryAcceptedPeers.set(peerId, true);
+        void this.dispatchConnectionStatus();
+      }
       return true;
     }
-    if (this.settings.P2P_IsHeadless) {
-      return false;
-    }
+    if (acceptance === "rejected" || acceptance === "unknown") return false;
+    if (this.currentSettings.P2P_IsHeadless) return false;
     return await this.confirmUserToAccept(peerId);
   }
   async __send(data, peerId) {
@@ -330,6 +356,7 @@ You can chose as follows:
     }
   }
   _onPeerJoin(peerId) {
+    if (this._hostLifetimeEnded) return;
     if (!this._room) {
       Logger(`Received peer join event from ${peerId}, but no active room. Ignoring.`, LOG_LEVEL_VERBOSE);
       return;
@@ -338,8 +365,10 @@ You can chose as follows:
     this.sendAdvertisement(peerId);
   }
   _onPeerLeave(peerId) {
+    if (this._hostLifetimeEnded) return;
     Logger(`Peer left: ${peerId}`, LOG_LEVEL_VERBOSE);
     this._knownAdvertisements.delete(peerId);
+    void Promise.resolve().then(() => this._sessionPeerHandlers?.onPeerLeft(peerId)).catch((error) => Logger(error, LOG_LEVEL_VERBOSE));
     void this._env.events.emitEvent(EVENT_DEVICE_LEAVED, peerId);
     void this.dispatchConnectionStatus();
   }
@@ -397,7 +426,7 @@ You can chose as follows:
     this._env.events.emitEvent(EVENT_P2P_CONNECTED);
     void this.dispatchConnectionStatus();
   }
-  async startService(bindings = []) {
+  async startService(bindings = [], beforeAdvertisement) {
     if (!this.isEnabled) {
       Logger(this._env.translate("P2P.NotEnabled"), LOG_LEVEL_NOTICE);
       return;
@@ -407,9 +436,10 @@ You can chose as follows:
     this._bindingObjects.forEach((b) => {
       this.serveObject(b);
     });
+    beforeAdvertisement?.();
     await Promise.resolve(this.sendAdvertisement());
   }
-  async start(bindings = []) {
+  async start(bindings = [], beforeAdvertisement) {
     await this.shutdown();
     if (!this.settings.P2P_Enabled) {
       Logger(this._env.translate("P2P.NotEnabled"), LOG_LEVEL_NOTICE);
@@ -436,7 +466,7 @@ You can chose as follows:
     this._activeRoomId = roomId;
     this.onAfterJoinRoom();
     void this.dispatchConnectionStatus();
-    await this.startService(bindings);
+    await this.startService(bindings, beforeAdvertisement);
   }
   /**
    * @deprecated Use serveFunction or serveObject instead. This is only for backward compatibility and may be removed in the future.
@@ -449,6 +479,13 @@ You can chose as follows:
       return await Promise.resolve(func.apply(this, [peerId, ...args]));
     });
   }
+  /** Serve one function whose finite work can observe caller cancellation. */
+  serveCancellationAwareFunction(type, func) {
+    this._rpcRoom?.registerCancellable(
+      toRpcMethodName(type),
+      async (context, peerId, ...args) => await Promise.resolve(func(context, peerId, ...args))
+    );
+  }
   serveObject(obj) {
     const keys = Object.keys(obj);
     keys.forEach((key) => {
@@ -483,7 +520,15 @@ You can chose as follows:
       Logger(`Serving function: [FAILED] ${data.type} sending back the failure information`, LOG_LEVEL_VERBOSE);
       Logger(e instanceof Error ? e.message : e, LOG_LEVEL_VERBOSE);
       await this.__send(
-        { type: data.type, seq: data.seq, direction: DIRECTION_RESPONSE, data: void 0, error: e },
+        {
+          type: data.type,
+          seq: data.seq,
+          direction: DIRECTION_RESPONSE,
+          data: void 0,
+          // This deprecated path predates RpcRoom, but it has the same
+          // JSON boundary and therefore must not send a native Error.
+          error: asRpcErrorShape(e)
+        },
         peerId
       );
     }

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

@@ -1,18 +1,22 @@
 import type { ReactiveSource } from "octagonal-wheels/dataobject/reactive_v2";
 import type { LiveSyncTrysteroReplicator } from "./LiveSyncTrysteroReplicator.js";
 import type { P2PLogCollector } from "./P2PLogCollector.js";
-export type UseP2PReplicatorResult = {
+import type { P2PServiceViews } from "../../p2p/P2PService.js";
+export type UseP2PReplicatorResult = P2PServiceViews & {
     /**
-     * The current replicator selected by the host lifecycle.
+     * Compatibility facade retained while existing panes migrate to the
+     * focused service views.
      *
-     * Read this property at the point of use. Retaining a destructured value
-     * across settings or database lifecycle events can target a closed,
-     * replaced instance.
+     * This facade is stable for the service lifetime, but it is not the active
+     * provider adapter. New consumers must request only the service view which
+     * they need.
+     *
+     * @deprecated Use the focused P2P service views instead.
      */
     readonly replicator: LiveSyncTrysteroReplicator;
 };
 export type P2PPaneParams = {
-    /** Current replicator; preserve the result object so its getter remains live. */
+    /** @deprecated Migrate panes to the focused P2P service views. */
     readonly replicator: LiveSyncTrysteroReplicator;
     p2pLogCollector: P2PLogCollector;
     storeP2PStatusLine: ReactiveSource<string>;

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

@@ -1,10 +1,13 @@
 import type { LiveSyncEventHub } from "../../hub/hub.js";
 import type { LiveSyncTrysteroReplicator } from "./LiveSyncTrysteroReplicator.js";
 import type { Advertisement } from "./types.js";
+import type { P2PServiceLifecycle } from "../../p2p/P2PService.js";
 /**
  * Minimal interface that a P2P replicator instance should satisfy for addP2PEventHandlers to work.
  */
 export interface P2PReplicatorLike {
+    /** True when peer callbacks are already fenced by the active room session. */
+    readonly handlesPeerEventsWithinSession?: boolean;
     onNewPeer(peer: Advertisement): Promise<void> | void;
     onPeerLeaved(peerId: string): void;
     requestStatus(): void;
@@ -17,21 +20,14 @@ export interface P2PReplicatorLike {
         isServing?: boolean;
     };
 }
+/** Host lifecycle subset consumed by the legacy event bridge. */
+export type P2PServiceEventTarget = Pick<P2PServiceLifecycle, "requestStatus" | "openAfterDatabaseRebuild" | "closeForLifecycle" | "reconcileAutoStart">;
 /** Resolves the replicator which currently owns P2P state. */
-export type P2PReplicatorProvider = () => P2PReplicatorLike;
+export type P2PEventTarget = P2PReplicatorLike | P2PServiceEventTarget;
+export type P2PReplicatorProvider = () => P2PEventTarget;
 /**
  * Add event handlers for P2P replication related events.
  * @param source A fixed compatibility instance or a provider for a replaceable replicator.
  */
-export declare function addP2PEventHandlers(source: P2PReplicatorLike | P2PReplicatorProvider, events: LiveSyncEventHub): void;
-/**
- * open P2P replicator if not opened yet.
- * @param instance
- */
-export declare function openP2PReplicator(instance: P2PReplicatorLike): Promise<void>;
-/**
- * close P2P replicator
- * @param instance
- */
-export declare function closeP2PReplicator(instance: P2PReplicatorLike): Promise<void>;
+export declare function addP2PEventHandlers(source: P2PEventTarget | P2PReplicatorProvider, events: LiveSyncEventHub): void;
 export type { LiveSyncTrysteroReplicator };

package/dist/replication/trystero/addP2PEventHandlers.js

@@ -1,42 +1,42 @@
 import { EVENT_DATABASE_REBUILT, EVENT_PLATFORM_UNLOADED, EVENT_SETTING_SAVED } from "../../events/coreEvents.js";
 import { EVENT_ADVERTISEMENT_RECEIVED, EVENT_DEVICE_LEAVED, EVENT_REQUEST_STATUS } from "./TrysteroReplicatorP2PServer.js";
+function isServiceEventTarget(target) {
+  return "reconcileAutoStart" in target;
+}
 function addP2PEventHandlers(source, events) {
   const current = () => typeof source === "function" ? source() : source;
   events.onEvent(EVENT_ADVERTISEMENT_RECEIVED, (peer) => {
-    void current().onNewPeer(peer);
+    const target = current();
+    if ("onNewPeer" in target && target.handlesPeerEventsWithinSession !== true) void target.onNewPeer(peer);
   });
   events.onEvent(EVENT_DEVICE_LEAVED, (peerId) => {
-    current().onPeerLeaved(peerId);
+    const target = current();
+    if ("onPeerLeaved" in target && target.handlesPeerEventsWithinSession !== true) target.onPeerLeaved(peerId);
   });
   events.onEvent(EVENT_REQUEST_STATUS, () => {
     current().requestStatus();
   });
   events.onEvent(EVENT_DATABASE_REBUILT, async () => {
-    await current().open();
+    const target = current();
+    await (isServiceEventTarget(target) ? target.openAfterDatabaseRebuild() : target.open());
   });
   events.onEvent(EVENT_PLATFORM_UNLOADED, () => {
-    void current().close();
+    const target = current();
+    void (isServiceEventTarget(target) ? target.closeForLifecycle() : target.close());
   });
   events.onEvent(EVENT_SETTING_SAVED, async (settings) => {
-    const instance = current();
+    const target = current();
+    if (isServiceEventTarget(target)) {
+      await target.reconcileAutoStart(settings);
+      return;
+    }
     if (settings.P2P_Enabled && settings.P2P_AutoStart) {
-      await instance.open();
+      await target.open();
       return;
     }
-    await instance.close();
+    await target.close();
   });
 }
-async function openP2PReplicator(instance) {
-  const isOpen = instance.isServing ?? instance.server?.isServing ?? false;
-  if (!isOpen) {
-    await instance.open();
-  }
-}
-async function closeP2PReplicator(instance) {
-  await instance.close();
-}
 export {
-  addP2PEventHandlers,
-  closeP2PReplicator,
-  openP2PReplicator
+  addP2PEventHandlers
 };

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

@@ -0,0 +1,9 @@
+import type { RemoteDBSettings } from "../../common/types.js";
+/**
+ * Project only values which fix the effective P2P transport generation.
+ *
+ * Persisted profile identifiers, enablement, and room automation or admission
+ * policy are deliberately excluded. The returned value can contain
+ * credentials and must not be logged, persisted, or displayed.
+ */
+export declare function getP2PReplicatorConfigurationIdentity(settings: RemoteDBSettings): string;

package/dist/replication/trystero/p2pReplicatorConfigurationIdentity.js

@@ -0,0 +1,30 @@
+import { P2PConnectionPaths } from "../../common/models/setting.const.js";
+import {
+  hasValidP2PTurnServerUrl,
+  normaliseP2PConnectionPath,
+  normaliseP2PMaxWirePayloadBytes,
+  splitP2PRelayUrls,
+  splitP2PTurnServerUrls
+} from "../../common/models/setting.p2p.js";
+function getP2PReplicatorConfigurationIdentity(settings) {
+  const turnServerValue = settings.P2P_turnServers ?? "";
+  const turnServers = splitP2PTurnServerUrls(turnServerValue);
+  const configuredPath = normaliseP2PConnectionPath(settings.P2P_connectionPath);
+  const effectivePath = configuredPath === P2PConnectionPaths.Relay && hasValidP2PTurnServerUrl(turnServerValue) ? P2PConnectionPaths.Relay : P2PConnectionPaths.Automatic;
+  const turnAuthentication = turnServers.length > 0 ? [settings.P2P_turnUsername, settings.P2P_turnCredential] : void 0;
+  return JSON.stringify([
+    "p2p",
+    settings.P2P_AppID || "self-hosted-livesync",
+    settings.P2P_roomID,
+    settings.P2P_passphrase,
+    splitP2PRelayUrls(settings.P2P_relays),
+    turnServers,
+    turnAuthentication,
+    normaliseP2PMaxWirePayloadBytes(settings.P2P_maxWirePayloadBytes),
+    effectivePath,
+    settings.P2P_useDiagRTC ?? false
+  ]);
+}
+export {
+  getP2PReplicatorConfigurationIdentity
+};

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

@@ -5,6 +5,7 @@ import type { Confirm } from "../../interfaces/Confirm.js";
 import type { AsyncActivityRunner } from "../../interfaces/AsyncActivityRunner.js";
 import type { LiveSyncEventHub } from "../../hub/hub.js";
 import type { MessageTranslator } from "../../services/base/MessageTranslator.js";
+import type { P2PAutomationCoordinator } from "./P2PAutomationCoordinator.js";
 export declare const DIRECTION_REQUEST = "request";
 export type DIRECTION_REQUEST = typeof DIRECTION_REQUEST;
 export declare const DIRECTION_RESPONSE = "response";
@@ -81,14 +82,31 @@ export interface ReplicatorHostEnv extends ReplicatorHost {
     events: LiveSyncEventHub;
     /** Message translation owned by the containing Commonlib service composition. */
     translate: MessageTranslator;
+    /**
+     * Immutable settings snapshot captured for this room session.
+     *
+     * Room join options, RPC framing, and other session-owned resources must
+     * use this snapshot so one session cannot mix transport generations.
+     */
     settings: P2PSyncSetting;
+    /**
+     * Return the latest host settings for policy evaluated on an open room.
+     *
+     * Older direct consumers may omit this port; they retain snapshot
+     * behaviour through the `settings` fallback.
+     */
+    currentSettings?(): P2PSyncSetting;
     db: PouchDB.Database<EntryDoc>;
     simpleStore: SimpleStore<unknown>;
     runFiniteReplicationActivity?: AsyncActivityRunner["run"];
     /** Lightweight, repeatable host policy checked before ordinary P2P replication starts. */
     canStartOrdinaryReplication?(showMessage?: boolean): Promise<boolean>;
+    /** Stable automatic-transfer state supplied by the owning P2P service. */
+    automationCoordinator?: P2PAutomationCoordinator;
     processReplicatedDocs(docs: Array<PouchDB.Core.ExistingDocument<EntryDoc>>): void | Promise<void>;
 }
+/** Resolve policy settings without weakening the immutable room snapshot. */
+export declare function resolveCurrentP2PSettings(env: ReplicatorHostEnv): P2PSyncSetting;
 export type Advertisement = {
     peerId: string;
     name: string;