@vrtmrz/livesync-commonlib 0.1.40 → 0.1.42

package/dist/replication/index.js

@@ -39,6 +39,7 @@ import {
   assessRemoteFeatureDocument,
   describeRemoteFeatureRejection,
   ENCRYPTED_INTERNAL_METADATA_FEATURE,
+  NFC_PATH_IDENTITY_FEATURE,
   REMOTE_FEATURE_GENERATION,
   usesEncryptedInternalMetadata
 } from "../pouchdb/remoteFeatureCompatibility.js";
@@ -54,6 +55,7 @@ export {
   CENTRAL_REMOTE_ADMINISTRATION_RESULT_STATUSES,
   CENTRAL_REMOTE_REPLICATION_READINESS,
   ENCRYPTED_INTERNAL_METADATA_FEATURE,
+  NFC_PATH_IDENTITY_FEATURE,
   NO_INTERACTION,
   NO_REMOTE_RESOURCE_CAPABILITIES,
   PEER_REPLICATION_READINESS,

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

@@ -61,6 +61,8 @@ 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;
     getConnectedDeviceList(setting?: RemoteDBSettings): Promise<false | {
         node_info: Record<string, NodeData>;
         accepted_nodes: string[];

package/dist/replication/journal/LiveSyncJournalReplicator.js

@@ -11,6 +11,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 { JournalStorageReadStatuses } from "./objectstore/JournalStorageAdapter.js";
 import { computeKeyedId, configuredIdKey } from "../../common/idDerivation.js";
 import { decryptString, encryptString } from "../../encryption/stringEncryption.js";
@@ -60,6 +61,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     return await this.setupJournalSyncClient(setting).getReplicationPBKDF2Salt(refresh);
   }
   setupJournalSyncClient(settings = this.currentSettings) {
+    this.assertLegacyPathIdentity(settings);
     if (this._client) {
       this._client.applyNewConfig(settings, this.simpleStore, this.env);
     } else {
@@ -281,13 +283,15 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
       (client) => client.receiveRemoteJournal(showingNotice)
     );
   }
-  async checkReplicationConnectivity(skipCheck, ignoreCleanLock = false, showMessage = false, setting = this.currentSettings, client = this.setupJournalSyncClient(setting), recordCompatibilityDecision) {
+  async checkReplicationConnectivity(skipCheck, ignoreCleanLock = false, showMessage = false, setting = this.currentSettings, client, recordCompatibilityDecision) {
     recordCompatibilityDecision?.(CENTRAL_COMPATIBILITY_NOT_ASSESSED);
-    if (!await client.isAvailable()) {
+    if (!this.supportsLegacyPathIdentity(setting)) return false;
+    const activeClient = client ?? this.setupJournalSyncClient(setting);
+    if (!await activeClient.isAvailable()) {
       return false;
     }
     if (!skipCheck) {
-      await client.ensureCheckpointCachesAreFresh();
+      await activeClient.ensureCheckpointCachesAreFresh();
       this.remoteCleaned = false;
       this.remoteLocked = false;
       this.remoteLockedAndDeviceNotAccepted = false;
@@ -298,7 +302,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
         this.nodeid,
         journalVersionRange(setting),
         setting,
-        client,
+        activeClient,
         (assessment) => {
           tweakAssessment = assessment;
         }
@@ -378,6 +382,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     this.updateInfo();
   }
   async tryResetRemoteDatabase(setting) {
+    this.assertLegacyPathIdentity(setting);
     this.closeReplication();
     try {
       if (!await this.client.resetBucket()) {
@@ -392,6 +397,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     }
   }
   async tryCreateRemoteDatabase(setting) {
+    this.assertLegacyPathIdentity(setting);
     this.closeReplication();
     Logger("Remote Database Created or Connected", LOG_LEVEL_NOTICE);
     if (!await this.ensurePBKDF2Salt(setting, true, false)) {
@@ -406,6 +412,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     return await encryptString(proof, setting.passphrase);
   }
   async markRemoteLocked(setting, locked, lockByClean) {
+    this.assertLegacyPathIdentity(setting);
     const defInitPoint = {
       _id: MILSTONE_DOCID,
       type: "milestoneinfo",
@@ -439,6 +446,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     }
   }
   async markRemoteResolved(setting) {
+    this.assertLegacyPathIdentity(setting);
     const defInitPoint = {
       _id: MILSTONE_DOCID,
       type: "milestoneinfo",
@@ -466,8 +474,10 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
   }
   async tryConnectRemote(setting, showResult = true) {
     const endpoint = setting.endpoint;
-    const testClient = new MinioStorageAdapter(setting, this.env);
+    let testClient;
     try {
+      this.assertLegacyPathIdentity(setting);
+      testClient = new MinioStorageAdapter(setting, this.env);
       await testClient.listFiles("", 1);
       Logger(`Connected to ${endpoint} successfully!`, LOG_LEVEL_NOTICE);
       return true;
@@ -477,10 +487,11 @@ ${ex.message}`, LOG_LEVEL_NOTICE);
       Logger(ex, LOG_LEVEL_NOTICE);
       return false;
     } finally {
-      testClient.dispose();
+      testClient?.dispose();
     }
   }
   async resetRemoteTweakSettings(setting) {
+    this.assertLegacyPathIdentity(setting);
     try {
       const remoteMilestone = await this.client.downloadJson(MILSTONE_DOCID);
       if (!remoteMilestone) {
@@ -495,6 +506,7 @@ ${ex.message}`, LOG_LEVEL_NOTICE);
     }
   }
   async setPreferredRemoteTweakSettings(setting) {
+    this.assertLegacyPathIdentity(setting);
     const trialClient = new JournalSyncCore(
       setting,
       this.simpleStore,
@@ -519,6 +531,7 @@ ${ex.message}`, LOG_LEVEL_NOTICE);
     }
   }
   async getRemotePreferredTweakValues(setting) {
+    this.assertLegacyPathIdentity(setting);
     const trialClient = new JournalSyncCore(
       setting,
       this.simpleStore,
@@ -555,6 +568,7 @@ ${ex.message}`, LOG_LEVEL_NOTICE);
     }
   }
   async getRemoteStatus(setting) {
+    this.assertLegacyPathIdentity(setting);
     const testClient = new MinioStorageAdapter(setting, this.env);
     try {
       return await testClient.getUsage();
@@ -562,6 +576,14 @@ ${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.");
+    }
+  }
   getConnectedDeviceList(setting) {
     return Promise.resolve(false);
   }

package/dist/replication/trystero/P2PRoomSessionOwner.js

@@ -12,6 +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 {
   ACTIVE_P2P_RELAY_BINDING_CONFLICT,
   activeP2PRelayBindingCovers
@@ -56,14 +57,18 @@ class P2PRoomSessionOwner {
   }
   /** Reconcile one long-lived reason for keeping the room available. */
   async setPersistentDemand(demand, active) {
-    const enabled = this.env.services.setting.currentSettings().P2P_Enabled;
+    const settings = this.env.services.setting.currentSettings();
+    const supportsPathIdentity = getPathNormalizationVersion(settings) === 0;
+    const enabled = settings.P2P_Enabled && supportsPathIdentity;
     if (active && enabled) {
       this.persistentDemands.add(demand);
     } else {
       this.persistentDemands.delete(demand);
     }
-    if (active && !enabled) {
+    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);
     }
     this.fencePreparationForCurrentSettings(enabled);
     await this.reconcileTransport();
@@ -75,9 +80,13 @@ class P2PRoomSessionOwner {
    * retained by another finite operation or by a persistent policy demand.
    */
   async runWithFiniteDemand(task) {
-    if (!this.env.services.setting.currentSettings().P2P_Enabled) {
+    const settings = this.env.services.setting.currentSettings();
+    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);
     this.fencePreparationForCurrentSettings(true);
@@ -99,6 +108,9 @@ 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."));
+    }
     return this.enqueueLifecycleOperation(async () => {
       const current = this.current;
       const activeBinding = this.activeBinding;
@@ -122,7 +134,8 @@ class P2PRoomSessionOwner {
   }
   async reconcileTransport() {
     await this.enqueueLifecycleOperation(async () => {
-      if (!this.env.services.setting.currentSettings().P2P_Enabled) {
+      const settings = this.env.services.setting.currentSettings();
+      if (!settings.P2P_Enabled || getPathNormalizationVersion(settings) !== 0) {
         this.persistentDemands.clear();
         this.finiteDemands.clear();
       }
@@ -374,7 +387,7 @@ class P2PRoomSessionOwner {
     );
     return {
       database,
-      enabled: settings.P2P_Enabled,
+      enabled: settings.P2P_Enabled && getPathNormalizationVersion(settings) === 0,
       settings,
       deviceName,
       signature: JSON.stringify([getP2PReplicatorConfigurationIdentity(settings), deviceName])

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

@@ -249,6 +249,7 @@ export declare class TrysteroReplicator {
         bucketPrefix?: string;
         forcePathStyle?: boolean;
         remoteType?: import("../../common/types.js").RemoteType;
+        pathNormalizationVersion?: import("../../settings.js").PathNormalizationVersion;
         encrypt?: boolean;
         passphrase?: string;
         idDerivationKey?: string;
@@ -436,6 +437,7 @@ export declare class TrysteroReplicator {
             bucketPrefix?: string;
             forcePathStyle?: boolean;
             remoteType?: import("../../common/types.js").RemoteType;
+            pathNormalizationVersion?: import("../../settings.js").PathNormalizationVersion;
             encrypt?: boolean;
             passphrase?: string;
             idDerivationKey?: string;

package/dist/replication/trystero/useP2PReplicatorFeature.js

@@ -15,6 +15,7 @@ import {
   supportedStopActiveTransfer
 } from "../index.js";
 import { getP2PReplicatorConfigurationIdentity } from "./p2pReplicatorConfigurationIdentity.js";
+import { getPathNormalizationVersion } from "../../common/pathNormalization.js";
 function useP2PReplicatorFeature(host, openReplicationUIFactory, openRebuildUIFactory, options = {}) {
   const service = createP2PService(
     {
@@ -62,7 +63,7 @@ function useP2PReplicatorFeature(host, openReplicationUIFactory, openRebuildUIFa
         kind: REMOTE_P2P,
         diagnosticName: "P2P",
         readiness: PEER_REPLICATION_READINESS,
-        isConfigured: (settings) => settings.remoteType === REMOTE_P2P && settings.P2P_Enabled,
+        isConfigured: (settings) => settings.remoteType === REMOTE_P2P && settings.P2P_Enabled && getPathNormalizationVersion(settings) === 0,
         configurationIdentity: getP2PReplicatorConfigurationIdentity,
         create: createP2PReplicator,
         remoteResources: NO_REMOTE_RESOURCE_CAPABILITIES,

package/dist/serviceFeatures/offlineScanner.d.ts

@@ -150,7 +150,7 @@ export declare function getPathFromEntry(host: NecessaryServices<"path", never>,
 export declare function syncFileBetweenDBandStorage(host: NecessaryServices<"setting" | "vault" | "path", "storageAccess" | "fileHandler">, log: LogFunction, file: UXFileInfoStub, doc: MetaEntry): Promise<FilePairProcessResult>;
 export declare function canProceedScan(host: NecessaryServices<"keyValueDB" | "setting", never>, errorManager: UnresolvedErrorManager, log: LogFunction, showingNotice?: boolean, ignoreSuspending?: boolean): boolean;
 /**
- * Convert file path to lower case if the settings indicate that filename case should be handled insensitively.
+ * Normalise the logical comparison key and lower case it when filename case should be handled insensitively.
  * @param settings
  * @param path
  * @returns

package/dist/serviceFeatures/offlineScanner.js

@@ -9,6 +9,7 @@ import {
 } from "../common/types.js";
 import { compareMTime, isAnyNote, isRemediationModeActive } from "../common/utils.js";
 import { shouldBeIgnored, stripAllPrefixes } from "../string_and_binary/path.js";
+import { getPathNormalizationVersion, normalisePathForIdentity } from "../common/pathNormalization.js";
 import { createInstanceLogFunction } from "../services/lib/logUtils.js";
 import { BASE_IS_NEW, EVEN, TARGET_IS_NEW } from "../common/models/shared.const.symbols.js";
 import { UnresolvedErrorManager } from "../services/base/UnresolvedErrorManager.js";
@@ -422,10 +423,11 @@ function canProceedScan(host, errorManager, log, showingNotice = false, ignoreSu
   return true;
 }
 function convertCase(settings, path) {
+  const normalisedPath = normalisePathForIdentity(path, getPathNormalizationVersion(settings));
   if (settings.handleFilenameCaseSensitive) {
-    return path;
+    return normalisedPath;
   }
-  return path.toLowerCase();
+  return normalisedPath.toLowerCase();
 }
 async function collectFilesOnStorage(host, settings, log) {
   log("Collecting local files on the storage", LOG_LEVEL_VERBOSE);

package/dist/serviceFeatures/targetFilter.d.ts

@@ -9,7 +9,7 @@ export declare function isAcceptedAlwaysFactory(host: NecessaryServices<never, n
 /**
  * Check if a file is accepted based on filename duplication in the vault.
  */
-export declare function isAcceptedInFilenameDuplicationFactory(host: NecessaryServices<"vault" | "fileProcessing", "storageAccess">, log: LogFunction): (file: string | UXFileInfoStub, options?: Parameters<IVaultService["isTargetFile"]>[1]) => Promise<boolean>;
+export declare function isAcceptedInFilenameDuplicationFactory(host: NecessaryServices<"vault" | "fileProcessing" | "setting", "storageAccess">, log: LogFunction): (file: string | UXFileInfoStub, options?: Parameters<IVaultService["isTargetFile"]>[1]) => Promise<boolean>;
 /**
  * Check if a file is accepted by the local database (e.g., not rejected by the local DB's target file check).
  * Local database responsible for non-internal files, syncOnlyRegEx, syncIgnoreRegEx

package/dist/serviceFeatures/targetFilter.js

@@ -4,6 +4,7 @@ import { getStoragePathFromUXFileInfo } from "../common/typeUtils.js";
 import { isAcceptedAll } from "../string_and_binary/path.js";
 import { Computed } from "octagonal-wheels/dataobject/Computed";
 import { promiseWithResolvers } from "octagonal-wheels/promises";
+import { getPathNormalizationVersion, normalisePathForIdentity } from "../common/pathNormalization.js";
 function isAcceptedAlwaysFactory(host, log) {
   return (file) => {
     log("File is target finally: " + getStoragePathFromUXFileInfo(file), LOG_LEVEL_DEBUG);
@@ -12,16 +13,15 @@ function isAcceptedAlwaysFactory(host, log) {
 }
 function isAcceptedInFilenameDuplicationFactory(host, log) {
   const fileCountMapComputed = new Computed({
-    evaluation: async (fileEventCount) => {
+    evaluation: async (fileEventCount, version, caseInsensitive) => {
       const vaultFiles = (await host.serviceModules.storageAccess.getFileNames()).sort();
-      const fileCountMap = {};
+      const fileCountMap = /* @__PURE__ */ new Map();
       for (const file of vaultFiles) {
-        const lc = file.toLowerCase();
-        if (!fileCountMap[lc]) {
-          fileCountMap[lc] = 1;
-        } else {
-          fileCountMap[lc]++;
-        }
+        const normalised = normalisePathForIdentity(file, version);
+        const key = caseInsensitive ? normalised.toLowerCase() : normalised;
+        const paths = fileCountMap.get(key) ?? [];
+        paths.push(file);
+        fileCountMap.set(key, paths);
       }
       return fileCountMap;
     },
@@ -29,7 +29,7 @@ function isAcceptedInFilenameDuplicationFactory(host, log) {
       if (!previousResult) return true;
       if (previousResult instanceof Error) return true;
       if (!previousArgs) return true;
-      if (args[0] === previousArgs[0]) {
+      if (args.every((value, index) => value === previousArgs[index])) {
         return false;
       }
       return true;
@@ -37,14 +37,20 @@ function isAcceptedInFilenameDuplicationFactory(host, log) {
   });
   return async function isAcceptedInFilenameDuplication(file, options) {
     if (options?.skipCaseCollisionCheck) return true;
-    const fileCountMap = (await fileCountMapComputed.update(host.services.fileProcessing.totalStorageFileEventCount)).value;
+    const version = getPathNormalizationVersion(host.services.setting.currentSettings());
+    const caseInsensitive = host.services.vault.shouldCheckCaseInsensitively();
+    const fileCountMap = (await fileCountMapComputed.update(
+      host.services.fileProcessing.totalStorageFileEventCount,
+      version,
+      caseInsensitive
+    )).value;
     const filepath = getStoragePathFromUXFileInfo(file);
-    const lc = filepath.toLowerCase();
-    if (host.services.vault.shouldCheckCaseInsensitively()) {
-      if (lc in fileCountMap && fileCountMap[lc] > 1) {
-        log("File is duplicated (case-insensitive): " + filepath);
-        return false;
-      }
+    const normalised = normalisePathForIdentity(filepath, version);
+    const key = caseInsensitive ? normalised.toLowerCase() : normalised;
+    const duplicates = fileCountMap.get(key);
+    if (duplicates && duplicates.length > 1) {
+      log("File path identity collision: " + duplicates.map((path) => JSON.stringify(path)).join(", "));
+      return false;
     }
     log("File is not duplicated: " + filepath, LOG_LEVEL_DEBUG);
     return true;
@@ -134,7 +140,12 @@ function useTargetFilters(host) {
   const serviceModules = host.serviceModules;
   const _isAcceptedFilenameDuplication = isAcceptedInFilenameDuplicationFactory(
     {
-      services: { context: services.context, vault: services.vault, fileProcessing: services.fileProcessing },
+      services: {
+        context: services.context,
+        vault: services.vault,
+        fileProcessing: services.fileProcessing,
+        setting: services.setting
+      },
       serviceModules: { storageAccess: serviceModules.storageAccess }
     },
     logger

package/dist/serviceModules/Rebuilder.d.ts

@@ -14,7 +14,7 @@ import type { StorageAccess } from "../interfaces/StorageAccess.js";
 import type { LiveSyncEventHub } from "../hub/hub.js";
 import { ServiceModuleBase } from "./ServiceModuleBase.js";
 import type { ControlService } from "../services/base/ControlService.js";
-import type { IFileProcessingService } from "../services/base/IService.js";
+import type { IFileProcessingService, IPathService } from "../services/base/IService.js";
 export interface ServiceRebuilderDependencies {
     events: LiveSyncEventHub;
     appLifecycle: AppLifecycleService;
@@ -31,6 +31,7 @@ export interface ServiceRebuilderDependencies {
     fileHandler: IFileHandler;
     fileProcessing: IFileProcessingService;
     control: ControlService;
+    path: IPathService;
 }
 export declare class ServiceRebuilder extends ServiceModuleBase<ServiceRebuilderDependencies> implements Rebuilder {
     private events;
@@ -48,6 +49,7 @@ export declare class ServiceRebuilder extends ServiceModuleBase<ServiceRebuilder
     private fileHandler;
     private fileProcessing;
     private control;
+    private path;
     constructor(services: ServiceRebuilderDependencies);
     $performRebuildDB(method: "localOnly" | "remoteOnly" | "rebuildBothByThisDevice" | "localOnlyWithChunks"): Promise<void>;
     informOptionalFeatures(): Promise<void>;
@@ -57,6 +59,8 @@ export declare class ServiceRebuilder extends ServiceModuleBase<ServiceRebuilder
     rebuildEverything(): Promise<void>;
     private performRebuildEverything;
     $rebuildEverything(): Promise<void>;
+    private checkPathIdentitiesBeforeReconstruction;
+    private checkRemotePathIdentityBeforeFetch;
     $fetchLocal(makeLocalChunkBeforeSync?: boolean, preventMakeLocalFilesBeforeSync?: boolean): Promise<void>;
     $fetchLocalDBFast(autoResume: boolean): Promise<void>;
     private scheduleInitialisation;

package/dist/serviceModules/Rebuilder.js

@@ -5,6 +5,12 @@ import { LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/log
 import { delay } from "octagonal-wheels/promises";
 import { EVENT_DATABASE_REBUILT } from "../events/coreEvents.js";
 import { ServiceModuleBase } from "./ServiceModuleBase.js";
+import { getPathNormalizationVersion } from "../common/pathNormalization.js";
+import { assertMetadataPathIdentities, assertUniqueStoragePathIdentities } from "../common/pathIdentity.js";
+import { VERSIONING_DOCID } from "../common/types.js";
+import { assertDatabasePathIdentity, assertMatchingPathIdentityFeature } from "../pouchdb/pathIdentityCompatibility.js";
+import { assessRemoteFeatureDocument, describeRemoteFeatureRejection } from "../pouchdb/remoteFeatureCompatibility.js";
+import { isErrorOfMissingDoc } from "../pouchdb/utils_couchdb.js";
 import {
   checkRemoteFeaturesForInitialSync,
   fetchChangesForInitialSync,
@@ -36,6 +42,7 @@ class ServiceRebuilder extends ServiceModuleBase {
   fileHandler;
   fileProcessing;
   control;
+  path;
   constructor(services) {
     super(services);
     this.events = services.events;
@@ -53,6 +60,7 @@ class ServiceRebuilder extends ServiceModuleBase {
     this.fileHandler = services.fileHandler;
     this.fileProcessing = services.fileProcessing;
     this.control = services.control;
+    this.path = services.path;
     services.database.onDatabaseReset.addHandler(this._onResetLocalDatabase.bind(this));
     services.setting.suspendAllSync.addHandler(this._allSuspendAllSync.bind(this));
   }
@@ -79,6 +87,7 @@ Please enable them from the settings screen after setup is complete.`,
     );
   }
   async rebuildRemote() {
+    await this.checkPathIdentitiesBeforeReconstruction(true);
     await this.replicator.runBoundedRemoteActivity(() => this.performRemoteRebuild(), {
       label: "rebuild-remote"
     });
@@ -104,6 +113,7 @@ Please enable them from the settings screen after setup is complete.`,
     return this.rebuildRemote();
   }
   async rebuildEverything() {
+    await this.checkPathIdentitiesBeforeReconstruction(false);
     await this.replicator.runBoundedRemoteActivity(() => this.performRebuildEverything(), {
       label: "rebuild-everything"
     });
@@ -154,6 +164,68 @@ Please enable them from the settings screen after setup is complete.`,
   $rebuildEverything() {
     return this.rebuildEverything();
   }
+  async checkPathIdentitiesBeforeReconstruction(requireMatchingIds) {
+    const settings = this.setting.currentSettings();
+    if (requireMatchingIds && this.database.isDatabaseReady()) {
+      await assertDatabasePathIdentity(this.database.localDatabase.localDatabase, settings);
+    }
+    if (getPathNormalizationVersion(settings) === 0) return;
+    if (settings.remoteType !== REMOTE_COUCHDB) {
+      throw new Error("NFC path identity is supported only with CouchDB. No database has been reset.");
+    }
+    const paths = await this.storageAccess.getFileNames();
+    const selected = [];
+    const databaseReady = this.database.isDatabaseReady();
+    for (const path of paths) {
+      if (!databaseReady || await this.vault.isTargetFile(path, { skipCaseCollisionCheck: true }))
+        selected.push(path);
+    }
+    await assertUniqueStoragePathIdentities(selected, this.path);
+    if (databaseReady) {
+      await assertMetadataPathIdentities(
+        this.database.localDatabase.findAllDocs(),
+        this.path,
+        requireMatchingIds
+      );
+    }
+  }
+  async checkRemotePathIdentityBeforeFetch() {
+    const settings = this.setting.currentSettings();
+    if (settings.remoteType !== REMOTE_COUCHDB) return;
+    const remote = settings.couchDB_URI.replace(/\/+$/, "") + (settings.couchDB_DBNAME === "" ? "" : "/" + settings.couchDB_DBNAME);
+    const connection = await this.remote.connect(
+      remote,
+      generateCredentialObject(settings),
+      settings.disableRequestURI || this.API.isMobile(),
+      false,
+      false,
+      false,
+      true,
+      false,
+      parseHeaderValues(settings.couchDB_CustomHeaders),
+      settings.useRequestAPI,
+      async () => {
+        throw new Error("A version document does not require decryption.");
+      }
+    );
+    if (typeof connection === "string") throw new Error(connection);
+    try {
+      let document;
+      try {
+        document = await connection.db.get(VERSIONING_DOCID);
+      } catch (error) {
+        if (!isErrorOfMissingDoc(error) || (await connection.db.info()).doc_count !== 0) throw error;
+        return;
+      }
+      const assessment = assessRemoteFeatureDocument(document);
+      if (assessment.status !== "supported" && assessment.status !== "older-generation") {
+        throw new Error(describeRemoteFeatureRejection(assessment));
+      }
+      assertMatchingPathIdentityFeature(document, settings);
+    } finally {
+      await connection.close();
+    }
+  }
   $fetchLocal(makeLocalChunkBeforeSync, preventMakeLocalFilesBeforeSync) {
     return this.fetchLocal(makeLocalChunkBeforeSync, preventMakeLocalFilesBeforeSync);
   }
@@ -289,6 +361,8 @@ Please enable them from the settings screen after setup is complete.`,
     return true;
   }
   async fetchLocal(makeLocalChunkBeforeSync, preventMakeLocalFilesBeforeSync, autoResume = true) {
+    await this.checkPathIdentitiesBeforeReconstruction(false);
+    await this.checkRemotePathIdentityBeforeFetch();
     await this.setting.suspendExtraSync();
     await this.setting.applyPartial({
       isConfigured: true,
@@ -393,7 +467,8 @@ Are you sure you wish to proceed?`;
       generateCredentialObject(settings)
     );
     const customHeaders = parseHeaderValues(settings.couchDB_CustomHeaders);
-    await checkRemoteFeaturesForInitialSync(remote, authHeader, customHeaders);
+    await this.checkPathIdentitiesBeforeReconstruction(false);
+    await checkRemoteFeaturesForInitialSync(remote, authHeader, customHeaders, settings);
     this.appLifecycle.resetIsReady();
     let checkpoint = this.getFastFetchCheckpoint(remote);
     await this.suspendReflectingDatabase();
@@ -557,7 +632,7 @@ Total bytes fetched: ${sizeToHumanReadable(progress.totalBytes)}`,
     if (!rawCheckpoint) return void 0;
     try {
       const checkpoint = JSON.parse(rawCheckpoint);
-      if (checkpoint.remote === remote && checkpoint.sequence !== void 0) {
+      if (checkpoint.remote === remote && checkpoint.sequence !== void 0 && getPathNormalizationVersion(checkpoint) === getPathNormalizationVersion(this.setting.currentSettings())) {
         return {
           remote,
           sequence: checkpoint.sequence
@@ -569,7 +644,14 @@ Total bytes fetched: ${sizeToHumanReadable(progress.totalBytes)}`,
     return void 0;
   }
   saveFastFetchCheckpoint(remote, sequence) {
-    this.setting.setSmallConfig(FAST_FETCH_CHECKPOINT_KEY, JSON.stringify({ remote, sequence }));
+    this.setting.setSmallConfig(
+      FAST_FETCH_CHECKPOINT_KEY,
+      JSON.stringify({
+        remote,
+        sequence,
+        pathNormalizationVersion: getPathNormalizationVersion(this.setting.currentSettings())
+      })
+    );
   }
   clearFastFetchCheckpoint() {
     this.setting.deleteSmallConfig(FAST_FETCH_CHECKPOINT_KEY);

package/dist/serviceModules/ServiceFileHandlerBase.d.ts

@@ -44,11 +44,14 @@ export declare abstract class ServiceFileHandlerBase extends ServiceModuleBase<S
     private setting;
     private vault;
     private fileReflectionProvenance?;
+    private readonly contentHashes;
     private readonly deferredConflictChecks;
     constructor(services: ServiceFileHandlerDependencies);
     get db(): DatabaseFileAccess;
     get storage(): StorageAccess;
+    private getProvenancePath;
     private getProvenance;
+    private contentEvidence;
     private setProvenance;
     private deleteProvenance;
     private findUniqueContentRevision;
@@ -62,8 +65,8 @@ export declare abstract class ServiceFileHandlerBase extends ServiceModuleBase<S
      * identifies provenance; no match is `unknown`.
      * `preferredPath` selects the provenance key during a rename, and
      * `currentLoaded` supplies an already decoded candidate body when available.
-     * Missing chunks do not clear provenance unless their metadata is also
-     * missing or deleted.
+     * A valid saved content hash can prove unchanged bytes after revision
+     * pruning. It cannot reconstruct ancestry for an edited file.
      */
     private classifyStorageContent;
     /** Record provenance only when storage matches one unambiguous live leaf. */