@vrtmrz/livesync-commonlib 0.1.25 → 0.1.27

package/dist/interfaces/DatabaseFileAccess.d.ts

@@ -2,7 +2,10 @@ import type { FilePathWithPrefix, LoadedEntry, MetaEntry, UXFileInfo, UXFileInfo
 export interface DatabaseFileAccess {
     delete: (file: UXFileInfoStub | FilePathWithPrefix, rev?: string) => Promise<boolean>;
     store: (file: UXFileInfo, force?: boolean, skipCheck?: boolean) => Promise<boolean>;
-    /** Store a file as a child of an exact revision and return the created revision. */
+    /**
+     * Store a child of the exact supplied revision, even after that branch has advanced.
+     * An undefined base uses the current winner. Return the created revision, or `false`.
+     */
     storeWithBaseRevision: (file: UXFileInfo, baseRevision: string | undefined, skipCheck?: boolean) => Promise<string | false>;
     /**
      * Store a file as a child of an exact revision only while that revision remains a live leaf.
@@ -14,8 +17,18 @@ export interface DatabaseFileAccess {
      * write without creating a Metadata successor.
      */
     storeWithLiveBaseRevision: (file: UXFileInfo, baseRevision: string, skipCheck?: boolean) => Promise<string | false>;
+    /**
+     * Preserve content of unknown ancestry as a fresh parentless revision of the same document.
+     * Existing branches remain intact; no historical byte match is used as the parent.
+     * Return the created revision, or `false` when no Metadata revision was stored.
+     */
+    storeIndependentRevision: (file: UXFileInfo, skipCheck?: boolean) => Promise<string | false>;
     storeAsConflictedRevision: (file: UXFileInfo, currentRev: string, skipCheck?: boolean) => Promise<boolean>;
-    /** Preserve unknown storage content as a conflict and return its exact revision. */
+    /**
+     * Store a sibling of `currentRev` below its parent and return the created revision.
+     * Return `false` if that parent is unavailable. Use `storeIndependentRevision`
+     * when the storage content has no known ancestor.
+     */
     storeAsConflictedRevisionWithResult: (file: UXFileInfo, currentRev: string, skipCheck?: boolean) => Promise<string | false>;
     /** Store a user deletion as a visible logical-deletion child of an exact revision. */
     storeDeletionWithBaseRevision: (file: UXFileInfoStub | FilePathWithPrefix, baseRevision: string) => Promise<string | false>;
@@ -24,9 +37,24 @@ export interface DatabaseFileAccess {
     hasContentInRevisionHistory: (file: UXFileInfoStub | FilePathWithPrefix, content: string | string[] | Blob | ArrayBuffer, currentRev?: string) => Promise<boolean>;
     /** Return every available revision whose content exactly matches the supplied bytes. */
     findContentRevisions: (file: UXFileInfoStub | FilePathWithPrefix, content: string | string[] | Blob | ArrayBuffer, currentRev?: string) => Promise<string[]>;
+    /**
+     * Return current, non-deleted leaf revisions whose decoded content matches the supplied bytes.
+     * Include the winning and conflicting leaves, but never their ancestors. Read only locally
+     * available Chunks, without requesting remote data or waiting for missing Chunks to arrive.
+     *
+     * A unique match can recover provenance; several matches avoid a duplicate write but leave
+     * its origin ambiguous. An empty result means no match was confirmed, including when data
+     * could not be read. This read neither records provenance nor reserves a leaf for a later write.
+     */
+    findLiveContentRevisions: (file: UXFileInfoStub | FilePathWithPrefix, content: string | string[] | Blob | ArrayBuffer) => Promise<string[]>;
     fetch: (file: UXFileInfoStub | FilePathWithPrefix, rev?: string, waitForReady?: boolean, skipCheck?: boolean) => Promise<UXFileInfo | false>;
     fetchEntryFromMeta: (meta: MetaEntry, waitForReady?: boolean, skipCheck?: boolean) => Promise<LoadedEntry | false>;
     fetchEntryMeta: (file: UXFileInfoStub | FilePathWithPrefix, rev?: string, skipCheck?: boolean) => Promise<MetaEntry | false>;
-    fetchEntry: (file: UXFileInfoStub | FilePathWithPrefix, rev?: string, waitForReady?: boolean, skipCheck?: boolean) => Promise<LoadedEntry | false>;
+    /**
+     * Load a revision's content, or return `false` when it cannot be loaded.
+     * `localOnly` overrides `waitForReady`: missing Chunks cause failure without remote requests
+     * or waiting for delivery, so provenance checks can use only content already available locally.
+     */
+    fetchEntry: (file: UXFileInfoStub | FilePathWithPrefix, rev?: string, waitForReady?: boolean, skipCheck?: boolean, localOnly?: boolean) => Promise<LoadedEntry | false>;
     getConflictedRevs: (file: UXFileInfoStub | FilePathWithPrefix) => Promise<string[]>;
 }

package/dist/interfaces/FileReflectionProvenance.d.ts

@@ -1,9 +1,9 @@
 import type { FilePathWithPrefix } from "../common/types.js";
 import type { SimpleStore } from "../common/utils.js";
 export type FileReflectionProvenanceRecord = {
-    /** Exact database revision which most recently produced the storage state. */
+    /** Exact revision most recently saved from or reflected in storage; the base for subsequent edits. */
     revision: string;
-    /** Raw modification time observed from this device's storage after reflection. */
+    /** Raw modification time of the saved snapshot or storage observed after reflection. */
     observedStorageMtime?: number;
 };
 export interface FileReflectionProvenance {

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

@@ -30,10 +30,12 @@ export declare class EntryManager {
     isTargetFile(filenameSrc: string): boolean;
     prepareChunk(piece: string): Promise<GeneratedChunk>;
     getDBEntryMeta(path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions, includeDeleted?: boolean): Promise<false | LoadedEntry>;
-    getDBEntry(path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions, dump?: boolean, waitForReady?: boolean, includeDeleted?: boolean): Promise<false | LoadedEntry>;
-    getDBEntryFromMeta(meta: LoadedEntry | MetaEntry, dump?: boolean, waitForReady?: boolean): Promise<false | LoadedEntry>;
+    getDBEntry(path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions, dump?: boolean, waitForReady?: boolean, includeDeleted?: boolean, localOnly?: boolean): Promise<false | LoadedEntry>;
+    getDBEntryFromMeta(meta: LoadedEntry | MetaEntry, dump?: boolean, waitForReady?: boolean, localOnly?: boolean): Promise<false | LoadedEntry>;
     deleteDBEntry(path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions): Promise<boolean>;
     storeDeletionAtRevision(path: FilePathWithPrefix | FilePath, baseRevision: string): Promise<false | PouchDB.Core.Response>;
     putDBEntry(note: SavingEntry, onlyChunks?: boolean, conflictBaseRev?: string): Promise<false | PouchDB.Core.Response>;
     putDBEntryWithLiveBaseRevision(note: SavingEntry, baseRevision: string, onlyChunks?: boolean): Promise<false | PouchDB.Core.Response>;
+    /** Store unknown ancestry as a fresh root; return the Metadata write result or `false`. */
+    putDBEntryAsIndependentRoot(note: SavingEntry): Promise<false | PouchDB.Core.Response>;
 }

package/dist/managers/EntryManager/EntryManager.js

@@ -10,6 +10,7 @@ import {
   prepareChunk,
   putDBEntry,
   putDBEntryWithLiveBaseRevision,
+  putDBEntryAsIndependentRoot,
   storeDeletionByPathAtRevision
 } from "./EntryManagerImpls.js";
 class EntryManager {
@@ -57,11 +58,11 @@ class EntryManager {
   async getDBEntryMeta(path, opt, includeDeleted = false) {
     return await getDBEntryMetaByPath(this.serviceHost, this, path, opt, includeDeleted);
   }
-  async getDBEntry(path, opt, dump = false, waitForReady = true, includeDeleted = false) {
-    return await getDBEntryByPath(this.serviceHost, this, path, opt, dump, waitForReady, includeDeleted);
+  async getDBEntry(path, opt, dump = false, waitForReady = true, includeDeleted = false, localOnly = false) {
+    return await getDBEntryByPath(this.serviceHost, this, path, opt, dump, waitForReady, includeDeleted, localOnly);
   }
-  async getDBEntryFromMeta(meta, dump = false, waitForReady = true) {
-    return await getDBEntryFromMeta(this.serviceHost, this, meta, dump, waitForReady);
+  async getDBEntryFromMeta(meta, dump = false, waitForReady = true, localOnly = false) {
+    return await getDBEntryFromMeta(this.serviceHost, this, meta, dump, waitForReady, localOnly);
   }
   async deleteDBEntry(path, opt) {
     return await deleteDBEntryByPath(this.serviceHost, this, path, opt);
@@ -75,6 +76,10 @@ class EntryManager {
   async putDBEntryWithLiveBaseRevision(note, baseRevision, onlyChunks) {
     return await putDBEntryWithLiveBaseRevision(this.serviceHost, this, note, baseRevision, onlyChunks);
   }
+  /** Store unknown ancestry as a fresh root; return the Metadata write result or `false`. */
+  async putDBEntryAsIndependentRoot(note) {
+    return await putDBEntryAsIndependentRoot(this.serviceHost, this, note);
+  }
 }
 export {
   EntryManager

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

@@ -20,20 +20,28 @@ export declare function putDBEntry(host: NecessaryServicesInterfaces<"path" | "s
  * base has already been advanced, so the caller receives `false` and can retry from fresh state.
  */
 export declare function putDBEntryWithLiveBaseRevision(host: NecessaryServicesInterfaces<"path" | "setting", never>, managers: NecessaryManagers<"localDatabase" | "chunkManager" | "hashManager" | "splitter">, note: SavingEntry, baseRevision: string, onlyChunks?: boolean): Promise<false | PouchDB.Core.Response>;
+/**
+ * Preserve content with unknown ancestry as a fresh parentless revision of the same document.
+ * Store the body as Chunks as usual, then insert a Metadata root with a random revision ID using
+ * `new_edits: false`. This retains existing branches without reusing an identical historical root.
+ * Return the Metadata write result, or `false` when the entry cannot be stored.
+ */
+export declare function putDBEntryAsIndependentRoot(host: NecessaryServicesInterfaces<"path" | "setting", never>, managers: NecessaryManagers<"localDatabase" | "chunkManager" | "hashManager" | "splitter">, note: SavingEntry): Promise<false | PouchDB.Core.Response>;
 export declare function isTargetFile(host: NecessaryServicesInterfaces<"setting", never>, filenameSrc: string): boolean;
 export declare function prepareChunk({ chunkManager, hashManager }: NecessaryManagers<"chunkManager" | "hashManager">, piece: string): Promise<GeneratedChunk>;
 export declare function getDBEntryMetaByPath(host: NecessaryServicesInterfaces<"path" | "setting", never>, { localDatabase }: NecessaryManagers<"localDatabase">, path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions, includeDeleted?: boolean): Promise<false | LoadedEntry>;
 export declare function isLegacyNote(meta: LoadedEntry | MetaEntry): boolean;
 export declare function canUseOnDemandChunking(settings: ObsidianLiveSyncSettings): boolean;
 /**
- * Decide how to retrieve chunks based on settings and waitForReady flag.
+ * Decide how to retrieve chunks based on settings and the caller's read policy.
  * `waitForReady` allows an already-observable finite delivery lifecycle to finish.
+ * `localOnly` overrides both settings and waiting for provenance comparisons.
  */
-export declare function computeChunkRetrievalMethod(waitForReady: boolean, settings: ObsidianLiveSyncSettings): {
+export declare function computeChunkRetrievalMethod(waitForReady: boolean, settings: ObsidianLiveSyncSettings, localOnly?: boolean): {
     waitForDelivery: boolean;
     preventRemoteRequest: boolean;
 };
-export declare function getDBEntryFromMeta(host: NecessaryServicesInterfaces<"path" | "setting", never>, { localDatabase, chunkManager }: NecessaryManagers<"localDatabase" | "chunkManager">, meta: LoadedEntry | MetaEntry, dump?: boolean, waitForReady?: boolean): Promise<false | (import("../../common/types.js").DatabaseEntry & EntryBase & import("../../common/types.js").EntryWithEden & {
+export declare function getDBEntryFromMeta(host: NecessaryServicesInterfaces<"path" | "setting", never>, { localDatabase, chunkManager }: NecessaryManagers<"localDatabase" | "chunkManager">, meta: LoadedEntry | MetaEntry, dump?: boolean, waitForReady?: boolean, localOnly?: boolean): Promise<false | (import("../../common/types.js").DatabaseEntry & EntryBase & import("../../common/types.js").EntryWithEden & {
     path: FilePathWithPrefix;
     data: string | string[];
     type: import("../../common/models/db.type.js").EntryTypes["NOTE_LEGACY"];
@@ -55,7 +63,7 @@ export declare function getDBEntryFromMeta(host: NecessaryServicesInterfaces<"pa
     data: string | string[];
     datatype: import("../../common/types.js").EntryTypeNotes;
 } & PouchDB.Core.IdMeta)>;
-export declare function getDBEntryByPath(host: NecessaryServicesInterfaces<"path" | "setting", never>, managers: NecessaryManagers<"localDatabase" | "chunkManager">, path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions, dump?: boolean, waitForReady?: boolean, includeDeleted?: boolean): Promise<false | (import("../../common/types.js").DatabaseEntry & EntryBase & import("../../common/types.js").EntryWithEden & {
+export declare function getDBEntryByPath(host: NecessaryServicesInterfaces<"path" | "setting", never>, managers: NecessaryManagers<"localDatabase" | "chunkManager">, path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions, dump?: boolean, waitForReady?: boolean, includeDeleted?: boolean, localOnly?: boolean): Promise<false | (import("../../common/types.js").DatabaseEntry & EntryBase & import("../../common/types.js").EntryWithEden & {
     path: FilePathWithPrefix;
     data: string | string[];
     type: import("../../common/models/db.type.js").EntryTypes["NOTE_LEGACY"];

package/dist/managers/EntryManager/EntryManagerImpls.js

@@ -6,6 +6,7 @@ import {
 } from "../../common/types.js";
 import { serialized } from "octagonal-wheels/concurrency/lock";
 import { createTextBlob, getFileRegExp, isTextBlob } from "../../common/utils.js";
+import { compatGlobal } from "../../common/coreEnvFunctions.js";
 import { isErrorOfMissingDoc } from "../../pouchdb/utils_couchdb.js";
 import { stripAllPrefixes } from "../../string_and_binary/path.js";
 import { ICHeader, ICXHeader, PSCHeader } from "../../common/models/fileaccess.const.js";
@@ -126,6 +127,9 @@ async function putDBEntryWithLiveBaseRevision(host, managers, note, baseRevision
     throw ex;
   }
 }
+async function putDBEntryAsIndependentRoot(host, managers, note) {
+  return await putDBEntryInternal(host, managers, note, false, { mode: "independent-root" });
+}
 async function putDBEntryInternal(host, managers, note, onlyChunks, revisionTarget) {
   const { localDatabase, chunkManager, splitter } = managers;
   const filename = host.services.path.id2path(note._id, note);
@@ -163,9 +167,9 @@ async function putDBEntryInternal(host, managers, note, onlyChunks, revisionTarg
       eden: {}
     };
     return await serialized("file:" + filename, async () => {
-      if (revisionTarget.mode !== "latest") {
+      if (revisionTarget.mode === "force-base" || revisionTarget.mode === "live-base") {
         newDoc._rev = revisionTarget.baseRevision;
-      } else {
+      } else if (revisionTarget.mode === "latest") {
         try {
           const old = await localDatabase.get(newDoc._id);
           newDoc._rev = old._rev;
@@ -176,6 +180,15 @@ async function putDBEntryInternal(host, managers, note, onlyChunks, revisionTarg
           }
         }
       }
+      if (revisionTarget.mode === "independent-root") {
+        const randomBytes = compatGlobal.crypto.getRandomValues(new Uint8Array(16));
+        const rootId = Array.from(randomBytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+        newDoc._rev = `1-${rootId}`;
+        const imported = { ...newDoc, _revisions: { start: 1, ids: [rootId] } };
+        await localDatabase.bulkDocs([imported], { new_edits: false });
+        const stored = await localDatabase.get(newDoc._id, { rev: newDoc._rev });
+        return stored._rev === newDoc._rev ? { id: newDoc._id, ok: true, rev: newDoc._rev } : false;
+      }
       const r = revisionTarget.mode === "live-base" ? await localDatabase.put(newDoc) : await localDatabase.put(newDoc, { force: true });
       if (r.ok) {
         return r;
@@ -324,7 +337,10 @@ function canFetchRemotely(settings) {
   }
   return true;
 }
-function computeChunkRetrievalMethod(waitForReady, settings) {
+function computeChunkRetrievalMethod(waitForReady, settings, localOnly = false) {
+  if (localOnly) {
+    return { waitForDelivery: false, preventRemoteRequest: true };
+  }
   const isOnDemandFetchEnabled = canFetchRemotely(settings);
   if (!waitForReady) {
     if (isOnDemandFetchEnabled) {
@@ -343,7 +359,7 @@ function computeChunkRetrievalMethod(waitForReady, settings) {
     preventRemoteRequest: !isOnDemandFetchEnabled
   };
 }
-async function respondEntryFromMeta({ localDatabase, chunkManager }, settings, filename, meta, dump, waitForReady) {
+async function respondEntryFromMeta({ localDatabase, chunkManager }, settings, filename, meta, dump, waitForReady, localOnly = false) {
   const dispFilename = stripAllPrefixes(filename);
   const deleted = meta.deleted ?? meta._deleted ?? void 0;
   if (dump) {
@@ -371,7 +387,7 @@ async function respondEntryFromMeta({ localDatabase, chunkManager }, settings, f
       }));
       edenChunks = Object.fromEntries(chunks2.map((e) => [e._id, e]));
     }
-    const { waitForDelivery, preventRemoteRequest } = computeChunkRetrievalMethod(waitForReady, settings);
+    const { waitForDelivery, preventRemoteRequest } = computeChunkRetrievalMethod(waitForReady, settings, localOnly);
     const childrenKeys = [...meta.children];
     const chunks = await chunkManager.read(
       childrenKeys,
@@ -421,7 +437,7 @@ async function respondEntryFromMeta({ localDatabase, chunkManager }, settings, f
   }
   return false;
 }
-async function getDBEntryFromMeta(host, { localDatabase, chunkManager }, meta, dump = false, waitForReady = true) {
+async function getDBEntryFromMeta(host, { localDatabase, chunkManager }, meta, dump = false, waitForReady = true, localOnly = false) {
   const filename = host.services.path.id2path(meta._id, meta);
   if (!isTargetFile(host, filename)) {
     return false;
@@ -438,15 +454,16 @@ async function getDBEntryFromMeta(host, { localDatabase, chunkManager }, meta, d
       filename,
       meta,
       dump,
-      waitForReady
+      waitForReady,
+      localOnly
     );
   }
   return false;
 }
-async function getDBEntryByPath(host, managers, path, opt, dump = false, waitForReady = true, includeDeleted = false) {
+async function getDBEntryByPath(host, managers, path, opt, dump = false, waitForReady = true, includeDeleted = false, localOnly = false) {
   const meta = await getDBEntryMetaByPath(host, managers, path, opt, includeDeleted);
   if (meta) {
-    return await getDBEntryFromMeta(host, managers, meta, dump, waitForReady);
+    return await getDBEntryFromMeta(host, managers, meta, dump, waitForReady, localOnly);
   } else {
     return false;
   }
@@ -540,6 +557,7 @@ export {
   isTargetFile,
   prepareChunk,
   putDBEntry,
+  putDBEntryAsIndependentRoot,
   putDBEntryWithLiveBaseRevision,
   storeDeletionByPathAtRevision
 };

package/dist/pouchdb/LiveSyncLocalDB.d.ts

@@ -196,12 +196,14 @@ export declare class LiveSyncLocalDB {
     bulkDocsRaw<T extends EntryDoc>(docs: Array<PouchDB.Core.PutDocument<T>>, options?: PouchDB.Core.BulkDocsOptions): Promise<Array<PouchDB.Core.Response | PouchDB.Core.Error>>;
     isTargetFile(filenameSrc: string): boolean;
     getDBEntryMeta(path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions, includeDeleted?: boolean): Promise<false | LoadedEntry>;
-    getDBEntry(path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions, dump?: boolean, waitForReady?: boolean, includeDeleted?: boolean): Promise<false | LoadedEntry>;
-    getDBEntryFromMeta(meta: LoadedEntry | MetaEntry, dump?: boolean, waitForReady?: boolean): Promise<false | LoadedEntry>;
+    getDBEntry(path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions, dump?: boolean, waitForReady?: boolean, includeDeleted?: boolean, localOnly?: boolean): Promise<false | LoadedEntry>;
+    getDBEntryFromMeta(meta: LoadedEntry | MetaEntry, dump?: boolean, waitForReady?: boolean, localOnly?: boolean): Promise<false | LoadedEntry>;
     deleteDBEntry(path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions): Promise<boolean>;
     storeDeletionAtRevision(path: FilePathWithPrefix | FilePath, baseRevision: string): Promise<false | PouchDB.Core.Response>;
     putDBEntry(note: SavingEntry, onlyChunks?: boolean, conflictBaseRev?: string): Promise<false | PouchDB.Core.Response>;
     putDBEntryWithLiveBaseRevision(note: SavingEntry, baseRevision: string, onlyChunks?: boolean): Promise<false | PouchDB.Core.Response>;
+    /** Preserve existing branches and delegate a fresh root write to the entry manager. */
+    putDBEntryAsIndependentRoot(note: SavingEntry): Promise<false | PouchDB.Core.Response>;
     getConflictedDoc(path: FilePathWithPrefix, rev: string): Promise<false | diff_result_leaf>;
     tryAutoMerge(path: FilePathWithPrefix, enableMarkdownAutoMerge: boolean): AutoMergeResult;
 }

package/dist/pouchdb/LiveSyncLocalDB.js

@@ -457,11 +457,11 @@ class LiveSyncLocalDB {
   async getDBEntryMeta(path, opt, includeDeleted = false) {
     return await this.managers.entryManager.getDBEntryMeta(path, opt, includeDeleted);
   }
-  async getDBEntry(path, opt, dump = false, waitForReady = true, includeDeleted = false) {
-    return await this.managers.entryManager.getDBEntry(path, opt, dump, waitForReady, includeDeleted);
+  async getDBEntry(path, opt, dump = false, waitForReady = true, includeDeleted = false, localOnly = false) {
+    return await this.managers.entryManager.getDBEntry(path, opt, dump, waitForReady, includeDeleted, localOnly);
   }
-  async getDBEntryFromMeta(meta, dump = false, waitForReady = true) {
-    return await this.managers.entryManager.getDBEntryFromMeta(meta, dump, waitForReady);
+  async getDBEntryFromMeta(meta, dump = false, waitForReady = true, localOnly = false) {
+    return await this.managers.entryManager.getDBEntryFromMeta(meta, dump, waitForReady, localOnly);
   }
   async deleteDBEntry(path, opt) {
     return await this.managers.entryManager.deleteDBEntry(path, opt);
@@ -475,6 +475,10 @@ class LiveSyncLocalDB {
   async putDBEntryWithLiveBaseRevision(note, baseRevision, onlyChunks) {
     return await this.managers.entryManager.putDBEntryWithLiveBaseRevision(note, baseRevision, onlyChunks);
   }
+  /** Preserve existing branches and delegate a fresh root write to the entry manager. */
+  async putDBEntryAsIndependentRoot(note) {
+    return await this.managers.entryManager.putDBEntryAsIndependentRoot(note);
+  }
   async getConflictedDoc(path, rev) {
     return await this.managers.conflictManager.getConflictedDoc(path, rev);
   }

package/dist/replication/ReplicatorProvider.d.ts

@@ -131,12 +131,16 @@ export type ReplicationFailed = {
 export type ReplicationOutcome = ReplicationCompleted | ReplicationCancelled | ReplicationBlocked | ReplicationPartial | ReplicationFailed;
 /** Preparation required before an ordinary operation may use a provider. */
 export interface ReplicationReadinessRequirements {
-    readonly centralRemotePreparation: "required" | "not-applicable";
+    readonly centralRemotePreparation: "required" | "provider-owned" | "not-applicable";
 }
 /** Shared readiness contract for providers backed by the central remote. */
 export declare const CENTRAL_REMOTE_REPLICATION_READINESS: Readonly<{
     readonly centralRemotePreparation: "required";
 }>;
+/** Central provider which prepares its Security Seed within each transfer. */
+export declare const PROVIDER_OWNED_CENTRAL_REMOTE_REPLICATION_READINESS: Readonly<{
+    readonly centralRemotePreparation: "provider-owned";
+}>;
 /** Shared readiness contract for peer-to-peer providers without a central remote. */
 export declare const PEER_REPLICATION_READINESS: Readonly<{
     readonly centralRemotePreparation: "not-applicable";

package/dist/replication/ReplicatorProvider.js

@@ -25,6 +25,9 @@ const REPLICATION_CANCELLED = Object.freeze({ status: "cancelled" });
 const CENTRAL_REMOTE_REPLICATION_READINESS = Object.freeze({
   centralRemotePreparation: "required"
 });
+const PROVIDER_OWNED_CENTRAL_REMOTE_REPLICATION_READINESS = Object.freeze({
+  centralRemotePreparation: "provider-owned"
+});
 const PEER_REPLICATION_READINESS = Object.freeze({
   centralRemotePreparation: "not-applicable"
 });
@@ -131,6 +134,7 @@ export {
   CENTRAL_REMOTE_REPLICATION_READINESS,
   NO_INTERACTION,
   PEER_REPLICATION_READINESS,
+  PROVIDER_OWNED_CENTRAL_REMOTE_REPLICATION_READINESS,
   REPLICATION_CANCELLED,
   REPLICATION_COMPLETED,
   REPLICATION_PROGRESS_PRESENTATIONS,

package/dist/replication/SyncParamsHandler.d.ts

@@ -32,4 +32,6 @@ export declare class SyncParamsNotFoundError extends SyncParamsHandlerError {
 }
 export declare class SyncParamsUpdateError extends SyncParamsHandlerError {
 }
+/** Create a handler owned by one operation rather than the process-wide server cache. */
+export declare function createSyncParamsHandler({ put, get, create }: CreateSyncParamsHanderOptions): SyncParamsHandler;
 export {};

package/dist/replication/SyncParamsHandler.js

@@ -114,5 +114,6 @@ export {
   SyncParamsNotFoundError,
   SyncParamsUpdateError,
   clearHandlers,
-  createSyncParamsHanderForServer
+  createSyncParamsHanderForServer,
+  createSyncParamsHandler
 };

package/dist/replication/index.d.ts

@@ -1,4 +1,4 @@
-export { CAPABILITY_NOT_APPLICABLE, CAPABILITY_NOT_IMPLEMENTED, CENTRAL_REMOTE_REPLICATION_READINESS, NO_INTERACTION, PEER_REPLICATION_READINESS, REPLICATION_CANCELLED, REPLICATION_COMPLETED, REPLICATION_PROGRESS_PRESENTATIONS, USER_INITIATED_REPLICATION_AUTHORITY, defineReplicatorProviderDefinitions, isReplicationCompleted, outcomeFromContinuousOpenReplication, outcomeFromFiniteOpenReplication, replicationBlocked, replicationFailed, supportedOpenReplicationContinuous, supportedOpenReplicationOneShot, supportedOpenReplicationUnattended, supportedStopActiveTransfer, supportedCapability, } from "./ReplicatorProvider.js";
+export { CAPABILITY_NOT_APPLICABLE, CAPABILITY_NOT_IMPLEMENTED, CENTRAL_REMOTE_REPLICATION_READINESS, NO_INTERACTION, PEER_REPLICATION_READINESS, PROVIDER_OWNED_CENTRAL_REMOTE_REPLICATION_READINESS, REPLICATION_CANCELLED, REPLICATION_COMPLETED, REPLICATION_PROGRESS_PRESENTATIONS, USER_INITIATED_REPLICATION_AUTHORITY, defineReplicatorProviderDefinitions, isReplicationCompleted, outcomeFromContinuousOpenReplication, outcomeFromFiniteOpenReplication, replicationBlocked, replicationFailed, supportedOpenReplicationContinuous, supportedOpenReplicationOneShot, supportedOpenReplicationUnattended, supportedStopActiveTransfer, supportedCapability, } from "./ReplicatorProvider.js";
 export type { ReplicatorInstance } from "./ReplicatorInstance.js";
 export type { ActiveReplicatorContext, CapabilitySupport, ContinuousReplicationRequest, ContinuousReplicationTrigger, ContinuousRunner, InteractionAuthority, InteractionPermissions, NotApplicableCapability, NotImplementedCapability, NoInteraction, PermittedInteractionPermissions, ReplicationBlockReason, ReplicationAttemptFailure, ReplicationCancelled, ReplicationCompleted, ReplicationFailed, ReplicationInteraction, ReplicationOutcome, ReplicationProgressPresentation, ReplicationReadinessRequirements, ReplicationPartial, ReplicationFailureRequest, ReplicatorConfigurationIdentity, ReplicatorProviderDefinition, ReplicatorProviderDefinitionMap, StopActiveTransferRunner, SupportedCapability, UnattendedOneShotRequest, UnattendedReplicationTrigger, UnattendedOneShotRunner, UserInitiatedOneShotRequest, UserInitiatedReplicationAuthority, UserInitiatedOneShotRunner, } from "./ReplicatorProvider.js";
 export { CAPABILITY_SUPPORT_KINDS, CAPABILITY_UNAVAILABLE_REASONS } from "./ProviderCapability.js";

package/dist/replication/index.js

@@ -4,6 +4,7 @@ import {
   CENTRAL_REMOTE_REPLICATION_READINESS,
   NO_INTERACTION,
   PEER_REPLICATION_READINESS,
+  PROVIDER_OWNED_CENTRAL_REMOTE_REPLICATION_READINESS,
   REPLICATION_CANCELLED,
   REPLICATION_COMPLETED,
   REPLICATION_PROGRESS_PRESENTATIONS,
@@ -48,6 +49,7 @@ export {
   NO_INTERACTION,
   NO_REMOTE_RESOURCE_CAPABILITIES,
   PEER_REPLICATION_READINESS,
+  PROVIDER_OWNED_CENTRAL_REMOTE_REPLICATION_READINESS,
   REMOTE_RESOURCE_KINDS,
   REPLICATION_CANCELLED,
   REPLICATION_COMPLETED,

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

@@ -16,6 +16,7 @@ export declare class JournalSyncCore {
     env: LiveSyncJournalReplicatorEnv;
     store: SimpleStore<CheckPointInfo>;
     requestedStop: boolean;
+    private syncParamsHandler?;
     getInitialSyncParameters(): Promise<SyncParameters>;
     getSyncParameters(): Promise<SyncParameters>;
     putSyncParameters(params: SyncParameters): Promise<boolean>;
@@ -44,6 +45,7 @@ export declare class JournalSyncCore {
     resetBucket(): Promise<boolean>;
     getRemoteKey(): string;
     getReplicationPBKDF2Salt(refresh?: boolean): Promise<Uint8Array<ArrayBuffer>>;
+    private getSyncParamsHandler;
     isEncryptionPrevented(fileName: string): boolean;
     private decryptDataV2;
     private decryptDataV1;

package/dist/replication/journal/JournalSyncCore.js

@@ -22,8 +22,7 @@ import {
   JournalStorageReadStatuses
 } from "./objectstore/JournalStorageAdapter.js";
 import {
-  clearHandlers,
-  createSyncParamsHanderForServer,
+  createSyncParamsHandler,
   SyncParamsFetchError,
   SyncParamsNotFoundError,
   SyncParamsUpdateError
@@ -61,6 +60,7 @@ class JournalSyncCore {
   env;
   store;
   requestedStop = false;
+  syncParamsHandler;
   getInitialSyncParameters() {
     return Promise.resolve({
       ...DEFAULT_SYNC_PARAMETERS,
@@ -109,7 +109,6 @@ class JournalSyncCore {
     this.store = store;
     this.hash = this.getHash(settings);
     this.storage = storage;
-    clearHandlers();
   }
   async downloadJson(key) {
     try {
@@ -156,7 +155,7 @@ class JournalSyncCore {
     this.store = store;
     this.hash = this.getHash(settings);
     this.storage.applyNewConfig(settings);
-    clearHandlers();
+    this.resetAllCaches();
   }
   updateInfo(info) {
     const old = this.env.services.replicator.replicationStatics.value;
@@ -205,23 +204,18 @@ class JournalSyncCore {
     return this._currentCheckPointInfo;
   }
   resetAllCaches() {
-    clearHandlers();
+    this.syncParamsHandler = void 0;
   }
   async resetCheckpointInfo() {
     await this.updateCheckPointInfo((info) => ({ ...CheckPointInfoDefault }));
-    clearHandlers();
   }
   getJournalEpochFromSyncParams(params) {
     return `${params.protocolVersion}:${params.pbkdf2salt}`;
   }
   async ensureCheckpointCachesAreFresh() {
-    let journalEpoch = "";
-    try {
-      const params = await this.getSyncParameters();
-      journalEpoch = this.getJournalEpochFromSyncParams(params);
-    } catch {
-      return;
-    }
+    const params = await this.getSyncParamsHandler().fetch(true);
+    if (!params) throw new SyncParamsFetchError("Could not prepare Journal synchronisation parameters");
+    const journalEpoch = this.getJournalEpochFromSyncParams(params);
     const current = await this.getCheckpointInfo();
     if (current.journalEpoch === journalEpoch) {
       return;
@@ -252,12 +246,12 @@ class JournalSyncCore {
       receivedFiles: /* @__PURE__ */ new Set(),
       sentFiles: /* @__PURE__ */ new Set()
     }));
-    clearHandlers();
   }
   async isAvailable() {
     return await this.storage.isAvailable();
   }
   async resetBucket() {
+    this.resetAllCaches();
     let files = [];
     try {
       do {
@@ -269,7 +263,6 @@ class JournalSyncCore {
           return false;
         }
       } while (files.length != 0);
-      clearHandlers();
     } catch (ex) {
       Logger(`WARNING! Could not delete files.`, LOG_LEVEL_NOTICE, "reset-bucket");
       Logger(ex, LOG_LEVEL_VERBOSE);
@@ -291,13 +284,14 @@ class JournalSyncCore {
     return this.getHash(this._settings);
   }
   async getReplicationPBKDF2Salt(refresh) {
-    const server = this.getRemoteKey();
-    const manager = createSyncParamsHanderForServer(server, {
+    return await this.getSyncParamsHandler().getPBKDF2Salt(refresh);
+  }
+  getSyncParamsHandler() {
+    return this.syncParamsHandler ??= createSyncParamsHandler({
       put: (params) => this.putSyncParameters(params),
       get: () => this.getSyncParameters(),
       create: () => this.getInitialSyncParameters()
     });
-    return await manager.getPBKDF2Salt(refresh);
   }
   isEncryptionPrevented(fileName) {
     if (fileName.endsWith(DOCID_JOURNAL_SYNC_PARAMETERS)) return true;
@@ -762,6 +756,7 @@ class JournalSyncCore {
   /** Stop this Journal operation owner and release its storage transport. */
   dispose() {
     this.requestStop();
+    this.resetAllCaches();
     this.storage.dispose?.();
   }
 }

package/dist/replication/journal/LiveSyncJournalReplicator.js

@@ -12,7 +12,6 @@ import { MinioStorageAdapter } from "./objectstore/MinioStorageAdapter.js";
 import { LiveSyncAbstractReplicator } from "../LiveSyncAbstractReplicator.js";
 import { ensureRemoteIsCompatible } from "../../pouchdb/LiveSyncDBFunctions.js";
 import { extractObject } from "../../common/utils.js";
-import { clearHandlers } from "../SyncParamsHandler.js";
 import { JournalStorageReadStatuses } from "./objectstore/JournalStorageAdapter.js";
 import {
   CENTRAL_COMPATIBILITY_ACCEPTED,
@@ -154,20 +153,24 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
   async openReplication(setting, _, showResult, ignoreCleanLock = false, recordCompatibilityDecision) {
     return await this.runJournalTransfer(async (stopGeneration) => {
       const client = this.setupJournalSyncClient(setting);
-      stopGeneration = this.journalTransferStopGeneration;
-      if (!await this.checkReplicationConnectivity(
-        false,
-        ignoreCleanLock,
-        showResult,
-        setting,
-        client,
-        recordCompatibilityDecision
-      )) {
-        return false;
+      try {
+        stopGeneration = this.journalTransferStopGeneration;
+        if (!await this.checkReplicationConnectivity(
+          false,
+          ignoreCleanLock,
+          showResult,
+          setting,
+          client,
+          recordCompatibilityDecision
+        )) {
+          return false;
+        }
+        if (stopGeneration !== this.journalTransferStopGeneration) return false;
+        this.hasEnteredReplication = true;
+        return await client.sync(showResult);
+      } finally {
+        client.resetAllCaches();
       }
-      if (stopGeneration !== this.journalTransferStopGeneration) return false;
-      this.hasEnteredReplication = true;
-      return await client.sync(showResult);
     });
   }
   /**
@@ -191,20 +194,24 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
   async runDirectionalReplication(setting, showingNotice, transfer, recordCompatibilityDecision) {
     return await this.runJournalTransfer(async (stopGeneration) => {
       const client = this.setupJournalSyncClient(setting);
-      stopGeneration = this.journalTransferStopGeneration;
-      if (!await this.checkReplicationConnectivity(
-        false,
-        false,
-        !!showingNotice,
-        setting,
-        client,
-        recordCompatibilityDecision
-      )) {
-        return false;
+      try {
+        stopGeneration = this.journalTransferStopGeneration;
+        if (!await this.checkReplicationConnectivity(
+          false,
+          false,
+          !!showingNotice,
+          setting,
+          client,
+          recordCompatibilityDecision
+        )) {
+          return false;
+        }
+        if (stopGeneration !== this.journalTransferStopGeneration) return false;
+        this.hasEnteredReplication = true;
+        return await transfer(client);
+      } finally {
+        client.resetAllCaches();
       }
-      if (stopGeneration !== this.journalTransferStopGeneration) return false;
-      this.hasEnteredReplication = true;
-      return await transfer(client);
     });
   }
   /** Capture only the compatibility decision made by this exact borrowed client. */
@@ -344,7 +351,6 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
       if (!await this.client.resetBucket()) {
         throw new Error("Could not reset remote bucket");
       }
-      clearHandlers();
       Logger("Remote Bucket Cleared", LOG_LEVEL_NOTICE);
       await this.tryCreateRemoteDatabase(setting);
     } catch (ex) {
@@ -356,7 +362,6 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
   async tryCreateRemoteDatabase(setting) {
     this.closeReplication();
     Logger("Remote Database Created or Connected", LOG_LEVEL_NOTICE);
-    clearHandlers();
     if (!await this.ensurePBKDF2Salt(setting, true, false)) {
       throw new Error("Could not ensure PBKDF2 salt (Security Seed)");
     }