@vrtmrz/livesync-commonlib 0.3.0 → 0.3.2

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 { assertSupportedPathNormalizationVersion, getPathNormalizationVersion } from "../../common/pathNormalization.js";
+import { assertSupportedPathNormalizationVersion } from "../../common/pathNormalization.js";
 import { JournalStorageReadStatuses } from "./objectstore/JournalStorageAdapter.js";
 import { computeKeyedId, configuredIdKey } from "../../common/idDerivation.js";
 import { decryptString, encryptString } from "../../encryption/stringEncryption.js";
@@ -31,6 +31,12 @@ import {
   forgetJoinedDevice as forgetJoinedDeviceFromStore,
   projectJoinedDevices
 } from "../joinedDevices.js";
+import {
+  journalVersionRange,
+  hasJournalNodeDeclarations,
+  matchesJournalPathIdentity,
+  inspectJournalPathIdentity
+} from "./journalCompatibility.js";
 const MILSTONE_DOCID = "_00000000-milestone.json";
 async function readRemoteMilestone(client) {
   const result = await client.downloadJsonWithResult(MILSTONE_DOCID);
@@ -38,23 +44,6 @@ async function readRemoteMilestone(client) {
   if (result.status === JournalStorageReadStatuses.NOT_FOUND) return void 0;
   throw result.error;
 }
-const currentVersionRange = {
-  min: 0,
-  max: 2,
-  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();
@@ -89,17 +78,8 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     return this._client;
   }
   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()) {
+    if (!matchesJournalPathIdentity(setting, milestone)) return false;
+    if (!hasJournalNodeDeclarations(milestone) && await client.hasRemoteJournals()) {
       throw new Error(
         "The Journal compatibility milestone is missing. Rebuild from the authoritative Vault before synchronising."
       );
@@ -144,22 +124,13 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
   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()) {
+    const identity = inspectJournalPathIdentity(milestone);
+    if (!hasJournalNodeDeclarations(milestone) && 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 };
+    return identity;
   }
   /** Lock existing journals for replacement without declaring the replacement's identity. */
   async markRemoteLockedForRebuild(setting) {
@@ -178,7 +149,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
       throw new Error("Could not upload remote milestone");
     }
   }
-  async ensureBucketIsCompatible(deviceNodeID, currentVersionRange2, setting = this.currentSettings, client = this.setupJournalSyncClient(setting), recordTweakAssessment) {
+  async ensureBucketIsCompatible(deviceNodeID, currentVersionRange, 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";
@@ -193,7 +164,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
       downloadedMilestone,
       setting,
       deviceNodeID,
-      currentVersionRange2,
+      currentVersionRange,
       {
         app_version: this.env.services.API.getAppVersion(),
         plugin_version: this.env.services.API.getPluginVersion(),
@@ -356,6 +327,18 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
       (client) => client.sendLocalJournal(showingNotice)
     );
   }
+  /** Return the stopped Journal from the current transfer client without creating another client. */
+  getStoppedJournal() {
+    return this._client?.getStoppedJournal();
+  }
+  /** Recheck connectivity and compatibility, skip the confirmed Journal, and resume receipt. */
+  async skipStoppedJournalAndResume(setting, stopped, showingNotice = true) {
+    return await this.runDirectionalReplication(
+      setting,
+      showingNotice,
+      (client) => client.skipStoppedJournalAndResume(stopped, showingNotice)
+    );
+  }
   async replicateAllFromServer(setting, showingNotice) {
     return await this.runDirectionalReplication(
       setting,
@@ -721,6 +704,10 @@ ${ex.message}`, LOG_LEVEL_NOTICE);
     return Promise.resolve(false);
   }
 }
+function isLiveSyncJournalReplicator(value) {
+  return value instanceof LiveSyncJournalReplicator;
+}
 export {
-  LiveSyncJournalReplicator
+  LiveSyncJournalReplicator,
+  isLiveSyncJournalReplicator
 };

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

@@ -0,0 +1,9 @@
+import { type ChunkVersionRange, type EntryMilestoneInfo, type RemoteDBSettings } from "../../common/types.js";
+import type { PathIdentityInspection } from "../../pouchdb/pathIdentityCompatibility.js";
+export declare function journalVersionRange(setting: RemoteDBSettings): ChunkVersionRange;
+export declare function pathIdentityFromJournalRange(range: ChunkVersionRange | undefined): 0 | 1;
+/** Without a node declaration, the caller must inspect storage before treating the bucket as empty. */
+export declare function hasJournalNodeDeclarations(milestone: EntryMilestoneInfo | undefined): boolean;
+export declare function matchesJournalPathIdentity(setting: RemoteDBSettings, milestone: EntryMilestoneInfo | undefined): boolean;
+/** Project declarations only; an empty result does not establish that remote storage is empty. */
+export declare function inspectJournalPathIdentity(milestone: EntryMilestoneInfo | undefined): PathIdentityInspection;

package/dist/replication/journal/journalCompatibility.js

@@ -0,0 +1,58 @@
+import {
+  DEVICE_ID_PREFERRED
+} from "../../common/types.js";
+import { configuredIdKey } from "../../common/idDerivation.js";
+import { getPathNormalizationVersion } from "../../common/pathNormalization.js";
+const currentVersionRange = {
+  min: 0,
+  max: 2,
+  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.");
+}
+function journalPathIdentityNodes(milestone) {
+  return /* @__PURE__ */ new Set([...milestone?.accepted_nodes ?? [], ...Object.keys(milestone?.node_chunk_info ?? {})]);
+}
+function hasJournalNodeDeclarations(milestone) {
+  return journalPathIdentityNodes(milestone).size > 0;
+}
+function matchesJournalPathIdentity(setting, milestone) {
+  const pathVersion = getPathNormalizationVersion(setting);
+  const ranges = milestone?.node_chunk_info ?? {};
+  for (const node of journalPathIdentityNodes(milestone)) {
+    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];
+  return !preferred || getPathNormalizationVersion(preferred) === pathVersion;
+}
+function inspectJournalPathIdentity(milestone) {
+  const versions = /* @__PURE__ */ new Set();
+  const ranges = milestone?.node_chunk_info ?? {};
+  for (const node of journalPathIdentityNodes(milestone)) {
+    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.");
+  const version = [...versions][0];
+  return version === void 0 ? { status: "empty" } : { status: "configured", pathNormalizationVersion: version };
+}
+export {
+  hasJournalNodeDeclarations,
+  inspectJournalPathIdentity,
+  journalVersionRange,
+  matchesJournalPathIdentity,
+  pathIdentityFromJournalRange
+};

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

@@ -0,0 +1,23 @@
+import type { EntryDoc } from "../../common/types.js";
+import type { ProcessingEntry } from "./journalRecords.js";
+type ChunkReadRow = {
+    id?: string;
+    error?: string;
+};
+type WriteResult = PouchDB.Core.Error | PouchDB.Core.Response;
+export declare function partitionJournalDocuments(entries: readonly ProcessingEntry[]): {
+    chunks: ProcessingEntry[];
+    docs: ProcessingEntry[];
+};
+/** Chunks have stable content, so only absent identifiers need a new local revision. */
+export declare function selectChunksToSave(chunks: readonly ProcessingEntry[], rows: readonly ChunkReadRow[]): PouchDB.Core.PutDocument<EntryDoc>[];
+export declare function hasJournalWriteErrors(results: readonly WriteResult[]): boolean;
+/** Report persisted Chunks even when another row failed, but require every requested Chunk for completion. */
+export declare function assessChunkWrites<T extends PouchDB.Core.PutDocument<EntryDoc>>(chunks: readonly T[], results: readonly WriteResult[]): {
+    persisted: T[];
+    failed: boolean;
+};
+export declare function journalMetadataRevisions(docs: readonly ProcessingEntry[]): PouchDB.Core.RevisionDiffOptions;
+/** Retain complete transferred Metadata, including revision ancestry, for each missing revision. */
+export declare function selectMetadataToSave(docs: readonly ProcessingEntry[], diff: PouchDB.Core.RevisionDiffResponse): ProcessingEntry[];
+export {};

package/dist/replication/journal/journalReceive.js

@@ -0,0 +1,44 @@
+function partitionJournalDocuments(entries) {
+  const chunks = [];
+  const docs = [];
+  for (const entry of entries) {
+    (entry._id.startsWith("h:") ? chunks : docs).push(entry);
+  }
+  return { chunks, docs };
+}
+function selectChunksToSave(chunks, rows) {
+  if (rows.some((row) => "error" in row && row.error !== "not_found")) {
+    throw new Error("Could not inspect existing Chunks");
+  }
+  const existingIDs = new Set(rows.map((row) => row.id).filter((id) => id !== void 0));
+  return chunks.filter((entry) => !existingIDs.has(entry._id)).map((entry) => ({ ...entry, _rev: void 0 }));
+}
+function hasJournalWriteErrors(results) {
+  return results.some((row) => "error" in row);
+}
+function assessChunkWrites(chunks, results) {
+  const persistedIDs = new Set(results.filter((row) => !("error" in row)).map((row) => row.id));
+  return {
+    persisted: chunks.filter((entry) => persistedIDs.has(entry._id)),
+    failed: hasJournalWriteErrors(results) || chunks.some((entry) => !persistedIDs.has(entry._id))
+  };
+}
+function journalMetadataRevisions(docs) {
+  return docs.reduce(
+    (revisions, entry) => ({ ...revisions, [entry._id]: [...revisions[entry._id] ?? [], entry._rev] }),
+    {}
+  );
+}
+function selectMetadataToSave(docs, diff) {
+  return docs.filter(
+    (entry) => entry._id in diff && "missing" in diff[entry._id] && (diff[entry._id].missing?.indexOf(entry._rev) ?? 0) !== -1
+  );
+}
+export {
+  assessChunkWrites,
+  hasJournalWriteErrors,
+  journalMetadataRevisions,
+  partitionJournalDocuments,
+  selectChunksToSave,
+  selectMetadataToSave
+};

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

@@ -0,0 +1,10 @@
+import { type EntryDoc } from "../../common/types.js";
+export type ProcessingEntry = PouchDB.Core.PutDocument<EntryDoc> & PouchDB.Core.GetMeta;
+export declare function serializeDoc(doc: EntryDoc): Uint8Array;
+export declare function decodeJournalRecords(data: Uint8Array): {
+    ok: true;
+    docs: ProcessingEntry[];
+} | {
+    ok: false;
+    stage: "decode" | "parse";
+};

package/dist/replication/journal/journalRecords.js

@@ -0,0 +1,96 @@
+import {} from "../../common/types.js";
+import { escapeNewLineFromString, unescapeNewLineFromString } from "../../common/utils.js";
+const RECORD_SPLIT = `
+`;
+const UNIT_SPLIT = ``;
+const te = new TextEncoder();
+function parseJournalRecord(value) {
+  const parsed = JSON.parse(value);
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new TypeError("Invalid Journal record");
+  }
+  const record = parsed;
+  if (typeof record._id !== "string" || record._id.length === 0) {
+    throw new TypeError("Invalid Journal document identifier");
+  }
+  if (record._id.startsWith("h:")) {
+    if (record._id.length <= 2 || typeof record._rev !== "string" || typeof record.data !== "string") {
+      throw new TypeError("Invalid Journal Chunk record");
+    }
+  } else if (typeof record._rev !== "string" || record._rev.length === 0) {
+    throw new TypeError("Invalid Journal Metadata revision");
+  }
+  return parsed;
+}
+function decodeCompactJournalRecord(value) {
+  const separatorIndex = value.indexOf(UNIT_SPLIT);
+  if (separatorIndex === -1) {
+    return { ok: false, stage: "parse" };
+  }
+  const idPart = value.substring(1, separatorIndex);
+  if (!idPart.startsWith("h:") || idPart.length <= 2) {
+    return { ok: false, stage: "parse" };
+  }
+  const dataPart = value.substring(separatorIndex + 1);
+  return {
+    ok: true,
+    doc: {
+      _id: idPart,
+      data: unescapeNewLineFromString(dataPart),
+      type: "leaf",
+      _rev: ""
+    }
+  };
+}
+function decodeJournalRecordFrame(frame, decoder) {
+  let value;
+  try {
+    value = decoder.decode(frame);
+  } catch {
+    return { ok: false, stage: "decode" };
+  }
+  if (value.startsWith("~")) {
+    return decodeCompactJournalRecord(value);
+  }
+  try {
+    return { ok: true, doc: parseJournalRecord(value) };
+  } catch {
+    return { ok: false, stage: "parse" };
+  }
+}
+function serializeDoc(doc) {
+  if (doc._id.startsWith("h:")) {
+    const data = doc.data;
+    const writeData = escapeNewLineFromString(data);
+    return te.encode(`~${doc._id}${UNIT_SPLIT}${writeData}${RECORD_SPLIT}`);
+  }
+  return te.encode(JSON.stringify(doc) + RECORD_SPLIT);
+}
+function decodeJournalRecords(data) {
+  if (data.length === 0) {
+    return { ok: true, docs: [] };
+  }
+  if (data[data.length - 1] !== 10) {
+    return { ok: false, stage: "parse" };
+  }
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let idxFrom = 0;
+  const result = [];
+  while (idxFrom < data.length) {
+    const idxTo = data.indexOf(10, idxFrom);
+    if (idxTo === -1 || idxTo === idxFrom) {
+      return { ok: false, stage: "parse" };
+    }
+    const record = decodeJournalRecordFrame(data.slice(idxFrom, idxTo), decoder);
+    if (record.ok === false) {
+      return record;
+    }
+    result.push(record.doc);
+    idxFrom = idxTo + 1;
+  }
+  return { ok: true, docs: result };
+}
+export {
+  decodeJournalRecords,
+  serializeDoc
+};

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

@@ -242,6 +242,7 @@ export declare class TrysteroReplicator {
         jwtSub?: string;
         jwtExpDuration?: number;
         useRequestAPI?: boolean;
+        useCouchDBCacheControlHeadersOnly?: boolean;
         accessKey?: string;
         secretKey?: string;
         bucket?: string;
@@ -432,6 +433,7 @@ export declare class TrysteroReplicator {
             jwtSub?: string;
             jwtExpDuration?: number;
             useRequestAPI?: boolean;
+            useCouchDBCacheControlHeadersOnly?: boolean;
             accessKey?: string;
             secretKey?: string;
             bucket?: string;

package/dist/serviceModules/Rebuilder.js

@@ -222,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 {

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]) {