@vrtmrz/livesync-commonlib 0.1.0-rc.1 → 0.1.0-rc.3

package/dist/replication/trystero/LiveSyncTrysteroReplicator.js

@@ -18,6 +18,8 @@ import { delay } from "octagonal-wheels/promises";
 class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
   _p2pHost;
   _replicator;
+  _lifecycleOperation = Promise.resolve();
+  _shouldBeOpen = false;
   get openReplicationUI() {
     return this.env.openReplicationUI;
   }
@@ -27,9 +29,6 @@ class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
   get rawHost() {
     return this._p2pHost;
   }
-  get isChunkSendingSupported() {
-    return false;
-  }
   getReplicationPBKDF2Salt(_setting, _refresh) {
     return Promise.resolve(new Uint8Array(32));
   }
@@ -59,6 +58,7 @@ class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
         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) {
@@ -75,36 +75,48 @@ class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
       }
     };
   }
+  _enqueueLifecycleOperation(operation) {
+    const queued = this._lifecycleOperation.catch(() => void 0).then(operation);
+    this._lifecycleOperation = queued.catch(() => void 0);
+    return queued;
+  }
   async open() {
     if (!this.env.services.setting.currentSettings().P2P_Enabled) {
       Logger(this.translate("P2P.NotEnabled"), LOG_LEVEL_NOTICE);
       return;
     }
-    if (this._replicator && this._p2pHost?.isServing) {
-      Logger("P2P replicator is already open.");
-      return;
-    }
-    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();
-    } 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._shouldBeOpen = true;
+    await this._enqueueLifecycleOperation(async () => {
+      if (!this._shouldBeOpen) return;
+      if (this._replicator && this._p2pHost?.isServing) {
+        Logger("P2P replicator is already open.");
+        return;
+      }
+      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();
+      } 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;
+      }
+    });
   }
   async close() {
-    if (this._replicator) {
-      this._replicator.disableBroadcastChanges();
-      await this._replicator.close();
-      this._replicator = void 0;
-    }
-    this._p2pHost = void 0;
+    this._shouldBeOpen = false;
+    await this._enqueueLifecycleOperation(async () => {
+      if (this._replicator) {
+        this._replicator.disableBroadcastChanges();
+        await this._replicator.close();
+        this._replicator = void 0;
+      }
+      this._p2pHost = void 0;
+    });
   }
   closeReplication() {
     this._replicator?.disconnectFromServer();
@@ -138,11 +150,11 @@ class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
       { label: "replication" }
     );
   }
-  async replicateFrom(peerId, showNotice = false) {
+  async replicateFrom(peerId, showNotice = false, skipOrdinaryReplicationPolicy = false) {
     const replicator = this._replicator;
     if (!replicator) throw new Error("P2P replicator is not open");
     return await this.env.services.replicator.runFiniteReplicationActivity(
-      () => replicator.replicateFrom(peerId, showNotice),
+      () => skipOrdinaryReplicationPolicy ? replicator.replicateFrom(peerId, showNotice, false, true) : replicator.replicateFrom(peerId, showNotice),
       { label: "replication" }
     );
   }
@@ -200,7 +212,7 @@ class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
   tryConnectRemote(_setting, _showResult) {
     return Promise.resolve(false);
   }
-  replicateAllToServer(_setting, _showingNotice, _sendChunksInBulkDisabled) {
+  replicateAllToServer(_setting, _showingNotice) {
     return Promise.resolve(false);
   }
   async selectPeer(settingPeerName, r, logLevel) {
@@ -303,7 +315,7 @@ class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
       }
       this.env.services.setting.currentSettings().P2P_RebuildFrom = "";
       Logger("Fetching from peer " + peerId + ".", logLevel);
-      const rep = await r.replicateFrom(peerId, showingNotice);
+      const rep = await r.replicateFrom(peerId, showingNotice, false, true);
       if (rep.ok) {
         Logger("P2P Fetching has been succeed from " + peerId + ".", logLevel);
         return true;

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

@@ -2,11 +2,7 @@ import type { NecessaryServices } from "../../interfaces/ServiceModule.js";
 import type { P2PPaneParams } from "./UseP2PReplicatorResult.js";
 export type P2PViewFactory = (leaf: unknown) => unknown;
 /**
- * ServiceFeature: P2P Replicator lifecycle management.
- * Binds a LiveSyncTrysteroReplicator to the host's lifecycle events,
- * following the same middleware style as useOfflineScanner.
- *
- * @param viewTypeAndFactory  Optional [viewType, factory] pair for registering the P2P pane view.
- *                            When provided, also registers commands and ribbon icon via services.API.
+ * @deprecated Compose `useP2PReplicatorFeature` with host-specific commands
+ * and UI instead. This wrapper remains for source compatibility.
  */
 export declare function useP2PReplicator(host: NecessaryServices<"API" | "appLifecycle" | "setting" | "vault" | "database" | "databaseEvents" | "keyValueDB" | "replication" | "config" | "UI" | "replicator" | "remote", never>, viewTypeAndFactory?: [viewType: string, factory: P2PViewFactory]): P2PPaneParams;

package/dist/replication/trystero/P2PReplicatorCore.js

@@ -1,110 +1,34 @@
-import { AutoAccepting, REMOTE_P2P } from "../../common/types.js";
-import { reactiveSource } from "octagonal-wheels/dataobject/reactive";
+import { REMOTE_P2P } from "../../common/types.js";
+import { reactiveSource } from "octagonal-wheels/dataobject/reactive_v2";
 import { EVENT_REQUEST_OPEN_P2P } from "../../events/coreEvents.js";
-import { LiveSyncTrysteroReplicator } from "./LiveSyncTrysteroReplicator.js";
-import { Logger, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "../../common/logger.js";
 import { P2PLogCollector } from "./P2PLogCollector.js";
-import { addP2PEventHandlers } from "./addP2PEventHandlers.js";
-import { compatGlobal } from "../../common/coreEnvFunctions.js";
+import { useP2PReplicatorCommands } from "./useP2PReplicatorCommands.js";
+import { useP2PReplicatorFeature } from "./useP2PReplicatorFeature.js";
 function useP2PReplicator(host, viewTypeAndFactory) {
-  const env = { services: host.services };
-  let replicator = new LiveSyncTrysteroReplicator(env);
-  const activeReplicator = {
-    get instance() {
-      return replicator;
-    }
-  };
+  const activeReplicator = useP2PReplicatorFeature(host);
   const events = host.services.context.events;
-  addP2PEventHandlers(activeReplicator.instance, events);
   const p2pLogCollector = new P2PLogCollector(events);
   const storeP2PStatusLine = reactiveSource("");
   p2pLogCollector.p2pReplicationLine.onChanged((line) => {
     storeP2PStatusLine.value = line.value;
   });
-  host.services.appLifecycle.onResumed.addHandler(() => {
-    const settings = host.services.setting.currentSettings();
-    if (settings.P2P_Enabled && settings.P2P_AutoStart) {
-      compatGlobal.setTimeout(() => void replicator.open(), 100);
-    }
-    return Promise.resolve(true);
-  });
-  host.services.appLifecycle.onUnload.addHandler(async () => {
-    await replicator.close();
-    return true;
-  });
-  host.services.appLifecycle.onSuspending.addHandler(async () => {
-    await replicator.close();
-    return true;
-  });
-  host.services.databaseEvents.onDatabaseInitialisation.addHandler(async () => {
-    await replicator.close();
-    return true;
-  });
-  host.services.setting.suspendExtraSync.addHandler(() => {
-    const s = host.services.setting.currentSettings();
-    if (s.remoteType !== REMOTE_P2P) {
-      s.P2P_Enabled = false;
-    }
-    s.P2P_AutoAccepting = AutoAccepting.NONE;
-    s.P2P_AutoBroadcast = false;
-    s.P2P_AutoStart = false;
-    s.P2P_AutoSyncPeers = "";
-    s.P2P_AutoWatchPeers = "";
-    return Promise.resolve(true);
-  });
-  host.services.replicator.getNewReplicator.addHandler(
-    async (settingOverride = {}) => {
-      const settings = { ...host.services.setting.currentSettings(), ...settingOverride };
-      if (settings.remoteType == REMOTE_P2P) {
-        try {
-          await replicator.close();
-        } catch (e) {
-          Logger(`Error closing existing p2p replicator`);
-          Logger(e, LOG_LEVEL_VERBOSE);
-        }
-        const newReplicator = new LiveSyncTrysteroReplicator({ services: host.services });
-        replicator = newReplicator;
-        return Promise.resolve(replicator);
-      }
-      return void 0;
-    }
-  );
   if (viewTypeAndFactory) {
     const [viewType, factory] = viewTypeAndFactory;
     const openPane = () => host.services.API.showWindow(viewType);
+    useP2PReplicatorCommands(host, activeReplicator);
     host.services.appLifecycle.onInitialise.addHandler(() => {
       host.services.API.registerWindow(viewType, factory);
-      events.onEvent(EVENT_REQUEST_OPEN_P2P, () => {
-        void openPane();
-      });
+      events.onEvent(EVENT_REQUEST_OPEN_P2P, () => void openPane());
       host.services.API.addCommand({
         id: "open-p2p-replicator",
         name: "P2P Sync : Open P2P Replicator",
-        callback: () => {
-          void openPane();
-        }
-      });
-      host.services.API.addCommand({
-        id: "p2p-establish-connection",
-        name: "P2P Sync : Connect to the Signalling Server",
-        checkCallback: (isChecking) => {
-          if (isChecking) return !(replicator.server?.isServing ?? false);
-          void replicator.open();
-        }
-      });
-      host.services.API.addCommand({
-        id: "p2p-close-connection",
-        name: "P2P Sync : Disconnect from the Signalling Server",
-        checkCallback: (isChecking) => {
-          if (isChecking) return replicator.server?.isServing ?? false;
-          Logger("Closing P2P Connection", LOG_LEVEL_NOTICE);
-          void replicator.close();
-        }
+        callback: () => void openPane()
       });
       host.services.API.addCommand({
         id: "replicate-now-by-p2p",
         name: "Replicate now by P2P",
         checkCallback: (isChecking) => {
+          const replicator = activeReplicator.replicator;
           const settings = host.services.setting.currentSettings();
           if (isChecking) {
             if (settings.remoteType == REMOTE_P2P) return false;
@@ -119,7 +43,13 @@ function useP2PReplicator(host, viewTypeAndFactory) {
       return Promise.resolve(true);
     });
   }
-  return { replicator, p2pLogCollector, storeP2PStatusLine };
+  return {
+    get replicator() {
+      return activeReplicator.replicator;
+    },
+    p2pLogCollector,
+    storeP2PStatusLine
+  };
 }
 export {
   useP2PReplicator

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

@@ -64,6 +64,7 @@ export declare class TrysteroReplicator {
     get confirm(): Confirm;
     get translate(): import("../../context.js").MessageTranslator;
     private runFiniteReplicationActivity;
+    private canStartOrdinaryReplication;
     constructor(env: ReplicatorHostEnv, server?: P2PHost);
     close(): Promise<void>;
     open(): Promise<void>;
@@ -123,7 +124,7 @@ export declare class TrysteroReplicator {
     onReplicationProgress(peerId: string, info?: ProgressInfo): boolean;
     onProgressAcknowledged(peerId: string, info?: ProgressInfo): boolean;
     acknowledgeProgress(remotePeerId: string, info?: ProgressInfo): void;
-    replicateFrom(remotePeer: string, showNotice?: boolean, fromStart?: boolean): Promise<{
+    replicateFrom(remotePeer: string, showNotice?: boolean, fromStart?: boolean, skipOrdinaryReplicationPolicy?: boolean): Promise<{
         error: any;
         ok?: undefined;
     } | {

package/dist/replication/trystero/TrysteroReplicator.js

@@ -51,6 +51,9 @@ class TrysteroReplicator {
     }
     return await task();
   }
+  async canStartOrdinaryReplication(showMessage = false) {
+    return this._env.canStartOrdinaryReplication ? await this._env.canStartOrdinaryReplication(showMessage) : true;
+  }
   constructor(env, server) {
     this._env = env;
     if (server) {
@@ -265,6 +268,9 @@ class TrysteroReplicator {
   // }
   lastSeq = "";
   async requestSynchroniseToPeer(peerId) {
+    if (!await this.canStartOrdinaryReplication(false)) {
+      return { error: new Error("Replication is not ready") };
+    }
     await delay(25);
     if (!this.server) throw new Error("Server is not available");
     const conn = this.server.getConnection(peerId);
@@ -440,7 +446,10 @@ class TrysteroReplicator {
       Logger(ex, LOG_LEVEL_VERBOSE);
     });
   }
-  async replicateFrom(remotePeer, showNotice = false, fromStart = false) {
+  async replicateFrom(remotePeer, showNotice = false, fromStart = false, skipOrdinaryReplicationPolicy = false) {
+    if (!skipOrdinaryReplicationPolicy && !await this.canStartOrdinaryReplication(showNotice)) {
+      return { error: new Error("Replication is not ready") };
+    }
     const logLevel = showNotice ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO;
     Logger(`P2P Requesting Authentication to ${remotePeer}`, logLevel, "p2p-replicator");
     if (await this.requestAuthenticate(remotePeer) !== true) {
@@ -664,9 +673,6 @@ ${info.lastSeq} / ${info.maxSeqInBatch})`,
     pauseRelayReconnection();
     sockets.forEach(([, s]) => {
       s.close();
-      s.onclose = () => {
-        void this.server?.dispatchConnectionStatus();
-      };
     });
     void this.pauseServe();
   }

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

@@ -1,4 +1,4 @@
-import { type ActionSender, type Room } from "@trystero-p2p/nostr";
+import { type Room } from "@trystero-p2p/nostr";
 import { type P2PSyncSetting } from "../../common/types.js";
 import { type ReplicatorHostEnv, type FullFilledDeviceInfo, type Request, type Response, type Payload, type Advertisement, type BindableObject, type BindableFunction } from "./types.js";
 import { StoredMapLike } from "../../dataobject/StoredMap.js";
@@ -56,7 +56,7 @@ export declare class TrysteroReplicatorP2PServer {
     _room?: Room;
     _serverPeerId: string;
     _activeRoomId: string;
-    ___send?: ActionSender<Payload>;
+    ___send?: (data: Payload, peerId?: string) => Promise<void>;
     assignedFunctions: Map<string, BindableFunction>;
     clients: Map<string, TrysteroReplicatorP2PClient>;
     _bindingObjects: BindableObject[];
@@ -81,7 +81,7 @@ export declare class TrysteroReplicatorP2PServer {
     get settings(): P2PSyncSetting;
     get isEnabled(): boolean;
     get deviceInfo(): FullFilledDeviceInfo;
-    _sendAdvertisement?: ActionSender<Advertisement>;
+    _sendAdvertisement?: (data: Advertisement, peerId?: string) => Promise<void>;
     sendAdvertisement(peerId?: string): void;
     _knownAdvertisements: Map<string, Advertisement>;
     get knownAdvertisements(): Advertisement[];
@@ -93,11 +93,10 @@ export declare class TrysteroReplicatorP2PServer {
     _acceptablePeers: Computed<[settings: P2PSyncSetting], RegExp[]>;
     _shouldDenyPeers: Computed<[settings: P2PSyncSetting], RegExp[]>;
     isAcceptablePeer(peerId: string): Promise<boolean>;
-    __send(data: Payload, peerId: string): Promise<void[]>;
+    __send(data: Payload, peerId: string): Promise<void>;
     processArrivedRPC(data: Payload, peerId: string): Promise<void>;
     private _onPeerJoin;
     private _onPeerLeave;
-    activePeer: Map<string, RTCPeerConnection>;
     onAfterJoinRoom(): void;
     startService(bindings?: BindableObject[]): Promise<void>;
     start(bindings?: BindableObject[]): Promise<void>;

package/dist/replication/trystero/TrysteroReplicatorP2PServer.js

@@ -14,6 +14,7 @@ import { shareRunningResult } from "octagonal-wheels/concurrency/lock_v2";
 import { Computed } from "octagonal-wheels/dataobject/Computed";
 import { RpcRoom } from "../../rpc/index.js";
 import { TRYSTERO_RPC_DEFAULTS } from "../../rpc/transports/TrysteroTransport.js";
+import { subscribeTrysteroPeerEvents } from "../../rpc/transports/trysteroRoomEvents.js";
 import { toRpcMethodName } from "./rpcCompat.js";
 import { generateJoinRoomOptions } from "../../rpc/transports/trysteroUtils.js";
 import { subscribeConnectionStatus, subscribeFailureDiagnosis } from "../../rpc/transports/DiagRTCPeerConnections.js";
@@ -333,52 +334,47 @@ You can chose as follows:
       Logger(`Received peer join event from ${peerId}, but no active room. Ignoring.`, LOG_LEVEL_VERBOSE);
       return;
     }
-    const peers = this._room.getPeers();
-    const peer = peers[peerId];
     Logger(`Peer joined: ${peerId}`, LOG_LEVEL_VERBOSE);
-    this.activePeer.set(peerId, peer);
     this.sendAdvertisement(peerId);
   }
   _onPeerLeave(peerId) {
     Logger(`Peer left: ${peerId}`, LOG_LEVEL_VERBOSE);
     this._knownAdvertisements.delete(peerId);
-    const peerConn = this.activePeer.get(peerId);
-    if (peerConn) {
-      peerConn.close();
-      this.activePeer.delete(peerId);
-    }
     void this._env.events.emitEvent(EVENT_DEVICE_LEAVED, peerId);
     void this.dispatchConnectionStatus();
   }
-  activePeer = /* @__PURE__ */ new Map();
   onAfterJoinRoom() {
     Logger(`Initializing...`, LOG_LEVEL_VERBOSE);
     const room = this.room;
     if (!room) throw new Error("This server has been already disconnected");
-    const [sendRpc, arrivedRpc] = room.makeAction("rpc2");
+    const rpcAction = room.makeAction("rpc2");
     const transport = {
       send: (message, peerId) => {
-        return sendRpc(message, peerId).then(() => void 0);
+        return rpcAction.send(message, { target: peerId });
       },
       onMessage: (handler) => {
-        arrivedRpc((data, peerId) => {
+        rpcAction.onMessage = (data, { peerId }) => {
           handler(data, peerId);
-        });
-        return () => void 0;
+        };
+        return () => {
+          rpcAction.onMessage = null;
+        };
       },
       onPeerJoin: (handler) => {
-        room.onPeerJoin((peerId) => {
-          this._onPeerJoin(peerId);
-          handler(peerId);
+        return subscribeTrysteroPeerEvents(room, {
+          onJoin: (peerId) => {
+            this._onPeerJoin(peerId);
+            handler(peerId);
+          }
         });
-        return () => void 0;
       },
       onPeerLeave: (handler) => {
-        room.onPeerLeave((peerId) => {
-          this._onPeerLeave(peerId);
-          handler(peerId);
+        return subscribeTrysteroPeerEvents(room, {
+          onLeave: (peerId) => {
+            this._onPeerLeave(peerId);
+            handler(peerId);
+          }
         });
-        return () => void 0;
       }
     };
     this._rpcRoom?.close();
@@ -393,11 +389,11 @@ You can chose as follows:
         Logger(`RPC Protocol warning${peerId ? ` from ${peerId}` : ""}: ${message}`, LOG_LEVEL_VERBOSE);
       }
     });
-    const [adSend, adArrived] = room.makeAction("ad");
-    this._sendAdvertisement = adSend;
-    adArrived((data, peerId) => {
+    const advertisementAction = room.makeAction("ad");
+    this._sendAdvertisement = (data, peerId) => advertisementAction.send(data, peerId ? { target: peerId } : void 0);
+    advertisementAction.onMessage = (data, { peerId }) => {
       void this.onAdvertisement(data, peerId);
-    });
+    };
     this._env.events.emitEvent(EVENT_P2P_CONNECTED);
     void this.dispatchConnectionStatus();
   }
@@ -494,14 +490,10 @@ You can chose as follows:
   }
   async close() {
     this.assignedFunctions.clear();
-    const peers = this.room?.getPeers() ?? {};
     this.clients.forEach((client) => client.close());
     this.clients.clear();
     this._rpcRoom?.close();
     this._rpcRoom = void 0;
-    for (const [, peer] of Object.entries(peers)) {
-      peer.close();
-    }
     await this.ensureLeaved();
     this._activeRoomId = "";
     this._knownAdvertisements.clear();

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

@@ -2,10 +2,18 @@ import type { ReactiveSource } from "octagonal-wheels/dataobject/reactive_v2";
 import type { LiveSyncTrysteroReplicator } from "./LiveSyncTrysteroReplicator.js";
 import type { P2PLogCollector } from "./P2PLogCollector.js";
 export type UseP2PReplicatorResult = {
-    replicator: LiveSyncTrysteroReplicator;
+    /**
+     * The current replicator selected by the host lifecycle.
+     *
+     * Read this property at the point of use. Retaining a destructured value
+     * across settings or database lifecycle events can target a closed,
+     * replaced instance.
+     */
+    readonly replicator: LiveSyncTrysteroReplicator;
 };
 export type P2PPaneParams = {
-    replicator: LiveSyncTrysteroReplicator;
+    /** Current replicator; preserve the result object so its getter remains live. */
+    readonly replicator: LiveSyncTrysteroReplicator;
     p2pLogCollector: P2PLogCollector;
     storeP2PStatusLine: ReactiveSource<string>;
 };

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

@@ -17,11 +17,13 @@ export interface P2PReplicatorLike {
         isServing?: boolean;
     };
 }
+/** Resolves the replicator which currently owns P2P state. */
+export type P2PReplicatorProvider = () => P2PReplicatorLike;
 /**
  * Add event handlers for P2P replication related events.
- * @param instance P2PReplicatorLike instance
+ * @param source A fixed compatibility instance or a provider for a replaceable replicator.
  */
-export declare function addP2PEventHandlers(instance: P2PReplicatorLike, events: LiveSyncEventHub): void;
+export declare function addP2PEventHandlers(source: P2PReplicatorLike | P2PReplicatorProvider, events: LiveSyncEventHub): void;
 /**
  * open P2P replicator if not opened yet.
  * @param instance

package/dist/replication/trystero/addP2PEventHandlers.js

@@ -1,22 +1,24 @@
 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 addP2PEventHandlers(instance, events) {
+function addP2PEventHandlers(source, events) {
+  const current = () => typeof source === "function" ? source() : source;
   events.onEvent(EVENT_ADVERTISEMENT_RECEIVED, (peer) => {
-    void instance.onNewPeer(peer);
+    void current().onNewPeer(peer);
   });
   events.onEvent(EVENT_DEVICE_LEAVED, (peerId) => {
-    instance.onPeerLeaved(peerId);
+    current().onPeerLeaved(peerId);
   });
   events.onEvent(EVENT_REQUEST_STATUS, () => {
-    instance.requestStatus();
+    current().requestStatus();
   });
   events.onEvent(EVENT_DATABASE_REBUILT, async () => {
-    await instance.open();
+    await current().open();
   });
   events.onEvent(EVENT_PLATFORM_UNLOADED, () => {
-    void instance.close();
+    void current().close();
   });
   events.onEvent(EVENT_SETTING_SAVED, async (settings) => {
+    const instance = current();
     const isOpen = instance.isServing ?? instance.server?.isServing ?? false;
     if (settings.P2P_Enabled && settings.P2P_AutoStart) {
       await instance.open();

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

@@ -85,6 +85,8 @@ export interface ReplicatorHostEnv extends ReplicatorHost {
     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>;
     processReplicatedDocs(docs: Array<PouchDB.Core.ExistingDocument<EntryDoc>>): void | Promise<void>;
 }
 export type Advertisement = {

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

@@ -4,4 +4,4 @@ import type { UseP2PReplicatorResult } from "./UseP2PReplicatorResult.js";
  * ServiceFeature: Registers event handlers for P2P replication and manages the lifecycle of a LiveSyncTrysteroReplicator instance.
  * @param host
  */
-export declare function useP2PReplicatorCommands(host: NecessaryServices<"API" | "setting", never>, { replicator }: UseP2PReplicatorResult): void;
+export declare function useP2PReplicatorCommands(host: NecessaryServices<"API" | "setting", never>, result: UseP2PReplicatorResult): void;

package/dist/replication/trystero/useP2PReplicatorCommands.js

@@ -1,9 +1,10 @@
 import { Logger, LOG_LEVEL_NOTICE } from "octagonal-wheels/common/logger";
-function useP2PReplicatorCommands(host, { replicator }) {
+function useP2PReplicatorCommands(host, result) {
   host.services.API.addCommand({
     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();
@@ -13,6 +14,7 @@ function useP2PReplicatorCommands(host, { replicator }) {
     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;
       Logger("Closing P2P Connection", LOG_LEVEL_NOTICE);

package/dist/replication/trystero/useP2PReplicatorFeature.js

@@ -19,7 +19,7 @@ function useP2PReplicatorFeature(host, openReplicationUIFactory, openRebuildUIFa
       return replicator;
     }
   };
-  addP2PEventHandlers(activeReplicator.replicator, host.services.context.events);
+  addP2PEventHandlers(() => activeReplicator.replicator, host.services.context.events);
   host.services.replicator.getNewReplicator.addHandler(
     async (settingOverride = {}) => {
       const settings = { ...host.services.setting.currentSettings(), ...settingOverride };

package/dist/rpc/RpcRoom.d.ts

@@ -10,7 +10,7 @@ export declare class RpcRoom {
     private incomingChunkMap;
     private incomingChunkTimers;
     private peerVersion;
-    private disposer;
+    private disposers;
     constructor(options: RpcRoomOptions);
     close(): void;
     session(peerId: string): RpcSession;