@vrtmrz/livesync-commonlib 0.1.24 → 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,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) => {

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/SettingService.d.ts

@@ -63,6 +63,7 @@ export declare abstract class SettingService<T extends ServiceContext = ServiceC
      */
     saveSettingData(): Promise<void>;
     private encryptRemoteConfigurationUris;
+    private hasManagedP2PProfileURI;
     private decryptRemoteConfigurationUris;
     /**
      * Event triggered before realising the settings.

package/dist/services/base/SettingService.js

@@ -5,6 +5,7 @@ import {
   LOG_LEVEL_VERBOSE,
   SALT_OF_PASSPHRASE,
   SETTING_KEY_P2P_DEVICE_NAME,
+  omitP2PRuntimeSettings,
   prepareSettingsForLoad
 } from "../../common/types.js";
 import { handlers } from "../lib/HandlerUtils.js";
@@ -143,12 +144,7 @@ class SettingService extends ServiceBase {
   async saveSettingData() {
     this.saveDeviceAndVaultName();
     const previousSettings = this._lastPersistedSettings ?? this.cloneSettings(this.settings);
-    const settings = {
-      ...this.settings,
-      remoteConfigurations: Object.fromEntries(
-        Object.entries(this.settings.remoteConfigurations || {}).map(([id, config]) => [id, { ...config }])
-      )
-    };
+    const settings = this.cloneSettings(this.settings);
     const hookResults = await this.onBeforeSaveSettingData(settings, previousSettings);
     for (const patch of hookResults) {
       if (patch instanceof Error || !patch) continue;
@@ -161,7 +157,15 @@ class SettingService extends ServiceBase {
       this.setSmallConfig(SETTING_KEY_P2P_DEVICE_NAME, settings.P2P_DevicePeerName.trim());
       settings.P2P_DevicePeerName = "";
     }
+    delete settings.P2P_managedType;
+    delete settings.P2P_managedId;
+    delete settings.P2P_managedToken;
     if (this.usedPassphrase == "" && !await this.getPassphrase(settings)) {
+      if (Object.values(settings.remoteConfigurations).some((config) => this.hasManagedP2PProfileURI(config.uri))) {
+        const message = "Failed to retrieve a passphrase for managed P2P source data. Settings were not saved.";
+        this._log(message, LOG_LEVEL_URGENT);
+        throw new Error(message);
+      }
       this._log("Failed to retrieve passphrase. data.json contains unencrypted items!", LOG_LEVEL_NOTICE);
     } else {
       if (settings.couchDB_PASSWORD != "" || settings.couchDB_URI != "" || settings.couchDB_USER != "" || settings.couchDB_DBNAME) {
@@ -218,8 +222,24 @@ class SettingService extends ServiceBase {
       if (config.isEncrypted || config.uri.trim() === "") {
         continue;
       }
-      const encryptedURI = await this.encryptConfigurationItem(config.uri, settings);
+      const managedP2PProfile = this.hasManagedP2PProfileURI(config.uri);
+      let encryptedURI;
+      try {
+        encryptedURI = await this.encryptConfigurationItem(config.uri, settings);
+      } catch (error) {
+        if (managedP2PProfile) {
+          const message = `Failed to encrypt managed P2P remote configuration '${id}'. Settings were not saved.`;
+          this._log(message, LOG_LEVEL_URGENT);
+          throw new Error(message);
+        }
+        throw error;
+      }
       if (encryptedURI === "") {
+        if (managedP2PProfile) {
+          const message = `Failed to encrypt managed P2P remote configuration '${id}'. Settings were not saved.`;
+          this._log(message, LOG_LEVEL_URGENT);
+          throw new Error(message);
+        }
         this._log(
           `Failed to encrypt remote configuration '${id}'. This entry will be saved in plain text.`,
           LOG_LEVEL_URGENT
@@ -233,6 +253,14 @@ class SettingService extends ServiceBase {
       };
     }
   }
+  hasManagedP2PProfileURI(uri) {
+    const trimmed = uri.trim();
+    if (!trimmed.startsWith("sls+p2p://")) return false;
+    const queryStart = trimmed.indexOf("?");
+    if (queryStart < 0) return false;
+    const query = trimmed.slice(queryStart + 1).split("#", 1)[0];
+    return (new URLSearchParams(query).get("managedType") ?? "").trim().length > 0;
+  }
   async decryptRemoteConfigurationUris(settings, passphrase) {
     const configs = settings.remoteConfigurations || {};
     for (const [id, config] of Object.entries(configs)) {
@@ -321,7 +349,7 @@ class SettingService extends ServiceBase {
     try {
       this.settings = await this.adjustSettings({
         ...this.settings,
-        ...partial
+        ...omitP2PRuntimeSettings(partial)
       });
     } catch (ex) {
       this._log("Error in applying external settings: ", LOG_LEVEL_URGENT);
@@ -550,7 +578,7 @@ class SettingService extends ServiceBase {
   }
   cloneSettings(settings) {
     return {
-      ...settings,
+      ...omitP2PRuntimeSettings(settings),
       remoteConfigurations: Object.fromEntries(
         Object.entries(settings.remoteConfigurations || {}).map(([id, config]) => [id, { ...config }])
       )

package/docs/development.md

@@ -134,15 +134,15 @@ Keep [the maintained-host evidence](proven-in-use.md) aligned with the downstrea
 
 ## Integration tests
 
-The integration suite owns Commonlib's direct CouchDB and S3-compatible storage checks. Run it with managed, disposable CouchDB and MinIO containers:
+The integration suite owns Commonlib's direct CouchDB and S3-compatible storage checks. Run it with managed, disposable CouchDB and RustFS containers:
 
 ```bash
 npm run test:integration:managed
 ```
 
-This command requires Docker Compose, creates only test credentials and data, and removes the containers and their volumes after the run. It is the same entry point used by package CI.
+This command requires Docker Compose, creates only test credentials and data, and removes the containers and their volumes after the run. It is the same entry point used by package CI. The RustFS server and client images are pinned by digest; the Compose services retain the names `minio` and `minio-init`.
 
-To test services that are already running, use `npm run test:integration`. The runner accepts `hostname`, `username`, and `password` for CouchDB, and `minioEndpoint`, `accessKey`, `secretKey`, and `bucketName` for S3-compatible storage. Without overrides, it uses the endpoints and test credentials from the managed Compose environment. The selected MinIO bucket must already exist when services are not managed by the runner.
+To test services that are already running, use `npm run test:integration`. The runner accepts `hostname`, `username`, and `password` for CouchDB, and `minioEndpoint`, `accessKey`, `secretKey`, and `bucketName` for S3-compatible storage. Without overrides, it uses the endpoints and test credentials from the managed Compose environment. The selected S3-compatible bucket must already exist when services are not managed by the runner.
 
 ## Messages and translation