@vrtmrz/livesync-commonlib 0.1.24 → 0.1.26

package/dist/p2p/P2PService.d.ts

@@ -5,6 +5,7 @@ import { LiveSyncTrysteroReplicator, type LiveSyncTrysteroReplicatorEnv } from "
 import type { P2PReplicationResult } from "../replication/trystero/TrysteroReplicator.js";
 import type { AcceptanceDecision, RevokeAcceptanceDecision } from "../replication/trystero/TrysteroReplicatorP2PServer.js";
 import type { Advertisement } from "../replication/trystero/types.js";
+import { type PrepareP2PSettings } from "../replication/trystero/P2PRoomSessionOwner.js";
 import { type ReplicationOutcome } from "../replication/ReplicatorProvider.js";
 import type { P2PConnectionProbeAdmission } from "../replication/trystero/P2PConnectionProbeAdmission.js";
 export { ACTIVE_P2P_RELAY_BINDING_CONFLICT } from "../replication/trystero/P2PConnectionProbeAdmission.js";
@@ -114,10 +115,15 @@ export interface P2PServiceComposition {
     /** Create a non-owning adapter for the active Replicator selection. */
     createActiveReplicator(): ReplicatorInstance;
 }
+/** Optional host dependencies used by the private P2P service composition. */
+export interface P2PServiceOptions {
+    readonly prepareP2PSettings?: PrepareP2PSettings;
+}
+export type { PrepareP2PSettings };
 /**
  * Compose stable capability views over one private P2P service context.
  *
  * `P2PRoomSessionOwner` remains the resource owner. The returned composition
  * object is host wiring, not a capability façade for ordinary consumers.
  */
-export declare function createP2PService(env: LiveSyncTrysteroReplicatorEnv): P2PServiceComposition;
+export declare function createP2PService(env: LiveSyncTrysteroReplicatorEnv, options?: P2PServiceOptions): P2PServiceComposition;

package/dist/p2p/P2PService.js

@@ -2,7 +2,9 @@ import { getPeerConnectionStats } from "../rpc/transports/DiagRTCPeerConnections
 import {
   LiveSyncTrysteroReplicator
 } from "../replication/trystero/LiveSyncTrysteroReplicator.js";
-import { P2PRoomSessionOwner } from "../replication/trystero/P2PRoomSessionOwner.js";
+import {
+  P2PRoomSessionOwner
+} from "../replication/trystero/P2PRoomSessionOwner.js";
 import { compatGlobal } from "../common/coreEnvFunctions.js";
 import {
   REPLICATION_CANCELLED,
@@ -75,12 +77,16 @@ function closeForLifecycle(owner, state) {
   cancelDelayedAutomation(owner, state);
   return owner.close();
 }
-function reconcileAutoStart(context, settings) {
+async function reconcileAutoStart(context, settings) {
   if (!settings.P2P_Enabled || !settings.P2P_AutoStart) {
-    return context.roomSessionOwner.setPersistentDemand("automatic", false);
+    await context.roomSessionOwner.setPersistentDemand("automatic", false);
+    return;
+  }
+  if (context.state.explicitDisconnectVeto || context.state.lifecycleClosed) return;
+  try {
+    await context.roomSessionOwner.setPersistentDemand("automatic", true);
+  } catch {
   }
-  if (context.state.explicitDisconnectVeto || context.state.lifecycleClosed) return Promise.resolve();
-  return context.roomSessionOwner.setPersistentDemand("automatic", true);
 }
 function scheduleAutoStart(context, delayMs = 100) {
   clearDelayedAutoStart(context.state);
@@ -224,8 +230,8 @@ function createServiceLifecycle(context) {
     scheduleAutoStart: (delayMs) => scheduleAutoStart(context, delayMs)
   };
 }
-function createP2PService(env) {
-  const roomSessionOwner = new P2PRoomSessionOwner(env);
+function createP2PService(env, options = {}) {
+  const roomSessionOwner = new P2PRoomSessionOwner(env, void 0, options);
   const state = {
     explicitDisconnectVeto: false,
     lifecycleClosed: false,

package/dist/p2p/index.d.ts

@@ -1,4 +1,4 @@
-export type { P2PCandidateSummary, P2PChangeRelay, P2PConfigurationExchange, P2PDiagnostics, P2PPeerConnectionMetrics, P2PPeerAdmission, P2PPeerDirectory, P2PServiceViews, P2PTargetedTransfer, P2PTransportLifecycle, P2PConnectionProbeAdmission, P2PConnectionProbeAdmissionResult, P2PConnectionProbeSettings, } from "./P2PService.js";
+export type { P2PCandidateSummary, P2PChangeRelay, P2PConfigurationExchange, P2PDiagnostics, P2PPeerConnectionMetrics, P2PPeerAdmission, P2PPeerDirectory, P2PServiceViews, P2PTargetedTransfer, P2PTransportLifecycle, P2PConnectionProbeAdmission, P2PConnectionProbeAdmissionResult, P2PConnectionProbeSettings, P2PServiceOptions, PrepareP2PSettings, } from "./P2PService.js";
 export { ACTIVE_P2P_RELAY_BINDING_CONFLICT } from "./P2PService.js";
 export { useP2PReplicatorCommands } from "../replication/trystero/useP2PReplicatorCommands.js";
 export { useP2PReplicatorFeature } from "../replication/trystero/useP2PReplicatorFeature.js";
@@ -6,3 +6,5 @@ export type { OpenRebuildUIFactory, OpenReplicationUIFactory, } from "../replica
 export type { UseP2PReplicatorResult } from "../replication/trystero/UseP2PReplicatorResult.js";
 export type { P2PReplicationResult } from "../replication/trystero/TrysteroReplicator.js";
 export type { Advertisement } from "../replication/trystero/types.js";
+export { P2P_ICE_SERVER_EXPIRY_MARGIN_MS, P2P_SETTINGS_PREPARATION_TIMEOUT_MS, } from "../replication/trystero/P2PRoomSessionOwner.js";
+export type { P2PReplicatorFeatureOptions } from "../replication/trystero/useP2PReplicatorFeature.js";

package/dist/p2p/index.js

@@ -1,8 +1,14 @@
 import { ACTIVE_P2P_RELAY_BINDING_CONFLICT } from "./P2PService.js";
 import { useP2PReplicatorCommands } from "../replication/trystero/useP2PReplicatorCommands.js";
 import { useP2PReplicatorFeature } from "../replication/trystero/useP2PReplicatorFeature.js";
+import {
+  P2P_ICE_SERVER_EXPIRY_MARGIN_MS,
+  P2P_SETTINGS_PREPARATION_TIMEOUT_MS
+} from "../replication/trystero/P2PRoomSessionOwner.js";
 export {
   ACTIVE_P2P_RELAY_BINDING_CONFLICT,
+  P2P_ICE_SERVER_EXPIRY_MARGIN_MS,
+  P2P_SETTINGS_PREPARATION_TIMEOUT_MS,
   useP2PReplicatorCommands,
   useP2PReplicatorFeature
 };

package/dist/pouchdb/LiveSyncLocalDB.d.ts

@@ -196,12 +196,14 @@ export declare class LiveSyncLocalDB {
     bulkDocsRaw<T extends EntryDoc>(docs: Array<PouchDB.Core.PutDocument<T>>, options?: PouchDB.Core.BulkDocsOptions): Promise<Array<PouchDB.Core.Response | PouchDB.Core.Error>>;
     isTargetFile(filenameSrc: string): boolean;
     getDBEntryMeta(path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions, includeDeleted?: boolean): Promise<false | LoadedEntry>;
-    getDBEntry(path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions, dump?: boolean, waitForReady?: boolean, includeDeleted?: boolean): Promise<false | LoadedEntry>;
-    getDBEntryFromMeta(meta: LoadedEntry | MetaEntry, dump?: boolean, waitForReady?: boolean): Promise<false | LoadedEntry>;
+    getDBEntry(path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions, dump?: boolean, waitForReady?: boolean, includeDeleted?: boolean, localOnly?: boolean): Promise<false | LoadedEntry>;
+    getDBEntryFromMeta(meta: LoadedEntry | MetaEntry, dump?: boolean, waitForReady?: boolean, localOnly?: boolean): Promise<false | LoadedEntry>;
     deleteDBEntry(path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions): Promise<boolean>;
     storeDeletionAtRevision(path: FilePathWithPrefix | FilePath, baseRevision: string): Promise<false | PouchDB.Core.Response>;
     putDBEntry(note: SavingEntry, onlyChunks?: boolean, conflictBaseRev?: string): Promise<false | PouchDB.Core.Response>;
     putDBEntryWithLiveBaseRevision(note: SavingEntry, baseRevision: string, onlyChunks?: boolean): Promise<false | PouchDB.Core.Response>;
+    /** Preserve existing branches and delegate a fresh root write to the entry manager. */
+    putDBEntryAsIndependentRoot(note: SavingEntry): Promise<false | PouchDB.Core.Response>;
     getConflictedDoc(path: FilePathWithPrefix, rev: string): Promise<false | diff_result_leaf>;
     tryAutoMerge(path: FilePathWithPrefix, enableMarkdownAutoMerge: boolean): AutoMergeResult;
 }

package/dist/pouchdb/LiveSyncLocalDB.js

@@ -457,11 +457,11 @@ class LiveSyncLocalDB {
   async getDBEntryMeta(path, opt, includeDeleted = false) {
     return await this.managers.entryManager.getDBEntryMeta(path, opt, includeDeleted);
   }
-  async getDBEntry(path, opt, dump = false, waitForReady = true, includeDeleted = false) {
-    return await this.managers.entryManager.getDBEntry(path, opt, dump, waitForReady, includeDeleted);
+  async getDBEntry(path, opt, dump = false, waitForReady = true, includeDeleted = false, localOnly = false) {
+    return await this.managers.entryManager.getDBEntry(path, opt, dump, waitForReady, includeDeleted, localOnly);
   }
-  async getDBEntryFromMeta(meta, dump = false, waitForReady = true) {
-    return await this.managers.entryManager.getDBEntryFromMeta(meta, dump, waitForReady);
+  async getDBEntryFromMeta(meta, dump = false, waitForReady = true, localOnly = false) {
+    return await this.managers.entryManager.getDBEntryFromMeta(meta, dump, waitForReady, localOnly);
   }
   async deleteDBEntry(path, opt) {
     return await this.managers.entryManager.deleteDBEntry(path, opt);
@@ -475,6 +475,10 @@ class LiveSyncLocalDB {
   async putDBEntryWithLiveBaseRevision(note, baseRevision, onlyChunks) {
     return await this.managers.entryManager.putDBEntryWithLiveBaseRevision(note, baseRevision, onlyChunks);
   }
+  /** Preserve existing branches and delegate a fresh root write to the entry manager. */
+  async putDBEntryAsIndependentRoot(note) {
+    return await this.managers.entryManager.putDBEntryAsIndependentRoot(note);
+  }
   async getConflictedDoc(path, rev) {
     return await this.managers.conflictManager.getConflictedDoc(path, rev);
   }

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

@@ -1,8 +1,16 @@
+import { type P2PSyncSetting } from "../../common/types.js";
 import type { LiveSyncReplicatorEnv } from "../LiveSyncAbstractReplicator.js";
 import { P2PRoomSession } from "./P2PRoomSession.js";
 import type { ReplicatorHostEnv } from "./types.js";
 import { type P2PConnectionProbeAdmissionResult, type P2PConnectionProbeSettings } from "./P2PConnectionProbeAdmission.js";
 type P2PRoomSessionFactory = (env: ReplicatorHostEnv) => P2PRoomSession;
+/** Prepare connection-only P2P settings for one room generation. */
+export type PrepareP2PSettings = (settings: Readonly<P2PSyncSetting>, signal: AbortSignal) => Promise<P2PSyncSetting>;
+export interface P2PRoomSessionOwnerOptions {
+    readonly prepareP2PSettings?: PrepareP2PSettings;
+}
+export declare const P2P_SETTINGS_PREPARATION_TIMEOUT_MS = 30000;
+export declare const P2P_ICE_SERVER_EXPIRY_MARGIN_MS = 30000;
 /** Session operations shared by the stable service and its compatibility facade. */
 export interface P2PRoomSessionAccess {
     readonly currentSession: P2PRoomSession | undefined;
@@ -22,13 +30,16 @@ export type P2PPersistentRoomDemand = "explicit" | "automatic" | "rebuild-contin
 export declare class P2PRoomSessionOwner implements P2PRoomSessionAccess {
     private readonly env;
     private readonly createSession;
+    private readonly options;
     private current?;
     private lifecycleOperation;
     private readonly persistentDemands;
     private readonly finiteDemands;
     private readonly automationCoordinator;
     private activeBinding?;
-    constructor(env: LiveSyncReplicatorEnv, createSession?: P2PRoomSessionFactory);
+    private pendingPreparation?;
+    private runtimeGeneration;
+    constructor(env: LiveSyncReplicatorEnv, createSession?: P2PRoomSessionFactory, options?: P2PRoomSessionOwnerOptions);
     get currentSession(): P2PRoomSession | undefined;
     get isConnected(): boolean;
     cancelActiveTransfers(): void;
@@ -52,6 +63,16 @@ export declare class P2PRoomSessionOwner implements P2PRoomSessionAccess {
     private enqueueLifecycleOperation;
     private closeTransport;
     private bindingsMatch;
+    private connectionSettingsRemainUsable;
+    private fencePreparationForCurrentSettings;
+    private invalidatePreparation;
+    private prepareConnectionSettings;
+    private prepareWithDeadline;
+    private copyPreparedIceServers;
+    private hasUsableIceServer;
+    private hasUsableTurnServer;
+    private withRoomOpenDeadline;
+    private assertReconciliationCurrent;
     /** Capture immutable session inputs while keeping policy live. */
     private getEffectiveBinding;
     /** Apply policy which can change without retiring the room session. */

package/dist/replication/trystero/P2PRoomSessionOwner.js

@@ -2,8 +2,12 @@ import { Logger } from "../../common/logger.js";
 import {
   LOG_LEVEL_NOTICE,
   LOG_LEVEL_VERBOSE,
-  SETTING_KEY_P2P_DEVICE_NAME
+  SETTING_KEY_P2P_DEVICE_NAME,
+  hasManagedP2PTurnConfiguration,
+  omitP2PRuntimeSettings
 } from "../../common/types.js";
+import { P2PConnectionPaths } from "../../common/models/setting.const.js";
+import { normaliseP2PConnectionPath } from "../../common/models/setting.p2p.js";
 import { P2PRoomSession } from "./P2PRoomSession.js";
 import { P2PAutomationCoordinator } from "./P2PAutomationCoordinator.js";
 import { PEER_REPLICATION_READINESS } from "../ReplicatorProvider.js";
@@ -12,19 +16,28 @@ import {
   ACTIVE_P2P_RELAY_BINDING_CONFLICT,
   activeP2PRelayBindingCovers
 } from "./P2PConnectionProbeAdmission.js";
+class StaleRoomReconciliationError extends Error {
+}
+const P2P_ROOM_OPEN_TIMEOUT_MS = 3e4;
+const P2P_SETTINGS_PREPARATION_TIMEOUT_MS = 3e4;
+const P2P_ICE_SERVER_EXPIRY_MARGIN_MS = 3e4;
 class P2PRoomSessionOwner {
-  constructor(env, createSession = (sessionEnv) => new P2PRoomSession(sessionEnv)) {
+  constructor(env, createSession = (sessionEnv) => new P2PRoomSession(sessionEnv), options = {}) {
     this.env = env;
     this.createSession = createSession;
+    this.options = options;
   }
   env;
   createSession;
+  options;
   current;
   lifecycleOperation = Promise.resolve();
   persistentDemands = /* @__PURE__ */ new Set();
   finiteDemands = /* @__PURE__ */ new Set();
   automationCoordinator = new P2PAutomationCoordinator();
   activeBinding;
+  pendingPreparation;
+  runtimeGeneration = 0;
   get currentSession() {
     return this.current;
   }
@@ -52,6 +65,7 @@ class P2PRoomSessionOwner {
     if (active && !enabled) {
       Logger(this.env.services.context.translate("P2P.NotEnabled"), LOG_LEVEL_NOTICE);
     }
+    this.fencePreparationForCurrentSettings(enabled);
     await this.reconcileTransport();
   }
   /**
@@ -66,6 +80,7 @@ class P2PRoomSessionOwner {
     }
     const demand = /* @__PURE__ */ Symbol("p2p-finite-room-demand");
     this.finiteDemands.add(demand);
+    this.fencePreparationForCurrentSettings(true);
     try {
       await this.reconcileTransport();
       if (!this.finiteDemands.has(demand)) {
@@ -116,7 +131,7 @@ class P2PRoomSessionOwner {
         return;
       }
       const binding = this.getEffectiveBinding();
-      if (this.current?.host.isServing && this.bindingsMatch(this.activeBinding, binding)) {
+      if (this.current?.host.isServing && this.bindingsMatch(this.activeBinding, binding) && this.connectionSettingsRemainUsable(this.activeBinding?.settings)) {
         this.reconcileCurrentSessionPolicy(this.current);
         Logger("P2P replicator is already open.");
         return;
@@ -125,34 +140,55 @@ class P2PRoomSessionOwner {
         await this.closeTransport();
       }
       let candidate;
+      const operationGeneration = this.runtimeGeneration;
       try {
-        candidate = this.createSession(this.buildSessionEnv(binding));
-        await candidate.open();
+        const connectionSettings = await this.prepareConnectionSettings(binding, operationGeneration);
+        this.assertReconciliationCurrent(binding, operationGeneration, connectionSettings);
+        const connectionBinding = { ...binding, settings: connectionSettings };
+        candidate = this.createSession(this.buildSessionEnv(connectionBinding));
+        if (hasManagedP2PTurnConfiguration(binding.settings)) {
+          await this.withRoomOpenDeadline(candidate.open());
+        } else {
+          await candidate.open();
+        }
         if (!candidate.host.isServing) {
           throw new Error("The P2P room did not start serving.");
         }
         const currentBinding = this.getEffectiveBinding();
-        if (!currentBinding.enabled || !this.hasRoomDemand() || !this.bindingsMatch(binding, currentBinding)) {
+        if (!currentBinding.enabled || !this.hasRoomDemand() || !this.bindingsMatch(binding, currentBinding) || operationGeneration !== this.runtimeGeneration || !this.connectionSettingsRemainUsable(connectionSettings)) {
           await candidate.retire();
           return;
         }
         this.current = candidate;
-        this.activeBinding = binding;
+        this.activeBinding = connectionBinding;
         this.reconcileCurrentSessionPolicy(candidate);
       } catch (error) {
         await candidate?.retire(error).catch((retirementError) => {
-          Logger(retirementError, LOG_LEVEL_VERBOSE);
+          if (hasManagedP2PTurnConfiguration(binding.settings)) {
+            Logger("The managed P2P room could not be retired cleanly.", LOG_LEVEL_VERBOSE);
+          } else {
+            Logger(retirementError, LOG_LEVEL_VERBOSE);
+          }
         });
-        Logger(error instanceof Error ? error.message : "Error while opening P2P connection", LOG_LEVEL_NOTICE);
-        Logger(error, LOG_LEVEL_VERBOSE);
         this.current = void 0;
         this.activeBinding = void 0;
+        if (error instanceof StaleRoomReconciliationError || operationGeneration !== this.runtimeGeneration) {
+          return;
+        }
+        if (hasManagedP2PTurnConfiguration(binding.settings)) {
+          Logger("The managed P2P room could not be prepared or opened.", LOG_LEVEL_NOTICE);
+          Logger("Managed P2P room failure details were omitted.", LOG_LEVEL_VERBOSE);
+          throw new Error("The managed P2P room could not be prepared or opened.");
+        }
+        Logger(error instanceof Error ? error.message : "Error while opening P2P connection", LOG_LEVEL_NOTICE);
+        Logger(error, LOG_LEVEL_VERBOSE);
       }
     });
   }
   async close() {
     this.persistentDemands.clear();
     this.finiteDemands.clear();
+    this.invalidatePreparation();
     await this.enqueueLifecycleOperation(async () => {
       await this.closeTransport();
     });
@@ -179,11 +215,153 @@ class P2PRoomSessionOwner {
   bindingsMatch(current, candidate) {
     return current?.database === candidate.database && current.signature === candidate.signature;
   }
+  connectionSettingsRemainUsable(settings) {
+    if (!settings) return false;
+    const managed = hasManagedP2PTurnConfiguration(settings);
+    const iceServers = settings.P2P_iceServers;
+    if (iceServers === void 0) return !managed;
+    if (!this.hasUsableIceServer(iceServers)) return false;
+    const hasTurnServer = this.hasUsableTurnServer(iceServers);
+    if (managed && !hasTurnServer) return false;
+    if (normaliseP2PConnectionPath(settings.P2P_connectionPath) === P2PConnectionPaths.Relay && !hasTurnServer) {
+      return false;
+    }
+    const expiresAt = settings.P2P_iceServersExpiresAt;
+    if (expiresAt === void 0) return !managed;
+    return Number.isFinite(expiresAt) && expiresAt > Date.now() + P2P_ICE_SERVER_EXPIRY_MARGIN_MS;
+  }
+  fencePreparationForCurrentSettings(enabled) {
+    if (!enabled) {
+      this.invalidatePreparation();
+      return;
+    }
+    const pendingChanged = this.pendingPreparation !== void 0 && this.pendingPreparation.signature !== this.getEffectiveBinding().signature;
+    if (pendingChanged) this.invalidatePreparation();
+  }
+  invalidatePreparation() {
+    this.runtimeGeneration += 1;
+    const pending = this.pendingPreparation;
+    this.pendingPreparation = void 0;
+    if (pending && !pending.controller.signal.aborted) {
+      pending.controller.abort(new Error("The P2P settings preparation was cancelled."));
+    }
+  }
+  async prepareConnectionSettings(binding, operationGeneration) {
+    const managed = hasManagedP2PTurnConfiguration(binding.settings);
+    const prepare = this.options.prepareP2PSettings;
+    if (!prepare) {
+      if (managed) throw new Error("The selected managed TURN configuration is not supported by this host.");
+      return binding.settings;
+    }
+    const controller = new AbortController();
+    const pending = {
+      signature: binding.signature,
+      controller
+    };
+    this.pendingPreparation = pending;
+    try {
+      const prepared = await this.prepareWithDeadline(prepare, binding.settings, controller);
+      if (prepared.P2P_iceServers === void 0 && prepared.P2P_iceServersExpiresAt === void 0) {
+        if (managed) throw new Error("The prepared managed TURN settings do not include ICE servers.");
+        return binding.settings;
+      }
+      const iceServers = this.copyPreparedIceServers(prepared.P2P_iceServers);
+      const expiresAt = prepared.P2P_iceServersExpiresAt;
+      const connectionSettings = {
+        ...binding.settings,
+        P2P_iceServers: iceServers,
+        P2P_iceServersExpiresAt: expiresAt
+      };
+      if (!this.connectionSettingsRemainUsable(connectionSettings)) {
+        throw new Error("The prepared managed TURN settings are missing usable ICE servers or expiry.");
+      }
+      this.assertReconciliationCurrent(binding, operationGeneration, connectionSettings);
+      return connectionSettings;
+    } finally {
+      if (this.pendingPreparation === pending) {
+        this.pendingPreparation = void 0;
+      }
+    }
+  }
+  prepareWithDeadline(prepare, settings, controller) {
+    const preparation = Promise.resolve().then(() => prepare(Object.freeze({ ...settings }), controller.signal));
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const finish = (operation) => {
+        if (settled) return;
+        settled = true;
+        globalThis.clearTimeout(timeout);
+        controller.signal.removeEventListener("abort", onAbort);
+        operation();
+      };
+      const onAbort = () => finish(
+        () => reject(
+          controller.signal.reason instanceof Error ? controller.signal.reason : new Error("The P2P settings preparation was cancelled.")
+        )
+      );
+      const timeout = globalThis.setTimeout(() => {
+        controller.abort(new Error("The P2P settings preparation timed out."));
+      }, P2P_SETTINGS_PREPARATION_TIMEOUT_MS);
+      controller.signal.addEventListener("abort", onAbort, { once: true });
+      if (controller.signal.aborted) onAbort();
+      preparation.then(
+        (prepared) => finish(() => resolve(prepared)),
+        () => finish(() => reject(new Error("The P2P settings preparation failed.")))
+      );
+    });
+  }
+  copyPreparedIceServers(iceServers) {
+    if (!Array.isArray(iceServers) || iceServers.length === 0) return [];
+    return iceServers.map((server) => ({
+      urls: typeof server.urls === "string" ? server.urls : [...server.urls],
+      ...server.username === void 0 ? {} : { username: server.username },
+      ...server.credential === void 0 ? {} : { credential: server.credential }
+    }));
+  }
+  hasUsableIceServer(iceServers) {
+    return Array.isArray(iceServers) && iceServers.some((server) => {
+      const urls = typeof server?.urls === "string" ? [server.urls] : server?.urls;
+      return Array.isArray(urls) && urls.some((url) => typeof url === "string" && url.trim().length > 0);
+    });
+  }
+  hasUsableTurnServer(iceServers) {
+    return Array.isArray(iceServers) && iceServers.some((server) => {
+      const urls = typeof server?.urls === "string" ? [server.urls] : server?.urls;
+      return Array.isArray(urls) && urls.some((url) => typeof url === "string" && /^turns?:/iu.test(url));
+    });
+  }
+  async withRoomOpenDeadline(opening) {
+    let timeout;
+    try {
+      await Promise.race([
+        opening,
+        new Promise((_resolve, reject) => {
+          timeout = globalThis.setTimeout(
+            () => reject(new Error("The P2P room opening timed out.")),
+            P2P_ROOM_OPEN_TIMEOUT_MS
+          );
+        })
+      ]);
+    } finally {
+      if (timeout !== void 0) globalThis.clearTimeout(timeout);
+    }
+  }
+  assertReconciliationCurrent(binding, operationGeneration, connectionSettings) {
+    if (operationGeneration !== this.runtimeGeneration || !this.hasRoomDemand()) {
+      throw new StaleRoomReconciliationError();
+    }
+    const currentBinding = this.getEffectiveBinding();
+    if (!currentBinding.enabled) throw new StaleRoomReconciliationError();
+    if (binding && !this.bindingsMatch(binding, currentBinding)) throw new StaleRoomReconciliationError();
+    if (connectionSettings && !this.connectionSettingsRemainUsable(connectionSettings)) {
+      throw new StaleRoomReconciliationError();
+    }
+  }
   /** Capture immutable session inputs while keeping policy live. */
   getEffectiveBinding() {
-    const settings = {
+    const settings = omitP2PRuntimeSettings({
       ...this.env.services.setting.currentSettings()
-    };
+    });
     const deviceName = this.env.services.config.getSmallConfig(SETTING_KEY_P2P_DEVICE_NAME) || this.env.services.vault.getVaultName();
     const database = this.env.services.database.localDatabase.localDatabase;
     this.automationCoordinator.reconcileIdentity(
@@ -245,5 +423,7 @@ class P2PRoomSessionOwner {
   }
 }
 export {
-  P2PRoomSessionOwner
+  P2PRoomSessionOwner,
+  P2P_ICE_SERVER_EXPIRY_MARGIN_MS,
+  P2P_SETTINGS_PREPARATION_TIMEOUT_MS
 };

package/dist/replication/trystero/TrysteroReplicator.js

@@ -1,4 +1,7 @@
-import { TweakValuesShouldMatchedTemplate } from "../../common/types.js";
+import {
+  TweakValuesShouldMatchedTemplate,
+  omitP2PRuntimeSettings
+} from "../../common/types.js";
 import { assessTweakCompatibility } from "../../common/models/tweak.compatibility.js";
 import {
   LOG_LEVEL_INFO,
@@ -253,12 +256,15 @@ class TrysteroReplicator {
           );
         });
         const setting = {
-          ...this.settings,
+          ...omitP2PRuntimeSettings(this.settings),
           configPassphraseStore: "",
           encryptedCouchDBConnection: "",
           encryptedPassphrase: "",
           pluginSyncExtendedSetting: {}
         };
+        delete setting.P2P_managedType;
+        delete setting.P2P_managedId;
+        delete setting.P2P_managedToken;
         if (!passphrase || passphrase.trim() == "") {
           Logger(
             "Passphrase is required to transfer the configuration. The peer cannot be decrypt the config\nIf you repeatedly receive unintended configuration-sharing requests, change the RPC channel immediately. It allows you to leave the connection and disappear, while they are trying brute force attack for the decoy on their local.",
@@ -700,7 +706,7 @@ ${info.lastSeq} / ${info.maxSeqInBatch})`,
       const decryptedConfig = JSON.parse(
         await decrypt(encryptedConfig, passphrase)
       );
-      return decryptedConfig;
+      return omitP2PRuntimeSettings(decryptedConfig);
     } catch (e) {
       Logger("Error while decrypting the configuration", LOG_LEVEL_NOTICE);
       Logger(e, LOG_LEVEL_VERBOSE);

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

@@ -121,6 +121,7 @@ export declare class TrysteroReplicatorP2PServer {
     onAfterJoinRoom(): void;
     startService(bindings?: BindableObject[], beforeAdvertisement?: () => void): Promise<void>;
     start(bindings?: BindableObject[], beforeAdvertisement?: () => void): Promise<void>;
+    private logTransportError;
     /**
      * @deprecated Use serveFunction or serveObject instead. This is only for backward compatibility and may be removed in the future.
      * @param type

package/dist/replication/trystero/TrysteroReplicatorP2PServer.js

@@ -79,7 +79,7 @@ class TrysteroReplicatorP2PServer {
           `Some error has been occurred while leaving the room, but possibly can be ignored`,
           LOG_LEVEL_VERBOSE
         );
-        Logger(ex, LOG_LEVEL_VERBOSE);
+        this.logTransportError(ex);
       }
       this._room = void 0;
       this._env.events.emitEvent(EVENT_P2P_DISCONNECTED);
@@ -97,7 +97,7 @@ class TrysteroReplicatorP2PServer {
       this._rpcRoom = void 0;
     } catch (ex) {
       Logger(`Some error has been occurred while shutting down the server`, LOG_LEVEL_INFO);
-      Logger(ex, LOG_LEVEL_VERBOSE);
+      this.logTransportError(ex);
     }
   }
   /** Release subscriptions whose lifetime is the host object rather than one transport join. */
@@ -459,7 +459,7 @@ You can chose as follows:
       handshakeTimeoutMs: 3e4,
       onJoinError: (error) => {
         Logger("Some peer Failed to join Trystero room");
-        Logger(error, LOG_LEVEL_VERBOSE);
+        this.logTransportError(error);
       }
     });
     await this.setRoom(room);
@@ -468,6 +468,13 @@ You can chose as follows:
     void this.dispatchConnectionStatus();
     await this.startService(bindings, beforeAdvertisement);
   }
+  logTransportError(error) {
+    if (this.settings.P2P_iceServers !== void 0) {
+      Logger("Managed P2P transport error details were omitted.", LOG_LEVEL_VERBOSE);
+      return;
+    }
+    Logger(error, LOG_LEVEL_VERBOSE);
+  }
   /**
    * @deprecated Use serveFunction or serveObject instead. This is only for backward compatibility and may be removed in the future.
    * @param type

package/dist/replication/trystero/p2pReplicatorConfigurationIdentity.js

@@ -1,25 +1,28 @@
 import { P2PConnectionPaths } from "../../common/models/setting.const.js";
 import {
   hasValidP2PTurnServerUrl,
+  hasManagedP2PTurnConfiguration,
   normaliseP2PConnectionPath,
   normaliseP2PMaxWirePayloadBytes,
   splitP2PRelayUrls,
   splitP2PTurnServerUrls
 } from "../../common/models/setting.p2p.js";
 function getP2PReplicatorConfigurationIdentity(settings) {
+  const managedTurnSelected = hasManagedP2PTurnConfiguration(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;
+  const effectivePath = configuredPath === P2PConnectionPaths.Relay && (managedTurnSelected || hasValidP2PTurnServerUrl(turnServerValue)) ? P2PConnectionPaths.Relay : P2PConnectionPaths.Automatic;
+  const turnAuthentication = !managedTurnSelected && 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,
+    managedTurnSelected ? void 0 : turnServers,
     turnAuthentication,
+    managedTurnSelected ? [settings.P2P_managedType, settings.P2P_managedId, settings.P2P_managedToken] : void 0,
     normaliseP2PMaxWirePayloadBytes(settings.P2P_maxWirePayloadBytes),
     effectivePath,
     settings.P2P_useDiagRTC ?? false

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

@@ -2,6 +2,7 @@ import type { NecessaryServices } from "../../interfaces/ServiceModule.js";
 import type { LiveSyncTrysteroReplicator } from "./LiveSyncTrysteroReplicator.js";
 import { type UseP2PReplicatorResult } from "./UseP2PReplicatorResult.js";
 import { type P2PServiceViews } from "../../p2p/P2PService.js";
+import type { PrepareP2PSettings } from "../../p2p/P2PService.js";
 /**
  * Factory type: given the compatibility Replicator and the stable service
  * views, returns the openReplicationUI callback for that instance.
@@ -14,6 +15,10 @@ import { type P2PServiceViews } from "../../p2p/P2PService.js";
 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;
+/** Optional host integrations for the P2P room lifecycle. */
+export interface P2PReplicatorFeatureOptions {
+    readonly prepareP2PSettings?: PrepareP2PSettings;
+}
 /**
  * Compose one private P2P service context and register non-owning active
  * provider adapters over it.
@@ -23,4 +28,4 @@ export type OpenRebuildUIFactory = OpenReplicationUIFactory;
  * 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;
+export declare function useP2PReplicatorFeature(host: NecessaryServices<"API" | "appLifecycle" | "setting" | "vault" | "database" | "databaseEvents" | "keyValueDB" | "replication" | "config" | "UI" | "replicator" | "remote", never>, openReplicationUIFactory?: OpenReplicationUIFactory, openRebuildUIFactory?: OpenRebuildUIFactory, options?: P2PReplicatorFeatureOptions): UseP2PReplicatorResult;

package/dist/replication/trystero/useP2PReplicatorFeature.js

@@ -15,10 +15,13 @@ import {
   supportedStopActiveTransfer
 } from "../index.js";
 import { getP2PReplicatorConfigurationIdentity } from "./p2pReplicatorConfigurationIdentity.js";
-function useP2PReplicatorFeature(host, openReplicationUIFactory, openRebuildUIFactory) {
-  const service = createP2PService({
-    services: host.services
-  });
+function useP2PReplicatorFeature(host, openReplicationUIFactory, openRebuildUIFactory, options = {}) {
+  const service = createP2PService(
+    {
+      services: host.services
+    },
+    options
+  );
   const replicator = service.compatibilityReplicator;
   const { views, lifecycle } = service;
   const configureReplicator = (instance) => {