@vrtmrz/livesync-commonlib 0.2.0 → 0.2.1

package/dist/replication/couchdb/LiveSyncReplicator.js

@@ -1,3 +1,4 @@
+import { observeReplicationProgress } from "./replicationProgress.js";
 import {
   VER,
   MILESTONE_DOCID,
@@ -122,6 +123,24 @@ class LiveSyncCouchDBReplicator extends LiveSyncAbstractReplicator {
   continuousTask;
   continuousStopWaiter;
   continuousStopRequested = false;
+  continuousPhase;
+  couchDBProgress;
+  getReplicationStatics() {
+    return {
+      ...super.getReplicationStatics(),
+      ...this.couchDBProgress ? { couchDB: this.couchDBProgress } : {}
+    };
+  }
+  publishPreparationPhase(phase) {
+    this.continuousPhase = phase;
+    this.couchDBProgress = { phase };
+    this.updateInfo();
+  }
+  finishReplicationProgress() {
+    if (!this.couchDBProgress || this.couchDBProgress.phase === "idle") return;
+    this.couchDBProgress = { ...this.couchDBProgress, phase: "idle" };
+    this.updateInfo();
+  }
   isMobile() {
     return this.env.services.API.isMobile();
   }
@@ -241,6 +260,7 @@ class LiveSyncCouchDBReplicator extends LiveSyncAbstractReplicator {
       this.continuousStopRequested = true;
     }
     this.abortController();
+    this.finishReplicationProgress();
     if (!task) {
       return Promise.resolve();
     }
@@ -352,6 +372,17 @@ class LiveSyncCouchDBReplicator extends LiveSyncAbstractReplicator {
       this.controller.abort();
     }
     this.controller = controller;
+    const progress = observeReplicationProgress(
+      syncHandler,
+      syncMode,
+      this.continuousPhase ?? "one-shot",
+      controller.signal,
+      (snapshot) => {
+        if (this.controller !== controller) return;
+        this.couchDBProgress = snapshot;
+        this.updateInfo();
+      }
+    );
     const gen = genReplication(syncHandler, controller.signal);
     try {
       for await (const [type, e] of gen) {
@@ -361,6 +392,7 @@ class LiveSyncCouchDBReplicator extends LiveSyncAbstractReplicator {
           return "FAILED";
         }
         releaser();
+        if (controller.signal.aborted || this.controller !== controller) break;
         switch (type) {
           case "change":
             if ("direction" in e) {
@@ -440,8 +472,9 @@ class LiveSyncCouchDBReplicator extends LiveSyncAbstractReplicator {
       Logger(ex, LOG_LEVEL_VERBOSE);
       return "FAILED";
     } finally {
-      this.abortController();
-      this.controller = void 0;
+      progress.dispose();
+      controller.abort();
+      if (this.controller === controller) this.controller = void 0;
     }
   }
   getEmptyMaxEntry(remoteID) {
@@ -1118,6 +1151,8 @@ ${sendingDocs}/(${sentDocsCount} done)`,
     if (this.continuousTask !== task) {
       return;
     }
+    this.finishReplicationProgress();
+    this.continuousPhase = void 0;
     this.continuousTask = void 0;
     this.continuousStopWaiter = void 0;
     this.continuousStopRequested = false;
@@ -1131,6 +1166,7 @@ ${sendingDocs}/(${sentDocsCount} done)`,
         );
         return false;
       }
+      this.publishPreparationPhase("catch-up");
       const localDB = this.rawDatabase;
       Logger(this.translate("liveSyncReplicator.beforeLiveSync"));
       const caughtUp = await this.env.services.replicator.runFiniteReplicationActivity(
@@ -1146,6 +1182,7 @@ ${sendingDocs}/(${sentDocsCount} done)`,
         { label: "replication" }
       );
       if (caughtUp && !this.continuousStopRequested) {
+        this.publishPreparationPhase("continuous");
         Logger(this.translate("liveSyncReplicator.liveSyncBegin"));
         const ret = await this.checkReplicationConnectivity(setting, true, false, showResult);
         if (ret === false || this.continuousStopRequested) {

package/dist/replication/couchdb/replicationProgress.d.ts

@@ -0,0 +1,6 @@
+import type { EntryDoc } from "../../common/types.js";
+import type { CouchDBReplicationPhase, CouchDBReplicationProgress } from "../../common/models/shared.definition.js";
+/** Observe one handler without adding its high-volume checkpoint events to the replication inbox. */
+export declare function observeReplicationProgress(handler: PouchDB.Replication.Sync<EntryDoc> | PouchDB.Replication.Replication<EntryDoc>, mode: "sync" | "pullOnly" | "pushOnly", phase: Exclude<CouchDBReplicationPhase, "idle">, signal: AbortSignal, publish: (progress: CouchDBReplicationProgress) => void): {
+    dispose(): void;
+};

package/dist/replication/couchdb/replicationProgress.js

@@ -0,0 +1,105 @@
+import { compatGlobal } from "../../common/coreEnvFunctions.js";
+const PROGRESS_PUBLICATION_INTERVAL_MS = 200;
+function asEmitter(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  if (!("on" in value) || typeof value.on !== "function") return void 0;
+  if (!("removeListener" in value) || typeof value.removeListener !== "function") return void 0;
+  return value;
+}
+function isSequence(value) {
+  return typeof value === "string" || typeof value === "number" && Number.isFinite(value);
+}
+function observeReplicationProgress(handler, mode, phase, signal, publish) {
+  const progress = {};
+  const detach = [];
+  let timer;
+  let dirty = false;
+  let disposed = false;
+  let currentPhase = phase;
+  const cancelTimer = () => {
+    if (timer === void 0) return;
+    compatGlobal.clearTimeout(timer);
+    timer = void 0;
+  };
+  const flush = () => {
+    cancelTimer();
+    if (!dirty) return;
+    dirty = false;
+    publish({
+      phase: currentPhase,
+      ...progress.pull ? { pull: { ...progress.pull } } : {},
+      ...progress.push ? { push: { ...progress.push } } : {}
+    });
+  };
+  const schedule = () => {
+    dirty = true;
+    timer ??= compatGlobal.setTimeout(flush, PROGRESS_PUBLICATION_INTERVAL_MS);
+  };
+  const listen = (emitter, event, listener) => {
+    emitter.on(event, listener);
+    detach.push(() => emitter.removeListener(event, listener));
+  };
+  const observeDirection = (direction, emitter) => {
+    if (!emitter) return;
+    const value = { checkedChanges: 0, completedBatches: 0, checking: false };
+    progress[direction] = value;
+    listen(emitter, "checkpoint", (event) => {
+      if (disposed || signal.aborted || typeof event !== "object" || event === null) return;
+      if ("revs_diff" in event && typeof event.revs_diff === "object" && event.revs_diff !== null && "id" in event.revs_diff && typeof event.revs_diff.id === "string") {
+        value.checkedChanges++;
+        value.checking = true;
+      } else if ("start_next_batch" in event && isSequence(event.start_next_batch)) {
+        value.checking = true;
+      } else if ("checkpoint" in event && isSequence(event.checkpoint)) {
+        value.completedBatches++;
+        value.lastSeq = event.checkpoint;
+      } else {
+        return;
+      }
+      schedule();
+    });
+    const stopChecking = () => {
+      if (disposed || signal.aborted) return;
+      if (value.checking) {
+        value.checking = false;
+        dirty = true;
+      }
+      flush();
+    };
+    listen(emitter, "change", stopChecking);
+    listen(emitter, "paused", stopChecking);
+  };
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    cancelTimer();
+    for (const remove of detach) remove();
+    signal.removeEventListener("abort", dispose);
+    currentPhase = "idle";
+    if (progress.pull) progress.pull.checking = false;
+    if (progress.push) progress.push.checking = false;
+    dirty = true;
+    flush();
+  };
+  if (mode === "sync") {
+    const duplex = handler;
+    observeDirection("pull", asEmitter(duplex.pull));
+    observeDirection("push", asEmitter(duplex.push));
+  } else {
+    observeDirection(mode === "pullOnly" ? "pull" : "push", asEmitter(handler));
+  }
+  const outer = asEmitter(handler);
+  if (outer) {
+    listen(outer, "complete", dispose);
+    listen(outer, "error", dispose);
+    listen(outer, "denied", dispose);
+  }
+  signal.addEventListener("abort", dispose, { once: true });
+  dirty = true;
+  if (signal.aborted) dispose();
+  else flush();
+  return { dispose };
+}
+export {
+  observeReplicationProgress
+};

package/dist/replication/index.d.ts

@@ -12,3 +12,4 @@ export type { CentralCompatibilityRecoveryHint, CentralCompatibilityRejectionRea
 export { assessRemoteFeatureDocument, describeRemoteFeatureRejection, ENCRYPTED_INTERNAL_METADATA_FEATURE, NFC_PATH_IDENTITY_FEATURE, REMOTE_FEATURE_GENERATION, usesEncryptedInternalMetadata, } from "../pouchdb/remoteFeatureCompatibility.js";
 export type { RemoteFeatureAssessment } from "../pouchdb/remoteFeatureCompatibility.js";
 export type { JoinedDevice, JoinedDevicesSnapshot, ForgetJoinedDeviceResult } from "./joinedDevices.js";
+export type { ReplicationStatics, CouchDBReplicationPhase, CouchDBReplicationProgress, ReplicationCheckpointProgress, } from "../common/models/shared.definition.js";

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

@@ -144,6 +144,7 @@ export declare class TrysteroReplicator {
         idDerivationVersion: 0 | 1;
         idDerivationProof: string;
         liveSync?: boolean;
+        batchSaveInLiveSync?: boolean;
         syncOnSave?: boolean;
         syncOnStart?: boolean;
         syncOnFileOpen?: boolean;
@@ -332,6 +333,7 @@ export declare class TrysteroReplicator {
             idDerivationVersion: 0 | 1;
             idDerivationProof: string;
             liveSync?: boolean;
+            batchSaveInLiveSync?: boolean;
             syncOnSave?: boolean;
             syncOnStart?: boolean;
             syncOnFileOpen?: boolean;

package/dist/serviceFeatures/offlineScanner.js

@@ -360,8 +360,7 @@ async function syncFileBetweenDBandStorage(host, log, file, doc) {
     case BASE_IS_NEW:
       if (!host.services.vault.isFileSizeTooLarge(file.stat.size)) {
         log("STORAGE -> DB :" + file.path);
-        await host.serviceModules.fileHandler.storeFileToDB(file);
-        return FilePairProcessResults.COMPLETED;
+        return await host.serviceModules.fileHandler.storeFileToDB(file) ? FilePairProcessResults.COMPLETED : FilePairProcessResults.FAILED;
       } else {
         log(
           `STORAGE -> DB : ${file.path} has been skipped due to file size exceeding the limit`,
@@ -390,11 +389,22 @@ async function syncFileBetweenDBandStorage(host, log, file, doc) {
         return FilePairProcessResults.SKIPPED;
       }
     case EVEN:
-      if (doc._rev) {
-        await host.serviceModules.fileHandler.tryRecordUntrackedFileRevision(file, doc._rev);
+      if (host.services.vault.isFileSizeTooLarge(file.stat.size) || host.services.vault.isFileSizeTooLarge(doc.size)) {
+        log(`STORAGE ? DB : ${file.path} has been skipped due to file size exceeding the limit`, LOG_LEVEL_NOTICE);
+        return FilePairProcessResults.SKIPPED;
+      }
+      if (doc._rev && await host.serviceModules.fileHandler.tryRecordUntrackedFileRevision(file, doc._rev)) {
+        log("STORAGE == DB :" + file.path, LOG_LEVEL_DEBUG);
+        return FilePairProcessResults.COMPLETED;
+      }
+      log("STORAGE ? DB :" + file.path + " Checking content", LOG_LEVEL_DEBUG);
+      try {
+        return await host.serviceModules.fileHandler.storeFileToDB(file, false, false, { revalidateStorage: true }) ? FilePairProcessResults.COMPLETED : FilePairProcessResults.FAILED;
+      } catch (error) {
+        log(`STORAGE ? DB : Could not reconcile ${file.path}`, LOG_LEVEL_NOTICE);
+        log(error, LOG_LEVEL_VERBOSE);
+        return FilePairProcessResults.FAILED;
       }
-      log("STORAGE == DB :" + file.path, LOG_LEVEL_DEBUG);
-      return FilePairProcessResults.COMPLETED;
     default:
       log("STORAGE ?? DB :" + file.path + " Something got weird");
       return FilePairProcessResults.FAILED;
@@ -501,7 +511,9 @@ async function collectDatabaseFiles(host, settings, log, showingNotice) {
 async function updateToDatabase(host, log, logLevel, file) {
   if (!host.services.vault.isFileSizeTooLarge(file.stat.size)) {
     const path = file.path;
-    await host.serviceModules.fileHandler.storeFileToDB(file);
+    if (!await host.serviceModules.fileHandler.storeFileToDB(file)) {
+      return FilePairProcessResults.FAILED;
+    }
     host.services.context.events.emitEvent("event-file-changed", { file: path, automated: true });
     return FilePairProcessResults.COMPLETED;
   } else {

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/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.
    *