@vrtmrz/livesync-commonlib 0.1.0-rc.0 → 0.1.0-rc.10

package/dist/serviceFeatures/checkRemoteSize.js

@@ -2,7 +2,17 @@ import { sizeToHumanReadable } from "octagonal-wheels/number";
 import { LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "../common/types.js";
 import { createInstanceLogFunction } from "../services/lib/logUtils.js";
 import { EVENT_REQUEST_CHECK_REMOTE_SIZE } from "../events/coreEvents.js";
-function onNotifyRemoteSizeNotConfiguredFactory(host, log) {
+import { fireAndForget } from "../common/utils.js";
+const REMOTE_SIZE_NOTICE_DURATION_MS = 5 * 60 * 1e3;
+function configureReviewAnchor(anchor, label, review) {
+  anchor.href = "#";
+  anchor.textContent = label;
+  anchor.addEventListener("click", (event) => {
+    event.preventDefault();
+    fireAndForget(review);
+  });
+}
+function onNotifyRemoteSizeNotConfiguredFactory(host, log, mode = "notice") {
   return async () => {
     const translate = host.services.context.translate;
     log(translate("moduleCheckRemoteSize.logCheckingStorageSizes"), LOG_LEVEL_VERBOSE);
@@ -15,13 +25,25 @@ function onNotifyRemoteSizeNotConfiguredFactory(host, log) {
     const ANSWER_800 = translate("moduleCheckRemoteSize.option800MB");
     const ANSWER_2000 = translate("moduleCheckRemoteSize.option2GB");
     const ASK_ME_NEXT_TIME = translate("moduleCheckRemoteSize.optionAskMeLater");
+    if (mode === "notice") {
+      host.services.API.confirm.askInPopup(
+        "remote-size-not-configured",
+        translate("moduleCheckRemoteSize.noticeNotConfigured"),
+        (anchor) => configureReviewAnchor(
+          anchor,
+          translate("moduleCheckRemoteSize.optionReview"),
+          () => onNotifyRemoteSizeNotConfiguredFactory(host, log, "dialogue")()
+        ),
+        REMOTE_SIZE_NOTICE_DURATION_MS
+      );
+      return true;
+    }
     const ret = await host.services.API.confirm.askSelectStringDialogue(
       message,
       [ANSWER_0, ANSWER_800, ANSWER_2000, ASK_ME_NEXT_TIME],
       {
         defaultAction: ASK_ME_NEXT_TIME,
-        title: translate("moduleCheckRemoteSize.titleDatabaseSizeNotify"),
-        timeout: 40
+        title: translate("moduleCheckRemoteSize.titleDatabaseSizeNotify")
       }
     );
     if (ret == ANSWER_0) {
@@ -49,7 +71,7 @@ function onNotifyRemoteSizeNotConfiguredFactory(host, log) {
     return true;
   };
 }
-function onNotifyRemoteSizeExceedFactory(host, log) {
+function onNotifyRemoteSizeExceedFactory(host, log, mode = "notice") {
   return async () => {
     const translate = host.services.context.translate;
     const settings = host.services.setting.currentSettings();
@@ -89,13 +111,28 @@ function onNotifyRemoteSizeExceedFactory(host, log) {
       });
       const ANSWER_REBUILD = translate("moduleCheckRemoteSize.optionRebuildAll");
       const ANSWER_IGNORE = translate("moduleCheckRemoteSize.optionDismiss");
+      if (mode === "notice") {
+        host.services.API.confirm.askInPopup(
+          "remote-size-exceeded",
+          translate("moduleCheckRemoteSize.noticeExceeded", {
+            measuredSize: sizeToHumanReadable(estimatedSize),
+            notifySize: sizeToHumanReadable(maxSize)
+          }),
+          (anchor) => configureReviewAnchor(
+            anchor,
+            translate("moduleCheckRemoteSize.optionReview"),
+            () => onNotifyRemoteSizeExceedFactory(host, log, "dialogue")()
+          ),
+          REMOTE_SIZE_NOTICE_DURATION_MS
+        );
+        return true;
+      }
       const ret = await host.services.API.confirm.askSelectStringDialogue(
         message,
         [ANSWER_ENLARGE_LIMIT, ANSWER_REBUILD, ANSWER_IGNORE],
         {
           defaultAction: ANSWER_IGNORE,
-          title: translate("moduleCheckRemoteSize.titleDatabaseSizeLimitExceeded"),
-          timeout: 60
+          title: translate("moduleCheckRemoteSize.titleDatabaseSizeLimitExceeded")
         }
       );
       if (ret == ANSWER_REBUILD) {
@@ -142,7 +179,7 @@ function onNotifyRemoteSizeExceedFactory(host, log) {
     return true;
   };
 }
-async function scanAllStat(host, log, resetThreshold = false) {
+async function scanAllStat(host, log, resetThreshold = false, mode = "notice") {
   if (resetThreshold) {
     await host.services.setting.applyPartial(
       {
@@ -151,8 +188,8 @@ async function scanAllStat(host, log, resetThreshold = false) {
       true
     );
   }
-  const onNotifyNotConfigured = onNotifyRemoteSizeNotConfiguredFactory(host, log);
-  const onNotifyExceed = onNotifyRemoteSizeExceedFactory(host, log);
+  const onNotifyNotConfigured = onNotifyRemoteSizeNotConfiguredFactory(host, log, mode);
+  const onNotifyExceed = onNotifyRemoteSizeExceedFactory(host, log, mode);
   return await onNotifyNotConfigured() && await onNotifyExceed();
 }
 function useCheckRemoteSize(host) {
@@ -163,10 +200,13 @@ function useCheckRemoteSize(host) {
       id: "livesync-reset-remote-size-threshold-and-check",
       name: "Reset notification threshold and check the remote database usage",
       callback: async () => {
-        await scanAllStat(host, log, true);
+        await scanAllStat(host, log, true, "dialogue");
       }
     });
-    host.services.context.events.onEvent(EVENT_REQUEST_CHECK_REMOTE_SIZE, () => scanAllStat(host, log, true));
+    host.services.context.events.onEvent(
+      EVENT_REQUEST_CHECK_REMOTE_SIZE,
+      () => scanAllStat(host, log, true, "dialogue")
+    );
     return Promise.resolve(true);
   });
 }

package/dist/serviceFeatures/remoteConfig.d.ts

@@ -1,5 +1,6 @@
 import { type LOG_LEVEL } from "../common/logger.js";
-import type { ObsidianLiveSyncSettings } from "../common/models/setting.type.js";
+import { type RemoteConfigurationResult } from "../common/ConnectionString.js";
+import type { ObsidianLiveSyncSettings, RemoteConfiguration } from "../common/models/setting.type.js";
 import type { NecessaryServices } from "../interfaces/ServiceModule.js";
 export type RemoteConfigHost = NecessaryServices<"setting" | "UI" | "replication" | "control" | "appLifecycle" | "API", never>;
 export declare function migrateLegacyRemoteConfigurationsInPlace(settings: ObsidianLiveSyncSettings, log?: (message: string, level?: LOG_LEVEL) => void): boolean;
@@ -8,6 +9,41 @@ export declare function migrateLegacyRemoteConfigurationsInPlace(settings: Obsid
  * @returns A unique string identifier.
  */
 export declare function createRemoteConfigurationId(): string;
+export type SerializableRemoteConfigurationType = Exclude<RemoteConfigurationResult["type"], "webdav">;
+export interface UpsertRemoteConfigurationOptions {
+    /**
+     * Reuse this identifier to update a known profile. Omit it to allocate a new opaque identifier.
+     */
+    id?: string;
+    /**
+     * User-visible name. Omit it to derive a descriptive name from the connection settings.
+     */
+    name?: string;
+    /**
+     * Select this profile as the main remote and project it onto the compatibility fields.
+     */
+    activate?: boolean;
+    /**
+     * Select this profile for P2P features without changing the main remote selection.
+     */
+    activateForP2P?: boolean;
+}
+/**
+ * Suggest a concise display name from a serialisable remote configuration.
+ *
+ * The name is presentation only. Callers must continue to use the profile ID for identity and
+ * `activeConfigurationId` for the selected main remote.
+ */
+export declare function suggestRemoteConfigurationName(configuration: RemoteConfigurationResult): string;
+/**
+ * Create or update a multiple-remote profile from the corresponding compatibility fields.
+ *
+ * This mutates `settings`. Passing an existing `id` intentionally replaces that profile; omitting
+ * it always allocates a new opaque ID and preserves all existing profiles. Generated display names
+ * are made unique for readability, but names never act as identifiers. The stored connection URI is
+ * plaintext at this boundary; `SettingService` applies configured at-rest encryption when saving it.
+ */
+export declare function upsertRemoteConfigurationInPlace(settings: ObsidianLiveSyncSettings, type: SerializableRemoteConfigurationType, options?: UpsertRemoteConfigurationOptions): RemoteConfiguration;
 /**
  * Keep compatibility for users who were already using P2P as their main active remote.
  */

package/dist/serviceFeatures/remoteConfig.js

@@ -51,6 +51,94 @@ function migrateLegacyRemoteConfigurationsInPlace(settings, log) {
 function createRemoteConfigurationId() {
   return `remote-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 }
+function toRemoteConfigurationResult(type, settings) {
+  if (type === "couchdb") {
+    return { type, settings };
+  }
+  if (type === "s3") {
+    return { type, settings };
+  }
+  return { type, settings };
+}
+function suggestRemoteConfigurationName(configuration) {
+  if (configuration.type === "couchdb") {
+    try {
+      const host = new URL(configuration.settings.couchDB_URI).host;
+      return host ? `CouchDB ${host}` : "CouchDB remote";
+    } catch {
+      return "CouchDB remote";
+    }
+  }
+  if (configuration.type === "s3") {
+    const bucket = configuration.settings.bucket.trim();
+    if (bucket) {
+      return `S3 ${bucket}`;
+    }
+    try {
+      const host = new URL(configuration.settings.endpoint).host;
+      return host ? `S3 ${host}` : "Object Storage remote";
+    } catch {
+      return "Object Storage remote";
+    }
+  }
+  if (configuration.type === "p2p") {
+    const room = configuration.settings.P2P_roomID.trim();
+    return room ? `P2P ${room}` : "P2P remote";
+  }
+  return "Remote configuration";
+}
+function allocateRemoteConfigurationId(configurations) {
+  let id = createRemoteConfigurationId();
+  while (configurations[id]) {
+    id = createRemoteConfigurationId();
+  }
+  return id;
+}
+function allocateRemoteConfigurationName(configurations, baseName, updatingId) {
+  const usedNames = new Set(
+    Object.values(configurations).filter((configuration) => configuration.id !== updatingId).map((configuration) => configuration.name)
+  );
+  if (!usedNames.has(baseName)) {
+    return baseName;
+  }
+  let suffix = 2;
+  while (usedNames.has(`${baseName} (${suffix})`)) {
+    suffix += 1;
+  }
+  return `${baseName} (${suffix})`;
+}
+function upsertRemoteConfigurationInPlace(settings, type, options = {}) {
+  if (options.activateForP2P && type !== "p2p") {
+    throw new Error("Only a P2P remote configuration can be selected for P2P features.");
+  }
+  const configurations = settings.remoteConfigurations ?? {};
+  const requestedId = options.id?.trim();
+  const id = requestedId || allocateRemoteConfigurationId(configurations);
+  const existing = configurations[id];
+  const serialisable = toRemoteConfigurationResult(type, settings);
+  const suggestedName = suggestRemoteConfigurationName(serialisable);
+  const requestedName = options.name?.trim();
+  const name = requestedName || existing?.name || allocateRemoteConfigurationName(configurations, suggestedName, existing?.id);
+  const configuration = {
+    id,
+    name,
+    uri: ConnectionStringParser.serialize(serialisable),
+    isEncrypted: false
+  };
+  settings.remoteConfigurations ??= configurations;
+  configurations[id] = configuration;
+  if (options.activate) {
+    if (!activateRemoteConfiguration(settings, id)) {
+      throw new Error(`Failed to activate remote configuration '${id}'.`);
+    }
+  }
+  if (options.activateForP2P) {
+    if (!activateP2PRemoteConfiguration(settings, id)) {
+      throw new Error(`Failed to activate P2P remote configuration '${id}'.`);
+    }
+  }
+  return configuration;
+}
 function migrateP2PActiveRemoteConfigurationIdInPlace(settings) {
   if ((settings.P2P_ActiveRemoteConfigurationId ?? "").trim() !== "") {
     return false;
@@ -242,6 +330,8 @@ export {
   migrateLegacyRemoteConfigurationsInPlace,
   migrateP2PActiveRemoteConfigurationIdInPlace,
   migrateToMultipleRemoteConfigurations,
+  suggestRemoteConfigurationName,
+  upsertRemoteConfigurationInPlace,
   useRemoteConfiguration,
   useRemoteConfigurationMigration
 };

package/dist/serviceModules/Rebuilder.d.ts

@@ -48,10 +48,6 @@ export declare class ServiceRebuilder extends ServiceModuleBase<ServiceRebuilder
     constructor(services: ServiceRebuilderDependencies);
     $performRebuildDB(method: "localOnly" | "remoteOnly" | "rebuildBothByThisDevice" | "localOnlyWithChunks"): Promise<void>;
     informOptionalFeatures(): Promise<void>;
-    askUsingOptionalFeature(opt: {
-        enableFetch?: boolean;
-        enableOverwrite?: boolean;
-    }): Promise<void>;
     rebuildRemote(): Promise<void>;
     private performRemoteRebuild;
     $rebuildRemote(): Promise<void>;
@@ -60,8 +56,9 @@ export declare class ServiceRebuilder extends ServiceModuleBase<ServiceRebuilder
     $rebuildEverything(): Promise<void>;
     $fetchLocal(makeLocalChunkBeforeSync?: boolean, preventMakeLocalFilesBeforeSync?: boolean): Promise<void>;
     $fetchLocalDBFast(autoResume: boolean): Promise<void>;
-    scheduleRebuild(): Promise<void>;
-    scheduleFetch(): Promise<void>;
+    private scheduleInitialisation;
+    scheduleRebuild(prepareBeforeRestart?: () => Promise<void>): Promise<boolean>;
+    scheduleFetch(prepareBeforeRestart?: () => Promise<void>): Promise<boolean>;
     private _tryResetRemoteDatabase;
     private _onResetLocalDatabase;
     suspendAllSync(): Promise<void>;

package/dist/serviceModules/Rebuilder.js

@@ -1,5 +1,5 @@
 import { FlagFilesHumanReadable } from "../common/models/redflag.const.js";
-import { REMOTE_COUCHDB, REMOTE_MINIO } from "../common/models/setting.const.js";
+import { REMOTE_COUCHDB, REMOTE_MINIO, REMOTE_P2P } from "../common/models/setting.const.js";
 import { DEFAULT_SETTINGS } from "../common/models/setting.const.defaults.js";
 import { LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
 import { delay } from "octagonal-wheels/promises";
@@ -67,14 +67,6 @@ Please enable them from the settings screen after setup is complete.`,
       ["OK"]
     );
   }
-  async askUsingOptionalFeature(opt) {
-    if (await this.UI.confirm.askYesNoDialog(
-      "Do you want to enable extra features? If you are new to Self-hosted LiveSync, try the core feature first!",
-      { title: "Enable extra features", defaultOption: "No", timeout: 15 }
-    ) == "yes") {
-      await this.setting.suggestOptionalFeatures(opt);
-    }
-  }
   async rebuildRemote() {
     await this.replicator.runBoundedRemoteActivity(() => this.performRemoteRebuild(), {
       label: "rebuild-remote"
@@ -95,7 +87,7 @@ Please enable them from the settings screen after setup is complete.`,
     await delay(1e3);
     await this.replication.replicateAllToRemote(true);
     await delay(1e3);
-    await this.replication.replicateAllToRemote(true, true);
+    await this.replication.replicateAllToRemote(true);
   }
   $rebuildRemote() {
     return this.rebuildRemote();
@@ -116,6 +108,9 @@ Please enable them from the settings screen after setup is complete.`,
     await this.resetLocalDatabase();
     await delay(1e3);
     await this.databaseEvents.initialiseDatabase(true, true, true);
+    if (this.setting.currentSettings().remoteType === REMOTE_P2P) {
+      return;
+    }
     await this.replication.markLocked();
     await this._tryResetRemoteDatabase();
     await this.replication.markLocked();
@@ -123,7 +118,7 @@ Please enable them from the settings screen after setup is complete.`,
     await delay(1e3);
     await this.replication.replicateAllToRemote(true);
     await delay(1e3);
-    await this.replication.replicateAllToRemote(true, true);
+    await this.replication.replicateAllToRemote(true);
   }
   $rebuildEverything() {
     return this.rebuildEverything();
@@ -134,23 +129,35 @@ Please enable them from the settings screen after setup is complete.`,
   $fetchLocalDBFast(autoResume) {
     return this.fetchLocalDBFast(autoResume);
   }
-  async scheduleRebuild() {
+  async scheduleInitialisation(flag, prepareBeforeRestart) {
     try {
-      await this.storageAccess.writeFileAuto(FlagFilesHumanReadable.REBUILD_ALL, "");
+      await this.storageAccess.writeFileAuto(flag, "");
     } catch (ex) {
-      this._log(`Could not create ${FlagFilesHumanReadable.REBUILD_ALL}`, LOG_LEVEL_NOTICE);
+      this._log(`Could not create ${flag}`, LOG_LEVEL_NOTICE);
       this._log(ex, LOG_LEVEL_VERBOSE);
+      return false;
     }
-    this.appLifecycle.performRestart();
-  }
-  async scheduleFetch() {
+    this.appLifecycle.setSuspended(true);
     try {
-      await this.storageAccess.writeFileAuto(FlagFilesHumanReadable.FETCH_ALL, "");
+      await prepareBeforeRestart?.();
     } catch (ex) {
-      this._log(`Could not create ${FlagFilesHumanReadable.FETCH_ALL}`, LOG_LEVEL_NOTICE);
-      this._log(ex, LOG_LEVEL_VERBOSE);
+      try {
+        await this.storageAccess.delete(flag, true);
+      } catch (cleanupError) {
+        this._log(`Could not remove ${flag} after restart preparation failed`, LOG_LEVEL_NOTICE);
+        this._log(cleanupError, LOG_LEVEL_VERBOSE);
+      }
+      this.appLifecycle.setSuspended(false);
+      throw ex;
     }
     this.appLifecycle.performRestart();
+    return true;
+  }
+  scheduleRebuild(prepareBeforeRestart) {
+    return this.scheduleInitialisation(FlagFilesHumanReadable.REBUILD_ALL, prepareBeforeRestart);
+  }
+  scheduleFetch(prepareBeforeRestart) {
+    return this.scheduleInitialisation(FlagFilesHumanReadable.FETCH_ALL, prepareBeforeRestart);
   }
   async _tryResetRemoteDatabase() {
     const currentReplicator = this.replicator.getActiveReplicator();
@@ -269,8 +276,10 @@ Are you sure you wish to proceed?`;
     await this.replication.markResolved();
     await delay(500);
     await this.replication.replicateAllFromRemote(true);
-    await delay(1e3);
-    await this.replication.replicateAllFromRemote(true);
+    if (this.setting.currentSettings().remoteType !== REMOTE_P2P) {
+      await delay(1e3);
+      await this.replication.replicateAllFromRemote(true);
+    }
     if (autoResume) {
       await this.finishRebuild();
     }

package/dist/serviceModules/ServiceDatabaseFileAccessBase.d.ts

@@ -26,10 +26,15 @@ export declare class ServiceDatabaseFileAccessBase extends ServiceModuleBase<Ser
     delete(file: UXFileInfoStub | FilePathWithPrefix, rev?: string): Promise<boolean>;
     createChunks(file: UXFileInfo, force?: boolean, skipCheck?: boolean): Promise<boolean>;
     store(file: UXFileInfo, force?: boolean, skipCheck?: boolean): Promise<boolean>;
+    storeWithBaseRevision(file: UXFileInfo, baseRevision: string | undefined, skipCheck?: boolean): Promise<string | false>;
     storeAsConflictedRevision(file: UXFileInfo, currentRev: string, skipCheck?: boolean): Promise<boolean>;
+    storeAsConflictedRevisionWithResult(file: UXFileInfo, currentRev: string, skipCheck?: boolean): Promise<string | false>;
+    storeDeletionWithBaseRevision(file: UXFileInfoStub | FilePathWithPrefix, baseRevision: string): Promise<string | false>;
     storeContent(path: FilePathWithPrefix, content: string): Promise<boolean>;
     private __store;
     private getParentRev;
+    private findContentRevisionsInternal;
+    findContentRevisions(file: UXFileInfoStub | FilePathWithPrefix, content: string | string[] | Blob | ArrayBuffer, currentRev?: string): Promise<string[]>;
     hasContentInRevisionHistory(file: UXFileInfoStub | FilePathWithPrefix, content: string | string[] | Blob | ArrayBuffer, currentRev?: string): Promise<boolean>;
     getConflictedRevs(file: UXFileInfoStub | FilePathWithPrefix): Promise<string[]>;
     fetch(file: UXFileInfoStub | FilePathWithPrefix, rev?: string, waitForReady?: boolean, skipCheck?: boolean): Promise<UXFileInfo | false>;

package/dist/serviceModules/ServiceDatabaseFileAccessBase.js

@@ -47,18 +47,37 @@ class ServiceDatabaseFileAccessBase extends ServiceModuleBase {
     }
   }
   async createChunks(file, force = false, skipCheck) {
-    return await this.__store(file, force, skipCheck, true);
+    return await this.__store(file, force, skipCheck, true) !== false;
   }
   async store(file, force = false, skipCheck) {
-    return await this.__store(file, force, skipCheck, false);
+    return await this.__store(file, force, skipCheck, false) !== false;
+  }
+  async storeWithBaseRevision(file, baseRevision, skipCheck) {
+    const result = await this.__store(file, true, skipCheck, false, baseRevision);
+    return result !== null && typeof result === "object" && "rev" in result ? result.rev : false;
   }
   async storeAsConflictedRevision(file, currentRev, skipCheck) {
+    return await this.storeAsConflictedRevisionWithResult(file, currentRev, skipCheck) !== false;
+  }
+  async storeAsConflictedRevisionWithResult(file, currentRev, skipCheck) {
     const conflictBaseRev = await this.getParentRev(file, currentRev);
     if (!conflictBaseRev) {
       this._log(`Could not find parent revision for ${file.path} (${currentRev})`, LOG_LEVEL_VERBOSE);
       return false;
     }
-    return await this.__store(file, true, skipCheck, false, conflictBaseRev);
+    return await this.storeWithBaseRevision(file, conflictBaseRev, skipCheck);
+  }
+  async storeDeletionWithBaseRevision(file, baseRevision) {
+    if (!await this.checkIsTargetFile(file)) {
+      return false;
+    }
+    const fullPath = getDatabasePathFromUXFileInfo(file);
+    const result = await this.database.localDatabase.storeDeletionAtRevision(fullPath, baseRevision);
+    if (result === false) {
+      return false;
+    }
+    this.events.emitEvent(EVENT_FILE_SAVED);
+    return result.rev;
   }
   async storeContent(path, content) {
     const blob = createTextBlob(content);
@@ -76,7 +95,7 @@ class ServiceDatabaseFileAccessBase extends ServiceModuleBase {
       body: blob,
       isInternal
     };
-    return await this.__store(dummyUXFileInfo, true, false, false);
+    return await this.__store(dummyUXFileInfo, true, false, false) !== false;
   }
   async __store(file, force = false, skipCheck, onlyChunks, conflictBaseRev) {
     if (!skipCheck) {
@@ -169,7 +188,7 @@ class ServiceDatabaseFileAccessBase extends ServiceModuleBase {
       this._log(msg + fullPath);
       this.events.emitEvent(EVENT_FILE_SAVED);
     }
-    return ret != false;
+    return ret;
   }
   async getParentRev(file, rev) {
     const filename = getDatabasePathFromUXFileInfo(file);
@@ -189,10 +208,7 @@ class ServiceDatabaseFileAccessBase extends ServiceModuleBase {
       return false;
     }
   }
-  async hasContentInRevisionHistory(file, content, currentRev) {
-    if (!await this.checkIsTargetFile(file)) {
-      return true;
-    }
+  async findContentRevisionsInternal(file, content, currentRev) {
     const filename = getDatabasePathFromUXFileInfo(file);
     try {
       const doc = await this.database.localDatabase.getDBEntryMeta(
@@ -201,24 +217,64 @@ class ServiceDatabaseFileAccessBase extends ServiceModuleBase {
         true
       );
       if (doc === false) {
-        return false;
+        return [];
       }
       const revisions = doc._revs_info;
       const availableRevs = new Set((revisions || []).filter((e) => e.status === "available").map((e) => e.rev));
       if (currentRev) {
         availableRevs.add(currentRev);
       }
+      const leaves = await this.database.localDatabase.getRaw(doc._id, {
+        open_revs: "all"
+      });
+      if (!Array.isArray(leaves)) {
+        return [];
+      }
+      for (const leaf of leaves) {
+        const leafRev = leaf.ok?._rev;
+        if (!leafRev) {
+          continue;
+        }
+        const branch = await this.database.localDatabase.getDBEntryMeta(
+          filename,
+          { rev: leafRev, revs_info: true },
+          true
+        );
+        if (branch === false) {
+          continue;
+        }
+        const branchRevisions = branch._revs_info;
+        for (const revision of branchRevisions || []) {
+          if (revision.status === "available") {
+            availableRevs.add(revision.rev);
+          }
+        }
+      }
+      const matchingRevisions = [];
       for (const rev of availableRevs) {
         const entry = await this.database.localDatabase.getDBEntry(filename, { rev }, false, true, true);
-        if (entry !== false && await isDocContentSame(readContent(entry), content)) {
-          return true;
+        if (entry !== false && !entry._deleted && await isDocContentSame(readContent(entry), content)) {
+          matchingRevisions.push(rev);
         }
       }
+      return matchingRevisions;
     } catch (ex) {
       this._log(`Could not check revision history for ${filename}`, LOG_LEVEL_VERBOSE);
       this._log(ex, LOG_LEVEL_VERBOSE);
     }
-    return false;
+    return [];
+  }
+  async findContentRevisions(file, content, currentRev) {
+    if (!await this.checkIsTargetFile(file)) {
+      return [];
+    }
+    return await this.findContentRevisionsInternal(file, content, currentRev);
+  }
+  async hasContentInRevisionHistory(file, content, currentRev) {
+    if (!await this.checkIsTargetFile(file)) {
+      return true;
+    }
+    return (await this.findContentRevisionsInternal(file, content, currentRev)).length > 0;
   }
   async getConflictedRevs(file) {
     if (!await this.checkIsTargetFile(file)) {

package/dist/serviceModules/ServiceFileHandlerBase.d.ts

@@ -11,6 +11,7 @@ import type { ConflictService } from "../services/base/ConflictService.js";
 import type { PathService } from "../services/base/PathService.js";
 import type { SettingService } from "../services/base/SettingService.js";
 import type { VaultService } from "../services/base/VaultService.js";
+import type { FileReflectionProvenance } from "../interfaces/FileReflectionProvenance.js";
 export interface ServiceFileHandlerDependencies {
     events: LiveSyncEventHub;
     API: APIService;
@@ -22,6 +23,17 @@ export interface ServiceFileHandlerDependencies {
     path: PathService;
     setting: SettingService;
     vault: VaultService;
+    /**
+     * Device-local record of the exact database revision reflected in storage.
+     *
+     * This is optional for compatibility hosts. Maintained hosts should provide
+     * it so edits made while a document is conflicted extend the displayed
+     * branch instead of whichever branch PouchDB currently selects as winner.
+     * The host must finish opening its backing store before it dispatches file
+     * or replication events; provenance does not hide lifecycle violations by
+     * waiting for readiness.
+     */
+    fileReflectionProvenance?: FileReflectionProvenance;
 }
 export declare abstract class ServiceFileHandlerBase extends ServiceModuleBase<ServiceFileHandlerDependencies> implements IFileHandler {
     private events;
@@ -31,20 +43,28 @@ export declare abstract class ServiceFileHandlerBase extends ServiceModuleBase<S
     private path;
     private setting;
     private vault;
+    private fileReflectionProvenance?;
     constructor(services: ServiceFileHandlerDependencies);
     get db(): DatabaseFileAccess;
     get storage(): StorageAccess;
+    private getProvenance;
+    private setProvenance;
+    private deleteProvenance;
+    private findUniqueContentRevision;
+    private getProvenBaseRevision;
     getPath(entry: AnyEntry): FilePathWithPrefix;
     getPathWithoutPrefix(entry: AnyEntry): FilePathWithPrefix;
     readFileFromStub(file: UXFileInfoStub | UXFileInfo): Promise<UXFileInfo>;
     private infoToStub;
     storeFileToDB(info: UXFileInfoStub | UXFileInfo | UXInternalFileInfoStub | FilePathWithPrefix, force?: boolean, onlyChunks?: boolean): Promise<boolean>;
+    private storeFileToDBFromRevision;
     deleteFileFromDB(info: UXFileInfoStub | UXInternalFileInfoStub | FilePath): Promise<boolean>;
     renameFileInDB(info: UXFileInfoStub | UXFileInfo, oldPath: FilePath | FilePathWithPrefix): Promise<boolean>;
     deleteRevisionFromDB(info: UXFileInfoStub | FilePath | FilePathWithPrefix, rev: string): Promise<boolean | undefined>;
     resolveConflictedByDeletingRevision(info: UXFileInfoStub | FilePath, rev: string): Promise<boolean | undefined>;
     dbToStorageWithSpecificRev(info: UXFileInfoStub | UXFileInfo | FilePath | null, rev: string, force?: boolean): Promise<boolean>;
     dbToStorage(entryInfo: MetaEntry | FilePathWithPrefix, info: UXFileInfoStub | UXFileInfo | FilePath | null, force?: boolean): Promise<boolean>;
+    private applyDatabaseEntryToStorage;
     private preserveUnsyncedStorageAsConflict;
     private _anyHandlerProcessesFileEvent;
     _anyProcessReplicatedDoc(entry: MetaEntry): Promise<boolean>;