@vrtmrz/livesync-commonlib 0.1.19-rc.0 → 0.1.20

package/dist/replication/couchdb/LiveSyncReplicator.js

@@ -42,6 +42,18 @@ import {
   SyncParamsUpdateError
 } from "../SyncParamsHandler.js";
 import { compatGlobal } from "../../common/coreEnvFunctions.js";
+import {
+  CENTRAL_COMPATIBILITY_ACCEPTED,
+  CENTRAL_COMPATIBILITY_NOT_ASSESSED,
+  CENTRAL_COMPATIBILITY_REJECTION_REASONS,
+  centralCompatibilityRejected,
+  centralCompatibilityRecoveryHint
+} from "../CentralCompatibility.js";
+import {
+  outcomeFromFiniteOpenReplication,
+  replicationBlocked,
+  replicationFailed
+} from "../ReplicatorProvider.js";
 const currentVersionRange = {
   min: 0,
   max: 2400,
@@ -49,6 +61,7 @@ const currentVersionRange = {
 };
 const selectorOnDemandPull = { selector: { type: { $ne: "leaf" } } };
 const DEFAULT_ONE_SHOT_CONNECTIVITY_TIMEOUT_MS = 6e4;
+const ONE_SHOT_REPLICATION_ALREADY_RUNNING = /* @__PURE__ */ Symbol("one-shot-replication-already-running");
 class OneShotConnectivityPreflightTimeoutError extends Error {
   constructor(timeoutMs) {
     super(`Remote connectivity preflight exceeded ${timeoutMs} ms.`);
@@ -96,6 +109,13 @@ async function* genReplication(s, signal) {
   }
 }
 class LiveSyncCouchDBReplicator extends LiveSyncAbstractReplicator {
+  /**
+   * Keep Continuous ownership visible before CouchDB has created its live
+   * controller, so a stop request cannot be lost during catch-up.
+   */
+  continuousTask;
+  continuousStopWaiter;
+  continuousStopRequested = false;
   isMobile() {
     return this.env.services.API.isMobile();
   }
@@ -147,23 +167,69 @@ class LiveSyncCouchDBReplicator extends LiveSyncAbstractReplicator {
     Logger(`Database updated from ${from} to ${to}`, LOG_LEVEL_NOTICE);
     return Promise.resolve(true);
   }
+  /** Abort only the active controller; internal transitions must not await their own task. */
+  abortController() {
+    this.controller?.abort();
+    this.controller = void 0;
+  }
+  /**
+   * Request cancellation of the current transfer and share the tracked
+   * Continuous settlement when startup has not created a controller yet.
+   */
   terminateSync() {
-    if (!this.controller) {
-      return;
+    const task = this.continuousTask;
+    if (task) {
+      this.continuousStopRequested = true;
     }
-    this.controller.abort();
-    this.controller = void 0;
+    this.abortController();
+    if (!task) {
+      return Promise.resolve();
+    }
+    return this.continuousStopWaiter ??= task.then(
+      () => void 0,
+      () => void 0
+    );
   }
   async openReplication(setting, keepAlive, showResult, ignoreCleanLock) {
-    if (!await this.initializeDatabaseForReplication()) {
-      return false;
-    }
+    if (!this.nodeid) return false;
     if (keepAlive) {
       void this.openContinuousReplication(setting, showResult, false);
     } else {
       return this.openOneShotReplication(setting, showResult, false, "sync", ignoreCleanLock);
     }
   }
+  /**
+   * Run one finite CouchDB attempt and retain only its own compatibility result.
+   *
+   * The decision is stack-local. A transport failure before assessment has no
+   * recovery hint, and a rejected assessment cannot leak into a later attempt.
+   */
+  async openOneShotReplicationWithOutcome(setting, showResult, ignoreCleanLock = false) {
+    return await this.runOneShotReplicationWithOutcome(setting, showResult, "sync", ignoreCleanLock);
+  }
+  /** Capture the compatibility decision made by this exact directional connection. */
+  async runOneShotReplicationWithOutcome(setting, showResult, syncMode, ignoreCleanLock = false) {
+    let decision = CENTRAL_COMPATIBILITY_NOT_ASSESSED;
+    const recordDecision = (next) => {
+      decision = next;
+    };
+    try {
+      const result = await this.runOneShotReplication(
+        setting,
+        showResult,
+        false,
+        syncMode,
+        ignoreCleanLock,
+        recordDecision
+      );
+      if (result === ONE_SHOT_REPLICATION_ALREADY_RUNNING) {
+        return replicationBlocked("replication-in-progress");
+      }
+      return outcomeFromFiniteOpenReplication(result, centralCompatibilityRecoveryHint(decision));
+    } catch (error) {
+      return replicationFailed(error, centralCompatibilityRecoveryHint(decision));
+    }
+  }
   replicationActivated(showResult) {
     this.syncStatus = "CONNECTED";
     this.updateInfo();
@@ -200,18 +266,18 @@ class LiveSyncCouchDBReplicator extends LiveSyncAbstractReplicator {
     this.syncStatus = "COMPLETED";
     this.updateInfo();
     Logger("Replication completed", showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO, showResult ? "sync" : "");
-    this.terminateSync();
+    this.abortController();
   }
   replicationDenied(e) {
     this.syncStatus = "ERRORED";
     this.updateInfo();
-    this.terminateSync();
+    this.abortController();
     Logger("Replication denied", LOG_LEVEL_NOTICE, "sync");
     Logger(e, LOG_LEVEL_VERBOSE);
   }
   replicationErrored(e) {
     this.syncStatus = "ERRORED";
-    this.terminateSync();
+    this.abortController();
     this.updateInfo();
     Logger("Replication error", LOG_LEVEL_NOTICE, "sync");
     Logger(e, LOG_LEVEL_VERBOSE);
@@ -315,7 +381,7 @@ class LiveSyncCouchDBReplicator extends LiveSyncAbstractReplicator {
       Logger(ex, LOG_LEVEL_VERBOSE);
       return "FAILED";
     } finally {
-      this.terminateSync();
+      this.abortController();
       this.controller = void 0;
     }
   }
@@ -444,22 +510,18 @@ class LiveSyncCouchDBReplicator extends LiveSyncAbstractReplicator {
         );
       }
     }
-    let bulkDocs = [];
-    let bulkDocsSizeBytes = 0;
-    let bulkDocsSizeCount = 0;
-    let maxSeq = 0;
     const maxBatchSizeBytes = setting.sendChunksBulkMaxSize * 1024 * 1024;
     const maxBatchSizeCount = 200;
     const semaphore = Semaphore(4);
     let sendingDocs = 0;
     let sentDocsCount = 0;
-    const sendChunks = async (bulkDocs2, bulkDocsSize, seq2) => {
+    const sendChunks = async (bulkDocs, bulkDocsSize, seq2) => {
       Logger(
-        `Sending ${bulkDocs2.length} (${bulkDocsSize} => ${sizeToHumanReadable(bulkDocsSize)} in plain) chunks to remote database...`,
+        `Sending ${bulkDocs.length} (${bulkDocsSize} => ${sizeToHumanReadable(bulkDocsSize)} in plain) chunks to remote database...`,
         LOG_LEVEL_VERBOSE
       );
       const releaser = await semaphore.acquire(1);
-      sendingDocs += bulkDocs2.length;
+      sendingDocs += bulkDocs.length;
       Logger(
         `\u2191 Uploading chunks 
 ${sendingDocs}/(${sentDocsCount} done)`,
@@ -467,12 +529,12 @@ ${sendingDocs}/(${sentDocsCount} done)`,
         "send"
       );
       try {
-        const uploadBulkDocTasks = bulkDocs2.map((e) => preprocessOutgoing(e));
+        const uploadBulkDocTasks = bulkDocs.map((e) => preprocessOutgoing(e));
         const uploadBulkDocs = await Promise.all(uploadBulkDocTasks);
         await remoteDB.bulkDocs(uploadBulkDocs, { new_edits: false });
         uploadBulkDocs.forEach((e) => sentMap[idSeqMap[e._id]] = true);
         await this.updateMaxTransferredSeqOnChunks(localDB, remoteID, sentMap);
-        sentDocsCount += bulkDocs2.length;
+        sentDocsCount += bulkDocs.length;
         Logger(
           `\u2191 Uploading chunks 
 ${sendingDocs}/(${sentDocsCount} done)`,
@@ -488,12 +550,16 @@ ${sendingDocs}/(${sentDocsCount} done)`,
       }
       return true;
     };
-    const tasks = [];
     do {
       const nowSendChunks = await trench.dequeue("send-chunks");
       if (!nowSendChunks || nowSendChunks.length == 0) {
         break;
       }
+      let bulkDocs = [];
+      let bulkDocsSizeBytes = 0;
+      let bulkDocsSizeCount = 0;
+      let maxSeq = 0;
+      const tasks = [];
       for (const chunk of nowSendChunks) {
         const jsonLength = te.encode(JSON.stringify(chunk.doc)).byteLength + 32;
         if ((bulkDocsSizeBytes + jsonLength > maxBatchSizeBytes || bulkDocsSizeCount + 1 > maxBatchSizeCount) && bulkDocs.length > 0) {
@@ -513,7 +579,7 @@ ${sendingDocs}/(${sentDocsCount} done)`,
       const results = await Promise.all(
         tasks.map(async (e) => {
           try {
-            await e;
+            return await e;
           } catch (ex) {
             Logger("Bulk sending failed.", showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO, "send");
             Logger(ex, LOG_LEVEL_VERBOSE);
@@ -527,111 +593,196 @@ ${sendingDocs}/(${sentDocsCount} done)`,
     } while (true);
     return true;
   }
-  async openOneShotReplication(setting, showResult, retrying, syncMode, ignoreCleanLock = false) {
-    if (await this.ensurePBKDF2Salt(setting, showResult, !retrying) === false) {
+  /** Run one finite transfer through the legacy boolean settlement contract. */
+  async openOneShotReplication(setting, showResult, retrying, syncMode, ignoreCleanLock = false, recordCompatibilityDecision, cancellationRequested = () => false) {
+    const result = await this.runOneShotReplication(
+      setting,
+      showResult,
+      retrying,
+      syncMode,
+      ignoreCleanLock,
+      recordCompatibilityDecision,
+      cancellationRequested
+    );
+    return result === ONE_SHOT_REPLICATION_ALREADY_RUNNING ? false : result;
+  }
+  /**
+   * Run one finite CouchDB transfer and close its owned remote connection.
+   *
+   * The caller which enters the shared task owns Security Seed preparation,
+   * transfer, and any retry or resurrection continuation. A joining caller
+   * waits for the shared step only so it cannot race the owner, then receives
+   * the internal non-admission result without running that continuation.
+   *
+   * Continuous catch-up supplies `cancellationRequested` so a stop observed
+   * during awaited preparation cannot proceed to a later connection or
+   * controller. The admitted owner retains the established transfer behaviour.
+   */
+  async runOneShotReplication(setting, showResult, retrying, syncMode, ignoreCleanLock = false, recordCompatibilityDecision, cancellationRequested = () => false) {
+    if (cancellationRequested()) {
       return false;
     }
-    const next = await shareRunningResult("oneShotReplication", async () => {
-      if (this.controller) {
-        Logger(
-          this.translate("liveSyncReplicator.replicationInProgress"),
-          showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO,
-          "sync"
-        );
-        return false;
-      }
-      const localDB = this.rawDatabase;
-      Logger(this.translate("liveSyncReplicator.oneShotSyncBegin", { syncMode }));
-      const ret = await this.checkOneShotReplicationConnectivity(setting, retrying, showResult, ignoreCleanLock);
-      if (ret === false) {
-        Logger(
-          this.translate("liveSyncReplicator.couldNotConnectToServer"),
-          showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO,
-          "sync"
-        );
-        return false;
-      }
-      const { db, syncOptionBase } = ret;
-      try {
-        this.maxPullSeq = Number(`${ret.info.update_seq}`.split("-")[0]);
-        this.maxPushSeq = Number(`${(await localDB.info()).update_seq}`.split("-")[0]);
-        if (showResult) {
-          Logger(this.translate("liveSyncReplicator.checkingLastSyncPoint"), LOG_LEVEL_NOTICE, "sync");
-        }
-        this.syncStatus = "STARTED";
-        this.updateInfo();
-        const docArrivedOnStart = this.docArrived;
-        const docSentOnStart = this.docSent;
-        if (!retrying) {
-          this.originalSetting = setting;
+    let ownsSharedAttempt = false;
+    let next;
+    try {
+      next = await shareRunningResult("oneShotReplication", async () => {
+        ownsSharedAttempt = true;
+        if (cancellationRequested()) {
+          return false;
         }
-        this.terminateSync();
-        const syncHandler = syncMode == "sync" ? localDB.sync(db, { ...syncOptionBase }) : syncMode == "pullOnly" ? localDB.replicate.from(db, {
-          ...syncOptionBase,
-          ...setting.readChunksOnline ? selectorOnDemandPull : {}
-        }) : syncMode == "pushOnly" ? localDB.replicate.to(db, { ...syncOptionBase }) : void 0;
-        const syncResult = await this.processSync(
-          syncHandler,
-          showResult,
-          docSentOnStart,
-          docArrivedOnStart,
-          syncMode,
-          retrying,
-          false
-        );
-        if (syncResult == "DONE") {
-          return true;
+        if (await this.ensurePBKDF2Salt(setting, showResult, !retrying) === false || cancellationRequested()) {
+          return false;
         }
-        if (syncResult == "CANCELLED") {
+        if (this.controller) {
+          Logger(
+            this.translate("liveSyncReplicator.replicationInProgress"),
+            showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO,
+            "sync"
+          );
           return false;
         }
-        if (syncResult == "FAILED") {
+        const localDB = this.rawDatabase;
+        Logger(this.translate("liveSyncReplicator.oneShotSyncBegin", { syncMode }));
+        const ret = await this.checkOneShotReplicationConnectivity(
+          setting,
+          false,
+          showResult,
+          ignoreCleanLock,
+          recordCompatibilityDecision
+        );
+        if (ret === false) {
+          if (!cancellationRequested()) {
+            Logger(
+              this.translate("liveSyncReplicator.couldNotConnectToServer"),
+              showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO,
+              "sync"
+            );
+          }
           return false;
         }
-        if (syncResult == "NEED_RESURRECT") {
-          this.terminateSync();
-          return async () => await this.openOneShotReplication(
-            this.originalSetting,
+        const { db, syncOptionBase } = ret;
+        try {
+          if (cancellationRequested()) {
+            return false;
+          }
+          this.maxPullSeq = Number(`${ret.info.update_seq}`.split("-")[0]);
+          this.maxPushSeq = Number(`${(await localDB.info()).update_seq}`.split("-")[0]);
+          if (cancellationRequested()) {
+            return false;
+          }
+          if (showResult) {
+            Logger(this.translate("liveSyncReplicator.checkingLastSyncPoint"), LOG_LEVEL_NOTICE, "sync");
+          }
+          this.syncStatus = "STARTED";
+          this.updateInfo();
+          const docArrivedOnStart = this.docArrived;
+          const docSentOnStart = this.docSent;
+          if (!retrying) {
+            this.originalSetting = setting;
+          }
+          this.abortController();
+          if (cancellationRequested()) {
+            return false;
+          }
+          const syncHandler = syncMode == "sync" ? localDB.sync(db, { ...syncOptionBase }) : syncMode == "pullOnly" ? localDB.replicate.from(db, {
+            ...syncOptionBase,
+            ...setting.readChunksOnline ? selectorOnDemandPull : {}
+          }) : syncMode == "pushOnly" ? localDB.replicate.to(db, { ...syncOptionBase }) : void 0;
+          const syncResult = await this.processSync(
+            syncHandler,
             showResult,
-            false,
+            docSentOnStart,
+            docArrivedOnStart,
             syncMode,
-            ignoreCleanLock
+            retrying,
+            false
           );
-        }
-        if (syncResult == "NEED_RETRY") {
-          const tempSetting = JSON.parse(JSON.stringify(setting));
-          tempSetting.batch_size = Math.ceil(tempSetting.batch_size / 2) + 2;
-          tempSetting.batches_limit = Math.ceil(tempSetting.batches_limit / 2) + 2;
-          if (tempSetting.batch_size <= 5 && tempSetting.batches_limit <= 5) {
-            Logger(
-              this.translate("liveSyncReplicator.cantReplicateLowerValue"),
-              showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO
-            );
+          if (cancellationRequested()) {
             return false;
-          } else {
-            Logger(
-              this.translate("liveSyncReplicator.retryLowerBatchSize", {
-                batch_size: tempSetting.batch_size.toString(),
-                batches_limit: tempSetting.batches_limit.toString()
-              }),
-              showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO
+          }
+          if (syncResult == "DONE") {
+            return true;
+          }
+          if (syncResult == "CANCELLED") {
+            return false;
+          }
+          if (syncResult == "FAILED") {
+            return false;
+          }
+          if (syncResult == "NEED_RESURRECT") {
+            this.abortController();
+            return async () => await this.runOneShotReplication(
+              this.originalSetting,
+              showResult,
+              false,
+              syncMode,
+              ignoreCleanLock,
+              recordCompatibilityDecision,
+              cancellationRequested
             );
-            return async () => await this.openOneShotReplication(tempSetting, showResult, true, syncMode, ignoreCleanLock);
           }
+          if (syncResult == "NEED_RETRY") {
+            const tempSetting = JSON.parse(JSON.stringify(setting));
+            tempSetting.batch_size = Math.ceil(tempSetting.batch_size / 2) + 2;
+            tempSetting.batches_limit = Math.ceil(tempSetting.batches_limit / 2) + 2;
+            if (tempSetting.batch_size <= 5 && tempSetting.batches_limit <= 5) {
+              Logger(
+                this.translate("liveSyncReplicator.cantReplicateLowerValue"),
+                showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO
+              );
+              return false;
+            } else {
+              Logger(
+                this.translate("liveSyncReplicator.retryLowerBatchSize", {
+                  batch_size: tempSetting.batch_size.toString(),
+                  batches_limit: tempSetting.batches_limit.toString()
+                }),
+                showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO
+              );
+              return async () => await this.runOneShotReplication(
+                tempSetting,
+                showResult,
+                true,
+                syncMode,
+                ignoreCleanLock,
+                recordCompatibilityDecision,
+                cancellationRequested
+              );
+            }
+          }
+          return false;
+        } finally {
+          await this.closeRemoteConnection(ret);
         }
-        return false;
-      } finally {
-        await this.closeRemoteConnection(ret);
+      });
+    } catch (error) {
+      if (!ownsSharedAttempt) {
+        return ONE_SHOT_REPLICATION_ALREADY_RUNNING;
       }
-    });
+      throw error;
+    }
+    if (!ownsSharedAttempt) {
+      return ONE_SHOT_REPLICATION_ALREADY_RUNNING;
+    }
     if (typeof next === "boolean") {
       return next;
     }
     return await next();
   }
-  async checkOneShotReplicationConnectivity(setting, skipCheck, showResult, ignoreCleanLock) {
+  async checkOneShotReplicationConnectivity(setting, skipCheck, showResult, ignoreCleanLock, recordCompatibilityDecision) {
     if (setting.useRequestAPI) {
-      return await this.checkReplicationConnectivity(setting, false, skipCheck, showResult, ignoreCleanLock);
+      if (!recordCompatibilityDecision) {
+        return await this.checkReplicationConnectivity(setting, false, skipCheck, showResult, ignoreCleanLock);
+      }
+      return await this.checkReplicationConnectivity(
+        setting,
+        false,
+        skipCheck,
+        showResult,
+        ignoreCleanLock,
+        void 0,
+        recordCompatibilityDecision
+      );
     }
     const timeoutMs = this.env.oneShotConnectivityTimeoutMs ?? DEFAULT_ONE_SHOT_CONNECTIVITY_TIMEOUT_MS;
     const controller = new AbortController();
@@ -640,10 +791,18 @@ ${sendingDocs}/(${sentDocsCount} done)`,
       timeoutMs
     );
     try {
-      return await this.checkReplicationConnectivity(setting, false, skipCheck, showResult, ignoreCleanLock, {
-        signal: controller.signal,
-        allowNativeFallback: false
-      });
+      return await this.checkReplicationConnectivity(
+        setting,
+        false,
+        skipCheck,
+        showResult,
+        ignoreCleanLock,
+        {
+          signal: controller.signal,
+          allowNativeFallback: false
+        },
+        recordCompatibilityDecision
+      );
     } finally {
       compatGlobal.clearTimeout(timeout);
     }
@@ -666,9 +825,15 @@ ${sendingDocs}/(${sentDocsCount} done)`,
   replicateAllToServer(setting, showingNotice) {
     return this.openOneShotReplication(setting, showingNotice ?? false, false, "pushOnly");
   }
+  replicateAllToServerWithOutcome(setting, showingNotice) {
+    return this.runOneShotReplicationWithOutcome(setting, showingNotice ?? false, "pushOnly");
+  }
   replicateAllFromServer(setting, showingNotice) {
     return this.openOneShotReplication(setting, showingNotice ?? false, false, "pullOnly");
   }
+  replicateAllFromServerWithOutcome(setting, showingNotice) {
+    return this.runOneShotReplicationWithOutcome(setting, showingNotice ?? false, "pullOnly");
+  }
   reportConnectivityPreflightTimeout(connectionOptions, showResult, error) {
     if (!connectionOptions?.signal?.aborted || !(connectionOptions.signal.reason instanceof OneShotConnectivityPreflightTimeoutError)) {
       return false;
@@ -679,7 +844,8 @@ ${sendingDocs}/(${sentDocsCount} done)`,
     }
     return true;
   }
-  async checkReplicationConnectivity(setting, keepAlive, skipCheck, showResult, ignoreCleanLock = false, connectionOptions) {
+  async checkReplicationConnectivity(setting, keepAlive, skipCheck, showResult, ignoreCleanLock = false, connectionOptions, recordCompatibilityDecision) {
+    recordCompatibilityDecision?.(CENTRAL_COMPATIBILITY_NOT_ASSESSED);
     if (setting.versionUpFlash != "") {
       Logger(this.translate("Replicator.Message.VersionUpFlash"), LOG_LEVEL_NOTICE);
       return false;
@@ -717,15 +883,18 @@ ${sendingDocs}/(${sentDocsCount} done)`,
     let ownershipTransferred = false;
     try {
       if (!skipCheck) {
-        if (!await checkRemoteVersion(dbRet.db, this.migrate.bind(this), VER)) {
-          Logger(this.translate("liveSyncReplicator.remoteDbCorrupted"), LOG_LEVEL_NOTICE);
-          return false;
-        }
         this.remoteCleaned = false;
         this.remoteLocked = false;
         this.remoteLockedAndDeviceNotAccepted = false;
         this.tweakSettingsMismatched = false;
         this.preferredTweakValue = void 0;
+        if (!await checkRemoteVersion(dbRet.db, this.migrate.bind(this), VER)) {
+          recordCompatibilityDecision?.(
+            centralCompatibilityRejected(CENTRAL_COMPATIBILITY_REJECTION_REASONS.INCOMPATIBLE_VERSION)
+          );
+          Logger(this.translate("liveSyncReplicator.remoteDbCorrupted"), LOG_LEVEL_NOTICE);
+          return false;
+        }
         const progress = `${dbRet.info.update_seq}`;
         const info = {
           app_version: this.env.services.API.getAppVersion(),
@@ -742,12 +911,18 @@ ${sendingDocs}/(${sentDocsCount} done)`,
           info
         );
         if (ensure == "INCOMPATIBLE") {
+          recordCompatibilityDecision?.(
+            centralCompatibilityRejected(CENTRAL_COMPATIBILITY_REJECTION_REASONS.INCOMPATIBLE_VERSION)
+          );
           Logger(
             "The remote database has no compatibility with the running version. Please upgrade the plugin.",
             LOG_LEVEL_NOTICE
           );
           return false;
         } else if (ensure == "NODE_LOCKED") {
+          recordCompatibilityDecision?.(
+            centralCompatibilityRejected(CENTRAL_COMPATIBILITY_REJECTION_REASONS.NODE_LOCKED)
+          );
           Logger(
             "The remote database has been rebuilt or corrupted since we have synchronized last time. Fetch rebuilt DB, explicit unlocking or chunk clean-up is required.",
             LOG_LEVEL_NOTICE
@@ -761,6 +936,9 @@ ${sendingDocs}/(${sentDocsCount} done)`,
           if (ignoreCleanLock) {
             this.remoteLocked = true;
           } else {
+            recordCompatibilityDecision?.(
+              centralCompatibilityRejected(CENTRAL_COMPATIBILITY_REJECTION_REASONS.NODE_CLEANED)
+            );
             Logger(
               "The remote database has been cleaned up. Fetch rebuilt DB, explicit unlocking or chunk clean-up is required.",
               LOG_LEVEL_NOTICE
@@ -772,11 +950,15 @@ ${sendingDocs}/(${sentDocsCount} done)`,
           }
         } else if (ensure == "OK") {
         } else if (ensure[0] == "MISMATCHED") {
+          recordCompatibilityDecision?.(
+            centralCompatibilityRejected(CENTRAL_COMPATIBILITY_REJECTION_REASONS.TWEAK_MISMATCH, ensure[1])
+          );
           Logger(this.translate("liveSyncReplicator.mismatchedTweakDetected"), LOG_LEVEL_NOTICE);
           this.tweakSettingsMismatched = true;
           this.preferredTweakValue = ensure[1];
           return false;
         }
+        recordCompatibilityDecision?.(CENTRAL_COMPATIBILITY_ACCEPTED);
       }
       const syncOptionBase = {
         batches_limit: setting.batches_limit,
@@ -808,9 +990,37 @@ ${sendingDocs}/(${sentDocsCount} done)`,
       }
     }
   }
-  async openContinuousReplication(setting, showResult, retrying) {
+  openContinuousReplication(setting, showResult, retrying) {
+    if (this.continuousTask) {
+      return this.continuousTask;
+    }
+    this.continuousStopRequested = false;
+    this.continuousStopWaiter = void 0;
+    let resolveTask;
+    let rejectTask;
+    const task = new Promise((resolve, reject) => {
+      resolveTask = resolve;
+      rejectTask = reject;
+    });
+    this.continuousTask = task;
+    void task.then(
+      () => this.clearContinuousTask(task),
+      () => this.clearContinuousTask(task)
+    );
+    void this.runContinuousReplication(setting, showResult, retrying).then(resolveTask, rejectTask);
+    return task;
+  }
+  clearContinuousTask(task) {
+    if (this.continuousTask !== task) {
+      return;
+    }
+    this.continuousTask = void 0;
+    this.continuousStopWaiter = void 0;
+    this.continuousStopRequested = false;
+  }
+  async runContinuousReplication(setting, showResult, retrying) {
     const next = await shareRunningResult("continuousReplication", async () => {
-      if (this.controller) {
+      if (this.continuousStopRequested || this.controller) {
         Logger(
           this.translate("liveSyncReplicator.replicationInProgress"),
           showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO
@@ -820,17 +1030,30 @@ ${sendingDocs}/(${sentDocsCount} done)`,
       const localDB = this.rawDatabase;
       Logger(this.translate("liveSyncReplicator.beforeLiveSync"));
       const caughtUp = await this.env.services.replicator.runFiniteReplicationActivity(
-        () => this.openOneShotReplication(setting, showResult, false, "pullOnly"),
+        () => this.openOneShotReplication(
+          setting,
+          showResult,
+          false,
+          "pullOnly",
+          false,
+          void 0,
+          () => this.continuousStopRequested
+        ),
         { label: "replication" }
       );
-      if (caughtUp) {
+      if (caughtUp && !this.continuousStopRequested) {
         Logger(this.translate("liveSyncReplicator.liveSyncBegin"));
-        const ret = await this.checkReplicationConnectivity(setting, true, true, showResult);
-        if (ret === false) {
-          Logger(
-            this.translate("liveSyncReplicator.couldNotConnectToServer"),
-            showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO
-          );
+        const ret = await this.checkReplicationConnectivity(setting, true, false, showResult);
+        if (ret === false || this.continuousStopRequested) {
+          if (ret !== false) {
+            await this.closeRemoteConnection(ret);
+          }
+          if (ret === false && !this.continuousStopRequested) {
+            Logger(
+              this.translate("liveSyncReplicator.couldNotConnectToServer"),
+              showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO
+            );
+          }
           return false;
         }
         if (showResult) {
@@ -838,16 +1061,25 @@ ${sendingDocs}/(${sentDocsCount} done)`,
         }
         const { db, syncOption } = ret;
         try {
+          if (this.continuousStopRequested) {
+            return false;
+          }
           this.syncStatus = "STARTED";
           this.maxPullSeq = Number(`${ret.info.update_seq}`.split("-")[0]);
           this.maxPushSeq = Number(`${(await localDB.info()).update_seq}`.split("-")[0]);
+          if (this.continuousStopRequested) {
+            return false;
+          }
           this.updateInfo();
           const docArrivedOnStart = this.docArrived;
           const docSentOnStart = this.docSent;
           if (!retrying) {
             this.originalSetting = setting;
           }
-          this.terminateSync();
+          this.abortController();
+          if (this.continuousStopRequested) {
+            return false;
+          }
           const syncHandler = localDB.sync(db, {
             ...syncOption
           });
@@ -860,6 +1092,9 @@ ${sendingDocs}/(${sentDocsCount} done)`,
             syncMode,
             retrying
           );
+          if (this.continuousStopRequested) {
+            return false;
+          }
           if (syncResult == "DONE") {
             return true;
           }
@@ -867,8 +1102,13 @@ ${sendingDocs}/(${sentDocsCount} done)`,
             return false;
           }
           if (syncResult == "NEED_RESURRECT") {
-            this.terminateSync();
-            return async () => await this.openContinuousReplication(this.originalSetting, showResult, false);
+            this.abortController();
+            return async () => {
+              if (this.continuousStopRequested) {
+                return false;
+              }
+              return await this.runContinuousReplication(this.originalSetting, showResult, false);
+            };
           }
           if (syncResult == "NEED_RETRY") {
             const tempSetting = JSON.parse(JSON.stringify(setting));
@@ -888,7 +1128,12 @@ ${sendingDocs}/(${sentDocsCount} done)`,
                 }),
                 showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO
               );
-              return async () => await this.openContinuousReplication(tempSetting, showResult, true);
+              return async () => {
+                if (this.continuousStopRequested) {
+                  return false;
+                }
+                return await this.runContinuousReplication(tempSetting, showResult, true);
+              };
             }
           }
         } finally {
@@ -903,41 +1148,45 @@ ${sendingDocs}/(${sentDocsCount} done)`,
     return await next();
   }
   closeReplication() {
-    if (!this.controller) {
-      return;
+    const hadController = !!this.controller;
+    const stopped = this.terminateSync();
+    if (!hadController) {
+      return stopped;
     }
-    this.controller.abort();
-    this.controller = void 0;
     this.syncStatus = "CLOSED";
     Logger(this.translate("liveSyncReplicator.replicationClosed"));
     this.updateInfo();
+    return stopped;
   }
   async tryResetRemoteDatabase(setting) {
-    this.closeReplication();
+    await this.closeReplication();
     const con = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), true);
-    if (typeof con == "string") return;
+    if (typeof con == "string") {
+      throw new Error(con);
+    }
     try {
-      try {
-        await con.db.destroy();
-        Logger(this.translate("liveSyncReplicator.remoteDbDestroyed"), LOG_LEVEL_NOTICE);
-        await this.tryCreateRemoteDatabase(setting);
-      } catch (ex) {
-        Logger(this.translate("liveSyncReplicator.remoteDbDestroyError"), LOG_LEVEL_NOTICE);
-        Logger(ex, LOG_LEVEL_NOTICE);
-      }
+      await con.db.destroy();
+      Logger(this.translate("liveSyncReplicator.remoteDbDestroyed"), LOG_LEVEL_NOTICE);
+    } catch (ex) {
+      Logger(this.translate("liveSyncReplicator.remoteDbDestroyError"), LOG_LEVEL_NOTICE);
+      Logger(ex, LOG_LEVEL_NOTICE);
+      throw ex;
     } finally {
       await this.closeRemoteConnection(con);
     }
-    clearHandlers();
-    await this.ensurePBKDF2Salt(setting, true, false);
+    await this.tryCreateRemoteDatabase(setting);
   }
   async tryCreateRemoteDatabase(setting) {
-    this.closeReplication();
+    await this.closeReplication();
     const con2 = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), true);
-    if (typeof con2 === "string") return;
+    if (typeof con2 === "string") {
+      throw new Error(con2);
+    }
     await this.closeRemoteConnection(con2);
     clearHandlers();
-    await this.ensurePBKDF2Salt(setting, true, false);
+    if (!await this.ensurePBKDF2Salt(setting, true, false)) {
+      throw new Error("Could not ensure PBKDF2 salt (Security Seed)");
+    }
     Logger(this.translate("liveSyncReplicator.remoteDbCreatedOrConnected"), LOG_LEVEL_NOTICE);
   }
   async markRemoteLocked(setting, locked, lockByClean) {
@@ -945,12 +1194,12 @@ ${sendingDocs}/(${sentDocsCount} done)`,
     const dbRet = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), true);
     if (typeof dbRet === "string") {
       Logger(this.translate("liveSyncReplicator.couldNotConnectToURI", { uri, dbRet }), LOG_LEVEL_NOTICE);
-      return;
+      throw new Error(dbRet);
     }
     await this.withRemoteConnection(dbRet, async (db) => {
       if (!await checkRemoteVersion(db, this.migrate.bind(this), VER)) {
         Logger(this.translate("liveSyncReplicator.remoteDbCorrupted"), LOG_LEVEL_NOTICE);
-        return;
+        throw new Error("The remote database version is not compatible");
       }
       const defInitPoint = {
         _id: MILESTONE_DOCID,
@@ -976,7 +1225,10 @@ ${sendingDocs}/(${sentDocsCount} done)`,
       } else {
         Logger(this.translate("liveSyncReplicator.unlockRemoteDb"), LOG_LEVEL_NOTICE);
       }
-      await db.put(remoteMilestone);
+      const result = await db.put(remoteMilestone);
+      if (!result.ok) {
+        throw new Error("Could not update the remote database lock state");
+      }
     });
   }
   async markRemoteResolved(setting) {
@@ -984,12 +1236,12 @@ ${sendingDocs}/(${sentDocsCount} done)`,
     const dbRet = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), true);
     if (typeof dbRet === "string") {
       Logger(this.translate("liveSyncReplicator.couldNotConnectToURI", { uri, dbRet }), LOG_LEVEL_NOTICE);
-      return;
+      throw new Error(dbRet);
     }
     await this.withRemoteConnection(dbRet, async (db) => {
       if (!await checkRemoteVersion(db, this.migrate.bind(this), VER)) {
         Logger(this.translate("liveSyncReplicator.remoteDbCorrupted"), LOG_LEVEL_NOTICE);
-        return;
+        throw new Error("The remote database version is not compatible");
       }
       const defInitPoint = {
         _id: MILESTONE_DOCID,
@@ -1013,10 +1265,11 @@ ${sendingDocs}/(${sentDocsCount} done)`,
         Logger(this.translate("liveSyncReplicator.remoteDbMarkedResolved"), LOG_LEVEL_VERBOSE);
       } else {
         Logger(this.translate("liveSyncReplicator.couldNotMarkResolveRemoteDb"), LOG_LEVEL_NOTICE);
+        throw new Error("Could not mark the remote database as resolved");
       }
     });
   }
-  connectRemoteCouchDBWithSetting(settings, isMobile, performSetup = false, skipInfo = false, connectionOptions) {
+  async connectRemoteCouchDBWithSetting(settings, isMobile, performSetup = false, skipInfo = false, connectionOptions) {
     if (settings.encrypt && settings.passphrase == "" && !settings.permitEmptyPassphrase) {
       return "Empty passphrases cannot be used without explicit permission";
     }
@@ -1045,7 +1298,7 @@ ${sendingDocs}/(${sentDocsCount} done)`,
       customHeaders,
       settings.useRequestAPI,
       async () => await this.getReplicationPBKDF2Salt(settings),
-      connectionOptions
+      { ...connectionOptions, encryptionAlgorithm: settings.E2EEAlgorithm }
     );
   }
   async openOwnedConnection(settings, performSetup = false) {
@@ -1108,8 +1361,8 @@ ${sendingDocs}/(${sentDocsCount} done)`,
       }
     }
   }
-  async fetchRemoteChunks(missingChunks, showResult) {
-    const ret = await this.connectRemoteCouchDBWithSetting(this.currentSettings, this.isMobile(), false, true);
+  async fetchRemoteChunks(missingChunks, showResult, setting = this.currentSettings) {
+    const ret = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), false, true);
     if (typeof ret === "string") {
       Logger(
         `${this.translate("liveSyncReplicator.couldNotConnectToServer")} ${ret} `,
@@ -1182,12 +1435,12 @@ ${sendingDocs}/(${sentDocsCount} done)`,
     const dbRet = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), true);
     if (typeof dbRet === "string") {
       Logger(this.translate("liveSyncReplicator.couldNotConnectToURI", { uri, dbRet }), LOG_LEVEL_NOTICE);
-      return;
+      throw new Error(dbRet);
     }
     await this.withRemoteConnection(dbRet, async (db) => {
       if (!await checkRemoteVersion(db, this.migrate.bind(this), VER)) {
         Logger(this.translate("liveSyncReplicator.remoteDbCorrupted"), LOG_LEVEL_NOTICE);
-        return;
+        throw new Error("The remote database version is not compatible");
       }
       try {
         const remoteMilestone = await db.get(MILESTONE_DOCID);