@vrtmrz/livesync-commonlib 0.1.44 → 0.2.1

package/dist/serviceModules/Rebuilder.js

@@ -404,7 +404,7 @@ Are you sure you wish to proceed?`;
     await this.suspendReflectingDatabase(!autoResume);
     await this.control.applySettings();
     await this.resetLocalDatabase();
-    this.clearFastFetchCheckpoint();
+    await this.clearFastFetchCheckpoint();
     await delay(1e3);
     if (isRemediationModeActive(this.setting.currentSettings())) {
       this._log(
@@ -470,10 +470,11 @@ Are you sure you wish to proceed?`;
     await this.checkPathIdentitiesBeforeReconstruction(false);
     await checkRemoteFeaturesForInitialSync(remote, authHeader, customHeaders, settings);
     this.appLifecycle.resetIsReady();
-    let checkpoint = this.getFastFetchCheckpoint(remote);
+    let checkpoint = await this.getFastFetchCheckpoint(remote);
     await this.suspendReflectingDatabase();
     await this.control.applySettings();
     let since = checkpoint?.sequence ?? "0";
+    let startsFresh = !checkpoint;
     if (checkpoint) {
       this._log(
         `Resuming fast database fetch from sequence: ${checkpoint.sequence}`,
@@ -497,16 +498,19 @@ Are you sure you wish to proceed?`;
         LOG_LEVEL_NOTICE,
         "fetch-init-resume"
       );
-      this.clearFastFetchCheckpoint();
+      await this.clearFastFetchCheckpoint();
       await this.resetLocalDatabase();
       await delay(1e3);
       localDB = this.database.localDatabase.localDatabase;
       since = "0";
+      startsFresh = true;
     }
     const securitySeed = await this.replicator.createRemoteResource(REMOTE_RESOURCE_KINDS.SECURITY_SEED, settings);
     if (!securitySeed) {
       throw new Error("The selected provider cannot supply a Security Seed for Fast Fetch.");
     }
+    let fastForwardResource;
+    let fastForward;
     try {
       const enc = getConfiguredFunctionsForEncryption(
         settings.passphrase,
@@ -515,6 +519,13 @@ Are you sure you wish to proceed?`;
         () => securitySeed.read(),
         settings.E2EEAlgorithm
       );
+      if (startsFresh && !settings.doNotSuspendOnFetching && (await localDB.info()).doc_count === 0) {
+        fastForwardResource = await this.replicator.createRemoteResource(
+          REMOTE_RESOURCE_KINDS.INITIAL_FETCH_FAST_FORWARD,
+          this.setting.currentSettings()
+        );
+        fastForward = await fastForwardResource?.prepare();
+      }
       for (let attempt = 0; ; attempt++) {
         try {
           await fetchChangesForInitialSync(
@@ -531,13 +542,17 @@ Total bytes fetched: ${sizeToHumanReadable(progress.totalBytes)}`,
                 "fetch-init-progress"
               );
             },
-            (sequence) => this.saveFastFetchCheckpoint(remote, sequence),
-            customHeaders
+            async (sequence) => {
+              await this.saveFastFetchCheckpoint(remote, sequence);
+              fastForward?.recordCheckpoint(sequence);
+            },
+            customHeaders,
+            fastForward?.recordStoredRevisions
           );
           break;
         } catch (ex) {
           if (!isRetryableStreamingFetchFailure(ex) || attempt >= FAST_FETCH_RETRY_DELAYS.length) throw ex;
-          checkpoint = this.getFastFetchCheckpoint(remote);
+          checkpoint = await this.getFastFetchCheckpoint(remote);
           since = checkpoint?.sequence ?? since;
           this._log(
             `Fast fetch interrupted. Retrying from sequence: ${since}`,
@@ -547,6 +562,13 @@ Total bytes fetched: ${sizeToHumanReadable(progress.totalBytes)}`,
           await delay(FAST_FETCH_RETRY_DELAYS[attempt]);
         }
       }
+      if (fastForward) {
+        const advanced = await fastForward.fastForward();
+        this._log(
+          advanced ? "Advanced the ordinary replication checkpoints through the verified initial Fast Fetch." : "The initial Fast Fetch did not advance ordinary replication checkpoints.",
+          LOG_LEVEL_VERBOSE
+        );
+      }
       const allDocs = await localDB.allDocs({ include_docs: false });
       this._log(
         `Fast database fetch completed. Total documents in local database: ${allDocs.total_rows}`,
@@ -559,9 +581,13 @@ Total bytes fetched: ${sizeToHumanReadable(progress.totalBytes)}`,
           throw new Error("Fast Fetch could not be finalised.");
         }
       }
-      this.clearFastFetchCheckpoint();
+      await this.clearFastFetchCheckpoint();
     } finally {
-      await securitySeed.dispose();
+      try {
+        await fastForwardResource?.dispose();
+      } finally {
+        await securitySeed.dispose();
+      }
     }
   }
   /**
@@ -627,8 +653,8 @@ Total bytes fetched: ${sizeToHumanReadable(progress.totalBytes)}`,
     }
     this.events.emitEvent(EVENT_DATABASE_REBUILT);
   }
-  getFastFetchCheckpoint(remote) {
-    const rawCheckpoint = this.setting.getSmallConfig(FAST_FETCH_CHECKPOINT_KEY);
+  async getFastFetchCheckpoint(remote) {
+    const rawCheckpoint = await this.setting.config.getValue(FAST_FETCH_CHECKPOINT_KEY);
     if (!rawCheckpoint) return void 0;
     try {
       const checkpoint = JSON.parse(rawCheckpoint);
@@ -640,11 +666,11 @@ Total bytes fetched: ${sizeToHumanReadable(progress.totalBytes)}`,
       }
     } catch {
     }
-    this.clearFastFetchCheckpoint();
+    await this.clearFastFetchCheckpoint();
     return void 0;
   }
-  saveFastFetchCheckpoint(remote, sequence) {
-    this.setting.setSmallConfig(
+  async saveFastFetchCheckpoint(remote, sequence) {
+    await this.setting.config.setValue(
       FAST_FETCH_CHECKPOINT_KEY,
       JSON.stringify({
         remote,
@@ -653,8 +679,8 @@ Total bytes fetched: ${sizeToHumanReadable(progress.totalBytes)}`,
       })
     );
   }
-  clearFastFetchCheckpoint() {
-    this.setting.deleteSmallConfig(FAST_FETCH_CHECKPOINT_KEY);
+  async clearFastFetchCheckpoint() {
+    await this.setting.config.delete(FAST_FETCH_CHECKPOINT_KEY);
   }
 }
 export {

package/dist/serviceModules/ServiceFileAccessBase.js

@@ -15,6 +15,11 @@ class ServiceFileAccessBase extends ServiceModuleBase {
     this.vaultAccess = services.vaultAccess;
     services.appLifecycle.onFirstInitialise.addHandler(this._everyOnFirstInitialize.bind(this));
     services.fileProcessing.commitPendingFileEvents.addHandler(this._everyCommitPendingFileEvent.bind(this));
+    services.appLifecycle.onBeforeUnload.addHandler(async () => {
+      if (this.vaultManager.stopWatching) await this.vaultManager.stopWatching();
+      else await this.vaultManager.waitForIdle();
+      return true;
+    });
   }
   restoreState() {
     return this.vaultManager.restoreState();

package/dist/serviceModules/ServiceFileHandlerBase.d.ts

@@ -1,6 +1,6 @@
 import type { AnyEntry, FilePath, FilePathWithPrefix, MetaEntry, UXFileInfo, UXFileInfoStub, UXInternalFileInfoStub } from "../common/types.js";
 import type { LiveSyncEventHub } from "../hub/hub.js";
-import type { IFileHandler } from "../interfaces/FileHandler.js";
+import type { IFileHandler, StoreFileOptions } from "../interfaces/FileHandler.js";
 import { ServiceModuleBase } from "./ServiceModuleBase.js";
 import type { APIService } from "../services/base/APIService.js";
 import type { DatabaseFileAccess } from "../interfaces/DatabaseFileAccess.js";
@@ -74,7 +74,8 @@ export declare abstract class ServiceFileHandlerBase extends ServiceModuleBase<S
     /**
      * Read the raw provenance value used by an optimistic storage snapshot.
      * Unlike `getProvenance`, this does not validate or remove the referenced
-     * database revision; an unreadable value is represented as `undefined`.
+     * database revision. Recovery callers require a readable value so a store
+     * failure cannot be mistaken for absent provenance.
      */
     private readProvenanceSnapshot;
     /**
@@ -99,7 +100,7 @@ export declare abstract class ServiceFileHandlerBase extends ServiceModuleBase<S
     readFileFromStub(file: UXFileInfoStub | UXFileInfo): Promise<UXFileInfo>;
     tryRecordUntrackedFileRevision(info: UXFileInfoStub | UXFileInfo, expectedRevision: string): Promise<boolean>;
     private infoToStub;
-    storeFileToDB(info: UXFileInfoStub | UXFileInfo | UXInternalFileInfoStub | FilePathWithPrefix, force?: boolean, onlyChunks?: boolean): Promise<boolean>;
+    storeFileToDB(info: UXFileInfoStub | UXFileInfo | UXInternalFileInfoStub | FilePathWithPrefix, force?: boolean, onlyChunks?: boolean, options?: StoreFileOptions): Promise<boolean>;
     storeFileToDBWithBaseRevision(info: UXFileInfoStub | UXFileInfo | FilePathWithPrefix, baseRevision: string, createIfDifferent?: boolean): Promise<boolean>;
     /**
      * Store current storage content below an exact live revision. A differing
@@ -110,11 +111,13 @@ export declare abstract class ServiceFileHandlerBase extends ServiceModuleBase<S
     /**
      * Save one storage snapshot while the caller holds its document lock.
      * Ordinary saves read once inside the lock and leave retries disabled.
-     * Restored startup events retain bounded rereads because file watching has
-     * not yet started and cannot supply a new event for a concurrent edit.
+     * Restored start-up events and recovery scans retain bounded rereads
+     * because a watcher event may not cover a concurrent edit.
      */
     private storeFileToDBFromRevision;
     deleteFileFromDB(info: UXFileInfoStub | UXInternalFileInfoStub | FilePath): Promise<boolean>;
+    /** Complete a validated storage deletion when its database effect is already represented. */
+    private deleteFileFromDBIfPresent;
     /**
      * Record a storage deletion under the caller's document lock, preserving
      * the displayed conflict branch when its provenance is known.

package/dist/serviceModules/ServiceFileHandlerBase.js

@@ -1,9 +1,9 @@
 import { LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
 import { serialized } from "octagonal-wheels/concurrency/lock";
 import {
+  createBlob,
   getDocDataAsArray,
   isDocContentSame,
-  readAsBlob,
   readContent
 } from "../common/utils.js";
 import { computeFileContentHash } from "../common/fileContentHash.js";
@@ -158,7 +158,7 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
    * A valid saved content hash can prove unchanged bytes after revision
    * pruning. It cannot reconstruct ancestry for an edited file.
    */
-  async classifyStorageContent(file, currentEntry, preferredPath, recorded, currentLoaded) {
+  async classifyStorageContent(file, currentEntry, preferredPath, recorded, currentLoaded, requireReadableContent = false) {
     const path = preferredPath ?? file.path;
     const recordedRevision = recorded?.revision;
     if (recordedRevision) {
@@ -173,6 +173,9 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
       }
       if (!base) {
         const meta = await this.db.fetchEntryMeta(file, recordedRevision, true);
+        if (requireReadableContent && meta && !meta.deleted && !meta._deleted) {
+          throw new Error(`Could not read the recorded file revision for ${file.path}`);
+        }
         if ((!meta || meta.deleted || meta._deleted) && !hasContentHash(recorded)) await this.deleteProvenance(path);
       }
     }
@@ -189,13 +192,15 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
   /**
    * Read the raw provenance value used by an optimistic storage snapshot.
    * Unlike `getProvenance`, this does not validate or remove the referenced
-   * database revision; an unreadable value is represented as `undefined`.
+   * database revision. Recovery callers require a readable value so a store
+   * failure cannot be mistaken for absent provenance.
    */
-  async readProvenanceSnapshot(path) {
+  async readProvenanceSnapshot(path, requireReadable = false) {
     try {
       const record = await this.fileReflectionProvenance?.get(this.getProvenancePath(path));
       return record ? { ...record } : void 0;
-    } catch {
+    } catch (error) {
+      if (requireReadable) throw error;
       return void 0;
     }
   }
@@ -203,20 +208,20 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
    * Check that storage still has the same path, bytes, timestamp, and
    * provenance as a previously captured snapshot.
    */
-  async currentStorageSnapshotMatches(file, revision) {
+  async currentStorageSnapshotMatches(file, revision, requireReadableProvenance = false) {
     const current = await this.storage.getStub(file.path);
     if (!current || isFolderInfo(current) || current.path !== file.path) return false;
     const readCurrent = await this.readFileFromStub(current);
-    return readCurrent.stat.mtime === file.stat.mtime && await isDocContentSame(readCurrent.body, file.body) && sameProvenance(await this.readProvenanceSnapshot(file.path), revision);
+    return readCurrent.stat.mtime === file.stat.mtime && await isDocContentSame(readCurrent.body, file.body) && sameProvenance(await this.readProvenanceSnapshot(file.path, requireReadableProvenance), revision);
   }
   /**
    * Publish provenance after a durable database write if storage is unchanged.
    * A failed revalidation leaves the database revision stored and asks the
    * caller to reread storage before proceeding.
    */
-  async finaliseStoredRevision(file, observedProvenance, storedRevision) {
+  async finaliseStoredRevision(file, observedProvenance, storedRevision, requireReadableProvenance = false) {
     const evidence = await this.contentEvidence(file.body);
-    if (await this.currentStorageSnapshotMatches(file, observedProvenance)) {
+    if (await this.currentStorageSnapshotMatches(file, observedProvenance, requireReadableProvenance)) {
       await this.setProvenance(file.path, storedRevision, file.stat.mtime, file.body, evidence);
       return true;
     } else {
@@ -293,10 +298,10 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
     const file = typeof info === "string" ? await this.storage.getFileStub(info) : info;
     return file;
   }
-  async storeFileToDB(info, force = false, onlyChunks = false) {
+  async storeFileToDB(info, force = false, onlyChunks = false, options = {}) {
     return await this.serializedByFileEventPaths(
       [getStoragePathFromUXFileInfo(info)],
-      () => this.storeFileToDBFromRevision(info, force, onlyChunks)
+      () => this.storeFileToDBFromRevision(info, force, onlyChunks, void 0, options.revalidateStorage)
     );
   }
   async storeFileToDBWithBaseRevision(info, baseRevision, createIfDifferent = true) {
@@ -366,8 +371,8 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
   /**
    * Save one storage snapshot while the caller holds its document lock.
    * Ordinary saves read once inside the lock and leave retries disabled.
-   * Restored startup events retain bounded rereads because file watching has
-   * not yet started and cannot supply a new event for a concurrent edit.
+   * Restored start-up events and recovery scans retain bounded rereads
+   * because a watcher event may not cover a concurrent edit.
    */
   async storeFileToDBFromRevision(info, force = false, onlyChunks = false, preferredBasePath, retryIfStorageChanges = false, snapshotRetry = 0) {
     const file = await this.infoToStub(info);
@@ -387,32 +392,36 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
       return await this.db.createChunks(readFile2, force, true);
     }
     const observedProvenance = await this.readProvenanceSnapshot(
-      preferredBasePath ?? file.path
+      preferredBasePath ?? file.path,
+      retryIfStorageChanges
     );
     const readFile = await this.readFileFromStub(file);
     const entry = await this.db.fetchEntry(file, void 0, true, true, true);
     const currentEntry = entry || await this.db.fetchEntryMeta(file, void 0, true);
     const conflictedRevs = await this.db.getConflictedRevs(file);
     const isConflicted = conflictedRevs.length > 0;
-    if (!force && currentEntry && !currentEntry.deleted && !currentEntry._deleted) {
+    const currentIsLive = currentEntry && !currentEntry.deleted && !currentEntry._deleted;
+    if (!force && (currentIsLive || retryIfStorageChanges)) {
+      if (retryIfStorageChanges && currentIsLive && !entry) return false;
       const classification = await this.classifyStorageContent(
         readFile,
         currentEntry,
         preferredBasePath,
         observedProvenance,
-        entry ? { _rev: entry._rev, data: readContent(entry) } : void 0
+        entry ? { _rev: entry._rev, data: readContent(entry) } : void 0,
+        retryIfStorageChanges
       );
-      const upgradeCurrentRecord = classification.kind === "unchanged" && !isConflicted && classification.revision === currentEntry._rev && !hasContentHash(observedProvenance);
+      const upgradeCurrentRecord = classification.kind === "unchanged" && !isConflicted && currentEntry && !currentEntry.deleted && !currentEntry._deleted && classification.revision === currentEntry._rev && !hasContentHash(observedProvenance);
       const evidence = upgradeCurrentRecord || classification.kind === "matching-leaf" && classification.revision ? await this.contentEvidence(readFile.body) : void 0;
-      const snapshotMatches = retryIfStorageChanges || upgradeCurrentRecord ? await this.currentStorageSnapshotMatches(readFile, observedProvenance) : true;
+      const snapshotMatches = retryIfStorageChanges || upgradeCurrentRecord ? await this.currentStorageSnapshotMatches(readFile, observedProvenance, retryIfStorageChanges) : true;
       if (retryIfStorageChanges && !snapshotMatches) {
         return await this.retryCurrentStorage(file.path, preferredBasePath, snapshotRetry);
       }
       if (classification.kind === "unchanged") {
         if (isConflicted) {
           await this.queueConflictCheckFor(file.path);
-        } else if (classification.revision !== currentEntry._rev) {
-          if (!entry) return false;
+        } else if (!currentEntry || currentEntry.deleted || currentEntry._deleted || classification.revision !== currentEntry._rev) {
+          if (!currentEntry) return false;
           return await this.dbToStorageCore(file.path, file);
         } else {
           if (upgradeCurrentRecord && snapshotMatches) {
@@ -430,7 +439,7 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
       const storedRevision2 = classification.kind === "edited" ? await this.db.storeWithBaseRevision(readFile, classification.revision, true) : await this.db.storeIndependentRevision(readFile, true);
       if (storedRevision2 === false) return false;
       if (preferredBasePath && preferredBasePath !== file.path) await this.deleteProvenance(preferredBasePath);
-      if (retryIfStorageChanges && !await this.finaliseStoredRevision(readFile, observedProvenance, storedRevision2)) {
+      if (retryIfStorageChanges && !await this.finaliseStoredRevision(readFile, observedProvenance, storedRevision2, true)) {
         return await this.retryCurrentStorage(file.path, preferredBasePath, snapshotRetry);
       }
       if (!retryIfStorageChanges) await this.setProvenance(file.path, storedRevision2, readFile.stat.mtime, readFile.body);
@@ -519,6 +528,12 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
       () => this.deleteFileFromDBCore(info)
     );
   }
+  /** Complete a validated storage deletion when its database effect is already represented. */
+  async deleteFileFromDBIfPresent(info) {
+    const entry = await this.db.fetchEntryMeta(info, void 0, true);
+    if (!entry || entry.deleted || entry._deleted) return true;
+    return await this.deleteFileFromDBCore(info);
+  }
   /**
    * Record a storage deletion under the caller's document lock, preserving
    * the displayed conflict branch when its provenance is known.
@@ -892,17 +907,17 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
       this._log(`File ${path} is not exist on the database`, LOG_LEVEL_VERBOSE);
       return false;
     }
+    const docData = readContent(docRead);
+    const reflectedContent = createBlob(docData);
     if (!settings.processSizeMismatchedFiles) {
-      if (docRead.size != 0 && docRead.size !== readAsBlob(docRead).size) {
+      if (docRead.size != 0 && docRead.size !== reflectedContent.size) {
         this._log(
-          `File ${path} seems to be corrupted! Writing prevented. (${docRead.size} != ${readAsBlob(docRead).size})`,
+          `File ${path} seems to be corrupted! Writing prevented. (${docRead.size} != ${reflectedContent.size})`,
           LOG_LEVEL_NOTICE
         );
         return false;
       }
     }
-    const docData = readContent(docRead);
-    const reflectedContent = readAsBlob(docRead);
     const reflectedEvidence = await this.contentEvidence(reflectedContent);
     if (allowExistingConflicts && existDoc && !force) {
       const readFile = await this.readFileFromStub(existDoc);
@@ -1080,14 +1095,23 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
     const relatedPath = type === "RENAME" ? eventItem.oldPath : type === "DELETE" ? eventItem.renameTarget : void 0;
     const eventPaths = relatedPath === void 0 ? [path] : [path, relatedPath];
     return await this.serializedByFileEventPaths(eventPaths, async () => {
-      if (!await this.isCurrentPathSelected(path)) return false;
+      if (!await this.isCurrentPathSelected(path)) {
+        return shouldBeIgnored(path) || !await this.vault.isTargetFile(path, { skipCaseCollisionCheck: true });
+      }
       switch (type) {
         case "CREATE":
-        case "CHANGED":
-          return await this.storeFileToDBFromRevision(item.args.file);
+        case "CHANGED": {
+          const current = this.getExactCurrentFile(await this.storage.getStub(path), path);
+          if (!current || this.vault.isFileSizeTooLarge(current.stat.size)) return true;
+          return await this.storeFileToDBFromRevision(current);
+        }
         case "DELETE":
-          if (!await this.canRecordStorageDeletion(item)) return true;
-          return await this.deleteFileFromDBCore(item.args.file);
+          try {
+            if (!await this.canRecordStorageDeletion(item)) return true;
+          } catch {
+            return false;
+          }
+          return await this.deleteFileFromDBIfPresent(item.args.file);
         case "RENAME":
           return await this.renameFileInDBCore(
             item.args.file,
@@ -1137,7 +1161,7 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
     } catch (ex) {
       this._log(`Could not validate deletion of ${path}; preserved the database entry`, LOG_LEVEL_NOTICE);
       this._log(ex, LOG_LEVEL_VERBOSE);
-      return false;
+      throw ex;
     }
   }
   /**
@@ -1222,15 +1246,19 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
         action = await this._planRestoredFileEvent(item, isSameDocument);
       } catch (ex) {
         this.logRestoredEventValidationFailure(path, ex);
-        return true;
+        return false;
       }
       switch (action.kind) {
         case "none":
           return true;
-        case "store":
-          return await this.storeFileToDBFromRevision(action.file, false, false, void 0, true);
+        case "unresolved":
+          return false;
+        case "store": {
+          const stored = await this.storeFileToDBFromRevision(action.file, false, false, void 0, true);
+          return stored && action.complete !== false;
+        }
         case "delete":
-          return await this.deleteFileFromDBCore(action.path);
+          return await this.deleteFileFromDBIfPresent(action.path);
         case "rename":
           return await this.renameFileInDBCore(action.file, action.oldPath, true);
       }
@@ -1266,6 +1294,10 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
       if (!currentTarget2 || !await this.isCurrentFileSelected(currentTarget2)) {
         return { kind: "none" };
       }
+      const entry = await this.db.fetchEntryMeta(newPath, void 0, true);
+      if (entry && !entry.deleted && !entry._deleted && this.storage.normalisePath(this.getPath(entry)) === this.storage.normalisePath(newPath)) {
+        return { kind: "store", file: currentTarget2 };
+      }
       return { kind: "rename", file: currentTarget2, oldPath };
     }
     const currentTargetItem = await this.storage.getStub(newPath);
@@ -1283,11 +1315,16 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
         return { kind: "none" };
       }
       if (!sourceWasInspected || currentSourceItem !== null || !await this.canApplyRestoredDeletion(oldPath)) {
+        return { kind: "store", file: currentTarget, complete: sourceWasInspected };
+      }
+      const sourceEntry = await this.db.fetchEntryMeta(oldPath, void 0, true);
+      if (!sourceEntry || sourceEntry.deleted || sourceEntry._deleted) {
         return { kind: "store", file: currentTarget };
       }
       return { kind: "rename", file: currentTarget, oldPath };
     }
-    if (!sourceWasInspected || currentSourceItem !== null || !await this.canApplyRestoredDeletion(oldPath)) {
+    if (!sourceWasInspected) return { kind: "unresolved" };
+    if (currentSourceItem !== null || !await this.canApplyRestoredDeletion(oldPath)) {
       return { kind: "none" };
     }
     return { kind: "delete", path: oldPath };
@@ -1324,12 +1361,12 @@ class ServiceFileHandlerBase extends ServiceModuleBase {
       return await this.isCurrentPathSelected(path);
     } catch (ex) {
       this.logRestoredEventValidationFailure(path, ex);
-      return false;
+      throw ex;
     }
   }
   logRestoredEventValidationFailure(path, ex) {
     this._log(
-      `Could not validate the saved storage operation for ${path} against current storage; the Offline Scanner will reconcile the current state`,
+      `Could not validate the saved storage operation for ${path} against current storage; the operation remains pending for recovery`,
       LOG_LEVEL_NOTICE
     );
     this._log(ex, LOG_LEVEL_VERBOSE);

package/dist/services/BrowserServices.d.ts

@@ -1,9 +1,9 @@
+import type { IConfigService } from "./base/IService.js";
 import { InjectableVaultServiceCompat } from "./implements/injectable/InjectableVaultService.js";
 import { ServiceContext } from "./base/ServiceBase.js";
 import { InjectableServiceHub } from "./implements/injectable/InjectableServiceHub.js";
 import { ControlService } from "./base/ControlService.js";
 import type { AppLifecycleService } from "./base/AppLifecycleService.js";
-import type { ConfigService } from "./base/ConfigService.js";
 import type { ReplicatorService } from "./base/ReplicatorService.js";
 import type { UIService } from "./implements/base/UIService.js";
 import type { InjectableAPIService } from "./implements/injectable/InjectableAPIService.js";
@@ -12,7 +12,7 @@ import type { ObsidianLiveSyncSettings } from "../common/types.js";
 export type BrowserServiceHostDependencies<T extends ServiceContext> = {
     API: InjectableAPIService<T>;
     appLifecycle: AppLifecycleService<T>;
-    config: ConfigService<T>;
+    config: IConfigService;
     control: ControlService<T>;
     replicator: ReplicatorService<T>;
 };
@@ -29,6 +29,8 @@ export interface BrowserServiceHost<T extends ServiceContext> {
 export type BrowserServiceHubOptions<T extends ServiceContext> = {
     context?: T;
     host: BrowserServiceHost<T>;
+    /** Exact-key storage selected and owned by the application. */
+    deviceValues: IConfigService;
     openKeyValueDatabase?: KeyValueDatabaseFactory;
     onDisplayLanguageChanged?: (language: ObsidianLiveSyncSettings["displayLanguage"]) => void;
 };

package/dist/services/BrowserServices.js

@@ -11,7 +11,6 @@ import { InjectableTestService } from "./implements/injectable/InjectableTestSer
 import { InjectableTweakValueService } from "./implements/injectable/InjectableTweakValueService.js";
 import { InjectableVaultServiceCompat } from "./implements/injectable/InjectableVaultService.js";
 import { ServiceContext } from "./base/ServiceBase.js";
-import { ConfigServiceBrowserCompat } from "./implements/browser/ConfigServiceBrowserCompat.js";
 import { InjectableServiceHub } from "./implements/injectable/InjectableServiceHub.js";
 import { BrowserDatabaseService, BrowserKeyValueDBService } from "./implements/browser/BrowserDatabaseService.js";
 import { ControlService } from "./base/ControlService.js";
@@ -34,6 +33,7 @@ class BrowserServiceHub extends InjectableServiceHub {
     const fileProcessing = new InjectableFileProcessingService(context);
     const setting = new InjectableSettingService(context, {
       APIService: API,
+      deviceValues: options.deviceValues,
       onDisplayLanguageChanged: options.onDisplayLanguageChanged
     });
     const appLifecycle = new BrowserAppLifecycleService(context, { settingService: setting });
@@ -60,10 +60,7 @@ class BrowserServiceHub extends InjectableServiceHub {
       setting,
       API
     });
-    const config = new ConfigServiceBrowserCompat(context, {
-      settingService: setting,
-      APIService: API
-    });
+    const config = setting.config;
     const replicator = new InjectableReplicatorService(context, {
       settingService: setting,
       appLifecycleService: appLifecycle,

package/dist/services/HeadlessServices.d.ts

@@ -1,3 +1,4 @@
+import type { IConfigService } from "./base/IService.js";
 import { ServiceContext } from "./base/ServiceBase.js";
 import { InjectableServiceHub } from "./implements/injectable/InjectableServiceHub.js";
 import type { DatabaseService } from "./base/DatabaseService.js";
@@ -9,6 +10,8 @@ export declare class HeadlessServiceHub<T extends ServiceContext> extends Inject
     constructor(_context: T | undefined, overrideServiceConstructor: {
         /** PouchDB with the adapters required by this headless runtime. */
         pouchDB: PouchDBConstructor;
+        /** Exact-key storage selected and owned by the application. */
+        deviceValues: IConfigService;
         database?: Constructor<DatabaseService<T>>;
         openKeyValueDatabase?: KeyValueDatabaseFactory;
         onDisplayLanguageChanged?: (language: ObsidianLiveSyncSettings["displayLanguage"]) => void;

package/dist/services/HeadlessServices.js

@@ -11,7 +11,6 @@ import { InjectableTestService } from "./implements/injectable/InjectableTestSer
 import { InjectableTweakValueService } from "./implements/injectable/InjectableTweakValueService.js";
 import { InjectableVaultServiceCompat } from "./implements/injectable/InjectableVaultService.js";
 import { ServiceContext } from "./base/ServiceBase.js";
-import { ConfigServiceBrowserCompat } from "./implements/browser/ConfigServiceBrowserCompat.js";
 import { InjectableServiceHub } from "./implements/injectable/InjectableServiceHub.js";
 import { UIService } from "./implements/base/UIService.js";
 import { HeadlessAPIService } from "./implements/headless/HeadlessAPIService.js";
@@ -56,6 +55,7 @@ class HeadlessServiceHub extends InjectableServiceHub {
     const fileProcessing = new InjectableFileProcessingService(context);
     const setting = new InjectableSettingService(context, {
       APIService: API,
+      deviceValues: overrideServiceConstructor.deviceValues,
       onDisplayLanguageChanged: overrideServiceConstructor.onDisplayLanguageChanged
     });
     const appLifecycle = new HeadlessAppLifecycleService(context, {
@@ -85,10 +85,7 @@ class HeadlessServiceHub extends InjectableServiceHub {
       vault,
       setting
     });
-    const config = new ConfigServiceBrowserCompat(context, {
-      settingService: setting,
-      APIService: API
-    });
+    const config = setting.config;
     const replicator = new InjectableReplicatorService(context, {
       settingService: setting,
       appLifecycleService: appLifecycle,

package/dist/services/ServiceHub.d.ts

@@ -1,5 +1,5 @@
+import type { IConfigService } from "./base/IService.js";
 import type { UIService } from "./implements/base/UIService.js";
-import type { ConfigService } from "./base/ConfigService.js";
 import type { TestService } from "./base/TestService.js";
 import type { VaultService } from "./base/VaultService.js";
 import type { TweakValueService } from "./base/TweakValueService.js";
@@ -34,7 +34,7 @@ export type ServiceInstances<T extends ServiceContext = ServiceContext> = {
     vault?: VaultService<T>;
     test?: TestService<T>;
     ui?: UIService<T>;
-    config?: ConfigService<T>;
+    config?: IConfigService;
     keyValueDB?: KeyValueDBService<T>;
     control?: ControlService<T>;
 };
@@ -56,7 +56,7 @@ export declare abstract class ServiceHub<T extends ServiceContext = ServiceConte
     protected abstract _vault: VaultService<T>;
     protected abstract _test: TestService<T>;
     protected abstract _ui: UIService<T>;
-    protected abstract _config: ConfigService<T>;
+    protected abstract _config: IConfigService;
     protected abstract _keyValueDB: KeyValueDBService<T>;
     protected abstract _control: ControlService<T>;
     protected _injected: ServiceInstances<T>;
@@ -76,7 +76,7 @@ export declare abstract class ServiceHub<T extends ServiceContext = ServiceConte
     get vault(): VaultService<T>;
     get test(): TestService<T>;
     get UI(): UIService<T>;
-    get config(): ConfigService<T>;
+    get config(): IConfigService;
     get keyValueDB(): KeyValueDBService<T>;
     get control(): ControlService<T>;
 }

package/dist/services/base/AppLifecycleService.js

@@ -60,7 +60,7 @@ class AppLifecycleService extends ServiceBase {
    * Event triggered before the plug-in is unloaded.
    * This is typically used to perform any necessary cleanup or save state before the plug-in is unloaded.
    */
-  onBeforeUnload = handlers().all("onBeforeUnload");
+  onBeforeUnload = handlers().allSettled("onBeforeUnload");
   /**
    * Event triggered when the plug-in is being unloaded.
    *