@vrtmrz/livesync-commonlib 0.1.23 → 0.1.25

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,8 @@
-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,
   LOG_LEVEL_NOTICE,
@@ -17,7 +21,6 @@ import {
 } from "./TrysteroReplicatorP2PServer.js";
 import { encryptWithEphemeralSalt, decryptWithEphemeralSalt } from "octagonal-wheels/encryption/hkdf";
 import { sha1 } from "octagonal-wheels/hash/purejs";
-import { isObjectDifferent } from "octagonal-wheels/object";
 import { getRelaySockets, pauseRelayReconnection, resumeRelayReconnection } from "@trystero-p2p/nostr";
 import { P2PAutomationCoordinator } from "./P2PAutomationCoordinator.js";
 import { compatGlobal } from "../../common/coreEnvFunctions.js";
@@ -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);
@@ -728,9 +734,6 @@ ${info.lastSeq} / ${info.maxSeqInBatch})`,
     const tweakValues = await connection.invokeRemoteObjectFunction("getTweakSettings", [this.server.serverPeerId], 5e3, signal);
     if (signal?.aborted) return false;
     const thisTweakValues = await this.getTweakSettings("");
-    if (!isObjectDifferent(thisTweakValues, tweakValues)) {
-      return true;
-    }
     if (thisTweakValues.passphrase !== tweakValues.passphrase) {
       Logger(
         "Replication cancelled: Passphrase is not matched\nCannot replicate to a remote database until the problem is resolved.",
@@ -738,6 +741,8 @@ ${info.lastSeq} / ${info.maxSeqInBatch})`,
       );
       return false;
     }
+    const tweakAssessment = assessTweakCompatibility(thisTweakValues, tweakValues);
+    if (!tweakAssessment.representationDiffers) return true;
     Logger(
       "Some mismatched configuration have been detected... Please check settings for efficient replication.",
       logLevel

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) => {

package/dist/rpc/transports/trysteroUtils.d.ts

@@ -1,3 +1,3 @@
 import type { BaseRoomConfig } from "@trystero-p2p/nostr";
-import type { P2PConnectionInfo } from "../../common/models/setting.type.js";
-export declare function generateJoinRoomOptions(settings: P2PConnectionInfo): BaseRoomConfig;
+import type { P2PConnectionInfo, P2PSyncSetting } from "../../common/models/setting.type.js";
+export declare function generateJoinRoomOptions(settings: P2PConnectionInfo & Partial<Pick<P2PSyncSetting, "P2P_iceServers" | "P2P_iceServersExpiresAt">>): BaseRoomConfig;

package/dist/rpc/transports/trysteroUtils.js

@@ -1,5 +1,6 @@
 import { P2PConnectionPaths } from "../../common/models/setting.const.js";
 import {
+  hasManagedP2PTurnConfiguration,
   hasValidP2PTurnServerUrl,
   normaliseP2PConnectionPath,
   splitP2PRelayUrls,
@@ -8,11 +9,38 @@ import {
 import { mixedHash } from "octagonal-wheels/hash/purejs";
 import { compatGlobal } from "../../common/coreEnvFunctions.js";
 import { createDiagRTCPeerConnectionConstructor } from "./DiagRTCPeerConnections.js";
+function containsTurnUrl(iceServers) {
+  return iceServers.some((server) => {
+    const urls = typeof server.urls === "string" ? [server.urls] : server.urls;
+    return urls.some((url) => /^turns?:/iu.test(url));
+  });
+}
+function copyIceServers(iceServers) {
+  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 }
+  }));
+}
 function generateJoinRoomOptions(settings) {
   const passphraseNumbers = mixedHash(settings.P2P_passphrase, 0);
   const passphrase = passphraseNumbers[0].toString(36) + passphraseNumbers[1].toString(36);
   const relays = splitP2PRelayUrls(settings.P2P_relays);
   const turnServers = splitP2PTurnServerUrls(settings.P2P_turnServers);
+  const managedTurnSelected = hasManagedP2PTurnConfiguration(settings);
+  const preparedIceServers = settings.P2P_iceServers;
+  if (preparedIceServers !== void 0 && preparedIceServers.length === 0) {
+    throw new Error("Prepared ICE servers must not be empty.");
+  }
+  if (managedTurnSelected && preparedIceServers === void 0) {
+    throw new Error("The selected managed TURN configuration requires prepared ICE servers.");
+  }
+  if (managedTurnSelected && preparedIceServers && !containsTurnUrl(preparedIceServers)) {
+    throw new Error("The prepared ICE servers do not contain a TURN route.");
+  }
+  if (preparedIceServers !== void 0 && normaliseP2PConnectionPath(settings.P2P_connectionPath) === P2PConnectionPaths.Relay && !containsTurnUrl(preparedIceServers)) {
+    throw new Error("Relay-only P2P requires a prepared TURN route.");
+  }
   const relayConfig = {
     manualReconnection: true,
     urls: relays
@@ -28,7 +56,9 @@ function generateJoinRoomOptions(settings) {
   } else if (typeof compatGlobal.RTCPeerConnection !== "undefined") {
     options.rtcPolyfill = compatGlobal.RTCPeerConnection;
   }
-  if (turnServers.length > 0) {
+  if (preparedIceServers !== void 0) {
+    options.turnConfig = copyIceServers(preparedIceServers);
+  } else if (!managedTurnSelected && turnServers.length > 0) {
     options.turnConfig = [
       {
         urls: turnServers,
@@ -37,7 +67,7 @@ function generateJoinRoomOptions(settings) {
       }
     ];
   }
-  if (normaliseP2PConnectionPath(settings.P2P_connectionPath) === P2PConnectionPaths.Relay && hasValidP2PTurnServerUrl(settings.P2P_turnServers)) {
+  if (normaliseP2PConnectionPath(settings.P2P_connectionPath) === P2PConnectionPaths.Relay && (preparedIceServers !== void 0 ? containsTurnUrl(preparedIceServers) : !managedTurnSelected && hasValidP2PTurnServerUrl(settings.P2P_turnServers))) {
     options.rtcConfig = {
       iceTransportPolicy: "relay"
     };

package/dist/serviceFeatures/remoteConfig.js

@@ -46,6 +46,9 @@ function migrateLegacyRemoteConfigurationsInPlace(settings, log) {
   }
   const preferredId = settings.remoteType === REMOTE_MINIO ? "legacy-s3" : settings.remoteType === REMOTE_P2P ? "legacy-p2p" : "legacy-couchdb";
   settings.activeConfigurationId = settings.remoteConfigurations[preferredId] ? preferredId : createdIds[0];
+  if (settings.remoteConfigurations["legacy-p2p"]) {
+    settings.P2P_ActiveRemoteConfigurationId = "legacy-p2p";
+  }
   return true;
 }
 function createRemoteConfigurationId() {

package/dist/services/base/IService.d.ts

@@ -1,6 +1,6 @@
 import type { FetchHttpHandler } from "@smithy/fetch-http-handler";
 import { type LOG_LEVEL } from "octagonal-wheels/common/logger";
-import type { AnyEntry, AUTO_MERGED, CouchDBCredentials, diff_result, DocumentID, EntryDoc, EntryHasPath, FileEventItem, FilePath, FilePathWithPrefix, LoadedEntry, MetaEntry, MISSING_OR_ERROR, ObsidianLiveSyncSettings, RemoteDBSettings, RemotePreferredTweakResult, SettingsMigrationState, TweakValues, UXFileInfo, UXFileInfoStub } from "../../common/types.js";
+import type { AnyEntry, AUTO_MERGED, CouchDBCredentials, diff_result, DocumentID, EntryDoc, EntryHasPath, FileEventItem, FilePath, FilePathWithPrefix, LoadedEntry, MetaEntry, MISSING_OR_ERROR, ObsidianLiveSyncSettings, RemoteDBSettings, RemotePreferredTweakResult, SettingsMigrationState, TweakAssessment, TweakValues, UXFileInfo, UXFileInfoStub } from "../../common/types.js";
 import type { LiveSyncLocalDB } from "../../pouchdb/LiveSyncLocalDB.js";
 import type { ReplicatorInstance } from "../../replication/ReplicatorInstance.js";
 import type { SimpleStore } from "octagonal-wheels/databases/SimpleStoreBase";
@@ -335,8 +335,8 @@ export interface ISettingService {
 }
 export interface ITweakValueService {
     fetchRemotePreferred(trialSetting: RemoteDBSettings): Promise<RemotePreferredTweakResult>;
-    checkAndAskResolvingMismatched(preferred: Partial<TweakValues>): Promise<[TweakValues | boolean, boolean]>;
-    askResolvingMismatched(preferredSource: TweakValues, updatePreferredRemote?: (setting: ObsidianLiveSyncSettings) => Promise<boolean>): Promise<"OK" | "CHECKAGAIN" | "IGNORE">;
+    checkAndAskResolvingMismatched(preferred: Partial<TweakValues>, assessment?: TweakAssessment): Promise<[TweakValues | boolean, boolean]>;
+    askResolvingMismatched(preferredSource: TweakValues, updatePreferredRemote?: (setting: ObsidianLiveSyncSettings) => Promise<boolean>, assessment?: TweakAssessment): Promise<"OK" | "CHECKAGAIN" | "IGNORE">;
     checkAndAskUseRemoteConfiguration(settings: RemoteDBSettings): Promise<{
         result: false | TweakValues;
         requireFetch: boolean;

package/dist/services/base/ReplicationService.d.ts

@@ -117,8 +117,8 @@ export declare abstract class ReplicationService<T extends ServiceContext = Serv
      *
      * Each attempt owns a separate reservation. Compatibility recovery runs
      * between those reservations, and a retry is admitted only when the exact
-     * first-attempt context remains active. Both attempts use one detached
-     * settings snapshot.
+     * first-attempt context remains active. Each attempt uses a detached settings
+     * snapshot, and a compatibility retry captures its snapshot after recovery.
      */
     private performDirectionalReplication;
     replicateAllToRemote(showingNotice?: boolean): Promise<boolean>;

package/dist/services/base/ReplicationService.js

@@ -329,40 +329,43 @@ class ReplicationService extends ServiceBase {
    *
    * Each attempt owns a separate reservation. Compatibility recovery runs
    * between those reservations, and a retry is admitted only when the exact
-   * first-attempt context remains active. Both attempts use one detached
-   * settings snapshot.
+   * first-attempt context remains active. Each attempt uses a detached settings
+   * snapshot, and a compatibility retry captures its snapshot after recovery.
    */
   async performDirectionalReplication(direction, showingNotice, admission = DIRECTIONAL_REPLICATION_ADMISSION.ORDINARY) {
     if (direction === DIRECTIONAL_REPLICATION.UPLOAD && !await this.onBeforeReplicate(showingNotice)) {
       this._log(this.context.translate("Replicator.Message.SomeModuleFailed"), LOG_LEVEL_NOTICE);
       return false;
     }
-    const detachedSetting = asCopy(this.settingService.currentSettings());
-    if (admission === DIRECTIONAL_REPLICATION_ADMISSION.EXPLICIT_REBUILD) {
-      detachedSetting.versionUpFlash = "";
-    }
-    const setting = Object.freeze(detachedSetting);
+    const captureSetting = () => {
+      const detachedSetting = asCopy(this.settingService.currentSettings());
+      if (admission === DIRECTIONAL_REPLICATION_ADMISSION.EXPLICIT_REBUILD) {
+        detachedSetting.versionUpFlash = "";
+      }
+      return Object.freeze(detachedSetting);
+    };
+    const setting = captureSetting();
     let expectedContext;
-    const run = async () => {
+    const run = async (attemptSetting) => {
       const admitted = await this.replicatorService.runWithActiveReplicatorContext((context) => {
         if (expectedContext && context !== expectedContext) {
           return replicationBlocked("not-ready");
         }
         expectedContext ??= context;
-        return runDirectionalReplication(context, setting, direction, showingNotice);
+        return runDirectionalReplication(context, attemptSetting, direction, showingNotice);
       });
       if (admitted) return admitted;
       this._log(`Active replicator not found during directional ${direction}`, LOG_LEVEL_NOTICE);
       return replicationBlocked("no-active-replicator");
     };
-    const outcome = await run();
+    const outcome = await run(setting);
     if (isReplicationCompleted(outcome)) return true;
     if (outcome.status !== "failed") return false;
     const failedContext = expectedContext;
     if (!failedContext) return false;
     const failure = Object.freeze({ context: failedContext, setting, outcome });
     const checkResult = await this.checkConnectionFailure(failure);
-    return checkResult === "CHECKAGAIN" && isReplicationCompleted(await run());
+    return checkResult === "CHECKAGAIN" && isReplicationCompleted(await run(captureSetting()));
   }
   async replicateAllToRemote(showingNotice = false) {
     if (!this.appLifecycleService.isReady()) return false;