@vrtmrz/livesync-commonlib 0.2.3 → 0.3.1

package/dist/replication/trystero/TrysteroReplicator.js

@@ -28,6 +28,9 @@ import { compatGlobal } from "../../common/coreEnvFunctions.js";
 import { computeKeyedId, configuredIdKey } from "../../common/idDerivation.js";
 import { getWebCrypto } from "../../mods.js";
 import { uint8ArrayToHexString } from "../../string_and_binary/convert.js";
+import { getPathNormalizationVersion } from "../../common/pathNormalization.js";
+import { readLocalP2PPathIdentity, readRemoteP2PPathIdentity } from "./TrysteroReplicator.pathIdentity.js";
+import { assertDatabasePathIdentity } from "../../pouchdb/pathIdentityCompatibility.js";
 import {
   fromP2PReplicationWireResult,
   toP2PReplicationWireResult,
@@ -205,6 +208,11 @@ class TrysteroReplicator {
     this._onSetup = false;
   }
   async getTweakSettings(fromPeerId) {
+    const currentSettings = this.currentSettings;
+    const pathNormalizationVersion = getPathNormalizationVersion(currentSettings);
+    if (pathNormalizationVersion === 1) {
+      await assertDatabasePathIdentity(this.db, currentSettings, true);
+    }
     const allSettings = JSON.parse(JSON.stringify(this.settings));
     for (const key in allSettings) {
       if (key == "encrypt") {
@@ -223,6 +231,7 @@ class TrysteroReplicator {
     const idKey = configuredIdKey({ idDerivationVersion, idDerivationKey: idSettings.idDerivationKey ?? "" });
     return {
       ...allSettings,
+      pathNormalizationVersion,
       idDerivationVersion,
       idDerivationProof: idKey && idSettings.encrypt && idSettings.usePathObfuscation ? await computeKeyedId(idKey, "peer-agreement", fromPeerId) : ""
     };
@@ -553,6 +562,28 @@ class TrysteroReplicator {
     }
     if (signal?.aborted) return P2P_REPLICATION_CANCELLED;
     const logLevel = showNotice ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO;
+    const rejection = await this.checkPeerForReplication(remotePeer, logLevel, signal);
+    if (rejection) return rejection;
+    Logger(`P2P Replicating from ${remotePeer}`, logLevel, "p2p-replicator");
+    if (this._replicateFromPeers.has(remotePeer)) {
+      Logger(`Replication from ${remotePeer} is already in progress`, logLevel, "p2p-replicator");
+      return p2pReplicationFailed(new Error("Replication from this peer is already in progress"));
+    }
+    this._replicateFromPeers.add(remotePeer);
+    this.dispatchStatus();
+    try {
+      return await this.transferFromPeer(remotePeer, fromStart, logLevel, signal);
+    } catch (e) {
+      if (signal?.aborted) return P2P_REPLICATION_CANCELLED;
+      Logger("Error while P2P replicating", logLevel, "p2p-replicator");
+      Logger(e, LOG_LEVEL_VERBOSE);
+      return p2pReplicationFailed(e);
+    } finally {
+      this._replicateFromPeers.delete(remotePeer);
+      this.dispatchStatus();
+    }
+  }
+  async checkPeerForReplication(remotePeer, logLevel, signal) {
     Logger(`P2P Requesting Authentication to ${remotePeer}`, logLevel, "p2p-replicator");
     const authenticated = signal ? await this.requestAuthenticate(remotePeer, signal) : await this.requestAuthenticate(remotePeer);
     if (authenticated !== true) {
@@ -572,71 +603,62 @@ class TrysteroReplicator {
       Logger("Tweak values are not matched", logLevel, "p2p-replicator");
       return p2pReplicationFailed(new Error("Tweak values are not matched"));
     }
-    Logger(`P2P Replicating from ${remotePeer}`, logLevel, "p2p-replicator");
-    if (this._replicateFromPeers.has(remotePeer)) {
-      Logger(`Replication from ${remotePeer} is already in progress`, logLevel, "p2p-replicator");
-      return p2pReplicationFailed(new Error("Replication from this peer is already in progress"));
-    }
-    this._replicateFromPeers.add(remotePeer);
-    this.dispatchStatus();
-    try {
-      if (!this.server) {
-        throw new Error("Server is not available");
-      }
-      const connection = this.server.getConnection(remotePeer);
-      const remoteDB = connection.getRemoteDB(signal);
-      Logger(`P2P replicateFrom preparing remote DB info for ${remotePeer}`, LOG_LEVEL_VERBOSE, "p2p-replicator");
-      const remoteDBInfo = await remoteDB.info();
-      Logger(
-        `P2P replicateFrom remote DB info for ${remotePeer}: ${remoteDBInfo.db_name} seq=${remoteDBInfo.update_seq}`,
-        LOG_LEVEL_VERBOSE,
-        "p2p-replicator"
-      );
-      const localDBInfo = await this.db.info();
-      Logger(
-        `P2P replicateFrom local DB info for ${remotePeer}: ${localDBInfo.db_name} seq=${localDBInfo.update_seq}`,
-        LOG_LEVEL_VERBOSE,
-        "p2p-replicator"
-      );
-      Logger(`P2P replicateFrom entering replicateShim for ${remotePeer}`, LOG_LEVEL_VERBOSE, "p2p-replicator");
-      const outcome = await replicateShim(
-        this.db,
-        remoteDB,
-        async (docs, info) => {
-          await this._env.processReplicatedDocs(docs);
-          void this.dispatchReplicationProgress(remotePeer, info);
-          void this.acknowledgeProgress(remotePeer, info);
-          void this.notifyProgress(remotePeer);
-          Logger(
-            `P2P Replication from ${remotePeer}
+    return void 0;
+  }
+  async transferFromPeer(remotePeer, fromStart, logLevel, signal) {
+    if (!this.server) {
+      throw new Error("Server is not available");
+    }
+    const connection = this.server.getConnection(remotePeer);
+    const remoteDB = connection.getRemoteDB(signal);
+    const pathNormalizationVersion = getPathNormalizationVersion(this.currentSettings);
+    const [localPathIdentity, remotePathIdentity] = await Promise.all([
+      readLocalP2PPathIdentity(this.db, pathNormalizationVersion),
+      readRemoteP2PPathIdentity(remoteDB, pathNormalizationVersion)
+    ]);
+    if (localPathIdentity !== pathNormalizationVersion || remotePathIdentity !== pathNormalizationVersion) {
+      const error = new Error("P2P database path identity does not match the configured path identity.");
+      Logger(error.message, logLevel, "p2p-replicator");
+      return p2pReplicationFailed(error);
+    }
+    Logger(`P2P replicateFrom preparing remote DB info for ${remotePeer}`, LOG_LEVEL_VERBOSE, "p2p-replicator");
+    const remoteDBInfo = await remoteDB.info();
+    Logger(
+      `P2P replicateFrom remote DB info for ${remotePeer}: ${remoteDBInfo.db_name} seq=${remoteDBInfo.update_seq}`,
+      LOG_LEVEL_VERBOSE,
+      "p2p-replicator"
+    );
+    const localDBInfo = await this.db.info();
+    Logger(
+      `P2P replicateFrom local DB info for ${remotePeer}: ${localDBInfo.db_name} seq=${localDBInfo.update_seq}`,
+      LOG_LEVEL_VERBOSE,
+      "p2p-replicator"
+    );
+    Logger(`P2P replicateFrom entering replicateShim for ${remotePeer}`, LOG_LEVEL_VERBOSE, "p2p-replicator");
+    const outcome = await replicateShim(
+      this.db,
+      remoteDB,
+      async (docs, info) => {
+        await this._env.processReplicatedDocs(docs);
+        void this.dispatchReplicationProgress(remotePeer, info);
+        void this.acknowledgeProgress(remotePeer, info);
+        void this.notifyProgress(remotePeer);
+        Logger(
+          `P2P Replication from ${remotePeer}
 ${info.lastSeq} / ${info.maxSeqInBatch})`,
-            logLevel,
-            "p2p-replicator"
-          );
-        },
-        {
-          live: false,
-          rewind: fromStart,
-          signal
-          /*, batch_size: batchSize */
-        }
-      );
-      Logger(`P2P replicateFrom replicateShim returned for ${remotePeer}`, LOG_LEVEL_VERBOSE, "p2p-replicator");
-      void this.acknowledgeProgress(remotePeer, void 0);
-      if (outcome.status === "cancelled") {
-        Logger(`P2P Replication from ${remotePeer} has been cancelled`, logLevel, "p2p-replicator");
-        return P2P_REPLICATION_CANCELLED;
-      }
-      Logger(`P2P Replication from ${remotePeer} has been completed`, logLevel, "p2p-replicator");
-    } catch (e) {
-      if (signal?.aborted) return P2P_REPLICATION_CANCELLED;
-      Logger("Error while P2P replicating", logLevel, "p2p-replicator");
-      Logger(e, LOG_LEVEL_VERBOSE);
-      return p2pReplicationFailed(e);
-    } finally {
-      this._replicateFromPeers.delete(remotePeer);
-      this.dispatchStatus();
+          logLevel,
+          "p2p-replicator"
+        );
+      },
+      { live: false, rewind: fromStart, signal }
+    );
+    Logger(`P2P replicateFrom replicateShim returned for ${remotePeer}`, LOG_LEVEL_VERBOSE, "p2p-replicator");
+    void this.acknowledgeProgress(remotePeer, void 0);
+    if (outcome.status === "cancelled") {
+      Logger(`P2P Replication from ${remotePeer} has been cancelled`, logLevel, "p2p-replicator");
+      return P2P_REPLICATION_CANCELLED;
     }
+    Logger(`P2P Replication from ${remotePeer} has been completed`, logLevel, "p2p-replicator");
     return P2P_REPLICATION_COMPLETED;
   }
   notifyProgress(excludePeerId) {
@@ -739,12 +761,6 @@ ${info.lastSeq} / ${info.maxSeqInBatch})`,
       Logger("Peer is not found", logLevel);
       return false;
     }
-    if (this.platform === "pseudo-replicator") {
-      return true;
-    }
-    if (peerPlatform === "pseudo-replicator") {
-      return true;
-    }
     const connection = this.server.getConnection(peerId);
     const challengeBytes = new Uint8Array(16);
     (await getWebCrypto()).getRandomValues(challengeBytes);
@@ -752,6 +768,15 @@ ${info.lastSeq} / ${info.maxSeqInBatch})`,
     const tweakValues = await connection.invokeRemoteObjectFunction("getTweakSettings", [challenge], 5e3, signal);
     if (signal?.aborted) return false;
     const thisTweakValues = await this.getTweakSettings(challenge);
+    const localPathNormalizationVersion = getPathNormalizationVersion(thisTweakValues);
+    const peerPathNormalizationVersion = getPathNormalizationVersion(tweakValues);
+    if (localPathNormalizationVersion !== peerPathNormalizationVersion) {
+      Logger("Replication cancelled: The path identity mode does not match this peer.", logLevel);
+      return false;
+    }
+    if (this.platform === "pseudo-replicator" || peerPlatform === "pseudo-replicator") {
+      return true;
+    }
     if (thisTweakValues.passphrase !== tweakValues.passphrase) {
       Logger(
         "Replication cancelled: Passphrase is not matched\nCannot replicate to a remote database until the problem is resolved.",
@@ -760,7 +785,10 @@ ${info.lastSeq} / ${info.maxSeqInBatch})`,
       return false;
     }
     if (thisTweakValues.encrypt !== tweakValues.encrypt || thisTweakValues.usePathObfuscation !== tweakValues.usePathObfuscation) {
-      Logger("Replication cancelled: The encryption or path obfuscation settings do not match this peer.", logLevel);
+      Logger(
+        "Replication cancelled: The encryption or path obfuscation settings do not match this peer.",
+        logLevel
+      );
       return false;
     }
     if (thisTweakValues.encrypt && thisTweakValues.usePathObfuscation && ((thisTweakValues.idDerivationVersion ?? 0) !== (tweakValues.idDerivationVersion ?? 0) || (thisTweakValues.idDerivationProof ?? "") !== (tweakValues.idDerivationProof ?? ""))) {

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

@@ -0,0 +1,11 @@
+import type { PathNormalizationVersion } from "../../common/models/setting.type.js";
+export declare function readLocalP2PPathIdentity(database: {
+    get(id: string): Promise<unknown>;
+}, configuredVersion: PathNormalizationVersion): Promise<PathNormalizationVersion>;
+export declare function readRemoteP2PPathIdentity(database: {
+    bulkGet(options: {
+        docs: {
+            id: string;
+        }[];
+    }): Promise<unknown>;
+}, configuredVersion: PathNormalizationVersion): Promise<PathNormalizationVersion>;

package/dist/replication/trystero/TrysteroReplicator.pathIdentity.js

@@ -0,0 +1,72 @@
+import { VERSIONING_DOCID } from "../../common/models/db.const.js";
+import {
+  assessRemoteFeatureDocument,
+  describeRemoteFeatureRejection,
+  NFC_PATH_IDENTITY_FEATURE
+} from "../../pouchdb/remoteFeatureCompatibility.js";
+import { isErrorOfMissingDoc } from "../../pouchdb/utils_couchdb.js";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOwnField(value, key) {
+  return Object.hasOwn(value, key);
+}
+function isVersionInfoResponse(value) {
+  if (!isRecord(value) || !Array.isArray(value.results) || value.results.length !== 1) return false;
+  const [result] = value.results;
+  return isRecord(result) && result.id === VERSIONING_DOCID && Array.isArray(result.docs) && result.docs.length === 1 && isRecord(result.docs[0]);
+}
+function isMissingDocumentResult(result) {
+  if (!hasOwnField(result, "error")) return false;
+  const error = result.error;
+  const errorDetails = isRecord(error) ? error : void 0;
+  const status = errorDetails?.status ?? result.status;
+  const errorName = errorDetails?.name ?? result.name;
+  const errorCode = typeof error === "string" ? error : errorDetails?.error;
+  return status === 404 || status === void 0 && (errorName === "not_found" || errorCode === "not_found");
+}
+function parseRemotePathIdentityDocument(response) {
+  if (!isVersionInfoResponse(response)) {
+    throw new Error("P2P remote versioninfo response is malformed.");
+  }
+  const [documentResult] = response.results[0].docs;
+  if (hasOwnField(documentResult, "ok")) {
+    const document = documentResult.ok;
+    if (!isRecord(document) || document._id !== VERSIONING_DOCID) {
+      throw new Error("P2P remote versioninfo response is malformed.");
+    }
+    return { kind: "found", document };
+  }
+  if (isMissingDocumentResult(documentResult)) return { kind: "missing" };
+  throw new Error("P2P remote versioninfo could not be read.");
+}
+function resolvePathIdentity(result, configuredVersion) {
+  if (result.kind === "missing") {
+    if (configuredVersion === 0) return 0;
+    throw new Error("P2P NFC database is missing path identity version information.");
+  }
+  const assessment = assessRemoteFeatureDocument(result.document);
+  if (assessment.status === "older-generation" && configuredVersion === 0) return 0;
+  if (assessment.status !== "supported") {
+    throw new Error(describeRemoteFeatureRejection(assessment));
+  }
+  return assessment.usedFeatures.includes(NFC_PATH_IDENTITY_FEATURE) ? 1 : 0;
+}
+async function readLocalP2PPathIdentity(database, configuredVersion) {
+  let result;
+  try {
+    result = { kind: "found", document: await database.get(VERSIONING_DOCID) };
+  } catch (error) {
+    if (!isErrorOfMissingDoc(error)) throw error;
+    result = { kind: "missing" };
+  }
+  return resolvePathIdentity(result, configuredVersion);
+}
+async function readRemoteP2PPathIdentity(database, configuredVersion) {
+  const response = await database.bulkGet({ docs: [{ id: VERSIONING_DOCID }] });
+  return resolvePathIdentity(parseRemotePathIdentityDocument(response), configuredVersion);
+}
+export {
+  readLocalP2PPathIdentity,
+  readRemoteP2PPathIdentity
+};

package/dist/replication/trystero/p2pReplicatorConfigurationIdentity.js

@@ -7,6 +7,7 @@ import {
   splitP2PRelayUrls,
   splitP2PTurnServerUrls
 } from "../../common/models/setting.p2p.js";
+import { getPathNormalizationVersion } from "../../common/pathNormalization.js";
 function getP2PReplicatorConfigurationIdentity(settings) {
   const managedTurnSelected = hasManagedP2PTurnConfiguration(settings);
   const turnServerValue = settings.P2P_turnServers ?? "";
@@ -25,6 +26,7 @@ function getP2PReplicatorConfigurationIdentity(settings) {
     managedTurnSelected ? [settings.P2P_managedType, settings.P2P_managedId, settings.P2P_managedToken] : void 0,
     normaliseP2PMaxWirePayloadBytes(settings.P2P_maxWirePayloadBytes),
     effectivePath,
+    getPathNormalizationVersion(settings),
     settings.P2P_useDiagRTC ?? false
   ]);
 }

package/dist/replication/trystero/useP2PReplicatorFeature.js

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

package/dist/serviceModules/Rebuilder.d.ts

@@ -66,6 +66,7 @@ export declare class ServiceRebuilder extends ServiceModuleBase<ServiceRebuilder
     private scheduleInitialisation;
     scheduleRebuild(prepareBeforeRestart?: () => Promise<void>): Promise<boolean>;
     scheduleFetch(prepareBeforeRestart?: () => Promise<void>): Promise<boolean>;
+    private markRemoteLockedForRebuild;
     private _tryResetRemoteDatabase;
     private _onResetLocalDatabase;
     suspendAllSync(): Promise<void>;

package/dist/serviceModules/Rebuilder.js

@@ -26,6 +26,12 @@ const FAST_FETCH_RETRY_DELAYS = [2e3, 5e3, 1e4, 2e4];
 function canResetCentralRemote(replicator) {
   return "tryResetRemoteDatabase" in replicator && typeof replicator.tryResetRemoteDatabase === "function";
 }
+function canCheckJournalPathIdentity(replicator) {
+  return "assertRemotePathIdentity" in replicator && typeof replicator.assertRemotePathIdentity === "function";
+}
+function canLockJournalForRebuild(replicator) {
+  return canResetCentralRemote(replicator) && "markRemoteLockedForRebuild" in replicator && typeof replicator.markRemoteLockedForRebuild === "function";
+}
 class ServiceRebuilder extends ServiceModuleBase {
   events;
   appLifecycle;
@@ -100,7 +106,7 @@ Please enable them from the settings screen after setup is complete.`,
       notifyThresholdOfRemoteStorageSize: DEFAULT_SETTINGS.notifyThresholdOfRemoteStorageSize
     });
     await this.control.applySettings();
-    await this.replication.markLocked();
+    await this.markRemoteLockedForRebuild();
     await this._tryResetRemoteDatabase();
     await this.replication.markLocked();
     await delay(500);
@@ -145,7 +151,7 @@ Please enable them from the settings screen after setup is complete.`,
       }
       return;
     }
-    await this.replication.markLocked();
+    await this.markRemoteLockedForRebuild();
     await this._tryResetRemoteDatabase();
     await this.replication.markLocked();
     await delay(500);
@@ -170,9 +176,6 @@ Please enable them from the settings screen after setup is complete.`,
       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();
@@ -191,6 +194,19 @@ Please enable them from the settings screen after setup is complete.`,
   }
   async checkRemotePathIdentityBeforeFetch() {
     const settings = this.setting.currentSettings();
+    if (settings.remoteType === REMOTE_MINIO) {
+      const trial = await this.replicator.getNewReplicator(settings);
+      if (!trial) throw new Error("Could not create a Journal replicator for the Fetch identity check.");
+      try {
+        if (!canCheckJournalPathIdentity(trial)) {
+          throw new Error("The Journal replicator does not support the Fetch identity check.");
+        }
+        await trial.assertRemotePathIdentity(settings);
+      } finally {
+        await trial.closeReplication();
+      }
+      return;
+    }
     if (settings.remoteType !== REMOTE_COUCHDB) return;
     const remote = settings.couchDB_URI.replace(/\/+$/, "") + (settings.couchDB_DBNAME === "" ? "" : "/" + settings.couchDB_DBNAME);
     const connection = await this.remote.connect(
@@ -206,7 +222,8 @@ Please enable them from the settings screen after setup is complete.`,
       settings.useRequestAPI,
       async () => {
         throw new Error("A version document does not require decryption.");
-      }
+      },
+      { useCouchDBCacheControlHeadersOnly: settings.useCouchDBCacheControlHeadersOnly === true }
     );
     if (typeof connection === "string") throw new Error(connection);
     try {
@@ -262,6 +279,18 @@ Please enable them from the settings screen after setup is complete.`,
   scheduleFetch(prepareBeforeRestart) {
     return this.scheduleInitialisation(FlagFilesHumanReadable.FETCH_ALL, prepareBeforeRestart);
   }
+  async markRemoteLockedForRebuild() {
+    const settings = this.setting.currentSettings();
+    if (settings.remoteType !== REMOTE_MINIO) {
+      await this.replication.markLocked();
+      return;
+    }
+    const replicator = this.replicator.getActiveReplicator();
+    if (!replicator || !canLockJournalForRebuild(replicator)) {
+      throw new Error("The active Journal replicator does not support safe reconstruction.");
+    }
+    await replicator.markRemoteLockedForRebuild(settings);
+  }
   async _tryResetRemoteDatabase() {
     const currentReplicator = this.replicator.getActiveReplicator();
     const settings = this.setting.currentSettings();

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

@@ -12,13 +12,13 @@ export declare class FileProcessingService<T extends ServiceContext = ServiceCon
      * Dispatch a legacy optional notification, without confirming persistence.
      * i.e., hidden files synchronisation or customisation sync.
      */
-    readonly processOptionalFileEvent: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(path: import("../../common/types.js").FilePath) => Promise<boolean>>;
+    readonly processOptionalFileEvent: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(path: import("../../storage.js").FilePath) => Promise<boolean>>;
     /**
      * Complete optional file operations through the first applicable handler.
      * Hosts migrate all optional providers together. Once any typed provider is
      * registered, dispatch uses this contract exclusively.
      */
-    readonly processOptionalFileEventWithResult?: import("../lib/HandlerUtils.js").FirstHandledFunction<(path: import("../../common/types.js").FilePath, options?: import("./IService.js").OptionalFileEventOptions) => Promise<import("../lib/HandlerUtils.js").HandlerOutcome<void, string>>>;
+    readonly processOptionalFileEventWithResult?: import("../lib/HandlerUtils.js").FirstHandledFunction<(path: import("../../storage.js").FilePath, options?: import("./IService.js").OptionalFileEventOptions) => Promise<import("../lib/HandlerUtils.js").HandlerOutcome<void, string>>>;
     /**
      * Commit any pending file events that have been queued for processing.
      */

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

@@ -8,6 +8,8 @@ export interface RemoteConnectionOpenOptions {
     readonly encryptionAlgorithm?: E2EEAlgorithm;
     /** Apply HKDF Metadata encryption to obfuscated internal entries on writes. */
     readonly encryptInternalMetadata?: boolean;
+    /** Use HTTP headers alone for cache control; an absent value is false. */
+    readonly useCouchDBCacheControlHeadersOnly?: boolean;
     /**
      * Cancels abort-capable requests made through the connection when the
      * owning operation is cancelled.

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

@@ -1,4 +1,4 @@
-import type { CouchDBCredentials, EntryDoc } from "../../common/types.js";
+import { type CouchDBCredentials, type EntryDoc } from "../../common/types.js";
 import type { IRemoteService } from "./IService.js";
 import { ServiceBase, type ServiceContext } from "./ServiceBase.js";
 import { type LOG_LEVEL } from "../../common/types.js";

package/dist/services/base/RemoteService.js

@@ -1,3 +1,4 @@
+import { E2EEAlgorithms } from "../../common/types.js";
 import { ServiceBase } from "./ServiceBase.js";
 import {
   LOG_LEVEL_DEBUG,
@@ -12,6 +13,7 @@ import { AuthorizationHeaderGenerator } from "../../replication/httplib.js";
 import { UnresolvedErrorManager } from "./UnresolvedErrorManager.js";
 import { createInstanceLogFunction, MARK_LOG_NETWORK_ERROR } from "../lib/logUtils.js";
 import { runWithTrackedPhysicalRequest } from "../lib/remoteActivity.js";
+import { createCouchDBHttpCache } from "../lib/couchdbHttpCache.js";
 import { LiveSyncError } from "../../common/LSError.js";
 function createRemoteConnectionScope(ownerSignal) {
   const controller = new AbortController();
@@ -188,6 +190,12 @@ class RemoteService extends ServiceBase {
       return "Network is offline";
     }
     const connectionScope = createRemoteConnectionScope(connectionOptions.signal);
+    const encryptionAlgorithm = connectionOptions.encryptionAlgorithm ?? this._settingService.currentSettings().E2EEAlgorithm;
+    const prepareCachedRequest = createCouchDBHttpCache(
+      uri,
+      typeof passphrase === "string" && passphrase !== "false" && encryptionAlgorithm !== E2EEAlgorithms.ForceV1 ? getPBKDF2Salt : void 0,
+      connectionOptions.useCouchDBCacheControlHeadersOnly === true
+    );
     const conf = {
       adapter: "http",
       auth: "username" in auth ? auth : void 0,
@@ -222,11 +230,12 @@ class RemoteService extends ServiceBase {
           if (!("username" in auth)) {
             headers.append("authorization", authHeader);
           }
+          const cachedRequest = await prepareCachedRequest(requestSrc, opts);
           try {
             const signal = connectionScope.combine(opts?.signal);
             const response = await this.performFetch(
-              requestSrc,
-              { ...opts, headers, signal, cache: "no-store" },
+              cachedRequest.request,
+              { ...opts, headers, signal, cache: cachedRequest.cache },
               useRequestAPI ? FetchMethod.native : FetchMethod.webCompat
             );
             return response;
@@ -243,8 +252,8 @@ class RemoteService extends ServiceBase {
                 "Failed to fetch by native fetch API. Trying to fetch by API to get more information."
               );
               const resp2 = await this.performFetch(
-                requestSrc,
-                { ...opts, headers, cache: "no-store" },
+                cachedRequest.request,
+                { ...opts, headers, cache: cachedRequest.cache },
                 FetchMethod.native
               );
               if (resp2.status / 100 == 2) {
@@ -279,7 +288,6 @@ class RemoteService extends ServiceBase {
         }
       }
     };
-    const encryptionAlgorithm = connectionOptions.encryptionAlgorithm ?? this._settingService.currentSettings().E2EEAlgorithm;
     let db;
     try {
       db = new this._pouchDB(uri, conf);

package/dist/services/implements/injectable/InjectableVaultService.d.ts

@@ -4,6 +4,6 @@ export declare abstract class InjectableVaultService<T extends ServiceContext> e
 }
 export declare class InjectableVaultServiceCompat<T extends ServiceContext> extends InjectableVaultService<T> {
     isStorageInsensitive: import("../../lib/HandlerUtils.js").HandlerFunction<() => boolean, unknown>;
-    getActiveFilePath: import("../../lib/HandlerUtils.js").HandlerFunction<() => import("../../../common/types.js").FilePath | undefined, unknown>;
+    getActiveFilePath: import("../../lib/HandlerUtils.js").HandlerFunction<() => import("../../../storage.js").FilePath | undefined, unknown>;
     isValidPath(path: string): boolean;
 }

package/dist/services/lib/couchdbHttpCache.d.ts

@@ -0,0 +1,5 @@
+/** Keep encrypted HTTP responses within the Security Seed which produced them. */
+export declare function createCouchDBHttpCache(uri: string, getPBKDF2Salt?: () => Promise<Uint8Array<ArrayBuffer>>, headersOnly?: boolean): (request: string | Request, options?: RequestInit) => Promise<{
+    request: string | Request;
+    cache: RequestCache;
+}>;

package/dist/services/lib/couchdbHttpCache.js

@@ -0,0 +1,36 @@
+import { uint8ArrayToHexString } from "../../string_and_binary/convert.js";
+const processEpoch = Math.floor(Date.now() / 1e3);
+function createCouchDBHttpCache(uri, getPBKDF2Salt, headersOnly = false) {
+  const databasePath = new URL(uri).pathname.replace(/\/$/, "");
+  let previousSalt;
+  let namespace;
+  const getNamespace = async () => {
+    const salt = await getPBKDF2Salt();
+    if (!previousSalt || previousSalt.length !== salt.length || previousSalt.some((byte, i) => byte !== salt[i])) {
+      previousSalt = salt.slice();
+      const epoch = new TextEncoder().encode(`${processEpoch}:`);
+      const input = new Uint8Array(epoch.length + previousSalt.length);
+      input.set(epoch);
+      input.set(previousSalt, epoch.length);
+      namespace = crypto.subtle.digest("SHA-256", input).then((digest) => uint8ArrayToHexString(new Uint8Array(digest)));
+    }
+    return namespace;
+  };
+  return async (request, options) => {
+    const method = (options?.method ?? (typeof request === "string" ? "GET" : request.method)).toUpperCase();
+    if (method !== "GET" && method !== "HEAD") {
+      return { request, cache: options?.cache };
+    }
+    if (headersOnly) return { request, cache: "no-store" };
+    const url = new URL(typeof request === "string" ? request : request.url);
+    const relativePath = url.pathname.startsWith(`${databasePath}/`) ? decodeURIComponent(url.pathname.slice(databasePath.length + 1)) : "";
+    if (getPBKDF2Salt && relativePath && !relativePath.startsWith("_local/")) {
+      url.searchParams.set("_livesync_epoch", await getNamespace());
+      request = typeof request === "string" ? url.href : new Request(url.href, request);
+    }
+    return { request, cache: "no-cache" };
+  };
+}
+export {
+  createCouchDBHttpCache
+};

package/dist/storage.d.ts

@@ -0,0 +1,4 @@
+/** Host-neutral path identity, namespace, and storage resolution contracts. */
+export type { FilePath, DocumentPath, StoragePath, PathComparisonKey, PathComparisonSettings, DocumentPathParts, DirectoryEntry, ReadDirectory, ResolvedRename, StorageEntry, StoragePathResolver, StoragePathResolverOptions, } from "./platform/pathTypes.js";
+export { parseFilePath, parseDocumentPath, splitDocumentPath, joinDocumentPath, getStoragePathComparisonKey, getDocumentPathComparisonKey, } from "./platform/pathComparison.js";
+export { createStoragePathResolver, AmbiguousNormalisedPathError } from "./platform/storagePathResolution.js";

package/dist/storage.js

@@ -0,0 +1,19 @@
+import {
+  parseFilePath,
+  parseDocumentPath,
+  splitDocumentPath,
+  joinDocumentPath,
+  getStoragePathComparisonKey,
+  getDocumentPathComparisonKey
+} from "./platform/pathComparison.js";
+import { createStoragePathResolver, AmbiguousNormalisedPathError } from "./platform/storagePathResolution.js";
+export {
+  AmbiguousNormalisedPathError,
+  createStoragePathResolver,
+  getDocumentPathComparisonKey,
+  getStoragePathComparisonKey,
+  joinDocumentPath,
+  parseDocumentPath,
+  parseFilePath,
+  splitDocumentPath
+};

package/dist/string_and_binary/path.js

@@ -1,3 +1,4 @@
+import { splitPathNamespace } from "../common/pathNamespace.js";
 import { Minimatch } from "minimatch";
 import { getWebCrypto } from "../mods.js";
 import {
@@ -13,7 +14,7 @@ import {
 import { memorizeFuncWithLRUCache } from "../common/utils.js";
 import { uint8ArrayToHexString, writeString } from "./convert.js";
 import { unique } from "octagonal-wheels/collection.js";
-import { CHeader, ICHeader, ICXHeader, PSCHeader } from "../common/models/fileaccess.const.js";
+import { CHeader } from "../common/models/fileaccess.const.js";
 import { computeKeyedId } from "../common/idDerivation.js";
 function isValidFilenameInWidows(filename) {
   const regex = /[\u0000-\u001f]|[\\":?<>|*#]/g;
@@ -45,12 +46,8 @@ function addPrefix(path, prefix) {
   return `${prefix ?? ""}${path}`;
 }
 function expandFilePathPrefix(path) {
-  for (const prefix of [ICHeader, ICXHeader, PSCHeader]) {
-    if (path.startsWith(prefix)) {
-      return [prefix, path.substring(prefix.length)];
-    }
-  }
-  return ["", path];
+  const [prefix, body] = splitPathNamespace(path);
+  return [prefix, body];
 }
 function expandDocumentIDPrefix(id) {
   for (const prefix of [CHeader, PREFIX_OBFUSCATED]) {