@vrtmrz/livesync-commonlib 0.2.0 → 0.2.2

package/dist/managers/StorageEventManager.js

@@ -8,8 +8,7 @@ import {
 } from "../common/types.js";
 import { delay, fireAndForget, isRemediationModeActive, throttle } from "../common/utils.js";
 import {} from "../common/types.js";
-import { serialized, skipIfDuplicated } from "octagonal-wheels/concurrency/lock";
-import { isWaitingForTimeout } from "octagonal-wheels/concurrency/task";
+import { serialized } from "octagonal-wheels/concurrency/lock";
 import { Semaphore } from "octagonal-wheels/concurrency/semaphore";
 import { promiseWithResolvers } from "octagonal-wheels/promises";
 import { StorageEventManager } from "../interfaces/StorageEventManager.js";
@@ -24,7 +23,8 @@ class StorageEventManagerBase extends StorageEventManager {
   storageAccess;
   adapter;
   get shouldBatchSave() {
-    return this.settings?.batchSave && this.settings?.liveSync != true;
+    const settings = this.settings;
+    return settings?.liveSync === true ? settings.batchSaveInLiveSync === true : settings?.batchSave;
   }
   get batchSaveMinimumDelay() {
     return this.settings?.batchSaveMinimumDelay ?? DEFAULT_SETTINGS.batchSaveMinimumDelay;
@@ -59,15 +59,10 @@ class StorageEventManagerBase extends StorageEventManager {
     return this.adapter.typeGuard.isFile(file);
   }
   updateStatus() {
-    const allFileEventItems = this.bufferedQueuedItems.filter((e) => "args" in e);
-    const allItems = allFileEventItems.filter((e) => !e.cancelled);
-    const totalItems = allItems.length + this.concurrentProcessing.waiting;
-    const processing = this.processingCount;
-    const batchedCount = this._waitingMap.size;
     this.adapter.status.updateStatus({
-      batched: batchedCount,
-      processing,
-      totalQueued: totalItems + batchedCount + processing
+      batched: this._waitingMap.size,
+      processing: this.processingCount,
+      totalQueued: [...this.pendingSnapshot.values()].filter((entry) => entry.operation && !entry.completed).length
     });
   }
   /**
@@ -82,7 +77,23 @@ class StorageEventManagerBase extends StorageEventManager {
     this.snapShotRestored = this._restoreFromSnapshot();
     return this.snapShotRestored;
   }
-  async appendQueue(params, ctx) {
+  acceptingEvents = true;
+  admissions = /* @__PURE__ */ new Set();
+  appendQueue(params, ctx) {
+    if (!this.acceptingEvents) return Promise.resolve();
+    const admission = { acceptedAt: Date.now(), completion: Promise.resolve(), operations: [], flushRequested: false };
+    this.admissions.add(admission);
+    admission.completion = this.appendQueueInternal(params, ctx, admission);
+    void admission.completion.then(
+      () => this.admissions.delete(admission),
+      (error) => {
+        this.admissions.delete(admission);
+        this.reportOperationFailure(error);
+      }
+    );
+    return admission.completion;
+  }
+  async appendQueueInternal(params, ctx, admission) {
     const settings = this.settings;
     if (!settings.isConfigured) return;
     if (settings.suspendFileWatching) return;
@@ -161,7 +172,7 @@ class StorageEventManagerBase extends StorageEventManager {
       if (param.cachedData) {
         cache = param.cachedData;
       }
-      void this.enqueue({
+      const item = {
         type,
         args: {
           file,
@@ -172,66 +183,126 @@ class StorageEventManagerBase extends StorageEventManager {
         },
         skipBatchWait: param.skipBatchWait,
         key: atomicKey
-      });
+      };
+      this.enqueue(item);
+      const operation = this.operations.get(item);
+      if (operation) {
+        operation.acceptedAt = admission.acceptedAt;
+        if (admission.flushRequested) this.releaseOperations([operation]);
+        admission.operations.push(operation);
+      }
     }
   }
   // Cache file and waiting to can be proceed.
   bufferedQueuedItems = [];
-  enqueue(newItem) {
-    if (newItem.type == "DELETE" || newItem.type == "RENAME") {
-      this.bufferedQueuedItems.push({
-        type: TYPE_SENTINEL_FLUSH
-      });
+  pendingSnapshot = /* @__PURE__ */ new Map();
+  operations = /* @__PURE__ */ new WeakMap();
+  latestByPath = /* @__PURE__ */ new Map();
+  nextSequence = 0;
+  snapshotTail = Promise.resolve();
+  dispatching = null;
+  retainEvent(event) {
+    const existing = this.pendingSnapshot.get(event);
+    if (existing) return existing;
+    const entry = { event, sequence: ++this.nextSequence, completed: false };
+    if (event.type !== TYPE_SENTINEL_FLUSH) {
+      const operation = this.operations.get(event) ?? {
+        event,
+        sequence: entry.sequence,
+        acceptedAt: Date.now(),
+        completion: promiseWithResolvers(),
+        prerequisites: /* @__PURE__ */ new Set(),
+        started: false,
+        flushRequested: false
+      };
+      entry.operation = operation;
+      this.operations.set(event, operation);
     }
+    this.pendingSnapshot.set(event, entry);
+    return entry;
+  }
+  reportOperationFailure(error) {
+    this._log("Storage operation remains pending after a failure", LOG_LEVEL_NOTICE);
+    this._log(error, LOG_LEVEL_VERBOSE);
+  }
+  failOperation(operation, error) {
+    if (operation.result) return;
+    operation.result = { ok: false, error };
+    operation.completion.resolve(operation.result);
+    this.reportOperationFailure(error);
     this.updateStatus();
+  }
+  enqueue(newItem) {
+    if (newItem.type === "DELETE" || newItem.type === "RENAME") {
+      const sentinel = { type: TYPE_SENTINEL_FLUSH };
+      this.retainEvent(sentinel);
+      this.bufferedQueuedItems.push(sentinel);
+    }
+    const operation = this.retainEvent(newItem).operation;
     this.bufferedQueuedItems.push(newItem);
-    fireAndForget(() => this._takeSnapshot().then(() => this.runQueuedEvents()));
+    this.updateStatus();
+    fireAndForget(async () => {
+      try {
+        await this._takeSnapshot();
+        await this.runQueuedEvents();
+      } catch (error) {
+        this.failOperation(operation, error);
+      }
+    });
   }
-  /**
-   * Immediately take snapshot.
-   */
   _triggerTakeSnapshot() {
-    void this._takeSnapshot();
+    fireAndForget(() => this._takeSnapshot().catch((error) => this.reportOperationFailure(error)));
   }
-  /**
-   * Trigger taking snapshot after throttled period.
-   */
   triggerTakeSnapshot = throttle(() => this._triggerTakeSnapshot(), 100);
-  // Limit concurrent processing to reduce the IO load. file-processing + scheduler (1), so file events can be processed in 4 slots.
+  // Waiting timers do not occupy a processing slot.
   concurrentProcessing = Semaphore(5);
   _waitingMap = /* @__PURE__ */ new Map();
-  _waitForIdle = null;
+  pendingOperations(before = Number.POSITIVE_INFINITY) {
+    return [...this.pendingSnapshot.values()].flatMap(
+      (entry) => entry.operation && entry.sequence < before ? [entry.operation] : []
+    );
+  }
+  releaseOperations(operations) {
+    for (const operation of operations) {
+      operation.flushRequested = true;
+      operation.flushSignal?.resolve();
+      const path = operation.event.args.file.path;
+      if (this._waitingMap.get(path)?.event === operation.event) this._proceedWaiting(path);
+    }
+  }
+  async waitForOperations(operations) {
+    this.releaseOperations(operations);
+    return await Promise.all(operations.map((operation) => operation.completion.promise));
+  }
   /**
-   * Wait until all queued events are processed.
-   * Subsequent new events will not be waited, but new events will not be added.
-   * @returns
+   * Complete the finite set of operations accepted before this call.
+   * Later edits cannot replace or extend that set while it is being flushed.
    */
-  waitForIdle() {
-    if (this._waitingMap.size === 0) {
-      return Promise.resolve();
-    }
-    if (this._waitForIdle) {
-      return this._waitForIdle;
+  async waitForIdle() {
+    const admissions = [...this.admissions];
+    for (const admission of admissions) admission.flushRequested = true;
+    for (const item of this.bufferedQueuedItems) this.retainEvent(item);
+    const operations = this.pendingOperations();
+    this.releaseOperations(operations);
+    const admitted = await Promise.allSettled(admissions.map((admission) => admission.completion));
+    const boundary = [.../* @__PURE__ */ new Set([...operations, ...admissions.flatMap((admission) => admission.operations)])];
+    this.releaseOperations(boundary);
+    fireAndForget(this.runQueuedEvents().catch((error) => this.reportOperationFailure(error)));
+    const results = await this.waitForOperations(boundary);
+    const admissionFailure = admitted.find((result) => result.status === "rejected");
+    if (admissionFailure?.status === "rejected") throw admissionFailure.reason;
+    const failure = results.find((result) => !result.ok);
+    if (failure?.ok === false) throw failure.error;
+  }
+  /** Stop watcher admission before draining or preserving accepted work. */
+  async stopWatching() {
+    this.acceptingEvents = false;
+    try {
+      await this.waitForIdle();
+    } catch (error) {
+      this.reportOperationFailure(error);
     }
-    const promises = [...this._waitingMap.entries()].map(([key, waitInfo]) => {
-      return new Promise((resolve) => {
-        waitInfo.canProceed.promise.then(() => {
-          this._log(`Processing ${key}: Wait for idle completed`, LOG_LEVEL_DEBUG);
-        }).catch((e) => {
-          this._log(`Processing ${key}: Wait for idle error`, LOG_LEVEL_INFO);
-          this._log(e, LOG_LEVEL_VERBOSE);
-        }).finally(() => {
-          resolve();
-        });
-        this._proceedWaiting(key);
-      });
-    });
-    const waitPromise = Promise.all(promises).then(() => {
-      this._waitForIdle = null;
-      this._log(`All wait for idle completed`, LOG_LEVEL_VERBOSE);
-    });
-    this._waitForIdle = waitPromise;
-    return waitPromise;
+    await this._takeSnapshot();
   }
   /**
    * Proceed waiting for the given key immediately.
@@ -269,11 +340,13 @@ class StorageEventManagerBase extends StorageEventManager {
     }
     const resolver = promiseWithResolvers();
     const now = Date.now();
-    const since = waitedSince ?? now;
+    const acceptedAt = this.operations.get(event)?.acceptedAt ?? now;
+    const since = waitedSince ?? acceptedAt;
     const elapsed = now - since;
     const maxDelay = this.batchSaveMaximumDelay * 1e3;
     const remainingDelay = Math.max(0, maxDelay - elapsed);
-    const nextDelay = Math.min(remainingDelay, this.batchSaveMinimumDelay * 1e3);
+    const quietDelay = Math.max(0, this.batchSaveMinimumDelay * 1e3 - (now - acceptedAt));
+    const nextDelay = Math.min(remainingDelay, quietDelay);
     if (elapsed >= maxDelay) {
       this._log(`Processing ${key}: Batch save maximum delay already exceeded: ${event.type}`, LOG_LEVEL_DEBUG);
     } else {
@@ -300,71 +373,91 @@ class StorageEventManagerBase extends StorageEventManager {
    * Process the given file event.
    */
   async processFileEvent(fei) {
-    const releaser = await this.concurrentProcessing.acquire();
+    const entry = this.retainEvent(fei);
+    const operation = entry.operation;
+    if (operation.started || operation.result) {
+      const result = await operation.completion.promise;
+      if (result.ok === false) throw result.error;
+      return;
+    }
+    operation.started = true;
+    const path = fei.args.file.path;
+    const relatedPath = fei.type === "RENAME" ? fei.args.oldPath : fei.args.renameTarget;
+    const paths = relatedPath ? [path, relatedPath] : [path];
+    const waiting = this._waitingMap.get(path);
+    let since = operation.acceptedAt;
+    for (const eventPath of paths) {
+      const previous = this.latestByPath.get(eventPath);
+      if (!previous || previous.result?.ok) continue;
+      const canReplace = waiting?.event === previous.event && !previous.flushRequested && (previous.event.type === fei.type || fei.type === "DELETE");
+      if (canReplace) {
+        since = waiting.since;
+        previous.successor = operation;
+        for (const dependency of previous.prerequisites) operation.prerequisites.add(dependency);
+        this._cancelWaiting(eventPath);
+      } else {
+        operation.prerequisites.add(previous);
+        if (this._waitingMap.get(eventPath)?.event === previous.event) this._proceedWaiting(eventPath);
+      }
+    }
+    if (this._waitingMap.get(path) === waiting && waiting) this._proceedWaiting(path);
+    for (const eventPath of paths) this.latestByPath.set(eventPath, operation);
+    if (operation.flushRequested) this.releaseOperations([...operation.prerequisites]);
+    const shouldWait = this.shouldBatchSave && !fei.skipBatchWait && !operation.flushRequested && (fei.type === "CREATE" || fei.type === "CHANGED");
+    const gate = shouldWait ? this._addWaiting(path, fei, since).canProceed.promise : Promise.resolve(true);
     try {
-      this.updateStatus();
-      const filename = fei.args.file.path;
-      const waitingKey = `${filename}`;
-      const previous = this._waitingMap.get(waitingKey);
-      let isShouldBeCancelled = fei.skipBatchWait || false;
-      let previousPromise = Promise.resolve(true);
-      let waitPromise = Promise.resolve(true);
-      if (previous) {
-        previousPromise = previous.canProceed.promise;
-        if (isShouldBeCancelled) {
-          this._log(
-            `Processing ${filename}: Requested to perform immediately, cancelling previous waiting: ${fei.type}`,
-            LOG_LEVEL_DEBUG
-          );
-        }
-        if (!isShouldBeCancelled && fei.type === "DELETE") {
-          this._log(
-            `Processing ${filename}: DELETE requested, cancelling previous waiting: ${fei.type}`,
-            LOG_LEVEL_DEBUG
-          );
-          isShouldBeCancelled = true;
-        }
-        if (!isShouldBeCancelled && previous.type === fei.type) {
-          this._log(`Processing ${filename}: Cancelling previous waiting: ${fei.type}`, LOG_LEVEL_DEBUG);
-          isShouldBeCancelled = true;
-        }
-        if (isShouldBeCancelled) {
-          this._cancelWaiting(waitingKey);
-          this._log(`Processing ${filename}: Previous cancelled: ${fei.type}`, LOG_LEVEL_DEBUG);
-          isShouldBeCancelled = true;
+      await this._takeSnapshot();
+      const canProceed = await gate;
+      if (!canProceed) {
+        if (!operation.successor) throw new Error(`Storage operation cancelled without a successor: ${path}`);
+        const result = await operation.successor.completion.promise;
+        if (result.ok === false) throw result.error;
+      } else {
+        for (const prerequisite of operation.prerequisites) {
+          const result = await prerequisite.completion.promise;
+          if (result.ok === false) throw result.error;
         }
-        if (!isShouldBeCancelled) {
-          this._log(`Processing ${filename}: Waiting for previous to complete: ${fei.type}`, LOG_LEVEL_DEBUG);
-          this._proceedWaiting(waitingKey);
-          this._log(`Processing ${filename}: Previous completed: ${fei.type}`, LOG_LEVEL_DEBUG);
+        const release = await this.concurrentProcessing.acquire();
+        try {
+          await this.requestProcessQueue(fei);
+        } finally {
+          release();
         }
       }
-      await previousPromise;
-      if (this.shouldBatchSave && !fei.skipBatchWait) {
-        if (fei.type == "CREATE" || fei.type == "CHANGED") {
-          const info = this._addWaiting(waitingKey, fei, previous?.since);
-          waitPromise = info.canProceed.promise;
-        } else if (fei.type == "DELETE") {
-        }
-        this._log(`Processing ${filename}: Waiting for batch save: ${fei.type}`, LOG_LEVEL_DEBUG);
-        const canProceed = await waitPromise;
-        if (!canProceed) {
-          this._log(`Processing ${filename}: Cancelled by new queue: ${fei.type}`, LOG_LEVEL_DEBUG);
-          return;
-        }
+      entry.completed = true;
+      try {
+        await this._takeSnapshot();
+      } catch (error) {
+        entry.completed = false;
+        throw error;
+      }
+      operation.result = { ok: true };
+      operation.completion.resolve(operation.result);
+      for (const eventPath of paths) {
+        if (this.latestByPath.get(eventPath) === operation) this.latestByPath.delete(eventPath);
       }
-      await this.requestProcessQueue(fei);
+    } catch (error) {
+      if (this._waitingMap.get(path)?.event === fei) this._cancelWaiting(path);
+      this.failOperation(operation, error);
+      throw error;
     } finally {
-      await this._takeSnapshot();
-      releaser();
+      this.updateStatus();
     }
   }
   async _takeSnapshot() {
-    const processingEvents = [...this._waitingMap.values()].map((e) => e.event);
-    const waitingEvents = this.bufferedQueuedItems;
-    const snapShot = [...processingEvents, ...waitingEvents];
-    await this._saveSnapshot(snapShot);
-    this.updateStatus();
+    for (const event of this.bufferedQueuedItems) this.retainEvent(event);
+    for (const waiting of this._waitingMap.values()) this.retainEvent(waiting.event);
+    const save = this.snapshotTail.then(async () => {
+      const entries = [...this.pendingSnapshot.values()];
+      const completed = entries.filter((entry) => entry.completed);
+      const snapshot = entries.filter((entry) => !entry.completed).map((entry) => entry.event);
+      await this._saveSnapshot(snapshot);
+      for (const entry of completed) this.pendingSnapshot.delete(entry.event);
+      this.updateStatus();
+    });
+    this.snapshotTail = save.catch(() => {
+    });
+    await save;
   }
   async _restoreFromSnapshot() {
     const snapShot = await this._loadSnapshot();
@@ -389,55 +482,42 @@ class StorageEventManagerBase extends StorageEventManager {
    * An individual restored operation failure is logged but does not prevent the
    * following Offline Scanner from reconciling the resulting current state.
    */
-  runQueuedEvents(options = {}) {
-    const waitForProcessing = options.waitForProcessing ?? false;
-    return skipIfDuplicated("storage-event-manager-run-queued-events", async () => {
-      let dispatched = [];
-      const waitForDispatched = async () => {
-        if (dispatched.length === 0) return;
-        const pending = dispatched;
-        dispatched = [];
-        const results = await Promise.allSettled(pending.map(({ processing }) => processing));
-        for (const [index, result] of results.entries()) {
-          if (result.status === "rejected") {
-            this._log(
-              `Restored storage operation failed for ${pending[index].path}; the Offline Scanner will reconcile the current state`,
-              LOG_LEVEL_NOTICE
-            );
-            this._log(result.reason, LOG_LEVEL_VERBOSE);
+  async runQueuedEvents(options = {}) {
+    for (const event of this.bufferedQueuedItems) this.retainEvent(event);
+    const accepted = this.pendingOperations();
+    if (!this.dispatching) {
+      const dispatch = async () => {
+        while (this.bufferedQueuedItems.length > 0) {
+          const event = this.bufferedQueuedItems.shift();
+          const entry = this.retainEvent(event);
+          if (event.type === TYPE_SENTINEL_FLUSH) {
+            const results = await this.waitForOperations(this.pendingOperations(entry.sequence));
+            if (results.every((result) => result.ok)) {
+              entry.completed = true;
+              try {
+                await this._takeSnapshot();
+              } catch (error) {
+                entry.completed = false;
+                this.reportOperationFailure(error);
+              }
+            }
+          } else if (!entry.operation.result) {
+            fireAndForget(this.processFileEvent(event).catch(() => {
+            }));
           }
         }
       };
-      do {
-        if (this.bufferedQueuedItems.length === 0) {
-          break;
-        }
-        const fei = this.bufferedQueuedItems.shift();
-        await this._takeSnapshot();
-        this.updateStatus();
-        const releaser = await this.concurrentProcessing.acquire();
-        releaser();
-        this.updateStatus();
-        if (fei.type === TYPE_SENTINEL_FLUSH) {
-          this._log(`Waiting for idle`, LOG_LEVEL_VERBOSE);
-          if (waitForProcessing) {
-            await waitForDispatched();
-          }
-          await this.waitForIdle();
-          this.updateStatus();
-          continue;
-        }
-        const processing = this.processFileEvent(fei);
-        if (waitForProcessing) {
-          dispatched.push({ path: fei.args.file.path, processing });
-        } else {
-          fireAndForget(processing);
-        }
-      } while (this.bufferedQueuedItems.length > 0);
-      if (waitForProcessing) {
-        await waitForDispatched();
+      this.dispatching = dispatch().finally(() => {
+        this.dispatching = null;
+      });
+    }
+    await this.dispatching;
+    if (options.waitForProcessing) {
+      const results = await this.waitForOperations(accepted);
+      for (const result of results) {
+        if (result.ok === false) this.reportOperationFailure(result.error);
       }
-    });
+    }
   }
   processingCount = 0;
   async requestProcessQueue(fei) {
@@ -445,50 +525,49 @@ class StorageEventManagerBase extends StorageEventManager {
       this.processingCount++;
       this.updateStatus();
       await this.handleFileEvent(fei);
-      await this._takeSnapshot();
     } finally {
       this.processingCount--;
       this.updateStatus();
     }
   }
+  hasPendingFileEvent(filename) {
+    for (const entry of this.pendingSnapshot.values()) {
+      if (entry.completed || entry.event.type === TYPE_SENTINEL_FLUSH) continue;
+      const event = entry.event;
+      const relatedPath = event.type === "RENAME" ? event.args.oldPath : event.args.renameTarget;
+      if ([event.args.file.path, relatedPath].some((path) => path && (filename === path || filename.startsWith(`${path}/`)))) return true;
+    }
+    return false;
+  }
   isWaiting(filename) {
-    return isWaitingForTimeout(`storage-event-manager-batchsave-${filename}`);
+    return this._waitingMap.has(filename);
   }
   async handleFileEvent(queue) {
     const file = queue.args.file;
-    const lockKey = `handleFile:${file.path}`;
-    await serialized(lockKey, async () => {
-      if (queue.cancelled) {
-        this._log(`File event cancelled before processing: ${file.path}`, LOG_LEVEL_INFO);
-        return;
-      }
-      if (queue.type == "INTERNAL" || file.isInternal) {
-        await this.fileProcessing.processOptionalFileEvent(file.path);
-      } else {
-        const last = 0;
-        if (queue.type == "DELETE") {
-          await this.fileProcessing.processFileEvent(queue);
-        } else {
-          if (file.stat.mtime == last) {
-            this._log(
-              `File has been already scanned on ${queue.type}, skip: ${file.path}`,
-              LOG_LEVEL_VERBOSE
-            );
-            return;
+    await serialized(`handleFile:${file.path}`, async () => {
+      if (queue.cancelled) throw new Error(`Storage operation has no confirmed result: ${file.path}`);
+      if (queue.type === "INTERNAL" || file.isInternal) {
+        const handler = this.fileProcessing.processOptionalFileEventWithResult;
+        if (handler && handler.hasHandlers !== false) {
+          const operation = this.operations.get(queue);
+          let whenFlushRequested;
+          if (operation) {
+            operation.flushSignal ??= promiseWithResolvers();
+            if (operation.flushRequested) operation.flushSignal.resolve();
+            whenFlushRequested = operation.flushSignal.promise;
           }
-          if (!await this.fileProcessing.processFileEvent(queue)) {
-            this._log(
-              `STORAGE -> DB: Handler failed, cancel the relative operations: ${file.path}`,
-              LOG_LEVEL_INFO
-            );
-            this.cancelRelativeEvent(queue);
-            return;
+          const outcome = await handler(file.path, { whenFlushRequested });
+          if (outcome.kind === "veto") {
+            throw new Error(`Optional storage operation declined: ${file.path} (${outcome.value})`);
           }
+        } else {
+          await this.fileProcessing.processOptionalFileEvent(file.path);
         }
+      } else if (!await this.fileProcessing.processFileEvent(queue)) {
+        throw new Error(`Storage operation failed: ${file.path}`);
       }
     });
     this.updateStatus();
-    return;
   }
   cancelRelativeEvent(item) {
     this._cancelWaiting(item.args.file.path);

package/dist/replication/LiveSyncAbstractReplicator.d.ts

@@ -1,3 +1,4 @@
+import type { ReplicationStatics } from "../common/models/shared.definition.js";
 import { type EntryDoc, type DatabaseConnectingStatus, type RemoteDBSettings, type TweakValues, type RemotePreferredTweakResult, type NodeData } from "../common/types.js";
 import type { RequiredServices } from "../interfaces/ServiceModule.js";
 import type { TranslationParameters } from "../services/base/MessageTranslator.js";
@@ -62,6 +63,7 @@ export declare abstract class LiveSyncAbstractReplicator implements ReplicatorIn
     constructor(env: LiveSyncReplicatorEnv);
     abstract terminateSync(): void | Promise<void>;
     abstract openReplication(setting: RemoteDBSettings, keepAlive: boolean, showResult: boolean, ignoreCleanLock: boolean): Promise<void | boolean>;
+    protected getReplicationStatics(): ReplicationStatics;
     updateInfo: () => void;
     abstract tryConnectRemote(setting: RemoteDBSettings, showResult?: boolean): Promise<boolean>;
     abstract replicateAllToServer(setting: RemoteDBSettings, showingNotice?: boolean): Promise<boolean>;

package/dist/replication/LiveSyncAbstractReplicator.js

@@ -75,8 +75,8 @@ class LiveSyncAbstractReplicator {
   constructor(env) {
     this.env = env;
   }
-  updateInfo = () => {
-    this.env.services.replicator.replicationStatics.value = {
+  getReplicationStatics() {
+    return {
       sent: this.docSent,
       arrived: this.docArrived,
       maxPullSeq: this.maxPullSeq,
@@ -85,6 +85,9 @@ class LiveSyncAbstractReplicator {
       lastSyncPushSeq: this.lastSyncPushSeq,
       syncStatus: this.syncStatus
     };
+  }
+  updateInfo = () => {
+    this.env.services.replicator.replicationStatics.value = this.getReplicationStatics();
   };
 }
 export {

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

@@ -1,3 +1,4 @@
+import type { ReplicationStatics } from "../../common/models/shared.definition.js";
 import { type EntryDoc, type RemoteDBSettings, type EntryLeaf, type SyncParameters, type DatabaseEntry, type NodeData, type RemotePreferredTweakResult } from "../../common/types.js";
 import type { InitialFetchFastForwardResource } from "../RemoteResource.js";
 import { LiveSyncAbstractReplicator, type LiveSyncReplicatorEnv, type RemoteDBStatus } from "../LiveSyncAbstractReplicator.js";
@@ -45,6 +46,11 @@ export declare class LiveSyncCouchDBReplicator extends LiveSyncAbstractReplicato
     private continuousTask;
     private continuousStopWaiter;
     private continuousStopRequested;
+    private continuousPhase?;
+    private couchDBProgress?;
+    protected getReplicationStatics(): ReplicationStatics;
+    private publishPreparationPhase;
+    private finishReplicationProgress;
     isMobile(): boolean;
     constructor(env: LiveSyncCouchDBReplicatorEnv);
     /** Own the checkpoint handoff for one fresh, suspended Fast Fetch only. */