@vrtmrz/livesync-commonlib 0.2.2 → 0.3.0

package/dist/replication/RemoteResource.d.ts

@@ -1,3 +1,4 @@
+import type { PathIdentityInspection } from "../pouchdb/pathIdentityCompatibility.js";
 import type { RemoteDBSettings, RemotePreferredTweakResult } from "../common/types.js";
 import type { JoinedDevicesSnapshot, ForgetJoinedDeviceResult } from "./joinedDevices.js";
 import type { RemoteDBStatus } from "./LiveSyncAbstractReplicator.js";
@@ -36,6 +37,8 @@ export type RemoteConnectionProbeResult = {
 export interface RemoteConnectionProbe {
     check(options?: RemoteConnectionProbeOptions): Promise<RemoteConnectionProbeResult>;
     getStatus(): Promise<false | RemoteDBStatus>;
+    /** Inspect a central remote before choosing initial host settings. */
+    inspectPathIdentity?(): Promise<PathIdentityInspection>;
     dispose(): Promise<void>;
 }
 /** A finite preferred-tweak reader bound to one trial configuration. */

package/dist/replication/index.d.ts

@@ -13,3 +13,5 @@ export { assessRemoteFeatureDocument, describeRemoteFeatureRejection, ENCRYPTED_
 export type { RemoteFeatureAssessment } from "../pouchdb/remoteFeatureCompatibility.js";
 export type { JoinedDevice, JoinedDevicesSnapshot, ForgetJoinedDeviceResult } from "./joinedDevices.js";
 export type { ReplicationStatics, CouchDBReplicationPhase, CouchDBReplicationProgress, ReplicationCheckpointProgress, } from "../common/models/shared.definition.js";
+export { inspectDatabasePathIdentity } from "../pouchdb/pathIdentityCompatibility.js";
+export type { PathIdentityInspection } from "../pouchdb/pathIdentityCompatibility.js";

package/dist/replication/index.js

@@ -43,6 +43,7 @@ import {
   REMOTE_FEATURE_GENERATION,
   usesEncryptedInternalMetadata
 } from "../pouchdb/remoteFeatureCompatibility.js";
+import { inspectDatabasePathIdentity } from "../pouchdb/pathIdentityCompatibility.js";
 export {
   CAPABILITY_NOT_APPLICABLE,
   CAPABILITY_NOT_IMPLEMENTED,
@@ -72,6 +73,7 @@ export {
   centralRemoteAdministrationVerified,
   defineReplicatorProviderDefinitions,
   describeRemoteFeatureRejection,
+  inspectDatabasePathIdentity,
   isCentralRemoteAdministrationVerified,
   isReplicationCompleted,
   milestoneSatisfiesCentralRemoteAdministration,

package/dist/replication/journal/JournalSyncCore.d.ts

@@ -62,6 +62,7 @@ export declare class JournalSyncCore {
     private _createSendCompressTransformStream;
     private _createSendUploadWritableStream;
     sendLocalJournal(showMessage?: boolean): Promise<boolean>;
+    hasRemoteJournals(): Promise<boolean>;
     _getRemoteJournals(): Promise<string[]>;
     processDocuments(allDocs: ProcessingEntry[]): Promise<boolean>;
     private _createReceiveReadableStream;

package/dist/replication/journal/JournalSyncCore.js

@@ -33,6 +33,7 @@ import {
   encryptBinary as encryptBinaryHKDF,
   decryptBinary as decryptBinaryHKDF
 } from "octagonal-wheels/encryption/hkdf";
+import { assertDatabasePathIdentity } from "../../pouchdb/pathIdentityCompatibility.js";
 const RECORD_SPLIT = `
 `;
 const UNIT_SPLIT = ``;
@@ -45,6 +46,9 @@ function serializeDoc(doc) {
   }
   return te.encode(JSON.stringify(doc) + RECORD_SPLIT);
 }
+function isJournalKey(key) {
+  return !key.startsWith("_");
+}
 class JournalSyncCore {
   _settings;
   storage;
@@ -217,7 +221,13 @@ class JournalSyncCore {
     this.syncParamsHandler = void 0;
   }
   async resetCheckpointInfo() {
-    await this.updateCheckPointInfo((info) => ({ ...CheckPointInfoDefault }));
+    await this.updateCheckPointInfo(() => ({
+      ...CheckPointInfoDefault,
+      knownIDs: /* @__PURE__ */ new Set(),
+      sentIDs: /* @__PURE__ */ new Set(),
+      receivedFiles: /* @__PURE__ */ new Set(),
+      sentFiles: /* @__PURE__ */ new Set()
+    }));
   }
   getJournalEpochFromSyncParams(params) {
     return `${params.protocolVersion}:${params.pbkdf2salt}`;
@@ -262,32 +272,33 @@ class JournalSyncCore {
   }
   async resetBucket() {
     this.resetAllCaches();
-    let files = [];
     try {
+      const skippedFiles = [];
+      let from = "";
+      let files;
       do {
-        files = await this.storage.listFiles("", 100);
-        if (files.length == 0) {
-          break;
-        }
-        if (!await this.storage.deleteFiles(files)) {
-          return false;
+        files = await this.storage.listFiles(from, 100);
+        if (files.length > 0) {
+          const nextFrom = files[files.length - 1];
+          if (nextFrom <= from) {
+            throw new Error("Journal reset listing did not advance. Control documents have been retained.");
+          }
+          skippedFiles.push(...files.filter((key) => !isJournalKey(key)));
+          const journals = files.filter(isJournalKey);
+          if (journals.length > 0 && !await this.storage.deleteFiles(journals)) return false;
+          from = nextFrom;
         }
-      } while (files.length != 0);
+      } while (files.length > 0);
+      while (skippedFiles.length > 0) {
+        if (!await this.storage.deleteFiles(skippedFiles.splice(0, 100))) return false;
+      }
     } catch (ex) {
       Logger(`WARNING! Could not delete files.`, LOG_LEVEL_NOTICE, "reset-bucket");
       Logger(ex, LOG_LEVEL_VERBOSE);
       return false;
     }
-    const journals = await this._getRemoteJournals();
-    if (journals.length == 0) {
-      Logger("Nothing to delete!", LOG_LEVEL_NOTICE);
-      return true;
-    }
-    if (!await this.storage.deleteFiles(journals)) {
-      return false;
-    }
-    Logger(`${journals.length} items has been deleted!`, LOG_LEVEL_NOTICE);
     await this.resetCheckpointInfo();
+    Logger("Remote bucket cleared", LOG_LEVEL_NOTICE);
     return true;
   }
   getRemoteKey() {
@@ -502,6 +513,7 @@ class JournalSyncCore {
     });
   }
   async sendLocalJournal(showMessage = false) {
+    await assertDatabasePathIdentity(this.db, this.currentSettings);
     this.updateInfo({ syncStatus: "JOURNAL_SEND" });
     return await shareRunningResult("send_journal_stream", async () => {
       this.requestedStop = false;
@@ -544,12 +556,15 @@ class JournalSyncCore {
       }
     });
   }
+  async hasRemoteJournals() {
+    return (await this.storage.listFiles("", 1)).some(isJournalKey);
+  }
   async _getRemoteJournals() {
     const checkPointInfo = await this.getCheckpointInfo();
     const StartAfter = [...checkPointInfo.receivedFiles.keys()].sort(
       (a, b) => b.localeCompare(a, void 0, { numeric: true })
     )[0];
-    const files = (await this.storage.listFiles(StartAfter)).filter((e) => !e.startsWith("_"));
+    const files = (await this.storage.listFiles(StartAfter)).filter(isJournalKey);
     if (!files) return [];
     return files.sort((a, b) => a.localeCompare(b, void 0, { numeric: true }));
   }
@@ -677,7 +692,12 @@ class JournalSyncCore {
             const piece = decompressed.slice(idxFrom, idxTo);
             const strPiece = d.decode(piece);
             if (strPiece.startsWith("~")) {
-              const [idPart, dataPart] = strPiece.substring(1).split(UNIT_SPLIT);
+              const separatorIndex = strPiece.indexOf(UNIT_SPLIT);
+              if (separatorIndex === -1) {
+                throw new Error("Invalid journal chunk record: missing separator");
+              }
+              const idPart = strPiece.substring(1, separatorIndex);
+              const dataPart = strPiece.substring(separatorIndex + 1);
               result.push({
                 _id: idPart,
                 data: unescapeNewLineFromString(dataPart),
@@ -718,6 +738,7 @@ class JournalSyncCore {
     });
   }
   async receiveRemoteJournal(showMessage = false) {
+    await assertDatabasePathIdentity(this.db, this.currentSettings);
     this.updateInfo({ syncStatus: "JOURNAL_RECEIVE" });
     return await shareRunningResult("receive_journal_stream", async () => {
       this.requestedStop = false;

package/dist/replication/journal/LiveSyncJournalReplicator.d.ts

@@ -1,3 +1,4 @@
+import type { PathIdentityInspection } from "../../pouchdb/pathIdentityCompatibility.js";
 import { type RemoteDBSettings, type ChunkVersionRange, type NodeData, type RemotePreferredTweakResult, type TweakAssessment } from "../../common/types.js";
 import { JournalSyncCore } from "./JournalSyncCore.js";
 import { LiveSyncAbstractReplicator, type RemoteDBStatus } from "../LiveSyncAbstractReplicator.js";
@@ -23,7 +24,16 @@ export declare class LiveSyncJournalReplicator extends LiveSyncAbstractReplicato
     private journalTransferStopGeneration;
     getReplicationPBKDF2Salt(setting: RemoteDBSettings, refresh?: boolean): Promise<Uint8Array<ArrayBuffer>>;
     setupJournalSyncClient(settings?: RemoteDBSettings): JournalSyncCore;
-    ensureBucketIsCompatible(deviceNodeID: string, currentVersionRange: ChunkVersionRange, setting?: RemoteDBSettings, client?: Pick<JournalSyncCore, "downloadJsonWithResult" | "getCheckpointInfo" | "uploadJson">, recordTweakAssessment?: (assessment: TweakAssessment) => void): Promise<ENSURE_DB_RESULT>;
+    private isBucketPathIdentityCompatible;
+    private isBucketIdDerivationCompatible;
+    private assertBucketIdentity;
+    /** Inspect identity without publishing this node, preparing a seed, or changing checkpoints. */
+    assertRemotePathIdentity(setting: RemoteDBSettings): Promise<void>;
+    /** Read path identity for initial setup without publishing a node or preparing a seed. */
+    inspectRemotePathIdentity(setting: RemoteDBSettings): Promise<PathIdentityInspection>;
+    /** Lock existing journals for replacement without declaring the replacement's identity. */
+    markRemoteLockedForRebuild(setting: RemoteDBSettings): Promise<void>;
+    ensureBucketIsCompatible(deviceNodeID: string, currentVersionRange: ChunkVersionRange, setting?: RemoteDBSettings, client?: Pick<JournalSyncCore, "downloadJsonWithResult" | "getCheckpointInfo" | "uploadJson" | "hasRemoteJournals">, recordTweakAssessment?: (assessment: TweakAssessment) => void): Promise<ENSURE_DB_RESULT>;
     constructor(env: LiveSyncJournalReplicatorEnv);
     migrate(from: number, to: number): Promise<boolean>;
     /**
@@ -62,8 +72,6 @@ export declare class LiveSyncJournalReplicator extends LiveSyncAbstractReplicato
     setPreferredRemoteTweakSettings(setting: RemoteDBSettings): Promise<void>;
     getRemotePreferredTweakValues(setting: RemoteDBSettings): Promise<RemotePreferredTweakResult>;
     getRemoteStatus(setting: RemoteDBSettings): Promise<false | RemoteDBStatus>;
-    private supportsLegacyPathIdentity;
-    private assertLegacyPathIdentity;
     private getOwnJoinedDeviceId;
     getJoinedDevices(setting: RemoteDBSettings): Promise<JoinedDevicesSnapshot>;
     forgetJoinedDevice(setting: RemoteDBSettings, deviceId: string): Promise<ForgetJoinedDeviceResult>;

package/dist/replication/journal/LiveSyncJournalReplicator.js

@@ -12,7 +12,7 @@ import { MinioStorageAdapter } from "./objectstore/MinioStorageAdapter.js";
 import { LiveSyncAbstractReplicator } from "../LiveSyncAbstractReplicator.js";
 import { ensureRemoteIsCompatible } from "../../pouchdb/LiveSyncDBFunctions.js";
 import { getEffectiveTweakValues } from "../../pouchdb/LiveSyncDBFunctions.js";
-import { getPathNormalizationVersion } from "../../common/pathNormalization.js";
+import { assertSupportedPathNormalizationVersion, getPathNormalizationVersion } from "../../common/pathNormalization.js";
 import { JournalStorageReadStatuses } from "./objectstore/JournalStorageAdapter.js";
 import { computeKeyedId, configuredIdKey } from "../../common/idDerivation.js";
 import { decryptString, encryptString } from "../../encryption/stringEncryption.js";
@@ -44,8 +44,17 @@ const currentVersionRange = {
   current: 2
 };
 function journalVersionRange(setting) {
+  if (getPathNormalizationVersion(setting) === 1) return { min: 4, max: 4, current: 4 };
   return configuredIdKey(setting) && setting.encrypt && setting.usePathObfuscation ? { min: 3, max: 3, current: 3 } : currentVersionRange;
 }
+function pathIdentityFromJournalRange(range) {
+  if (range?.min === 4 && range?.max === 4) return 1;
+  if (!range) return 0;
+  if (Number.isSafeInteger(range.min) && Number.isSafeInteger(range.max) && range.min >= 0 && range.max <= 3 && range.min <= range.max) {
+    return 0;
+  }
+  throw new Error("The Journal declares an unsupported path identity range.");
+}
 class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
   get client() {
     return this.setupJournalSyncClient();
@@ -66,7 +75,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     return await this.setupJournalSyncClient(setting).getReplicationPBKDF2Salt(refresh);
   }
   setupJournalSyncClient(settings = this.currentSettings) {
-    this.assertLegacyPathIdentity(settings);
+    assertSupportedPathNormalizationVersion(settings.pathNormalizationVersion);
     if (this._client) {
       this._client.applyNewConfig(settings, this.simpleStore, this.env);
     } else {
@@ -79,33 +88,105 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     }
     return this._client;
   }
-  async ensureBucketIsCompatible(deviceNodeID, currentVersionRange2, setting = this.currentSettings, client = this.setupJournalSyncClient(setting), recordTweakAssessment) {
-    const milestoneResult = await client.downloadJsonWithResult(MILSTONE_DOCID);
-    if (milestoneResult.status === JournalStorageReadStatuses.UNAVAILABLE) {
-      throw milestoneResult.error;
+  async isBucketPathIdentityCompatible(setting, milestone, client) {
+    const pathVersion = getPathNormalizationVersion(setting);
+    const ranges = milestone?.node_chunk_info ?? {};
+    const nodes = /* @__PURE__ */ new Set([...milestone?.accepted_nodes ?? [], ...Object.keys(ranges)]);
+    for (const node of nodes) {
+      const range = ranges[node];
+      const usesNFC = range?.min === 4 && range?.max === 4;
+      if (usesNFC !== (pathVersion === 1)) return false;
+    }
+    const preferred = milestone?.tweak_values?.[DEVICE_ID_PREFERRED];
+    if (preferred && getPathNormalizationVersion(preferred) !== pathVersion) return false;
+    if (nodes.size === 0 && await client.hasRemoteJournals()) {
+      throw new Error(
+        "The Journal compatibility milestone is missing. Rebuild from the authoritative Vault before synchronising."
+      );
     }
-    const downloadedMilestone = milestoneResult.status === JournalStorageReadStatuses.AVAILABLE ? milestoneResult.value : false;
+    return true;
+  }
+  async isBucketIdDerivationCompatible(setting, milestone) {
     const idKey = configuredIdKey(setting);
-    let encryptedProof;
-    const preferredTweak = downloadedMilestone && downloadedMilestone.tweak_values?.[DEVICE_ID_PREFERRED];
-    if (preferredTweak?.idDerivationVersion === 1 && preferredTweak.usePathObfuscation === true && (!idKey || !setting.encrypt || !setting.usePathObfuscation)) {
-      return "ID_KEY_MISMATCH";
+    const usesKeyedDocumentIds = !!idKey && setting.encrypt && setting.usePathObfuscation;
+    const preferred = milestone?.tweak_values?.[DEVICE_ID_PREFERRED];
+    const stored = milestone?.encrypted_id_derivation_proof;
+    if (!usesKeyedDocumentIds) {
+      return !stored && !(preferred?.idDerivationVersion === 1 && preferred.usePathObfuscation === true);
     }
-    if (idKey && setting.encrypt && setting.usePathObfuscation) {
-      const expected = await computeKeyedId(idKey, "remote-agreement", "journal-milestone-v1");
-      const stored = downloadedMilestone && downloadedMilestone.encrypted_id_derivation_proof;
-      if (stored) {
-        try {
-          if (await decryptString(stored, setting.passphrase) !== expected) return "ID_KEY_MISMATCH";
-        } catch {
-          return "ID_KEY_MISMATCH";
-        }
-      } else if (downloadedMilestone) {
-        return "ID_KEY_MISMATCH";
-      } else {
-        encryptedProof = await encryptString(expected, setting.passphrase);
-      }
+    if (!milestone) return true;
+    if (!stored) return false;
+    const expected = await computeKeyedId(idKey, "remote-agreement", "journal-milestone-v1");
+    try {
+      return await decryptString(stored, setting.passphrase) === expected;
+    } catch {
+      return false;
+    }
+  }
+  async assertBucketIdentity(setting, milestone, client) {
+    if (!await this.isBucketPathIdentityCompatible(setting, milestone, client)) {
+      throw new Error(
+        "The Journal and settings use different path identity versions. Rebuild from the authoritative Vault or Fetch with matching settings before synchronising."
+      );
     }
+    if (!await this.isBucketIdDerivationCompatible(setting, milestone)) {
+      throw new Error(
+        "The Journal and settings use different document ID derivation modes or keys. Rebuild from the authoritative Vault or Fetch with matching settings before synchronising."
+      );
+    }
+  }
+  /** Inspect identity without publishing this node, preparing a seed, or changing checkpoints. */
+  async assertRemotePathIdentity(setting) {
+    const client = this.setupJournalSyncClient(setting);
+    await this.assertBucketIdentity(setting, await readRemoteMilestone(client), client);
+  }
+  /** Read path identity for initial setup without publishing a node or preparing a seed. */
+  async inspectRemotePathIdentity(setting) {
+    const client = this.setupJournalSyncClient(setting);
+    const milestone = await readRemoteMilestone(client);
+    const versions = /* @__PURE__ */ new Set();
+    const ranges = milestone?.node_chunk_info ?? {};
+    const nodes = /* @__PURE__ */ new Set([...milestone?.accepted_nodes ?? [], ...Object.keys(ranges)]);
+    for (const node of nodes) {
+      versions.add(pathIdentityFromJournalRange(ranges[node]));
+    }
+    const preferred = milestone?.tweak_values?.[DEVICE_ID_PREFERRED];
+    if (preferred) versions.add(getPathNormalizationVersion(preferred));
+    if (versions.size > 1) throw new Error("The Journal has conflicting path identity declarations.");
+    if (nodes.size === 0 && await client.hasRemoteJournals()) {
+      throw new Error(
+        "The Journal path identity declaration is missing. Use matching settings or Rebuild from the authoritative Vault."
+      );
+    }
+    const version = [...versions][0];
+    return version === void 0 ? { status: "empty" } : { status: "configured", pathNormalizationVersion: version };
+  }
+  /** Lock existing journals for replacement without declaring the replacement's identity. */
+  async markRemoteLockedForRebuild(setting) {
+    assertSupportedPathNormalizationVersion(setting.pathNormalizationVersion);
+    const client = this.setupJournalSyncClient(setting);
+    const milestone = await readRemoteMilestone(client);
+    if (!milestone) return;
+    const previousRange = Object.values(milestone.node_chunk_info ?? {}).sort((a, b) => b.min - a.min)[0];
+    const lockedMilestone = {
+      ...milestone,
+      locked: true,
+      accepted_nodes: previousRange ? [this.nodeid] : [],
+      node_chunk_info: previousRange ? { ...milestone.node_chunk_info, [this.nodeid]: { ...previousRange } } : milestone.node_chunk_info
+    };
+    if (!await client.uploadJson(MILSTONE_DOCID, lockedMilestone)) {
+      throw new Error("Could not upload remote milestone");
+    }
+  }
+  async ensureBucketIsCompatible(deviceNodeID, currentVersionRange2, setting = this.currentSettings, client = this.setupJournalSyncClient(setting), recordTweakAssessment) {
+    const downloadedMilestone = await readRemoteMilestone(client) ?? false;
+    if (!await this.isBucketPathIdentityCompatible(setting, downloadedMilestone || void 0, client)) {
+      return "INCOMPATIBLE";
+    }
+    if (!await this.isBucketIdDerivationCompatible(setting, downloadedMilestone || void 0)) {
+      return "ID_KEY_MISMATCH";
+    }
+    const encryptedProof = downloadedMilestone ? void 0 : await this.createInitialIdDerivationProof(setting);
     const cPointInfo = await client.getCheckpointInfo();
     const progress = [...cPointInfo?.receivedFiles || []].sort().pop() || "";
     return await ensureRemoteIsCompatible(
@@ -291,7 +372,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
   }
   async checkReplicationConnectivity(skipCheck, ignoreCleanLock = false, showMessage = false, setting = this.currentSettings, client, recordCompatibilityDecision) {
     recordCompatibilityDecision?.(CENTRAL_COMPATIBILITY_NOT_ASSESSED);
-    if (!this.supportsLegacyPathIdentity(setting)) return false;
+    assertSupportedPathNormalizationVersion(setting.pathNormalizationVersion);
     const activeClient = client ?? this.setupJournalSyncClient(setting);
     if (!await activeClient.isAvailable()) {
       return false;
@@ -388,7 +469,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     this.updateInfo();
   }
   async tryResetRemoteDatabase(setting) {
-    this.assertLegacyPathIdentity(setting);
+    assertSupportedPathNormalizationVersion(setting.pathNormalizationVersion);
     this.closeReplication();
     try {
       if (!await this.client.resetBucket()) {
@@ -403,7 +484,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     }
   }
   async tryCreateRemoteDatabase(setting) {
-    this.assertLegacyPathIdentity(setting);
+    assertSupportedPathNormalizationVersion(setting.pathNormalizationVersion);
     this.closeReplication();
     Logger("Remote Database Created or Connected", LOG_LEVEL_NOTICE);
     if (!await this.ensurePBKDF2Salt(setting, true, false)) {
@@ -418,7 +499,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     return await encryptString(proof, setting.passphrase);
   }
   async markRemoteLocked(setting, locked, lockByClean) {
-    this.assertLegacyPathIdentity(setting);
+    assertSupportedPathNormalizationVersion(setting.pathNormalizationVersion);
     const defInitPoint = {
       _id: MILSTONE_DOCID,
       type: "milestoneinfo",
@@ -432,6 +513,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     };
     const client = this.setupJournalSyncClient(setting);
     const existingMilestone = await readRemoteMilestone(client);
+    await this.assertBucketIdentity(setting, existingMilestone, client);
     const initialProof = existingMilestone ? void 0 : await this.createInitialIdDerivationProof(setting);
     const remoteMilestone = {
       ...defInitPoint,
@@ -452,7 +534,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     }
   }
   async markRemoteResolved(setting) {
-    this.assertLegacyPathIdentity(setting);
+    assertSupportedPathNormalizationVersion(setting.pathNormalizationVersion);
     const defInitPoint = {
       _id: MILSTONE_DOCID,
       type: "milestoneinfo",
@@ -465,6 +547,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     };
     const client = this.setupJournalSyncClient(setting);
     const existingMilestone = await readRemoteMilestone(client);
+    await this.assertBucketIdentity(setting, existingMilestone, client);
     const initialProof = existingMilestone ? void 0 : await this.createInitialIdDerivationProof(setting);
     const remoteMilestone = {
       ...defInitPoint,
@@ -482,7 +565,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     const endpoint = setting.endpoint;
     let testClient;
     try {
-      this.assertLegacyPathIdentity(setting);
+      assertSupportedPathNormalizationVersion(setting.pathNormalizationVersion);
       testClient = new MinioStorageAdapter(setting, this.env);
       await testClient.listFiles("", 1);
       Logger(`Connected to ${endpoint} successfully!`, LOG_LEVEL_NOTICE);
@@ -497,12 +580,13 @@ ${ex.message}`, LOG_LEVEL_NOTICE);
     }
   }
   async resetRemoteTweakSettings(setting) {
-    this.assertLegacyPathIdentity(setting);
+    assertSupportedPathNormalizationVersion(setting.pathNormalizationVersion);
     try {
       const remoteMilestone = await this.client.downloadJson(MILSTONE_DOCID);
       if (!remoteMilestone) {
         throw new Error("Missing remote milestone");
       }
+      await this.assertBucketIdentity(setting, remoteMilestone, this.client);
       remoteMilestone.tweak_values = {};
       Logger(`tweak values on the remote database have been cleared`, LOG_LEVEL_VERBOSE);
       await this.client.uploadJson(MILSTONE_DOCID, remoteMilestone);
@@ -512,7 +596,7 @@ ${ex.message}`, LOG_LEVEL_NOTICE);
     }
   }
   async setPreferredRemoteTweakSettings(setting) {
-    this.assertLegacyPathIdentity(setting);
+    assertSupportedPathNormalizationVersion(setting.pathNormalizationVersion);
     const trialClient = new JournalSyncCore(
       setting,
       this.simpleStore,
@@ -524,6 +608,7 @@ ${ex.message}`, LOG_LEVEL_NOTICE);
       if (!remoteMilestone) {
         throw new Error("Missing remote milestone");
       }
+      await this.assertBucketIdentity(setting, remoteMilestone, trialClient);
       remoteMilestone.tweak_values[DEVICE_ID_PREFERRED] = getEffectiveTweakValues(setting);
       Logger(`Preferred tweak values have been registered`, LOG_LEVEL_VERBOSE);
       if (!await trialClient.uploadJson(MILSTONE_DOCID, remoteMilestone)) {
@@ -537,7 +622,7 @@ ${ex.message}`, LOG_LEVEL_NOTICE);
     }
   }
   async getRemotePreferredTweakValues(setting) {
-    this.assertLegacyPathIdentity(setting);
+    assertSupportedPathNormalizationVersion(setting.pathNormalizationVersion);
     const trialClient = new JournalSyncCore(
       setting,
       this.simpleStore,
@@ -574,7 +659,7 @@ ${ex.message}`, LOG_LEVEL_NOTICE);
     }
   }
   async getRemoteStatus(setting) {
-    this.assertLegacyPathIdentity(setting);
+    assertSupportedPathNormalizationVersion(setting.pathNormalizationVersion);
     const testClient = new MinioStorageAdapter(setting, this.env);
     try {
       return await testClient.getUsage();
@@ -582,14 +667,6 @@ ${ex.message}`, LOG_LEVEL_NOTICE);
       testClient.dispose();
     }
   }
-  supportsLegacyPathIdentity(setting) {
-    return getPathNormalizationVersion(setting) === 0;
-  }
-  assertLegacyPathIdentity(setting) {
-    if (!this.supportsLegacyPathIdentity(setting)) {
-      throw new Error("Object Storage does not support NFC path identity.");
-    }
-  }
   async getOwnJoinedDeviceId() {
     const nodeInfo = await this.rawDatabase.get(NODEINFO_DOCID);
     const nodeId = nodeInfo?.nodeid;
@@ -599,7 +676,7 @@ ${ex.message}`, LOG_LEVEL_NOTICE);
     return nodeId;
   }
   async getJoinedDevices(setting) {
-    this.assertLegacyPathIdentity(setting);
+    assertSupportedPathNormalizationVersion(setting.pathNormalizationVersion);
     const trialClient = new JournalSyncCore(
       setting,
       this.simpleStore,
@@ -616,7 +693,7 @@ ${ex.message}`, LOG_LEVEL_NOTICE);
     }
   }
   async forgetJoinedDevice(setting, deviceId) {
-    this.assertLegacyPathIdentity(setting);
+    assertSupportedPathNormalizationVersion(setting.pathNormalizationVersion);
     const ownDeviceId = await this.getOwnJoinedDeviceId();
     const trialClient = new JournalSyncCore(
       setting,
@@ -630,6 +707,7 @@ ${ex.message}`, LOG_LEVEL_NOTICE);
           const result = await trialClient.downloadJsonWithResult(MILSTONE_DOCID);
           if (result.status === JournalStorageReadStatuses.NOT_FOUND) return void 0;
           if (result.status === JournalStorageReadStatuses.UNAVAILABLE) throw result.error;
+          await this.assertBucketIdentity(setting, result.value, trialClient);
           return { milestone: result.value, revision: result.revision };
         },
         write: async (milestone, revision) => await trialClient.uploadJsonIfUnchanged(MILSTONE_DOCID, milestone, revision)

package/dist/replication/trystero/P2PRoomSessionOwner.js

@@ -12,7 +12,7 @@ import { P2PRoomSession } from "./P2PRoomSession.js";
 import { P2PAutomationCoordinator } from "./P2PAutomationCoordinator.js";
 import { PEER_REPLICATION_READINESS } from "../ReplicatorProvider.js";
 import { getP2PReplicatorConfigurationIdentity } from "./p2pReplicatorConfigurationIdentity.js";
-import { getPathNormalizationVersion } from "../../common/pathNormalization.js";
+import { assertSupportedPathNormalizationVersion, getPathNormalizationVersion } from "../../common/pathNormalization.js";
 import {
   ACTIVE_P2P_RELAY_BINDING_CONFLICT,
   activeP2PRelayBindingCovers
@@ -58,8 +58,8 @@ class P2PRoomSessionOwner {
   /** Reconcile one long-lived reason for keeping the room available. */
   async setPersistentDemand(demand, active) {
     const settings = this.env.services.setting.currentSettings();
-    const supportsPathIdentity = getPathNormalizationVersion(settings) === 0;
-    const enabled = settings.P2P_Enabled && supportsPathIdentity;
+    assertSupportedPathNormalizationVersion(settings.pathNormalizationVersion);
+    const enabled = settings.P2P_Enabled;
     if (active && enabled) {
       this.persistentDemands.add(demand);
     } else {
@@ -67,8 +67,6 @@ class P2PRoomSessionOwner {
     }
     if (active && !settings.P2P_Enabled) {
       Logger(this.env.services.context.translate("P2P.NotEnabled"), LOG_LEVEL_NOTICE);
-    } else if (active && !supportsPathIdentity) {
-      Logger("P2P does not support NFC path identity.", LOG_LEVEL_NOTICE);
     }
     await this.fencePreparationForCurrentSettings(enabled);
     await this.reconcileTransport();
@@ -81,12 +79,10 @@ class P2PRoomSessionOwner {
    */
   async runWithFiniteDemand(task) {
     const settings = this.env.services.setting.currentSettings();
+    assertSupportedPathNormalizationVersion(settings.pathNormalizationVersion);
     if (!settings.P2P_Enabled) {
       throw new Error("P2P is not enabled.");
     }
-    if (getPathNormalizationVersion(settings) !== 0) {
-      throw new Error("P2P does not support NFC path identity.");
-    }
     const demand = /* @__PURE__ */ Symbol("p2p-finite-room-demand");
     this.finiteDemands.add(demand);
     try {
@@ -108,8 +104,10 @@ class P2PRoomSessionOwner {
   }
   /** Arbitrate a complete signalling probe on the room lifecycle queue. */
   runConnectionProbe(trialSettings, runOwnedTrial) {
-    if (getPathNormalizationVersion(this.env.services.setting.currentSettings()) !== 0) {
-      return Promise.reject(new Error("P2P does not support NFC path identity."));
+    try {
+      assertSupportedPathNormalizationVersion(this.env.services.setting.currentSettings().pathNormalizationVersion);
+    } catch (error) {
+      return Promise.reject(error);
     }
     return this.enqueueLifecycleOperation(async () => {
       const current = this.current;
@@ -135,7 +133,8 @@ class P2PRoomSessionOwner {
   async reconcileTransport() {
     await this.enqueueLifecycleOperation(async () => {
       const settings = this.env.services.setting.currentSettings();
-      if (!settings.P2P_Enabled || getPathNormalizationVersion(settings) !== 0) {
+      assertSupportedPathNormalizationVersion(settings.pathNormalizationVersion);
+      if (!settings.P2P_Enabled) {
         this.persistentDemands.clear();
         this.finiteDemands.clear();
       }
@@ -390,17 +389,19 @@ class P2PRoomSessionOwner {
       ...this.env.services.setting.currentSettings()
     });
     const database = this.env.services.database.localDatabase.localDatabase;
+    const pathNormalizationVersion = getPathNormalizationVersion(settings);
     this.automationCoordinator.reconcileIdentity(
       JSON.stringify([
         settings.P2P_AppID || "self-hosted-livesync",
         settings.P2P_roomID,
-        settings.P2P_passphrase
+        settings.P2P_passphrase,
+        pathNormalizationVersion
       ]),
       database
     );
     return {
       database,
-      enabled: settings.P2P_Enabled && getPathNormalizationVersion(settings) === 0,
+      enabled: settings.P2P_Enabled,
       settings,
       deviceName,
       signature: JSON.stringify([getP2PReplicatorConfigurationIdentity(settings), deviceName])