@delali/sirannon-db 0.2.3-next.38 → 0.3.0

package/dist/{chunk-G7AXGAEA.mjs → chunk-OJQHM4MT.mjs}

@@ -1,10 +1,11 @@
-import { verifyBackupRecord } from './chunk-CR6HTXSC.mjs';
-import { BackupManager, BackupScheduler, DEFAULT_PIECE_BYTES, sendFileInPieces } from './chunk-IPDHHIG2.mjs';
+import { verifyBackupRecord } from './chunk-7SC2TZAS.mjs';
+import { BackupManager, BackupScheduler, DEFAULT_PIECE_BYTES, sendFileInPieces } from './chunk-DXXCLTFF.mjs';
 import { DEFAULT_BACKUP_NAME_PREFIX, defaultStagingDir, DEFAULT_CAPTURE_INTERVAL_MS, DEFAULT_FULL_COPY_INTERVAL_MS } from './chunk-LXCGPZPA.mjs';
 import { WORKER_CANCELLED_CODE, deserializeError } from './chunk-YLAVDZCS.mjs';
-import { readCycleState, writeCycleState, removeCycleState, stagedCapturePath, captureAndCheckpointTurn } from './chunk-GJ6SX53Z.mjs';
-import { checkpointLog } from './chunk-KSYFFYAP.mjs';
-import { destinationWithDeadline, DEFAULT_DESTINATION_TIMEOUT_MS } from './chunk-GBM4AU24.mjs';
+import { readCycleState, writeCycleState, removeCycleState, stagedCapturePath, captureAndCheckpointTurn } from './chunk-W77EEVOT.mjs';
+import { checkpointLog } from './chunk-U445A3C4.mjs';
+import { logPathFor } from './chunk-2QCPVE67.mjs';
+import { destinationWithDeadline, DEFAULT_DESTINATION_TIMEOUT_MS } from './chunk-DVS4QSIZ.mjs';
 import { DEFAULT_CHAIN_NAME, readBackupChains, appendChainRecord, appendChainHead, readChainHeadAt, readChainHeads } from './chunk-YVF2ZJTE.mjs';
 import { randomHex } from './chunk-V5FUJEYY.mjs';
 import { SirannonError, ExtensionError } from './chunk-PBRXXISQ.mjs';
@@ -407,15 +408,6 @@ function clearPendingTimers(entry) {
   if (entry.graceTimer) clearTimeout(entry.graceTimer);
 }
 
-// src/core/backup/cycle-callbacks.ts
-function reportQuietly(callback, value) {
-  if (!callback) return;
-  try {
-    callback(value);
-  } catch {
-  }
-}
-
 // src/core/backup/preferred-node.ts
 function preferredBackupNode(membership, preference) {
   if (typeof preference !== "string") {
@@ -552,6 +544,162 @@ async function chainLostFromList(request, chainName, state) {
   return chainMissingFromList(request.destination, chainName, state.chainId, request.databaseId, state.headIndex);
 }
 
+// src/core/backup/cycle-callbacks.ts
+function reportQuietly(callback, value) {
+  if (!callback) return;
+  try {
+    callback(value);
+  } catch {
+  }
+}
+
+// src/core/backup/cycle-status.ts
+var BackupCycleStatusRecorder = class {
+  turnRunning = false;
+  turnStartedAt = 0;
+  latestProgress;
+  latestRun;
+  latestSkip;
+  latestError;
+  /** Marks a turn as under way and clears the progress the previous turn recorded. */
+  turnStarted() {
+    this.turnRunning = true;
+    this.turnStartedAt = Date.now();
+    this.latestProgress = void 0;
+  }
+  /** Marks the turn as finished. A caller then reads the outcome from the last run, skip, or failure. */
+  turnFinished() {
+    this.turnRunning = false;
+    this.turnStartedAt = 0;
+    this.latestProgress = void 0;
+  }
+  /** Records how far the turn under way has got. */
+  progressed(progress) {
+    this.latestProgress = progress;
+  }
+  /** Records what a finished turn wrote. */
+  ran(report) {
+    this.latestRun = report;
+  }
+  /** Records a turn the cycle passed over. */
+  skipped(skip) {
+    this.latestSkip = skip;
+  }
+  /**
+   * Records a failure, under the code a caller matches on, along with how far
+   * the run had got and which chain it was extending.
+   *
+   * @param err - What the turn failed with.
+   * @param chainId - The chain the cycle was extending, where it held one.
+   */
+  failed(err, chainId) {
+    const at = Date.now();
+    this.latestError = {
+      code: err instanceof SirannonError ? err.code : "BACKUP_ERROR",
+      message: err.message,
+      at,
+      durationMs: this.turnStartedAt === 0 ? 0 : at - this.turnStartedAt,
+      ...chainId === void 0 ? {} : { chainId },
+      ...this.latestProgress === void 0 ? {} : { progress: this.latestProgress }
+    };
+  }
+  /**
+   * Reads everything recorded so far.
+   *
+   * @param chainId - The chain the cycle is extending, where it has one.
+   * @returns What the cycle is doing, and what its recent turns produced.
+   */
+  read(chainId) {
+    return {
+      running: this.turnRunning,
+      ...chainId === void 0 ? {} : { chainId },
+      ...this.latestProgress === void 0 ? {} : { progress: this.latestProgress },
+      ...this.latestRun === void 0 ? {} : { lastRun: this.latestRun },
+      ...this.latestSkip === void 0 ? {} : { lastSkip: this.latestSkip },
+      ...this.latestError === void 0 ? {} : { lastError: this.latestError }
+    };
+  }
+};
+
+// src/core/backup/cycle-reporting.ts
+var BackupTurnLog = class {
+  constructor(audience, logPath) {
+    this.audience = audience;
+    this.logPath = logPath;
+  }
+  record = new BackupCycleStatusRecorder();
+  announced = /* @__PURE__ */ new Set();
+  /**
+   * Records a finished run and passes it to the caller.
+   *
+   * @param report - What that run produced.
+   */
+  ran(report) {
+    this.record.ran(report);
+    reportQuietly(this.audience.onRun, report);
+  }
+  /**
+   * Records how far the run under way has reached and passes that to the caller.
+   *
+   * @param progress - The counters that run has reached.
+   */
+  progressed(progress) {
+    this.record.progressed(progress);
+    reportQuietly(this.audience.onProgress, progress);
+  }
+  /** Marks a turn as under way, and forgets whatever failures the previous turn announced. */
+  turnStarted() {
+    this.announced.clear();
+    this.record.turnStarted();
+  }
+  /** Marks the turn as finished. */
+  turnFinished() {
+    this.record.turnFinished();
+  }
+  /**
+   * Records a failure as the turn's outcome and passes it to the caller.
+   *
+   * @param err - What the turn failed with.
+   * @param chainId - The chain to record it against, where the cycle holds one.
+   */
+  failed(err, chainId) {
+    this.announced.add(err);
+    const failure = toBackupError(err);
+    this.record.failed(failure, chainId);
+    reportQuietly(this.audience.onError, failure);
+  }
+  /**
+   * Answers whether this turn has already passed one failure to the caller.
+   *
+   * @param err - The failure to look for.
+   * @returns Whether the caller has already heard about that failure.
+   */
+  hasAnnounced(err) {
+    return this.announced.has(err);
+  }
+  /**
+   * Records a turn the cycle passed over and passes it to the caller, stating
+   * how much log this node was still holding as it skipped.
+   *
+   * @param skip - Why the cycle passed the turn over.
+   */
+  async skipped(skip) {
+    const held = await uncapturedLogBytes(this.logPath);
+    const passed = held === void 0 ? skip : { ...skip, uncapturedLogBytes: held };
+    this.record.skipped(passed);
+    reportQuietly(this.audience.onSkip, passed);
+  }
+  /**
+   * Reads everything recorded so far.
+   *
+   * @param chainId - The chain the cycle is extending, where it has one.
+   * @returns What the cycle is doing, and what its recent turns produced.
+   */
+  read(chainId) {
+    return this.record.read(chainId);
+  }
+};
+
 // src/core/backup/cycle-scheduling.ts
 var BackupCycleTimer = class {
   handle = null;
@@ -630,61 +778,6 @@ async function confirmChainStillListed(grip) {
   grip.report(lost);
   return false;
 }
-
-// src/core/backup/cycle-status.ts
-var BackupCycleStatusRecorder = class {
-  turnRunning = false;
-  latestProgress;
-  latestRun;
-  latestSkip;
-  latestError;
-  /** Marks a turn as under way and clears the progress the previous turn recorded. */
-  turnStarted() {
-    this.turnRunning = true;
-    this.latestProgress = void 0;
-  }
-  /** Marks the turn as finished. A caller then reads the outcome from the last run, skip, or failure. */
-  turnFinished() {
-    this.turnRunning = false;
-    this.latestProgress = void 0;
-  }
-  /** Records how far the turn under way has got. */
-  progressed(progress) {
-    this.latestProgress = progress;
-  }
-  /** Records what a finished turn wrote. */
-  ran(report) {
-    this.latestRun = report;
-  }
-  /** Records a turn the cycle passed over. */
-  skipped(skip) {
-    this.latestSkip = skip;
-  }
-  /** Records a failure, under the code a caller matches on. */
-  failed(err) {
-    this.latestError = {
-      code: err instanceof SirannonError ? err.code : "BACKUP_ERROR",
-      message: err.message,
-      at: Date.now()
-    };
-  }
-  /**
-   * Reads everything recorded so far.
-   *
-   * @param chainId - The chain the cycle is extending, where it has one.
-   * @returns What the cycle is doing, and what its recent turns produced.
-   */
-  read(chainId) {
-    return {
-      running: this.turnRunning,
-      ...chainId === void 0 ? {} : { chainId },
-      ...this.latestProgress === void 0 ? {} : { progress: this.latestProgress },
-      ...this.latestRun === void 0 ? {} : { lastRun: this.latestRun },
-      ...this.latestSkip === void 0 ? {} : { lastSkip: this.latestSkip },
-      ...this.latestError === void 0 ? {} : { lastError: this.latestError }
-    };
-  }
-};
 async function startChain(request, chainName, namePrefix, previousChainId) {
   const chainId = randomHex(8);
   const startedAt = Date.now();
@@ -836,24 +929,19 @@ var BackupCycle = class {
   sendRefused = false;
   stopped = false;
   request;
-  statusRecord = new BackupCycleStatusRecorder();
+  turnLog;
   /** @internal */
   constructor(request) {
+    this.logPath = logPathFor(request.sourcePath);
+    this.turnLog = new BackupTurnLog(request, this.logPath);
     this.request = {
       ...request,
-      onRun: (report) => {
-        this.statusRecord.ran(report);
-        reportQuietly(request.onRun, report);
-      },
-      onProgress: (progress) => {
-        this.statusRecord.progressed(progress);
-        reportQuietly(request.onProgress, progress);
-      }
+      onRun: (report) => this.turnLog.ran(report),
+      onProgress: (progress) => this.turnLog.progressed(progress)
     };
     this.chainName = request.chainName ?? DEFAULT_CHAIN_NAME;
     this.namePrefix = request.namePrefix ?? DEFAULT_BACKUP_NAME_PREFIX;
     this.stagingDir = request.stagingDir ?? defaultStagingDir(request.sourcePath);
-    this.logPath = `${request.sourcePath}-wal`;
     this.intervalMs = request.intervalMs ?? DEFAULT_CAPTURE_INTERVAL_MS;
     this.fullCopyIntervalMs = request.fullCopyIntervalMs ?? DEFAULT_FULL_COPY_INTERVAL_MS;
     this.preferredNode = request.preferredNode ?? "replica";
@@ -945,7 +1033,7 @@ var BackupCycle = class {
    * @returns Whether a turn is under way, how far it has got, and the last run, skip, and failure.
    */
   status() {
-    return this.statusRecord.read(this.state?.chainId);
+    return this.turnLog.read(this.state?.chainId);
   }
   /**
    * Reads one of this chain's backups back out of the destination and compares
@@ -957,21 +1045,29 @@ var BackupCycle = class {
   async verify(name) {
     return verifyBackupRecord(this.request.destination, await this.chains(), name);
   }
+  /**
+   * Runs one turn and passes whatever broke it to the operator. A deeper step
+   * announces some failures itself and then raises them, so this announces a
+   * failure only where no step has announced it already. The operator therefore
+   * hears each failure exactly once. Sirannon empties a log the turn has
+   * outgrown once all of that is done, and the report of writes reaching no
+   * backup replaces whatever failure the turn recorded.
+   */
   runTurn(op) {
     return this.turns.run(async () => {
       this.busy = true;
       this.captured = false;
       this.sendRefused = false;
-      this.statusRecord.turnStarted();
+      this.turnLog.turnStarted();
       try {
         return await op();
       } catch (err) {
-        this.statusRecord.failed(toBackupError(err));
+        if (!this.turnLog.hasAnnounced(err)) this.report(err);
         throw err;
       } finally {
         if (!this.captured) await this.releaseLogPastLimit();
         this.busy = false;
-        this.statusRecord.turnFinished();
+        this.turnLog.turnFinished();
       }
     });
   }
@@ -1018,13 +1114,9 @@ var BackupCycle = class {
     }
     return false;
   }
-  /** Passes a skipped turn on, counting the log this node was holding as it skipped. */
+  /** Passes a skipped turn on, where the cycle has a reason to give for it. */
   async reportSkip(skip) {
-    if (!skip) return;
-    const held = await uncapturedLogBytes(this.logPath);
-    const passed = held === void 0 ? skip : { ...skip, uncapturedLogBytes: held };
-    this.statusRecord.skipped(passed);
-    reportQuietly(this.request.onSkip, passed);
+    if (skip) await this.turnLog.skipped(skip);
   }
   async tick() {
     if (this.stopped) return;
@@ -1032,11 +1124,8 @@ var BackupCycle = class {
       await this.reportSkip(previousRunStillActive());
       return;
     }
-    try {
-      await this.runOnce();
-    } catch (err) {
-      this.report(err);
-    }
+    await this.runOnce().catch(() => {
+    });
   }
   async verifyChain() {
     this.verified = await confirmChainStillListed({
@@ -1057,14 +1146,19 @@ var BackupCycle = class {
    * Runs one turn. A log that restarted before the capture reached it leaves a
    * chain nothing can extend, so this starts a fresh one. The caller still gets
    * the error: those writes are in no backup, and an operator has to hear that.
+   * Where the replacement chain also fails to start, Sirannon records that
+   * second failure against the chain the restart broke, because the cycle holds
+   * no chain of its own by then and an operator reading the status has to know
+   * which one they have lost.
    */
   async turnOrStartOver() {
     try {
       return await this.turn();
     } catch (err) {
       if (startsAFreshChain(err)) {
-        this.report(err);
-        await this.replaceChain().catch((chainErr) => this.report(chainErr));
+        const broken = this.state?.chainId;
+        this.reportAgainstChain(err, broken);
+        await this.replaceChain().catch((chainErr) => this.reportAgainstChain(chainErr, broken));
       }
       throw err;
     }
@@ -1082,10 +1176,18 @@ var BackupCycle = class {
     last = await this.sendWaitingCapture() ?? last;
     return last;
   }
+  /**
+   * Passes a failure to the operator and records it as the turn's outcome.
+   *
+   * @param err - What the turn failed with.
+   * @param chainId - The chain to record it against, which defaults to the one the cycle holds now.
+   */
   report(err) {
-    const failure = toBackupError(err);
-    this.statusRecord.failed(failure);
-    reportQuietly(this.request.onError, failure);
+    this.turnLog.failed(err, this.state?.chainId);
+  }
+  /** Records a failure against a chain the cycle may already have let go of. */
+  reportAgainstChain(err, chainId) {
+    this.turnLog.failed(err, chainId);
   }
   async replaceChain() {
     const previousChainId = this.state?.chainId;
@@ -1220,7 +1322,7 @@ function nodeBackupEngine(streaming) {
     copyToDestination: (conn, request) => manager.copyToDestination(conn, request),
     streamsToDestination: () => manager.streamsToDestination(),
     createCycle: (request) => createBackupCycle(request),
-    schedule: (conn, options, runExclusive) => scheduler.schedule(conn, options, runExclusive)
+    schedule: (conn, request) => scheduler.schedule(conn, request)
   };
 }
 

package/dist/{chunk-KSYFFYAP.mjs → chunk-U445A3C4.mjs}

@@ -85,73 +85,4 @@ async function fetchStoredFile(destination, file, pieces, take) {
   return { bytesFetched, pieceCount: pieces.length, ...fingerprint === void 0 ? {} : { fingerprint } };
 }
 
-// src/core/backup/wal-format.ts
-var MAGIC_WITH_LITTLE_ENDIAN_CONTENT = 931071618;
-var MAGIC_WITH_BIG_ENDIAN_CONTENT = 931071619;
-var LOG_FORMAT_VERSION = 3007e3;
-var SMALLEST_PAGE_BYTES = 512;
-var LARGEST_PAGE_BYTES = 65536;
-var LOG_HEADER_BYTES = 32;
-var LOG_FRAME_HEADER_BYTES = 24;
-function foldLogChecksum(view, offset, byteLength, bigEndianContent, seed) {
-  const littleEndian = !bigEndianContent;
-  const end = offset + byteLength;
-  let first = seed.first;
-  let second = seed.second;
-  for (let at = offset; at < end; at += 8) {
-    first = first + view.getUint32(at, littleEndian) + second >>> 0;
-    second = second + view.getUint32(at + 4, littleEndian) + first >>> 0;
-  }
-  return { first, second };
-}
-function readLogHeader(bytes) {
-  if (bytes.byteLength < LOG_HEADER_BYTES) return void 0;
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  const magic = view.getUint32(0, false);
-  if (magic !== MAGIC_WITH_LITTLE_ENDIAN_CONTENT && magic !== MAGIC_WITH_BIG_ENDIAN_CONTENT) return void 0;
-  const bigEndianContent = magic === MAGIC_WITH_BIG_ENDIAN_CONTENT;
-  const pageSize = view.getUint32(8, false);
-  if (pageSize < SMALLEST_PAGE_BYTES || pageSize > LARGEST_PAGE_BYTES || (pageSize & pageSize - 1) !== 0) {
-    return void 0;
-  }
-  const stored = { first: view.getUint32(24, false), second: view.getUint32(28, false) };
-  const computed = foldLogChecksum(view, 0, 24, bigEndianContent, { first: 0, second: 0 });
-  if (computed.first !== stored.first || computed.second !== stored.second) return void 0;
-  return {
-    pageSize,
-    frameBytes: LOG_FRAME_HEADER_BYTES + pageSize,
-    logSequence: view.getUint32(12, false),
-    salt1: view.getUint32(16, false),
-    salt2: view.getUint32(20, false),
-    checksum: stored,
-    bigEndianContent
-  };
-}
-function readLogFrameHeader(view, offset) {
-  return {
-    pageNumber: view.getUint32(offset, false),
-    databasePages: view.getUint32(offset + 4, false),
-    salt1: view.getUint32(offset + 8, false),
-    salt2: view.getUint32(offset + 12, false),
-    checksum: { first: view.getUint32(offset + 16, false), second: view.getUint32(offset + 20, false) }
-  };
-}
-function readValidLogFrame(view, offset, header, seed) {
-  const frame = readLogFrameHeader(view, offset);
-  if (frame.salt1 !== header.salt1 || frame.salt2 !== header.salt2) return void 0;
-  const overHeader = foldLogChecksum(view, offset, 8, header.bigEndianContent, seed);
-  const checksum = foldLogChecksum(
-    view,
-    offset + LOG_FRAME_HEADER_BYTES,
-    header.pageSize,
-    header.bigEndianContent,
-    overHeader
-  );
-  if (checksum.first !== frame.checksum.first || checksum.second !== frame.checksum.second) return void 0;
-  return { frame, checksum };
-}
-function logFrameOffset(frameNumber, frameBytes) {
-  return LOG_HEADER_BYTES + (frameNumber - 1) * frameBytes;
-}
-
-export { LOG_FORMAT_VERSION, LOG_FRAME_HEADER_BYTES, LOG_HEADER_BYTES, MAGIC_WITH_LITTLE_ENDIAN_CONTENT, checkpointLog, fetchStoredFile, foldLogChecksum, listStoredFilePieces, logFrameOffset, readLogHeader, readValidLogFrame };
+export { checkpointLog, fetchStoredFile, listStoredFilePieces };

package/dist/{chunk-GJ6SX53Z.mjs → chunk-W77EEVOT.mjs}

@@ -1,8 +1,10 @@
-import { checkpointLog, logFrameOffset, LOG_HEADER_BYTES, readLogHeader, readValidLogFrame } from './chunk-KSYFFYAP.mjs';
+import { checkpointLog } from './chunk-U445A3C4.mjs';
+import { readLogFileHeader, sameLog, cursorChecksum, scanLogFrames, copyLogRange } from './chunk-2QCPVE67.mjs';
+import { logFrameOffset } from './chunk-DVS4QSIZ.mjs';
 import { isBackupChainPosition } from './chunk-YVF2ZJTE.mjs';
 import { randomHex } from './chunk-V5FUJEYY.mjs';
 import { SirannonError } from './chunk-PBRXXISQ.mjs';
-import { readFile, mkdir, writeFile, rename, rm, readdir, open } from 'fs/promises';
+import { readFile, mkdir, writeFile, rename, rm, readdir } from 'fs/promises';
 import { dirname, join } from 'path';
 
 var STATE_FILE_NAME = "cycle.json";
@@ -43,124 +45,6 @@ async function writeCycleState(stagingDir, state) {
 async function removeCycleState(stagingDir) {
   await rm(cycleStatePath(stagingDir), { force: true });
 }
-var READ_CHUNK_BYTES = 4 * 1024 * 1024;
-async function openForReading(path) {
-  try {
-    return await open(path, "r");
-  } catch (err) {
-    if (err.code === "ENOENT") return void 0;
-    throw err;
-  }
-}
-async function readLogFileHeader(logPath) {
-  const file = await openForReading(logPath);
-  if (!file) return void 0;
-  try {
-    const buffer = Buffer.allocUnsafe(LOG_HEADER_BYTES);
-    const { bytesRead } = await file.read(buffer, 0, LOG_HEADER_BYTES, 0);
-    if (bytesRead < LOG_HEADER_BYTES) return void 0;
-    return readLogHeader(buffer);
-  } finally {
-    await file.close();
-  }
-}
-async function scanLogFrames(logPath, header, from) {
-  const stopped = {
-    lastCommitFrame: from.frame,
-    endOffset: logFrameOffset(from.frame + 1, header.frameBytes),
-    checksum: from.checksum
-  };
-  const file = await openForReading(logPath);
-  if (!file) return stopped;
-  try {
-    const { size } = await file.stat();
-    const framesInFile = Math.max(0, Math.floor((size - LOG_HEADER_BYTES) / header.frameBytes));
-    const framesPerChunk = Math.max(1, Math.floor(READ_CHUNK_BYTES / header.frameBytes));
-    const buffer = Buffer.allocUnsafe(framesPerChunk * header.frameBytes);
-    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-    let running = from.checksum;
-    let found = stopped;
-    let frame = from.frame + 1;
-    while (frame <= framesInFile) {
-      const frames = Math.min(framesPerChunk, framesInFile - frame + 1);
-      const wanted = frames * header.frameBytes;
-      let filled = 0;
-      while (filled < wanted) {
-        const { bytesRead } = await file.read(
-          buffer,
-          filled,
-          wanted - filled,
-          logFrameOffset(frame, header.frameBytes) + filled
-        );
-        if (bytesRead === 0) break;
-        filled += bytesRead;
-      }
-      const readable = Math.floor(filled / header.frameBytes);
-      if (readable === 0) break;
-      for (let inChunk = 0; inChunk < readable; inChunk++) {
-        const read = readValidLogFrame(view, inChunk * header.frameBytes, header, running);
-        if (!read) return found;
-        running = read.checksum;
-        if (read.frame.databasePages !== 0) {
-          found = {
-            lastCommitFrame: frame + inChunk,
-            endOffset: logFrameOffset(frame + inChunk + 1, header.frameBytes),
-            checksum: running
-          };
-        }
-      }
-      frame += readable;
-    }
-    return found;
-  } finally {
-    await file.close();
-  }
-}
-async function copyLogRange(logPath, startOffset, endOffset, destPath) {
-  const source = await open(logPath, "r");
-  try {
-    const dest = await open(destPath, "w");
-    try {
-      const buffer = Buffer.allocUnsafe(Math.min(READ_CHUNK_BYTES, Math.max(endOffset - startOffset, 1)));
-      let at = startOffset;
-      let written = 0;
-      while (at < endOffset) {
-        const wanted = Math.min(buffer.byteLength, endOffset - at);
-        const { bytesRead } = await source.read(buffer, 0, wanted, at);
-        if (bytesRead === 0) {
-          throw new SirannonError(
-            `The write-ahead log '${logPath}' ends at byte ${at} while the frames captured from it run to byte ${endOffset}, so it lost frames while Sirannon was reading it. Another connection checkpointed the log. Route every write and every checkpoint through Sirannon, and take a fresh full copy so a new chain starts from a known state.`,
-            "BACKUP_LOG_REWOUND"
-          );
-        }
-        let put = 0;
-        while (put < bytesRead) {
-          const { bytesWritten } = await dest.write(buffer, put, bytesRead - put);
-          if (bytesWritten === 0) {
-            throw new SirannonError(
-              `The capture of '${logPath}' could write no more than ${written + put} of its ${endOffset - startOffset} bytes into '${destPath}'. Check the free space and the permissions on that directory.`,
-              "BACKUP_ERROR"
-            );
-          }
-          put += bytesWritten;
-        }
-        at += bytesRead;
-        written += bytesRead;
-      }
-      return written;
-    } finally {
-      await dest.close();
-    }
-  } finally {
-    await source.close();
-  }
-}
-function cursorChecksum(cursor) {
-  return { first: cursor.checksum1, second: cursor.checksum2 };
-}
-function sameLog(header, cursor) {
-  return header.salt1 === cursor.salt1 && header.salt2 === cursor.salt2;
-}
 
 // src/core/backup/cycle-capture.ts
 var STAGED_CAPTURE_PREFIX = "capture-";

package/dist/client/index.d.ts

@@ -1,17 +1,17 @@
 export { F as FieldMergeResolver, L as LWWResolver, P as PrimaryWinsResolver } from '../primary-wins-B0np8JS3.js';
 import { C as ConflictResolver, R as ReplicationBatch } from '../types-CjhxcjhA.js';
 export { a as ConflictContext, b as ConflictResolution } from '../types-CjhxcjhA.js';
-import { C as ClientOptions, B as BulkLoadDurability } from '../server-options-CFgBQDLz.js';
-import { D as DatabaseClient, T as Transport, L as LiveHandlers, R as RemoteSubscription, a as RemoteSubscriptionBuilder, S as SubscribeOptions, b as RegistryDigestSource } from '../client-base-DldBgJWS.js';
-export { c as LoadAllOptions, d as RemoteDatabase, e as RemoteError, f as SQL_REFUSED_MESSAGE, g as ServerCapabilities, h as ServerCapabilityCheck } from '../client-base-DldBgJWS.js';
+import { C as ClientOptions, B as BulkLoadDurability } from '../server-options-DeK6ZG8u.js';
+import { D as DatabaseClient, T as Transport, L as LiveHandlers, R as RemoteSubscription, a as RemoteSubscriptionBuilder, S as SubscribeOptions, b as RegistryDigestSource } from '../client-base-C-B8u5Lm.js';
+export { c as LoadAllOptions, d as RemoteDatabase, e as RemoteError, f as SQL_REFUSED_MESSAGE, g as ServerCapabilities, h as ServerCapabilityCheck } from '../client-base-C-B8u5Lm.js';
 import { a as LiveQuery, b as LiveQueryState, c as LiveUpdate } from '../types-BCejqzNA.js';
-import { k as DeviceSyncPort, D as Database } from '../database-DSbJl-k5.js';
+import { k as DeviceSyncPort, D as Database } from '../database-BlhUdJAO.js';
 import { C as ChangeEvent, P as Params, R as ReadConcern, W as WriteConcern } from '../query-types-Cv8N7pXj.js';
-import { Q as QueryResponse, E as ExecuteResponse, T as TransactionResponse, B as BatchResponse, L as LoadResponse, A as AckResponse } from '../protocol-BK0Yxu5P.js';
+import { Q as QueryResponse, E as ExecuteResponse, T as TransactionResponse, B as BatchResponse, L as LoadResponse, A as AckResponse } from '../protocol-QekTGoKn.js';
 import '../operation-registry-C1FmwQWR.js';
-import '../types-CopTgHG3.js';
-import '../database-backup-CliAhaEm.js';
-import '../change-tracker-BLKRX8ic.js';
+import '../types-DApb7dvw.js';
+import '../database-backup-C090lMHc.js';
+import '../change-tracker-uG9gWvsY.js';
 
 /**
  * @public

package/dist/client/topology.d.ts

@@ -1,11 +1,11 @@
 import { a as ReadConcernLevel } from '../query-types-Cv8N7pXj.js';
-import { C as ClientOptions } from '../server-options-CFgBQDLz.js';
-import { T as Transport, D as DatabaseClient } from '../client-base-DldBgJWS.js';
+import { C as ClientOptions } from '../server-options-DeK6ZG8u.js';
+import { T as Transport, D as DatabaseClient } from '../client-base-C-B8u5Lm.js';
 import '../operation-registry-C1FmwQWR.js';
 import '../types-CjhxcjhA.js';
-import '../types-CopTgHG3.js';
+import '../types-DApb7dvw.js';
 import '../types-BCejqzNA.js';
-import '../protocol-BK0Yxu5P.js';
+import '../protocol-QekTGoKn.js';
 
 interface TopologyRouting {
     _getReadEndpoint(databaseId?: string, readConcern?: ReadConcernLevel): Promise<string>;

package/dist/{client-base-DldBgJWS.d.ts → client-base-C-B8u5Lm.d.ts}

@@ -1,8 +1,8 @@
-import { B as BulkLoadDurability, a as BulkLoadResult, C as ClientOptions } from './server-options-CFgBQDLz.js';
+import { B as BulkLoadDurability, a as BulkLoadResult, C as ClientOptions } from './server-options-DeK6ZG8u.js';
 import { R as ResultOp, a as LiveQuery } from './types-BCejqzNA.js';
 import { O as OperationRef, b as OperationArguments } from './operation-registry-C1FmwQWR.js';
 import { P as Params, R as ReadConcern, W as WriteConcern, C as ChangeEvent, Q as QueryOptions } from './query-types-Cv8N7pXj.js';
-import { Q as QueryResponse, E as ExecuteResponse, T as TransactionResponse, B as BatchResponse, L as LoadResponse } from './protocol-BK0Yxu5P.js';
+import { Q as QueryResponse, E as ExecuteResponse, T as TransactionResponse, B as BatchResponse, L as LoadResponse } from './protocol-QekTGoKn.js';
 
 /**
  * Message a client raises when the server accepts no SQL over the network.