@vrtmrz/livesync-commonlib 0.1.16 → 0.1.18

package/dist/common/ConnectionString.js

@@ -1,3 +1,4 @@
+import { normaliseP2PConnectionPath, normaliseP2PMaxWirePayloadBytes } from "./models/setting.p2p.js";
 const PROXY_SCHEME = "https";
 function parseSlsUri(uriString) {
   const match = uriString.match(/^sls\+([^:]+):(.*)$/);
@@ -155,7 +156,9 @@ class ConnectionStringParser {
       P2P_AutoBroadcast: searchParams.get("autoBroadcast") === "true",
       P2P_turnServers: searchParams.get("turnServers") || "",
       P2P_turnUsername: searchParams.get("turnUser") || "",
-      P2P_turnCredential: searchParams.get("turnPass") || ""
+      P2P_turnCredential: searchParams.get("turnPass") || "",
+      P2P_maxWirePayloadBytes: normaliseP2PMaxWirePayloadBytes(Number(searchParams.get("maxWirePayloadBytes"))),
+      P2P_connectionPath: normaliseP2PConnectionPath(searchParams.get("connectionPath"))
     };
   }
   static serializeP2P(settings) {
@@ -168,6 +171,11 @@ class ConnectionStringParser {
     if (settings.P2P_turnServers) searchParams.set("turnServers", settings.P2P_turnServers);
     if (settings.P2P_turnUsername) searchParams.set("turnUser", settings.P2P_turnUsername);
     if (settings.P2P_turnCredential) searchParams.set("turnPass", settings.P2P_turnCredential);
+    searchParams.set(
+      "maxWirePayloadBytes",
+      String(normaliseP2PMaxWirePayloadBytes(settings.P2P_maxWirePayloadBytes))
+    );
+    searchParams.set("connectionPath", normaliseP2PConnectionPath(settings.P2P_connectionPath));
     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.d.ts

@@ -9,6 +9,24 @@ export declare const RemoteTypes: {
 export declare const REMOTE_COUCHDB: "";
 export declare const REMOTE_MINIO: "MINIO";
 export declare const REMOTE_P2P: "ONLY_P2P";
+/** ICE route policies supported by a P2P connection profile. */
+export declare const P2PConnectionPaths: {
+    readonly Automatic: "automatic";
+    readonly Relay: "relay";
+};
+export type P2PConnectionPath = (typeof P2PConnectionPaths)[keyof typeof P2PConnectionPaths];
+/**
+ * User-facing message-size presets for the P2P RPC transport.
+ *
+ * These values limit Commonlib wire payloads before Trystero applies its own
+ * framing. They are not file Chunk sizes or network MTUs.
+ */
+export declare const P2PMessageSizePresets: {
+    readonly Standard: 15360;
+    readonly Reduced: 2048;
+    readonly Conservative: 1024;
+    readonly MaximumCompatibility: 800;
+};
 export declare const E2EEAlgorithmNames: {
     readonly "": "V1: Legacy";
     readonly v2: "V2: AES-256-GCM With HKDF";

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

@@ -1,4 +1,11 @@
-import { ChunkAlgorithms, CURRENT_SETTING_VERSION, E2EEAlgorithms, REMOTE_COUCHDB } from "./setting.const.js";
+import {
+  ChunkAlgorithms,
+  CURRENT_SETTING_VERSION,
+  E2EEAlgorithms,
+  P2PConnectionPaths,
+  P2PMessageSizePresets,
+  REMOTE_COUCHDB
+} from "./setting.const.js";
 import { PREFERRED_BASE } from "./setting.const.preferred.js";
 import { AutoAccepting } from "./setting.type.js";
 const P2P_DEFAULT_SETTINGS = {
@@ -21,6 +28,8 @@ const P2P_DEFAULT_SETTINGS = {
   P2P_turnServers: "",
   P2P_turnUsername: "",
   P2P_turnCredential: "",
+  P2P_maxWirePayloadBytes: P2PMessageSizePresets.Standard,
+  P2P_connectionPath: P2PConnectionPaths.Automatic,
   P2P_useDiagRTC: false
 };
 const SETTINGS_SCHEMA_DEFAULTS = {

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

@@ -9,6 +9,16 @@ const RemoteTypes = {
 const REMOTE_COUCHDB = RemoteTypes.REMOTE_COUCHDB;
 const REMOTE_MINIO = RemoteTypes.REMOTE_MINIO;
 const REMOTE_P2P = RemoteTypes.REMOTE_P2P;
+const P2PConnectionPaths = {
+  Automatic: "automatic",
+  Relay: "relay"
+};
+const P2PMessageSizePresets = {
+  Standard: 15360,
+  Reduced: 2048,
+  Conservative: 1024,
+  MaximumCompatibility: 800
+};
 const E2EEAlgorithmNames = {
   "": "V1: Legacy",
   v2: "V2: AES-256-GCM With HKDF",
@@ -59,6 +69,8 @@ export {
   MODE_SELECTIVE,
   MODE_SHINY,
   NetworkWarningStyles,
+  P2PConnectionPaths,
+  P2PMessageSizePresets,
   REMOTE_COUCHDB,
   REMOTE_MINIO,
   REMOTE_P2P,

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

@@ -168,8 +168,10 @@ const KeyIndexOfSettings = {
   P2P_ActiveRemoteConfigurationId: 159,
   autoAcceptCompatibleTweak: 160,
   tweakModified: -1,
-  P2P_useDiagRTC: -1
+  P2P_useDiagRTC: -1,
   // Do not encode into the QR Code.
+  P2P_maxWirePayloadBytes: 163,
+  P2P_connectionPath: 164
 };
 export {
   KeyIndexOfSettings

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

@@ -0,0 +1,21 @@
+import { type P2PConnectionPath } from "./setting.const.js";
+/**
+ * Return a safe outgoing RPC wire-payload bound for Trystero.
+ *
+ * Existing profiles can omit this value. Invalid, excessively small, and
+ * excessively large values retain the established 15,360-byte behaviour.
+ */
+export declare function normaliseP2PMaxWirePayloadBytes(value: unknown): number;
+/** Return a recognised P2P connection path, defaulting legacy values to automatic selection. */
+export declare function normaliseP2PConnectionPath(value: unknown): P2PConnectionPath;
+/** Split the stored comma-separated TURN server list without changing its entries. */
+export declare function splitP2PTurnServerUrls(value: string): string[];
+/**
+ * Report whether a value is a minimally valid TURN or TURN-over-TLS URL.
+ *
+ * Full allocation validation remains the responsibility of WebRTC. This
+ * check only prevents relay-only mode when no TURN endpoint can be attempted.
+ */
+export declare function isValidP2PTurnServerUrl(value: string): boolean;
+/** Report whether a stored TURN server list contains at least one usable TURN URL. */
+export declare function hasValidP2PTurnServerUrl(value: string): boolean;

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

@@ -0,0 +1,35 @@
+import { P2PConnectionPaths, P2PMessageSizePresets } from "./setting.const.js";
+function normaliseP2PMaxWirePayloadBytes(value) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < P2PMessageSizePresets.MaximumCompatibility || value > P2PMessageSizePresets.Standard) {
+    return P2PMessageSizePresets.Standard;
+  }
+  return value;
+}
+function normaliseP2PConnectionPath(value) {
+  return value === P2PConnectionPaths.Relay ? P2PConnectionPaths.Relay : P2PConnectionPaths.Automatic;
+}
+function splitP2PTurnServerUrls(value) {
+  return value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+}
+function isValidP2PTurnServerUrl(value) {
+  const candidate = value.trim();
+  if (!candidate || /\s/.test(candidate)) return false;
+  try {
+    const parsed = new URL(candidate);
+    const protocol = parsed.protocol.toLowerCase();
+    if (protocol !== "turn:" && protocol !== "turns:") return false;
+    return (parsed.hostname || parsed.pathname).length > 0;
+  } catch {
+    return false;
+  }
+}
+function hasValidP2PTurnServerUrl(value) {
+  return splitP2PTurnServerUrls(value).some(isValidP2PTurnServerUrl);
+}
+export {
+  hasValidP2PTurnServerUrl,
+  isValidP2PTurnServerUrl,
+  normaliseP2PConnectionPath,
+  normaliseP2PMaxWirePayloadBytes,
+  splitP2PTurnServerUrls
+};

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

@@ -1,4 +1,4 @@
-import type { ChunkAlgorithms, E2EEAlgorithms, HashAlgorithms, MODE_AUTOMATIC, MODE_PAUSED, MODE_SELECTIVE, MODE_SHINY, RemoteTypes } from "./setting.const.js";
+import type { ChunkAlgorithms, E2EEAlgorithms, HashAlgorithms, MODE_AUTOMATIC, MODE_PAUSED, MODE_SELECTIVE, MODE_SHINY, P2PConnectionPath, RemoteTypes } from "./setting.const.js";
 import type { CustomRegExpSourceList } from "./shared.type.util.js";
 import type { JWTAlgorithm } from "./auth.type.js";
 /** Display languages recognised by the current LiveSync settings schema. */
@@ -528,6 +528,16 @@ export interface P2PConnectionInfo {
      * The TURN credential (password, secret, etc...) for the P2P connection.
      */
     P2P_turnCredential: string;
+    /**
+     * Maximum serialised RPC wire payload sent through Trystero before
+     * Commonlib splits it. Applies to outgoing messages.
+     */
+    P2P_maxWirePayloadBytes?: number;
+    /**
+     * ICE route policy for this P2P profile. Relay-only mode is effective only
+     * when the profile contains at least one valid TURN URL.
+     */
+    P2P_connectionPath?: P2PConnectionPath;
     /**
      * Use Diagnostic Wrapper for RTCPeerConnection to collect statistics.
      */

package/dist/common/models/shared.definition.configNames.js

@@ -152,6 +152,14 @@ const configurationNames = {
     desc: "The credential/password for the TURN servers.",
     isHidden: true
   },
+  P2P_maxWirePayloadBytes: {
+    name: "P2P Message Size",
+    desc: "The maximum outgoing RPC wire payload before Commonlib splits it for the P2P transport."
+  },
+  P2P_connectionPath: {
+    name: "Connection Path",
+    desc: "Select the WebRTC route automatically or require a configured TURN relay."
+  },
   useOnlyLocalChunk: {
     name: "Use Only Local Chunks",
     desc: "If enabled, the plugin will not attempt to connect to the remote database even if the chunk was not found locally.",

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

@@ -186,6 +186,8 @@ export declare const TweakValuesTemplate: {
     P2P_turnServers?: string;
     P2P_turnUsername?: string;
     P2P_turnCredential?: string;
+    P2P_maxWirePayloadBytes?: number;
+    P2P_connectionPath?: import("./setting.const.js").P2PConnectionPath;
     P2P_useDiagRTC?: boolean;
 };
 export type TweakValues = Partial<typeof TweakValuesTemplate>;

package/dist/common/settingConstants.d.ts

@@ -196,6 +196,8 @@ export declare const AllSettingDefault: {
     P2P_turnServers: string;
     P2P_turnUsername: string;
     P2P_turnCredential: string;
+    P2P_maxWirePayloadBytes?: number;
+    P2P_connectionPath?: import("./types.js").P2PConnectionPath;
     P2P_useDiagRTC?: boolean;
 };
 export type AllSettings = ObsidianLiveSyncSettings & OnDialogSettings;

package/dist/common/types.d.ts

@@ -8,7 +8,8 @@ import { ChunkTypes, EntryTypes, MILESTONE_DOCID, NODEINFO_DOCID, NoteTypes, SYN
 import { AUTO_MERGED, CANCELLED, LEAVE_TO_SUBSEQUENT, MISSING_OR_ERROR, NOT_CONFLICTED, TIME_ARGUMENT_INFINITY } from "./models/shared.const.symbols.js";
 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 } from "./models/setting.const.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 { 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";
@@ -34,8 +35,9 @@ export { MODE_SELECTIVE, MODE_AUTOMATIC, MODE_PAUSED, MODE_SHINY, type SYNC_MODE
 export { type PluginSyncSettingEntry };
 export { SETTING_VERSION_INITIAL, SETTING_VERSION_SUPPORT_CASE_INSENSITIVE, CURRENT_SETTING_VERSION };
 export type { BucketSyncSetting, LocalDBSettings };
-export { RemoteTypes, REMOTE_COUCHDB, REMOTE_MINIO, REMOTE_P2P, type RemoteType, AutoAccepting };
-export type { P2PConnectionInfo, P2PSyncSetting };
+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 { P2P_DEFAULT_SETTINGS };
 export type { RemoteTypeSettings };
 export { E2EEAlgorithmNames, E2EEAlgorithms, type E2EEAlgorithm };

package/dist/common/types.js

@@ -59,8 +59,17 @@ import {
   MODE_AUTOMATIC,
   MODE_PAUSED,
   MODE_SELECTIVE,
-  MODE_SHINY
+  MODE_SHINY,
+  P2PConnectionPaths,
+  P2PMessageSizePresets
 } from "./models/setting.const.js";
+import {
+  hasValidP2PTurnServerUrl,
+  isValidP2PTurnServerUrl,
+  normaliseP2PConnectionPath,
+  normaliseP2PMaxWirePayloadBytes,
+  splitP2PTurnServerUrls
+} from "./models/setting.p2p.js";
 import {
   PREFERRED_BASE,
   PREFERRED_JOURNAL_SYNC,
@@ -181,6 +190,8 @@ export {
   NODEINFO_DOCID,
   NOT_CONFLICTED,
   NoteTypes,
+  P2PConnectionPaths,
+  P2PMessageSizePresets,
   P2P_DEFAULT_SETTINGS,
   PREFERRED_BASE,
   PREFERRED_JOURNAL_SYNC,
@@ -225,7 +236,12 @@ export {
   configURIBaseQR,
   configurationNames,
   createNewVaultSettings,
+  hasValidP2PTurnServerUrl,
   isMetaEntry,
+  isValidP2PTurnServerUrl,
+  normaliseP2PConnectionPath,
+  normaliseP2PMaxWirePayloadBytes,
   prepareSettingsForLoad,
+  splitP2PTurnServerUrls,
   statusDisplay
 };

package/dist/common/utils.js

@@ -7,6 +7,7 @@ import {
   PREFIX_OBFUSCATED,
   SYNCINFO_ID
 } from "./types.js";
+import { normaliseP2PConnectionPath, normaliseP2PMaxWirePayloadBytes } from "./models/setting.p2p.js";
 import { isErrorOfMissingDoc } from "../pouchdb/utils_couchdb.js";
 import { replaceAll, replaceAllPairs } from "octagonal-wheels/string";
 import { concatUInt8Array } from "octagonal-wheels/binary";
@@ -459,7 +460,9 @@ function pickP2PSyncSettings(setting) {
     P2P_DevicePeerName: setting.P2P_DevicePeerName || "",
     P2P_turnServers: setting.P2P_turnServers,
     P2P_turnUsername: setting.P2P_turnUsername,
-    P2P_turnCredential: setting.P2P_turnCredential
+    P2P_turnCredential: setting.P2P_turnCredential,
+    P2P_maxWirePayloadBytes: normaliseP2PMaxWirePayloadBytes(setting.P2P_maxWirePayloadBytes),
+    P2P_connectionPath: normaliseP2PConnectionPath(setting.P2P_connectionPath)
   };
 }
 function wrapByDefault(func, onError) {

package/dist/interfaces/DatabaseFileAccess.d.ts

@@ -4,6 +4,16 @@ export interface DatabaseFileAccess {
     store: (file: UXFileInfo, force?: boolean, skipCheck?: boolean) => Promise<boolean>;
     /** Store a file as a child of an exact revision and return the created revision. */
     storeWithBaseRevision: (file: UXFileInfo, baseRevision: string | undefined, skipCheck?: boolean) => Promise<string | false>;
+    /**
+     * Store a file as a child of an exact revision only while that revision remains a live leaf.
+     *
+     * Unlike {@link storeWithBaseRevision}, this method does not force a branch below an obsolete
+     * revision. 'Live leaf' means any current revision-tree leaf, including a non-winning conflict
+     * leaf or a logical-deletion leaf. In particular, it returns `false` when another writer has
+     * already advanced the supplied base; ordinary target and Chunk validation can also refuse the
+     * write without creating a Metadata successor.
+     */
+    storeWithLiveBaseRevision: (file: UXFileInfo, baseRevision: string, skipCheck?: boolean) => Promise<string | false>;
     storeAsConflictedRevision: (file: UXFileInfo, currentRev: string, skipCheck?: boolean) => Promise<boolean>;
     /** Preserve unknown storage content as a conflict and return its exact revision. */
     storeAsConflictedRevisionWithResult: (file: UXFileInfo, currentRev: string, skipCheck?: boolean) => Promise<string | false>;

package/dist/managers/EntryManager/EntryManager.d.ts

@@ -35,4 +35,5 @@ export declare class EntryManager {
     deleteDBEntry(path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions): Promise<boolean>;
     storeDeletionAtRevision(path: FilePathWithPrefix | FilePath, baseRevision: string): Promise<false | PouchDB.Core.Response>;
     putDBEntry(note: SavingEntry, onlyChunks?: boolean, conflictBaseRev?: string): Promise<false | PouchDB.Core.Response>;
+    putDBEntryWithLiveBaseRevision(note: SavingEntry, baseRevision: string, onlyChunks?: boolean): Promise<false | PouchDB.Core.Response>;
 }

package/dist/managers/EntryManager/EntryManager.js

@@ -9,6 +9,7 @@ import {
   isTargetFile,
   prepareChunk,
   putDBEntry,
+  putDBEntryWithLiveBaseRevision,
   storeDeletionByPathAtRevision
 } from "./EntryManagerImpls.js";
 class EntryManager {
@@ -71,6 +72,9 @@ class EntryManager {
   async putDBEntry(note, onlyChunks, conflictBaseRev) {
     return await putDBEntry(this.serviceHost, this, note, onlyChunks, conflictBaseRev);
   }
+  async putDBEntryWithLiveBaseRevision(note, baseRevision, onlyChunks) {
+    return await putDBEntryWithLiveBaseRevision(this.serviceHost, this, note, baseRevision, onlyChunks);
+  }
 }
 export {
   EntryManager

package/dist/managers/EntryManager/EntryManagerImpls.d.ts

@@ -13,6 +13,13 @@ type Managers = {
 type NecessaryManagers<T extends keyof Managers> = Pick<Managers, T>;
 export declare function createChunks(managers: NecessaryManagers<"chunkManager" | "hashManager" | "splitter">, dispFilename: string, note: SavingEntry): Promise<false | DocumentID[]>;
 export declare function putDBEntry(host: NecessaryServicesInterfaces<"path" | "setting", never>, managers: NecessaryManagers<"localDatabase" | "chunkManager" | "hashManager" | "splitter">, note: SavingEntry, onlyChunks?: boolean, conflictBaseRev?: string): Promise<false | PouchDB.Core.Response>;
+/**
+ * Store an entry below an exact revision only while that revision remains a live leaf.
+ *
+ * PouchDB's ordinary MVCC write is the authority for this check. A 409 response means that the
+ * base has already been advanced, so the caller receives `false` and can retry from fresh state.
+ */
+export declare function putDBEntryWithLiveBaseRevision(host: NecessaryServicesInterfaces<"path" | "setting", never>, managers: NecessaryManagers<"localDatabase" | "chunkManager" | "hashManager" | "splitter">, note: SavingEntry, baseRevision: string, onlyChunks?: boolean): Promise<false | PouchDB.Core.Response>;
 export declare function isTargetFile(host: NecessaryServicesInterfaces<"setting", never>, filenameSrc: string): boolean;
 export declare function prepareChunk({ chunkManager, hashManager }: NecessaryManagers<"chunkManager" | "hashManager">, piece: string): Promise<GeneratedChunk>;
 export declare function getDBEntryMetaByPath(host: NecessaryServicesInterfaces<"path" | "setting", never>, { localDatabase }: NecessaryManagers<"localDatabase">, path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions, includeDeleted?: boolean): Promise<false | LoadedEntry>;

package/dist/managers/EntryManager/EntryManagerImpls.js

@@ -110,6 +110,23 @@ async function createChunks(managers, dispFilename, note) {
   return chunks;
 }
 async function putDBEntry(host, managers, note, onlyChunks, conflictBaseRev) {
+  const revisionTarget = conflictBaseRev ? { mode: "force-base", baseRevision: conflictBaseRev } : { mode: "latest" };
+  return await putDBEntryInternal(host, managers, note, onlyChunks, revisionTarget);
+}
+async function putDBEntryWithLiveBaseRevision(host, managers, note, baseRevision, onlyChunks) {
+  try {
+    return await putDBEntryInternal(host, managers, note, onlyChunks, {
+      mode: "live-base",
+      baseRevision
+    });
+  } catch (ex) {
+    if (ex && typeof ex === "object" && "status" in ex && ex.status === 409) {
+      return false;
+    }
+    throw ex;
+  }
+}
+async function putDBEntryInternal(host, managers, note, onlyChunks, revisionTarget) {
   const { localDatabase, chunkManager, splitter } = managers;
   const filename = host.services.path.id2path(note._id, note);
   const dispFilename = stripAllPrefixes(filename);
@@ -146,8 +163,8 @@ async function putDBEntry(host, managers, note, onlyChunks, conflictBaseRev) {
       eden: {}
     };
     return await serialized("file:" + filename, async () => {
-      if (conflictBaseRev) {
-        newDoc._rev = conflictBaseRev;
+      if (revisionTarget.mode !== "latest") {
+        newDoc._rev = revisionTarget.baseRevision;
       } else {
         try {
           const old = await localDatabase.get(newDoc._id);
@@ -159,7 +176,7 @@ async function putDBEntry(host, managers, note, onlyChunks, conflictBaseRev) {
           }
         }
       }
-      const r = await localDatabase.put(newDoc, { force: true });
+      const r = revisionTarget.mode === "live-base" ? await localDatabase.put(newDoc) : await localDatabase.put(newDoc, { force: true });
       if (r.ok) {
         return r;
       } else {
@@ -523,5 +540,6 @@ export {
   isTargetFile,
   prepareChunk,
   putDBEntry,
+  putDBEntryWithLiveBaseRevision,
   storeDeletionByPathAtRevision
 };

package/dist/pouchdb/LiveSyncLocalDB.d.ts

@@ -192,6 +192,7 @@ export declare class LiveSyncLocalDB {
     deleteDBEntry(path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions): Promise<boolean>;
     storeDeletionAtRevision(path: FilePathWithPrefix | FilePath, baseRevision: string): Promise<false | PouchDB.Core.Response>;
     putDBEntry(note: SavingEntry, onlyChunks?: boolean, conflictBaseRev?: string): Promise<false | PouchDB.Core.Response>;
+    putDBEntryWithLiveBaseRevision(note: SavingEntry, baseRevision: string, onlyChunks?: boolean): Promise<false | PouchDB.Core.Response>;
     getConflictedDoc(path: FilePathWithPrefix, rev: string): Promise<false | diff_result_leaf>;
     tryAutoMerge(path: FilePathWithPrefix, enableMarkdownAutoMerge: boolean): AutoMergeResult;
 }

package/dist/pouchdb/LiveSyncLocalDB.js

@@ -370,6 +370,9 @@ class LiveSyncLocalDB {
   async putDBEntry(note, onlyChunks, conflictBaseRev) {
     return await this.managers.entryManager.putDBEntry(note, onlyChunks, conflictBaseRev);
   }
+  async putDBEntryWithLiveBaseRevision(note, baseRevision, onlyChunks) {
+    return await this.managers.entryManager.putDBEntryWithLiveBaseRevision(note, baseRevision, onlyChunks);
+  }
   async getConflictedDoc(path, rev) {
     return await this.managers.conflictManager.getConflictedDoc(path, rev);
   }

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

@@ -20,6 +20,7 @@ export declare class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicat
     private _replicator?;
     private _lifecycleOperation;
     private _shouldBeOpen;
+    private _activeTransportCompatibilitySignature?;
     get openReplicationUI(): (showResult: boolean) => Promise<boolean | void>;
     get rawReplicator(): TrysteroReplicator;
     get rawHost(): P2PHost;
@@ -27,6 +28,13 @@ export declare class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicat
     terminateSync(): void;
     private _buildEnv;
     private _enqueueLifecycleOperation;
+    /**
+     * Capture settings which are fixed when the active P2P transport joins its room.
+     * A later open request can remain idempotent only while these effective values match.
+     */
+    private _getTransportCompatibilitySignature;
+    /** Close and forget the transport without changing the requested lifecycle state. */
+    private _closeTransport;
     open(): Promise<void>;
     close(): Promise<void>;
     closeReplication(): void;

package/dist/replication/trystero/LiveSyncTrysteroReplicator.js

@@ -16,11 +16,18 @@ import {
   P2PHost
 } from "./TrysteroReplicatorP2PServer.js";
 import { delay } from "octagonal-wheels/promises";
+import {
+  hasValidP2PTurnServerUrl,
+  normaliseP2PConnectionPath,
+  normaliseP2PMaxWirePayloadBytes
+} from "../../common/models/setting.p2p.js";
+import { P2PConnectionPaths } from "../../common/models/setting.const.js";
 class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
   _p2pHost;
   _replicator;
   _lifecycleOperation = Promise.resolve();
   _shouldBeOpen = false;
+  _activeTransportCompatibilitySignature;
   get openReplicationUI() {
     return this.env.openReplicationUI;
   }
@@ -81,6 +88,26 @@ class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
     this._lifecycleOperation = queued.catch(() => void 0);
     return queued;
   }
+  /**
+   * Capture settings which are fixed when the active P2P transport joins its room.
+   * A later open request can remain idempotent only while these effective values match.
+   */
+  _getTransportCompatibilitySignature() {
+    const settings = this.env.services.setting.currentSettings();
+    const configuredPath = normaliseP2PConnectionPath(settings.P2P_connectionPath);
+    const effectivePath = configuredPath === P2PConnectionPaths.Relay && hasValidP2PTurnServerUrl(settings.P2P_turnServers ?? "") ? P2PConnectionPaths.Relay : P2PConnectionPaths.Automatic;
+    return `${normaliseP2PMaxWirePayloadBytes(settings.P2P_maxWirePayloadBytes)}:${effectivePath}`;
+  }
+  /** Close and forget the transport without changing the requested lifecycle state. */
+  async _closeTransport() {
+    if (this._replicator) {
+      this._replicator.disableBroadcastChanges();
+      await this._replicator.close();
+      this._replicator = void 0;
+    }
+    this._p2pHost = void 0;
+    this._activeTransportCompatibilitySignature = void 0;
+  }
   async open() {
     if (!this.env.services.setting.currentSettings().P2P_Enabled) {
       Logger(this.translate("P2P.NotEnabled"), LOG_LEVEL_NOTICE);
@@ -89,9 +116,13 @@ class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
     this._shouldBeOpen = true;
     await this._enqueueLifecycleOperation(async () => {
       if (!this._shouldBeOpen) return;
+      const compatibilitySignature = this._getTransportCompatibilitySignature();
       if (this._replicator && this._p2pHost?.isServing) {
-        Logger("P2P replicator is already open.");
-        return;
+        if (this._activeTransportCompatibilitySignature === compatibilitySignature) {
+          Logger("P2P replicator is already open.");
+          return;
+        }
+        await this._closeTransport();
       }
       try {
         const env = this._buildEnv();
@@ -100,23 +131,20 @@ class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
         this._p2pHost = host;
         this._replicator = replicator;
         await replicator.open();
+        this._activeTransportCompatibilitySignature = compatibilitySignature;
       } catch (e) {
         Logger(e instanceof Error ? e.message : "Error while opening P2P connection", LOG_LEVEL_NOTICE);
         Logger(e, LOG_LEVEL_VERBOSE);
         this._p2pHost = void 0;
         this._replicator = void 0;
+        this._activeTransportCompatibilitySignature = void 0;
       }
     });
   }
   async close() {
     this._shouldBeOpen = false;
     await this._enqueueLifecycleOperation(async () => {
-      if (this._replicator) {
-        this._replicator.disableBroadcastChanges();
-        await this._replicator.close();
-        this._replicator = void 0;
-      }
-      this._p2pHost = void 0;
+      await this._closeTransport();
     });
   }
   closeReplication() {

package/dist/replication/trystero/TrysteroReplicatorP2PServer.js

@@ -13,7 +13,7 @@ import { EVENT_PLATFORM_UNLOADED } from "../../events/coreEvents.js";
 import { shareRunningResult } from "octagonal-wheels/concurrency/lock_v2";
 import { Computed } from "octagonal-wheels/dataobject/Computed";
 import { RpcRoom } from "../../rpc/index.js";
-import { TRYSTERO_RPC_DEFAULTS } from "../../rpc/transports/TrysteroTransport.js";
+import { resolveTrysteroRpcOptions } from "../../rpc/transports/TrysteroTransport.js";
 import { subscribeTrysteroPeerEvents } from "../../rpc/transports/trysteroRoomEvents.js";
 import { toRpcMethodName } from "./rpcCompat.js";
 import { generateJoinRoomOptions } from "../../rpc/transports/trysteroUtils.js";
@@ -379,7 +379,7 @@ You can chose as follows:
     };
     this._rpcRoom?.close();
     this._rpcRoom = new RpcRoom({
-      ...TRYSTERO_RPC_DEFAULTS,
+      ...resolveTrysteroRpcOptions(this.settings),
       transport,
       canAcceptRequest: async (peerId, method) => {
         if (method === toRpcMethodName("!reqAuth")) return true;

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

@@ -68,6 +68,8 @@ export declare const TRYSTERO_RPC_DEFAULTS: {
     /** SCTP guarantees delivery; retransmission is a last-resort safety net. */
     readonly chunkMissingRetryMs: 150;
 };
+/** Resolve the RpcRoom defaults contributed by one P2P connection profile. */
+export declare function resolveTrysteroRpcOptions(settings: Pick<P2PConnectionInfo, "P2P_maxWirePayloadBytes">): Required<Pick<RpcRoomOptions, "maxWirePayloadBytes" | "chunkMissingRetryMs">>;
 /**
  * Wrap an already-joined Trystero `Room` as a `TransportAdapter` for `RpcRoom`.
  *

package/dist/rpc/transports/TrysteroTransport.js

@@ -2,6 +2,7 @@ import { joinRoom, selfId } from "@trystero-p2p/nostr";
 import { RpcRoom } from "../RpcRoom.js";
 import { exposeDB } from "../pouchdb/RpcPouchDBServer.js";
 import { RpcPouchDBProxy } from "../pouchdb/RpcPouchDBProxy.js";
+import { normaliseP2PMaxWirePayloadBytes } from "../../common/models/setting.p2p.js";
 import { ConnectionStringParser } from "../../common/ConnectionString.js";
 import { compatGlobal } from "../../common/coreEnvFunctions.js";
 import { generateJoinRoomOptions } from "./trysteroUtils.js";
@@ -46,6 +47,12 @@ const TRYSTERO_RPC_DEFAULTS = {
   /** SCTP guarantees delivery; retransmission is a last-resort safety net. */
   chunkMissingRetryMs: 150
 };
+function resolveTrysteroRpcOptions(settings) {
+  return {
+    ...TRYSTERO_RPC_DEFAULTS,
+    maxWirePayloadBytes: normaliseP2PMaxWirePayloadBytes(settings.P2P_maxWirePayloadBytes)
+  };
+}
 function wrapTrysteroRoom(room) {
   const rpcAction = room.makeAction(RPC_ACTION_NAME);
   return {
@@ -93,7 +100,11 @@ function joinTrysteroRoomFromUrl(url) {
 }
 function serveTrysteroDB(settings, db, ns = "pdb", options) {
   const roomHandle = joinTrysteroRoom(settings);
-  const rpcRoom = new RpcRoom({ ...TRYSTERO_RPC_DEFAULTS, transport: roomHandle.transport, ...options });
+  const rpcRoom = new RpcRoom({
+    ...resolveTrysteroRpcOptions(settings),
+    transport: roomHandle.transport,
+    ...options
+  });
   exposeDB(rpcRoom, db, ns);
   return {
     peerId: roomHandle.peerId,
@@ -107,7 +118,11 @@ function serveTrysteroDB(settings, db, ns = "pdb", options) {
 }
 function connectTrysteroDBClient(settings, serverPeerId, dbName, ns = "pdb", options) {
   const roomHandle = joinTrysteroRoom(settings);
-  const rpcRoom = new RpcRoom({ ...TRYSTERO_RPC_DEFAULTS, transport: roomHandle.transport, ...options });
+  const rpcRoom = new RpcRoom({
+    ...resolveTrysteroRpcOptions(settings),
+    transport: roomHandle.transport,
+    ...options
+  });
   const proxy = new RpcPouchDBProxy(rpcRoom.session(serverPeerId), dbName, ns);
   return {
     proxy,
@@ -136,6 +151,7 @@ export {
   connectTrysteroDBClient,
   joinTrysteroRoom,
   joinTrysteroRoomFromUrl,
+  resolveTrysteroRpcOptions,
   serveTrysteroDB,
   wrapTrysteroRoom
 };