@vrtmrz/livesync-commonlib 0.1.24 → 0.1.25

package/dist/API/processSetting.d.ts

@@ -37,5 +37,5 @@ type ErasureProperties = keyof ObsidianLiveSyncSettings;
  * @returns Generated setup URI
  */
 export declare function encodeSettingsToSetupURI(settingString: ObsidianLiveSyncSettings, passphrase: string, removeProperties?: ErasureProperties[], skipDefaultValue?: boolean): Promise<string>;
-export declare function decodeSettingsFromSetupURI(uri: string, passphrase: string): Promise<false | ObsidianLiveSyncSettings>;
+export declare function decodeSettingsFromSetupURI(uri: string, passphrase: string): Promise<false | Omit<ObsidianLiveSyncSettings, "P2P_iceServers" | "P2P_iceServersExpiresAt">>;
 export {};

package/dist/API/processSetting.js

@@ -4,11 +4,13 @@ import { decodeAnyArray, encodeAnyArray } from "octagonal-wheels/object";
 import {
   DEFAULT_SETTINGS,
   KeyIndexOfSettings,
-  LOG_LEVEL_NOTICE
+  LOG_LEVEL_NOTICE,
+  omitP2PRuntimeSettings
 } from "../common/types.js";
 import { decryptString, encryptString } from "../encryption/stringEncryption.js";
 import { LOG_LEVEL_VERBOSE, Logger } from "octagonal-wheels/common/logger";
 function encodeSettingsToQRCodeData(settings) {
+  settings = omitP2PRuntimeSettings(settings);
   const fullIndexes = Object.entries(KeyIndexOfSettings);
   let maxIndex = 0;
   for (const [, index] of fullIndexes) {
@@ -48,7 +50,7 @@ function decodeSettingsFromQRCodeData(qr) {
       LOG_LEVEL_VERBOSE
     );
   }
-  return newSettings;
+  return omitP2PRuntimeSettings(newSettings);
 }
 var OutputFormat = /* @__PURE__ */ ((OutputFormat2) => {
   OutputFormat2[OutputFormat2["SVG"] = 0] = "SVG";
@@ -99,8 +101,11 @@ const necessaryErasureProperties = [
 ];
 async function encodeSettingsToSetupURI(settingString, passphrase, removeProperties = ["pluginSyncExtendedSetting"], skipDefaultValue = false) {
   const setting = {
-    ...settingString
+    ...omitP2PRuntimeSettings(settingString)
   };
+  delete setting.P2P_managedType;
+  delete setting.P2P_managedId;
+  delete setting.P2P_managedToken;
   if (skipDefaultValue) {
     const keys = Object.keys(setting);
     for (const k of keys) {
@@ -123,10 +128,9 @@ async function decodeSettingsFromSetupURI(uri, passphrase) {
   const encryptedSetting = uri.substring(configURIBase.length);
   const decrypted = await decryptString(decodeURIComponent(encryptedSetting), passphrase);
   try {
-    return JSON.parse(decrypted);
-  } catch (e) {
+    return omitP2PRuntimeSettings(JSON.parse(decrypted));
+  } catch {
     Logger(`Failed to parse settings from decrypted data`, LOG_LEVEL_NOTICE);
-    Logger(e, LOG_LEVEL_VERBOSE);
     return false;
   }
 }

package/dist/common/ConnectionString.js

@@ -1,9 +1,12 @@
-import { normaliseP2PConnectionPath, normaliseP2PMaxWirePayloadBytes } from "./models/setting.p2p.js";
+import {
+  normaliseP2PConnectionPath,
+  normaliseP2PMaxWirePayloadBytes
+} from "./models/setting.p2p.js";
 const PROXY_SCHEME = "https";
 function parseSlsUri(uriString) {
   const match = uriString.match(/^sls\+([^:]+):(.*)$/);
   if (!match) {
-    throw new Error(`Unsupported URI: ${uriString}`);
+    throw new Error("Unsupported URI");
   }
   const subscheme = match[1];
   const rest = match[2];
@@ -20,7 +23,7 @@ class ConnectionStringParser {
   static parse(uriString) {
     const match = uriString.match(/^sls\+([^:]+):/);
     if (!match) {
-      throw new Error(`Unsupported URI: ${uriString}`);
+      throw new Error("Unsupported URI");
     }
     const subscheme = match[1];
     if (subscheme === "p2p") {
@@ -43,7 +46,7 @@ class ConnectionStringParser {
           settings: this.parseS3(url)
         };
       default:
-        throw new Error(`Unsupported protocol: sls+${subscheme}`);
+        throw new Error("Unsupported protocol");
     }
   }
   /**
@@ -126,9 +129,7 @@ class ConnectionStringParser {
   }
   static parseP2P(uriString) {
     const match = uriString.match(/^sls\+p2p:\/\/([^?#]+)(?:\?([^#]*))?(?:#(.*))?$/);
-    if (!match) {
-      throw new Error(`Invalid P2P URI: ${uriString}`);
-    }
+    if (!match) throw new Error("Invalid P2P URI");
     const authority = match[1];
     const queryString = match[2] || "";
     let userinfo = "";
@@ -158,7 +159,10 @@ class ConnectionStringParser {
       P2P_turnUsername: searchParams.get("turnUser") || "",
       P2P_turnCredential: searchParams.get("turnPass") || "",
       P2P_maxWirePayloadBytes: normaliseP2PMaxWirePayloadBytes(Number(searchParams.get("maxWirePayloadBytes"))),
-      P2P_connectionPath: normaliseP2PConnectionPath(searchParams.get("connectionPath"))
+      P2P_connectionPath: normaliseP2PConnectionPath(searchParams.get("connectionPath")),
+      P2P_managedType: searchParams.get("managedType") || void 0,
+      P2P_managedId: searchParams.get("managedId") || void 0,
+      P2P_managedToken: searchParams.get("token") || void 0
     };
   }
   static serializeP2P(settings) {
@@ -176,6 +180,9 @@ class ConnectionStringParser {
       String(normaliseP2PMaxWirePayloadBytes(settings.P2P_maxWirePayloadBytes))
     );
     searchParams.set("connectionPath", normaliseP2PConnectionPath(settings.P2P_connectionPath));
+    if (settings.P2P_managedType) searchParams.set("managedType", settings.P2P_managedType);
+    if (settings.P2P_managedId) searchParams.set("managedId", settings.P2P_managedId);
+    if (settings.P2P_managedToken) searchParams.set("token", settings.P2P_managedToken);
     const credentials = settings.P2P_passphrase ? `:${encodeURIComponent(settings.P2P_passphrase)}@` : "";
     const host = encodeURIComponent(settings.P2P_roomID);
     const query = searchParams.toString() ? `?${searchParams.toString()}` : "";

package/dist/common/models/setting.const.qr.js

@@ -159,6 +159,11 @@ const KeyIndexOfSettings = {
   P2P_turnServers: 150,
   P2P_turnUsername: 151,
   P2P_turnCredential: 152,
+  P2P_managedType: -1,
+  P2P_managedId: -1,
+  P2P_managedToken: -1,
+  P2P_iceServers: -1,
+  P2P_iceServersExpiresAt: -1,
   syncInternalFileOverwritePatterns: 153,
   useOnlyLocalChunk: 154,
   maxMTimeForReflectEvents: 155,

package/dist/common/models/setting.lifecycle.js

@@ -4,6 +4,7 @@ import {
   SETTING_VERSION_INITIAL,
   SETTING_VERSION_SUPPORT_CASE_INSENSITIVE
 } from "./setting.const.js";
+import { omitP2PRuntimeSettings } from "./setting.p2p.js";
 const SettingsMigrationReviewCodes = {
   LegacyUpdatePending: "legacy-update-review-pending",
   FutureSchema: "settings-schema-newer-than-runtime",
@@ -22,18 +23,19 @@ const SETTINGS_MIGRATIONS = [
   }
 ];
 function cloneSettings(source, fallbacks) {
+  const persistableSource = omitP2PRuntimeSettings(source);
   return {
     ...fallbacks,
-    ...source,
+    ...persistableSource,
     remoteConfigurations: Object.fromEntries(
-      Object.entries(source.remoteConfigurations ?? fallbacks.remoteConfigurations).map(([id, config]) => [
+      Object.entries(persistableSource.remoteConfigurations ?? fallbacks.remoteConfigurations).map(([id, config]) => [
         id,
         { ...config }
       ])
     ),
     pluginSyncExtendedSetting: {
       ...fallbacks.pluginSyncExtendedSetting,
-      ...source.pluginSyncExtendedSetting
+      ...persistableSource.pluginSyncExtendedSetting
     }
   };
 }

package/dist/common/models/setting.p2p.d.ts

@@ -1,4 +1,14 @@
 import { type P2PConnectionPath } from "./setting.const.js";
+import type { P2PConnectionInfo, P2PSyncSetting } from "./setting.type.js";
+/** Report whether the selected P2P settings request host-managed TURN credentials. */
+export declare function hasManagedP2PTurnConfiguration(settings: Partial<Pick<P2PConnectionInfo, "P2P_managedType">>): boolean;
+/** Remove connection-only ICE credentials before settings cross a serialisation boundary. */
+export declare function omitP2PRuntimeSettings<T extends Partial<P2PSyncSetting>>(settings: T): Omit<T, "P2P_iceServers" | "P2P_iceServersExpiresAt">;
+/**
+ * Report whether a P2P profile has a usable manual TURN endpoint or requests
+ * host-managed TURN credentials. STUN-only profiles remain false.
+ */
+export declare function hasP2PTurnConfiguration(settings: Partial<Pick<P2PConnectionInfo, "P2P_turnServers" | "P2P_managedType">>): boolean;
 /**
  * Return a safe outgoing RPC wire-payload bound for Trystero.
  *

package/dist/common/models/setting.p2p.js

@@ -1,4 +1,14 @@
 import { P2PConnectionPaths, P2PMessageSizePresets } from "./setting.const.js";
+function hasManagedP2PTurnConfiguration(settings) {
+  return typeof settings.P2P_managedType === "string" && settings.P2P_managedType.trim().length > 0;
+}
+function omitP2PRuntimeSettings(settings) {
+  const { P2P_iceServers: _iceServers, P2P_iceServersExpiresAt: _expiresAt, ...persistable } = settings;
+  return persistable;
+}
+function hasP2PTurnConfiguration(settings) {
+  return hasManagedP2PTurnConfiguration(settings) || typeof settings.P2P_turnServers === "string" && hasValidP2PTurnServerUrl(settings.P2P_turnServers);
+}
 function normaliseP2PMaxWirePayloadBytes(value) {
   if (typeof value !== "number" || !Number.isSafeInteger(value) || value < P2PMessageSizePresets.MaximumCompatibility || value > P2PMessageSizePresets.Standard) {
     return P2PMessageSizePresets.Standard;
@@ -31,10 +41,13 @@ function hasValidP2PTurnServerUrl(value) {
   return splitP2PTurnServerUrls(value).some(isValidP2PTurnServerUrl);
 }
 export {
+  hasManagedP2PTurnConfiguration,
+  hasP2PTurnConfiguration,
   hasValidP2PTurnServerUrl,
   isValidP2PTurnServerUrl,
   normaliseP2PConnectionPath,
   normaliseP2PMaxWirePayloadBytes,
+  omitP2PRuntimeSettings,
   splitP2PRelayUrls,
   splitP2PTurnServerUrls
 };

package/dist/common/models/setting.type.d.ts

@@ -528,6 +528,12 @@ export interface P2PConnectionInfo {
      * The TURN credential (password, secret, etc...) for the P2P connection.
      */
     P2P_turnCredential: string;
+    /** Host-defined managed TURN provider type. */
+    P2P_managedType?: string;
+    /** Host-defined managed TURN provider identifier. */
+    P2P_managedId?: string;
+    /** Host-defined managed TURN provider token. */
+    P2P_managedToken?: string;
     /**
      * Maximum serialised RPC wire payload sent through Trystero before
      * Commonlib splits it. Applies to outgoing messages.
@@ -552,6 +558,10 @@ export interface P2PSyncSetting extends P2PConnectionInfo {
     P2P_AutoAcceptingPeers: string;
     P2P_AutoDenyingPeers: string;
     P2P_IsHeadless?: boolean;
+    /** ICE servers prepared for one room connection. Never persist or share this value. */
+    P2P_iceServers?: readonly RTCIceServer[];
+    /** Absolute Unix timestamp in milliseconds for the prepared ICE servers. */
+    P2P_iceServersExpiresAt?: number;
 }
 /**
  * Interface representing the settings for a remote type.

package/dist/common/models/tweak.definition.d.ts

@@ -261,6 +261,8 @@ export declare const TweakValuesTemplate: {
     P2P_AutoAcceptingPeers?: string;
     P2P_AutoDenyingPeers?: string;
     P2P_IsHeadless?: boolean;
+    P2P_iceServers?: readonly RTCIceServer[];
+    P2P_iceServersExpiresAt?: number;
     P2P_Enabled?: boolean;
     P2P_relays?: string;
     P2P_roomID?: string;
@@ -272,6 +274,9 @@ export declare const TweakValuesTemplate: {
     P2P_turnServers?: string;
     P2P_turnUsername?: string;
     P2P_turnCredential?: string;
+    P2P_managedType?: string;
+    P2P_managedId?: string;
+    P2P_managedToken?: string;
     P2P_maxWirePayloadBytes?: number;
     P2P_connectionPath?: import("./setting.const.js").P2PConnectionPath;
     P2P_useDiagRTC?: boolean;

package/dist/common/settingConstants.d.ts

@@ -185,6 +185,8 @@ export declare const AllSettingDefault: {
     P2P_AutoAcceptingPeers: string;
     P2P_AutoDenyingPeers: string;
     P2P_IsHeadless?: boolean;
+    P2P_iceServers?: readonly RTCIceServer[];
+    P2P_iceServersExpiresAt?: number;
     P2P_Enabled: boolean;
     P2P_relays: string;
     P2P_roomID: string;
@@ -196,6 +198,9 @@ export declare const AllSettingDefault: {
     P2P_turnServers: string;
     P2P_turnUsername: string;
     P2P_turnCredential: string;
+    P2P_managedType?: string;
+    P2P_managedId?: string;
+    P2P_managedToken?: string;
     P2P_maxWirePayloadBytes?: number;
     P2P_connectionPath?: import("./types.js").P2PConnectionPath;
     P2P_useDiagRTC?: boolean;

package/dist/common/types.d.ts

@@ -9,7 +9,7 @@ import { AUTO_MERGED, CANCELLED, LEAVE_TO_SUBSEQUENT, MISSING_OR_ERROR, NOT_CONF
 import { IDPrefixes, LEAF_WAIT_ONLY_REMOTE, LEAF_WAIT_TIMEOUT, LEAF_WAIT_TIMEOUT_SEQUENTIAL_REPLICATOR, MAX_DOC_SIZE, MAX_DOC_SIZE_BIN, PREFIX_CHUNK, PREFIX_ENCRYPTED_CHUNK, PREFIX_OBFUSCATED, RECENT_MODIFIED_DOCS_QTY, REPLICATION_BUSY_TIMEOUT, SALT_OF_ID, SALT_OF_PASSPHRASE, SEED_MURMURHASH, VER } from "./models/shared.const.behabiour.js";
 import { AutoAccepting, type BucketSyncSetting, type ChunkSplitterVersion, type ConfigPassphraseStore, type CouchDBConnection, type E2EEAlgorithm, type EncryptionSettings, type HashAlgorithm, type HasSettings, type LocalDBSettings, type ObsidianLiveSyncSettings, type P2PConnectionInfo, type P2PSyncSetting, type PluginSyncSettingEntry, type RemoteDBSettings, type RemoteType, type RemoteTypeSettings, type SYNC_MODE } from "./models/setting.type.js";
 import { ChunkAlgorithmNames, ChunkAlgorithms, CURRENT_SETTING_VERSION, E2EEAlgorithmNames, E2EEAlgorithms, HashAlgorithms, REMOTE_COUCHDB, REMOTE_MINIO, REMOTE_P2P, RemoteTypes, SETTING_VERSION_INITIAL, SETTING_VERSION_SUPPORT_CASE_INSENSITIVE, MODE_AUTOMATIC, MODE_PAUSED, MODE_SELECTIVE, MODE_SHINY, P2PConnectionPaths, P2PMessageSizePresets, type P2PConnectionPath } from "./models/setting.const.js";
-import { hasValidP2PTurnServerUrl, isValidP2PTurnServerUrl, normaliseP2PConnectionPath, normaliseP2PMaxWirePayloadBytes, splitP2PTurnServerUrls } from "./models/setting.p2p.js";
+import { hasManagedP2PTurnConfiguration, hasP2PTurnConfiguration, hasValidP2PTurnServerUrl, omitP2PRuntimeSettings, isValidP2PTurnServerUrl, normaliseP2PConnectionPath, normaliseP2PMaxWirePayloadBytes, splitP2PTurnServerUrls } from "./models/setting.p2p.js";
 import { PREFERRED_BASE, PREFERRED_JOURNAL_SYNC, PREFERRED_SETTING_CLOUDANT, PREFERRED_SETTING_SELF_HOSTED } from "./models/setting.const.preferred.js";
 import { P2P_DEFAULT_SETTINGS, DEFAULT_SETTINGS, NEW_VAULT_SETTINGS, SETTINGS_SCHEMA_DEFAULTS, createNewVaultSettings } from "./models/setting.const.defaults.js";
 import { prepareSettingsForLoad, SettingsMigrationReviewCodes, type PreparedSettings, type SettingsMigrationReviewCode, type SettingsMigrationReviewReason, type SettingsMigrationState } from "./models/setting.lifecycle.js";
@@ -39,7 +39,7 @@ export { SETTING_VERSION_INITIAL, SETTING_VERSION_SUPPORT_CASE_INSENSITIVE, CURR
 export type { BucketSyncSetting, LocalDBSettings };
 export { RemoteTypes, REMOTE_COUCHDB, REMOTE_MINIO, REMOTE_P2P, P2PConnectionPaths, P2PMessageSizePresets, type RemoteType, AutoAccepting, };
 export type { P2PConnectionInfo, P2PConnectionPath, P2PSyncSetting };
-export { hasValidP2PTurnServerUrl, isValidP2PTurnServerUrl, normaliseP2PConnectionPath, normaliseP2PMaxWirePayloadBytes, splitP2PTurnServerUrls, };
+export { hasManagedP2PTurnConfiguration, hasP2PTurnConfiguration, hasValidP2PTurnServerUrl, omitP2PRuntimeSettings, isValidP2PTurnServerUrl, normaliseP2PConnectionPath, normaliseP2PMaxWirePayloadBytes, splitP2PTurnServerUrls, };
 export { P2P_DEFAULT_SETTINGS };
 export type { RemoteTypeSettings };
 export { E2EEAlgorithmNames, E2EEAlgorithms, type E2EEAlgorithm };
@@ -116,4 +116,4 @@ export { DOCID_SYNC_PARAMETERS };
 export { DOCID_JOURNAL_SYNC_PARAMETERS };
 export type { SyncParameters };
 export { DEFAULT_SYNC_PARAMETERS };
-export { SETTING_KEY_P2P_DEVICE_NAME, configURIBase, configURIBaseQR, SuffixDatabaseName, ExtraSuffixIndexedDB };
+export { SETTING_KEY_P2P_DEVICE_NAME, configURIBase, configURIBaseQR, SuffixDatabaseName, ExtraSuffixIndexedDB, };

package/dist/common/types.js

@@ -64,7 +64,10 @@ import {
   P2PMessageSizePresets
 } from "./models/setting.const.js";
 import {
+  hasManagedP2PTurnConfiguration,
+  hasP2PTurnConfiguration,
   hasValidP2PTurnServerUrl,
+  omitP2PRuntimeSettings,
   isValidP2PTurnServerUrl,
   normaliseP2PConnectionPath,
   normaliseP2PMaxWirePayloadBytes,
@@ -236,11 +239,14 @@ export {
   configURIBaseQR,
   configurationNames,
   createNewVaultSettings,
+  hasManagedP2PTurnConfiguration,
+  hasP2PTurnConfiguration,
   hasValidP2PTurnServerUrl,
   isMetaEntry,
   isValidP2PTurnServerUrl,
   normaliseP2PConnectionPath,
   normaliseP2PMaxWirePayloadBytes,
+  omitP2PRuntimeSettings,
   prepareSettingsForLoad,
   splitP2PTurnServerUrls,
   statusDisplay

package/dist/common/utils.js

@@ -462,7 +462,10 @@ function pickP2PSyncSettings(setting) {
     P2P_turnUsername: setting.P2P_turnUsername,
     P2P_turnCredential: setting.P2P_turnCredential,
     P2P_maxWirePayloadBytes: normaliseP2PMaxWirePayloadBytes(setting.P2P_maxWirePayloadBytes),
-    P2P_connectionPath: normaliseP2PConnectionPath(setting.P2P_connectionPath)
+    P2P_connectionPath: normaliseP2PConnectionPath(setting.P2P_connectionPath),
+    P2P_managedType: setting.P2P_managedType,
+    P2P_managedId: setting.P2P_managedId,
+    P2P_managedToken: setting.P2P_managedToken
   };
 }
 function wrapByDefault(func, onError) {

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/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. */