@vrtmrz/livesync-commonlib 0.3.0 → 0.3.2

package/dist/replication/journal/JournalSyncCore.js

@@ -11,13 +11,15 @@ import {
 import { Logger } from "../../common/logger.js";
 import {
   concatUInt8Array,
-  escapeNewLineFromString,
   setAllItems,
-  unescapeNewLineFromString
+  pickBucketSyncSettings,
+  pickEncryptionSettings
 } from "../../common/utils.js";
 import { shareRunningResult } from "octagonal-wheels/concurrency/lock";
 import { wrappedDeflate, wrappedInflate } from "../../pouchdb/compress.js";
-import { CheckPointInfoDefault } from "./JournalSyncTypes.js";
+import {
+  CheckPointInfoDefault
+} from "./JournalSyncTypes.js";
 import {
   JournalStorageReadStatuses
 } from "./objectstore/JournalStorageAdapter.js";
@@ -25,7 +27,8 @@ import {
   createSyncParamsHandler,
   SyncParamsFetchError,
   SyncParamsNotFoundError,
-  SyncParamsUpdateError
+  SyncParamsUpdateError,
+  isSyncParamsError
 } from "../SyncParamsHandler.js";
 import { REMOTE_CHUNK_FETCHED } from "../../pouchdb/LiveSyncLocalDB.js";
 import { decryptBinary, encryptBinary } from "octagonal-wheels/encryption/encryption";
@@ -34,18 +37,16 @@ import {
   decryptBinary as decryptBinaryHKDF
 } from "octagonal-wheels/encryption/hkdf";
 import { assertDatabasePathIdentity } from "../../pouchdb/pathIdentityCompatibility.js";
-const RECORD_SPLIT = `
-`;
-const UNIT_SPLIT = ``;
-const te = new TextEncoder();
-function serializeDoc(doc) {
-  if (doc._id.startsWith("h:")) {
-    const data = doc.data;
-    const writeData = escapeNewLineFromString(data);
-    return te.encode(`~${doc._id}${UNIT_SPLIT}${writeData}${RECORD_SPLIT}`);
-  }
-  return te.encode(JSON.stringify(doc) + RECORD_SPLIT);
-}
+import { decodeJournalRecords, serializeDoc } from "./journalRecords.js";
+import { JournalReceiveFailure, isJournalReceiveFailure } from "./JournalReceiveFailure.js";
+import {
+  partitionJournalDocuments,
+  selectChunksToSave,
+  assessChunkWrites,
+  journalMetadataRevisions,
+  selectMetadataToSave,
+  hasJournalWriteErrors
+} from "./journalReceive.js";
 function isJournalKey(key) {
   return !key.startsWith("_");
 }
@@ -65,6 +66,38 @@ class JournalSyncCore {
   store;
   requestedStop = false;
   syncParamsHandler;
+  receiveTask;
+  stoppedJournal;
+  checkpointGeneration = 0;
+  receiveConfiguration() {
+    return JSON.stringify([
+      pickBucketSyncSettings({ ...this.currentSettings, ...this._settings }),
+      pickEncryptionSettings(this.currentSettings),
+      this.currentSettings.pathNormalizationVersion,
+      this.currentSettings.handleFilenameCaseSensitive
+    ]);
+  }
+  matchesStoppedContext(stopped) {
+    return stopped.database === this.db && stopped.store === this.store && stopped.configuration === this.receiveConfiguration() && stopped.checkpointGeneration === this.checkpointGeneration;
+  }
+  /** Return the current failure for presentation before an explicit single-Journal skip. */
+  getStoppedJournal() {
+    if (this.stoppedJournal && !this.matchesStoppedContext(this.stoppedJournal)) {
+      this.stoppedJournal = void 0;
+    }
+    return this.stoppedJournal?.snapshot;
+  }
+  /**
+   * Acknowledge only the exact failure presented to the user, then resume receipt.
+   * Stale snapshots, another active receive, and a later Stop request are rejected.
+   * Any subsequent Journal failure stops the resumed operation normally.
+   */
+  skipStoppedJournalAndResume(stopped, showMessage = false) {
+    if (!stopped || this.receiveTask || this.requestedStop || this.getStoppedJournal() !== stopped) {
+      return Promise.resolve(false);
+    }
+    return this.startReceive(showMessage, this.stoppedJournal);
+  }
   getInitialSyncParameters() {
     return Promise.resolve({
       ...DEFAULT_SYNC_PARAMETERS,
@@ -184,11 +217,13 @@ class JournalSyncCore {
     };
   }
   async updateCheckPointInfo(func) {
+    this.stoppedJournal = void 0;
+    this.checkpointGeneration++;
     const checkPointKey = `bucketsync-checkpoint-${this.hash}`;
     const old = await this.getCheckpointInfo();
     const newInfo = func(old);
-    this._currentCheckPointInfo = newInfo;
     await this.store.set(checkPointKey, newInfo);
+    this._currentCheckPointInfo = newInfo;
     return newInfo;
   }
   _currentCheckPointInfo = { ...CheckPointInfoDefault };
@@ -341,6 +376,9 @@ class JournalSyncCore {
       const decrypted = await this.decryptDataV2(u, set);
       return decrypted;
     } catch (ex) {
+      if (isSyncParamsError(ex)) {
+        throw ex;
+      }
       Logger(`Failed to decrypt in v2. Falling back to v1: ${key}`, LOG_LEVEL_INFO);
       try {
         const r = await this.decryptDataV1(u, set);
@@ -348,8 +386,6 @@ class JournalSyncCore {
         return r;
       } catch (ex2) {
         Logger(`Could not decrypt in v1: ${key}`, LOG_LEVEL_VERBOSE);
-        Logger(ex, LOG_LEVEL_VERBOSE);
-        Logger(ex2, LOG_LEVEL_VERBOSE);
         throw ex2;
       }
     }
@@ -569,75 +605,67 @@ class JournalSyncCore {
     return files.sort((a, b) => a.localeCompare(b, void 0, { numeric: true }));
   }
   async processDocuments(allDocs) {
-    let applyTotal = 0;
-    let wholeItems = 0;
     try {
-      const chunks = [];
-      const docs = [];
-      allDocs.forEach((e) => {
-        if (e._id.startsWith("h:")) {
-          chunks.push(e);
-        } else {
-          docs.push(e);
-        }
-      });
-      try {
-        const e1 = (await this.db.allDocs({ include_docs: true, keys: [...chunks.map((e) => e._id)] })).rows;
-        const e2 = e1.map((e) => e.id ?? void 0);
-        const existChunks = new Set(e2.filter((e) => e !== void 0));
-        const saveChunks = chunks.filter((e) => !existChunks.has(e._id)).map((e) => ({ ...e, _rev: void 0 }));
-        const ret = await this.db.bulkDocs(saveChunks, { new_edits: true });
-        const saveError = ret.filter((e) => "error" in e).map((e) => e.id);
-        saveChunks.filter((e) => saveError.indexOf(e._id) === -1).forEach(
-          (doc) => this.env.services.context.events.emitEvent(REMOTE_CHUNK_FETCHED, doc)
-        );
-        await this.updateCheckPointInfo((info) => ({
-          ...info,
-          knownIDs: setAllItems(
-            info.knownIDs,
-            chunks.map((e) => this.getDocKey(e))
-          )
-        }));
-      } catch (ex) {
-        Logger(`Applying chunks failed`, LOG_LEVEL_INFO);
-        Logger(ex, LOG_LEVEL_VERBOSE);
-      }
-      const params = docs.map((e) => [e._id, [e._rev]]);
-      const docsRevs = params.reduce(
-        (acc, [id, revs]) => {
-          return { ...acc, [id]: [...acc[id] ?? [], ...revs] };
-        },
-        {}
-      );
-      const diffRevs = await this.db.revsDiff(docsRevs);
-      const saveDocs = docs.filter(
-        (e) => e._id in diffRevs && "missing" in diffRevs[e._id] && (diffRevs[e._id].missing?.indexOf(e._rev) ?? 0) !== -1
-      );
-      await this.db.bulkDocs(saveDocs, { new_edits: false });
-      const writeDoc = !this.env.services.setting.currentSettings().suspendParseReplicationResult;
-      if (writeDoc) {
-        await this.processReplication(saveDocs);
-      }
-      await this.updateCheckPointInfo((info) => ({
-        ...info,
-        knownIDs: setAllItems(
-          info.knownIDs,
-          docs.map((e) => this.getDocKey(e))
-        )
-      }));
-      applyTotal += saveDocs.length;
-      wholeItems += docs.length;
-      Logger(
-        `Applied ${applyTotal} of ${wholeItems} docs (${wholeItems - applyTotal} skipped)`,
-        LOG_LEVEL_VERBOSE
-      );
+      await this.processDocumentsForReceive(allDocs);
       return true;
-    } catch (ex) {
-      Logger(`Applying journal failed`, LOG_LEVEL_INFO);
-      Logger(ex, LOG_LEVEL_VERBOSE);
+    } catch {
+      Logger("Applying journal failed", LOG_LEVEL_INFO);
       return false;
     }
   }
+  async processDocumentsForReceive(allDocs, key) {
+    const { chunks, docs } = partitionJournalDocuments(allDocs);
+    const chunkRows = (await this.db.allDocs({ include_docs: true, keys: chunks.map((entry) => entry._id) })).rows;
+    const saveChunks = selectChunksToSave(chunks, chunkRows);
+    let chunkResults;
+    try {
+      chunkResults = await this.db.bulkDocs(saveChunks, { new_edits: true });
+    } catch (error) {
+      throw new JournalReceiveFailure("chunk-write", key);
+    }
+    const chunkWrites = assessChunkWrites(saveChunks, chunkResults);
+    chunkWrites.persisted.forEach(
+      (entry) => this.env.services.context.events.emitEvent(REMOTE_CHUNK_FETCHED, entry)
+    );
+    if (chunkWrites.failed) {
+      throw new JournalReceiveFailure("chunk-write", key);
+    }
+    await this.updateCheckPointInfo((info) => ({
+      ...info,
+      knownIDs: setAllItems(
+        info.knownIDs,
+        chunks.map((entry) => this.getDocKey(entry))
+      )
+    }));
+    const diffRevs = await this.db.revsDiff(journalMetadataRevisions(docs));
+    const saveDocs = selectMetadataToSave(docs, diffRevs);
+    let metadataResults;
+    try {
+      metadataResults = await this.db.bulkDocs(saveDocs, { new_edits: false });
+    } catch (error) {
+      throw new JournalReceiveFailure("metadata-write", key);
+    }
+    if (hasJournalWriteErrors(metadataResults)) {
+      throw new JournalReceiveFailure("metadata-write", key);
+    }
+    const writeDoc = !this.currentSettings.suspendParseReplicationResult;
+    if (writeDoc) {
+      await this.processReplication(docs);
+    }
+    await this.updateCheckPointInfo((info) => ({
+      ...info,
+      knownIDs: setAllItems(
+        info.knownIDs,
+        docs.map((entry) => this.getDocKey(entry))
+      )
+    }));
+    const applyTotal = saveDocs.length;
+    const wholeItems = docs.length;
+    Logger(
+      "Applied " + applyTotal + " of " + wholeItems + " docs (" + (wholeItems - applyTotal) + " skipped)",
+      LOG_LEVEL_VERBOSE
+    );
+  }
   _createReceiveReadableStream(files) {
     return new ReadableStream({
       pull: (controller) => {
@@ -657,62 +685,60 @@ class JournalSyncCore {
     return new TransformStream({
       transform: async (key, controller) => {
         count++;
-        Logger(`Receiving Journal: ${count}`, logLevel, "receivejournal");
-        const checkPointInfo = await this.getCheckpointInfo();
-        if (checkPointInfo.sentFiles.has(key) || checkPointInfo.receivedFiles.has(key)) {
-          Logger(`Receiving Journal: ${key} is already processed`, LOG_LEVEL_VERBOSE);
-          await this.updateCheckPointInfo((info) => ({
-            ...info,
-            receivedFiles: info.receivedFiles.add(key)
-          }));
+        Logger("Receiving Journal: " + count, logLevel, "receivejournal");
+        const checkpointInfo = await this.getCheckpointInfo();
+        if (checkpointInfo.sentFiles.has(key) || checkpointInfo.receivedFiles.has(key)) {
+          Logger("Receiving Journal: " + key + " is already processed", LOG_LEVEL_VERBOSE);
+          controller.enqueue({ key, docs: [], alreadyProcessed: true });
           return;
         }
-        try {
-          const encryptedData = await this.storage.download(key, true);
-          if (encryptedData === false) {
-            throw new Error("Download Error");
-          }
-          const data = await this.decryptDownloaded(
+        const enqueueFailure = (stage) => {
+          controller.enqueue({
             key,
-            encryptedData,
-            this.currentSettings
-          );
-          const decompressed = await wrappedInflate(new Uint8Array(data), { consume: true });
-          if (decompressed.length == 0) {
-            controller.enqueue({ key, docs: [] });
-            return;
+            docs: [],
+            failure: new JournalReceiveFailure(stage, key)
+          });
+        };
+        let downloadResult;
+        try {
+          downloadResult = await this.storage.downloadWithResult(key, true);
+        } catch (error) {
+          controller.error(error);
+          return;
+        }
+        if (downloadResult.status === JournalStorageReadStatuses.NOT_FOUND) {
+          enqueueFailure("download");
+          return;
+        }
+        if (downloadResult.status === JournalStorageReadStatuses.UNAVAILABLE) {
+          controller.error(new Error("Journal download unavailable"));
+          return;
+        }
+        const settings = this.currentSettings;
+        let data;
+        try {
+          data = await this.decryptDownloaded(key, downloadResult.value, settings);
+        } catch (error) {
+          if (isSyncParamsError(error)) {
+            controller.error(error);
+          } else {
+            enqueueFailure("decrypt");
           }
-          let idxFrom = 0;
-          let idxTo = 0;
-          const d = new TextDecoder();
-          const result = [];
-          do {
-            idxTo = decompressed.indexOf(10, idxFrom);
-            if (idxTo == -1) break;
-            const piece = decompressed.slice(idxFrom, idxTo);
-            const strPiece = d.decode(piece);
-            if (strPiece.startsWith("~")) {
-              const separatorIndex = strPiece.indexOf(UNIT_SPLIT);
-              if (separatorIndex === -1) {
-                throw new Error("Invalid journal chunk record: missing separator");
-              }
-              const idPart = strPiece.substring(1, separatorIndex);
-              const dataPart = strPiece.substring(separatorIndex + 1);
-              result.push({
-                _id: idPart,
-                data: unescapeNewLineFromString(dataPart),
-                type: "leaf",
-                _rev: ""
-              });
-            } else {
-              result.push(JSON.parse(strPiece));
-            }
-            idxFrom = idxTo + 1;
-          } while (idxTo > 0);
-          controller.enqueue({ key, docs: result });
-        } catch (ex) {
-          controller.error(ex);
+          return;
+        }
+        let decompressed;
+        try {
+          decompressed = await wrappedInflate(new Uint8Array(data), { consume: true });
+        } catch {
+          enqueueFailure("inflate");
+          return;
+        }
+        const decoded = decodeJournalRecords(decompressed);
+        if (decoded.ok === false) {
+          enqueueFailure(decoded.stage);
+          return;
         }
+        controller.enqueue({ key, docs: decoded.docs });
       }
     });
   }
@@ -721,49 +747,144 @@ class JournalSyncCore {
     return new WritableStream({
       write: async (chunk) => {
         const { key, docs } = chunk;
-        if (docs.length > 0) {
-          const success = await this.processDocuments(docs);
-          if (!success) {
-            throw new Error(`Could not process downloaded journals for ${key}`);
+        const checkpointInfo = await this.getCheckpointInfo();
+        if (chunk.alreadyProcessed || checkpointInfo.sentFiles.has(key) || checkpointInfo.receivedFiles.has(key)) {
+          await this.updateCheckPointInfo((info) => {
+            const receivedFiles = new Set(info.receivedFiles);
+            receivedFiles.add(key);
+            return { ...info, receivedFiles };
+          });
+          return;
+        }
+        let failure = chunk.failure;
+        if (!failure && docs.length > 0) {
+          try {
+            await this.processDocumentsForReceive(docs, key);
+          } catch (error) {
+            if (isJournalReceiveFailure(error)) {
+              failure = error;
+            } else {
+              throw error;
+            }
           }
         }
-        await this.updateCheckPointInfo((info) => ({
-          ...info,
-          receivedFiles: info.receivedFiles.add(key)
-        }));
+        if (failure) throw new JournalReceiveFailure(failure.stage, key);
+        await this.updateCheckPointInfo((info) => {
+          const receivedFiles = new Set(info.receivedFiles);
+          receivedFiles.add(key);
+          return { ...info, receivedFiles };
+        });
         downloaded++;
         this.updateInfo({ arrived: downloaded, maxPullSeq: downloaded, lastSyncPullSeq: downloaded });
-        Logger(`Processing journal: ${key} has been processed`, LOG_LEVEL_INFO);
+        Logger("Processing journal: " + key + " has been processed", LOG_LEVEL_INFO);
       }
     });
   }
-  async receiveRemoteJournal(showMessage = false) {
-    await assertDatabasePathIdentity(this.db, this.currentSettings);
+  /** Receive until completion, a failure, or an explicit Stop request. */
+  receiveRemoteJournal(showMessage = false) {
+    return this.receiveTask ?? this.startReceive(showMessage);
+  }
+  startReceive(showMessage, stopped) {
+    this.stoppedJournal = void 0;
+    this.requestedStop = false;
+    const task = Promise.resolve().then(() => this.performReceive(showMessage, stopped)).finally(() => {
+      if (this.receiveTask === task) this.receiveTask = void 0;
+    });
+    this.receiveTask = task;
+    return task;
+  }
+  async prepareStoppedJournalSkip(files, stopped) {
+    const checkpoint = await this.getCheckpointInfo();
+    const nextKey = files.find((key) => !checkpoint.sentFiles.has(key) && !checkpoint.receivedFiles.has(key));
+    if (this.requestedStop || !this.matchesStoppedContext(stopped) || nextKey !== stopped.snapshot.key) {
+      Logger(
+        "The stopped Journal has changed. Retry replication before choosing a Journal to skip.",
+        LOG_LEVEL_NOTICE,
+        "receivejournal"
+      );
+      this.updateInfo({ syncStatus: this.requestedStop ? "CLOSED" : "ERRORED" });
+      return void 0;
+    }
+    await this.updateCheckPointInfo((info) => ({
+      ...info,
+      receivedFiles: setAllItems(new Set(info.receivedFiles), [stopped.snapshot.key])
+    }));
+    return files.filter((key) => key !== stopped.snapshot.key);
+  }
+  recordReceiveFailure(error, logLevel, context) {
+    if (!isJournalReceiveFailure(error)) return;
+    Logger("Receive Journal " + (error.key ?? "item") + " failed at " + error.stage, logLevel, "receivejournal");
+    if (!this.requestedStop && error.key && context.database === this.db && context.store === this.store && context.configuration === this.receiveConfiguration()) {
+      this.stoppedJournal = {
+        snapshot: Object.freeze({ key: error.key, stage: error.stage }),
+        ...context,
+        checkpointGeneration: this.checkpointGeneration
+      };
+    }
+  }
+  async receiveJournalFiles(files, logLevel) {
+    if (this.requestedStop) {
+      this.updateInfo({ syncStatus: "CLOSED" });
+      return false;
+    }
+    if (files.length === 0) {
+      Logger("Receiving Journal: No journals needs to be downloaded", logLevel, "receivejournal");
+      this.updateInfo({ syncStatus: "COMPLETED" });
+      return true;
+    }
+    const readable = this._createReceiveReadableStream(files);
+    const transform = this._createReceiveTransformStream(logLevel);
+    const writable = this._createReceiveWritableStream();
+    await readable.pipeThrough(transform).pipeTo(writable);
+    if (this.requestedStop) {
+      Logger("Receive Journal closed after the active operation", LOG_LEVEL_NOTICE, "receivejournal");
+      this.updateInfo({ syncStatus: "CLOSED" });
+      return false;
+    }
+    this.updateInfo({ syncStatus: "COMPLETED" });
+    return true;
+  }
+  async performReceive(showMessage, stopped) {
+    const database = this.db;
+    const store = this.store;
+    const configuration = this.receiveConfiguration();
+    await assertDatabasePathIdentity(database, this.currentSettings);
     this.updateInfo({ syncStatus: "JOURNAL_RECEIVE" });
-    return await shareRunningResult("receive_journal_stream", async () => {
-      this.requestedStop = false;
-      const logLevel = showMessage ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO;
+    const logLevel = showMessage ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO;
+    let skippedKey;
+    try {
       Logger("Receiving Journal: Getting list of remote journal", logLevel, "receivejournal");
-      const files = await this._getRemoteJournals();
-      if (files.length == 0) {
-        Logger(`Receiving Journal: No journals needs to be downloaded`, logLevel, "receivejournal");
-        this.updateInfo({ syncStatus: "COMPLETED" });
-        return true;
-      }
-      const readable = this._createReceiveReadableStream(files);
-      const transform = this._createReceiveTransformStream(logLevel);
-      const writable = this._createReceiveWritableStream();
-      try {
-        await readable.pipeThrough(transform).pipeTo(writable);
-        this.updateInfo({ syncStatus: "COMPLETED" });
-        return true;
-      } catch (ex) {
-        Logger(`Receive Journal Error`, logLevel);
-        Logger(ex, LOG_LEVEL_VERBOSE);
-        this.updateInfo({ syncStatus: "ERRORED" });
+      let files = await this._getRemoteJournals();
+      if (this.requestedStop) {
+        this.updateInfo({ syncStatus: "CLOSED" });
         return false;
       }
-    });
+      if (stopped) {
+        const remainingFiles = await this.prepareStoppedJournalSkip(files, stopped);
+        if (!remainingFiles) return false;
+        skippedKey = stopped.snapshot.key;
+        files = remainingFiles;
+        Logger(
+          "Skipping Journal " + skippedKey + " at " + stopped.snapshot.stage + " by explicit request. Content or history may remain missing.",
+          LOG_LEVEL_NOTICE,
+          "receivejournal"
+        );
+      }
+      return await this.receiveJournalFiles(files, logLevel);
+    } catch (error) {
+      Logger(
+        this.requestedStop ? "Receive Journal closed after an active operation failed" : "Receive Journal Error",
+        this.requestedStop ? LOG_LEVEL_NOTICE : logLevel,
+        "receivejournal"
+      );
+      this.recordReceiveFailure(error, logLevel, { database, store, configuration });
+      this.updateInfo({ syncStatus: this.requestedStop ? "CLOSED" : "ERRORED" });
+      return false;
+    } finally {
+      if (skippedKey) {
+        Logger("Receiving Journal: explicitly skipped " + skippedKey, LOG_LEVEL_NOTICE, "receivejournal");
+      }
+    }
   }
   async sync(showResult = false) {
     return await shareRunningResult("replicate", async () => {
@@ -782,6 +903,7 @@ class JournalSyncCore {
     }) ?? false;
   }
   requestStop() {
+    this.stoppedJournal = void 0;
     this.requestedStop = true;
   }
   /** Stop this Journal operation owner and release its storage transport. */

package/dist/replication/journal/JournalSyncTypes.d.ts

@@ -7,3 +7,16 @@ export type CheckPointInfo = {
     sentFiles: Set<string>;
 };
 export declare const CheckPointInfoDefault: CheckPointInfo;
+/** Processing stages at which one identified Journal can stop receipt. */
+export type JournalReceiveFailureStage = "download" | "decrypt" | "inflate" | "decode" | "parse" | "chunk-write" | "metadata-write";
+/**
+ * The exact failure presented for a single explicit skip operation.
+ * Pass the returned object unchanged; copies and snapshots from earlier attempts
+ * are rejected. This state is local to the active Journal client and is not saved.
+ */
+export interface StoppedJournal {
+    /** Object key of the Journal which stopped receipt. */
+    readonly key: string;
+    /** Stage at which receipt stopped. */
+    readonly stage: JournalReceiveFailureStage;
+}

package/dist/replication/journal/LiveSyncJournalReplicator.d.ts

@@ -3,7 +3,7 @@ import { type RemoteDBSettings, type ChunkVersionRange, type NodeData, type Remo
 import { JournalSyncCore } from "./JournalSyncCore.js";
 import { LiveSyncAbstractReplicator, type RemoteDBStatus } from "../LiveSyncAbstractReplicator.js";
 import { type ENSURE_DB_RESULT } from "../../pouchdb/LiveSyncDBFunctions.js";
-import type { CheckPointInfo } from "./JournalSyncTypes.js";
+import type { CheckPointInfo, StoppedJournal } from "./JournalSyncTypes.js";
 import type { SimpleStore } from "../../common/utils.js";
 import type { LiveSyncJournalReplicatorEnv } from "./LiveSyncJournalReplicatorEnv.js";
 import { type CentralCompatibilityDecisionRecorder } from "../CentralCompatibility.js";
@@ -58,6 +58,10 @@ export declare class LiveSyncJournalReplicator extends LiveSyncAbstractReplicato
     private runDirectionalReplicationWithOutcome;
     replicateAllToServer(setting: RemoteDBSettings, showingNotice?: boolean): Promise<boolean>;
     replicateAllToServerWithOutcome(setting: RemoteDBSettings, showingNotice?: boolean): Promise<ReplicationOutcome>;
+    /** Return the stopped Journal from the current transfer client without creating another client. */
+    getStoppedJournal(): StoppedJournal | undefined;
+    /** Recheck connectivity and compatibility, skip the confirmed Journal, and resume receipt. */
+    skipStoppedJournalAndResume(setting: RemoteDBSettings, stopped: StoppedJournal, showingNotice?: boolean): Promise<boolean>;
     replicateAllFromServer(setting: RemoteDBSettings, showingNotice?: boolean): Promise<boolean>;
     replicateAllFromServerWithOutcome(setting: RemoteDBSettings, showingNotice?: boolean): Promise<ReplicationOutcome>;
     checkReplicationConnectivity(skipCheck: boolean, ignoreCleanLock?: boolean, showMessage?: boolean, setting?: RemoteDBSettings, client?: JournalSyncCore, recordCompatibilityDecision?: CentralCompatibilityDecisionRecorder): Promise<boolean>;
@@ -80,3 +84,4 @@ export declare class LiveSyncJournalReplicator extends LiveSyncAbstractReplicato
         accepted_nodes: string[];
     }>;
 }
+export declare function isLiveSyncJournalReplicator(value: unknown): value is LiveSyncJournalReplicator;