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

package/dist/backup/index.d.ts

@@ -1,6 +1,8 @@
-import { j as BackupDestination, k as BackupRunReport, a as SQLiteDriver } from '../types-Xb0L3o3w.js';
-export { g as BackupChain, e as BackupChainBase, f as BackupChainChange, l as BackupChainPosition, h as BackupChainRecord, m as BackupCycle, n as BackupCycleOptions, o as BackupGroupMembership, p as BackupGroupSource, q as BackupNodePreference, r as BackupPiece, s as BackupProgress, t as BackupSkip, u as BackupSkipReason, v as BackupToDestinationOptions, w as DEFAULT_CHAIN_NAME, x as chainLogName, y as readBackupChains } from '../types-Xb0L3o3w.js';
-export { B as BackupCapabilities, a as BackupRestorePlan, b as BackupSafeToDeleteOptions, c as backupPiecesSafeToDelete, p as planBackupRestore } from '../chain-queries-D5aZ-8v2.js';
+import { B as BackupDestination, f as BackupRunReport } from '../types-CopTgHG3.js';
+export { g as BackupChain, h as BackupChainBase, i as BackupChainChange, j as BackupChainPosition, k as BackupChainRecord, l as BackupCycle, m as BackupCycleError, n as BackupCycleOptions, o as BackupCycleStatus, p as BackupGroupMembership, q as BackupGroupSource, r as BackupNodePreference, s as BackupPiece, t as BackupProgress, u as BackupSkip, v as BackupSkipReason, w as BackupToDestinationOptions, x as BackupVerifyResult, y as DEFAULT_CHAIN_NAME, z as chainLogName, C as readBackupChains, E as verifyBackupRecord } from '../types-CopTgHG3.js';
+export { B as BackupCapabilities, a as BackupChainLocation, b as BackupRestorePlan, c as BackupSafeToDeleteOptions, d as backupPiecesSafeToDelete, p as planBackupRestore } from '../database-backup-CliAhaEm.js';
+import { B as BackupRestoreOptions, a as BackupRestoreReport } from '../restore-options-O5gYlr3n.js';
+export { b as BackupRestoreProgress } from '../restore-options-O5gYlr3n.js';
 import '../query-types-Cv8N7pXj.js';
 
 /** What one assembled file took to build.
@@ -27,86 +29,6 @@ interface AssembleResult {
  */
 declare function assembleFromDestination(destination: BackupDestination, report: BackupRunReport, destPath: string): Promise<AssembleResult>;
 
-/** How far one restore has got, reported after every piece it fetches.
- * @public
- */
-interface BackupRestoreProgress {
-    /** Whether the restore is fetching the full copy or replaying the change pieces on top of it. */
-    phase: 'full-copy' | 'changes';
-    /** Pieces the restore has fetched. */
-    piecesFetched: number;
-    /** Bytes it has fetched. */
-    bytesFetched: number;
-    /** Change pieces it has replayed. */
-    changesApplied: number;
-    /** Change pieces the plan holds altogether. */
-    changesTotal: number;
-}
-/**
- * How Sirannon rebuilds a database from a moment you name.
- *
- * @public
- */
-interface BackupRestoreOptions {
-    /** Where the backups and their records are stored. */
-    destination: BackupDestination;
-    /** Driver the restore opens the rebuilt database through, so it can fold each batch of changes in. */
-    driver: SQLiteDriver;
-    /** Path Sirannon writes the rebuilt database to. A file already there stops the restore unless you set {@link BackupRestoreOptions.replaceExisting}. */
-    destPath: string;
-    /**
-     * Whether to replace a database already at that path. It defaults to false,
-     * because a restore removes the write-ahead log beside the path it writes to
-     * and any commit that log still held would go with it. Set this where you
-     * mean to restore over a database you no longer want.
-     */
-    replaceExisting?: boolean;
-    /** Epoch milliseconds you want back. Defaults to now, which reaches the newest backup the destination holds. */
-    moment?: number;
-    /** Name the list of chains is stored under. Defaults to `sirannon-backup-chain`. */
-    chainName?: string;
-    /**
-     * How many change pieces to replay between one checkpoint and the next.
-     * Defaults to 16. This is what bounds the log the restore writes beside the
-     * database, so lower it where disk is tight and raise it where a long chain
-     * takes too many checkpoints.
-     */
-    batchSize?: number;
-    /** Milliseconds one call to the destination may take before the restore stops with an error. Defaults to 10 minutes, and zero leaves the calls unbounded. */
-    destinationTimeoutMs?: number;
-    /** Called after every piece the restore fetches. */
-    onProgress?: (progress: BackupRestoreProgress) => void;
-}
-/** What one finished restore produced.
- * @public
- */
-interface BackupRestoreReport {
-    /** The chain the restore read. */
-    chainId: string;
-    /** Path of the rebuilt database. */
-    destPath: string;
-    /** Name the full copy underneath it is stored under. */
-    baseName: string;
-    /** Epoch milliseconds the rebuilt database reflects, which is when the last piece replayed was captured. */
-    restoresTo: number;
-    /** Pieces the restore fetched, counting the full copy and every change piece. */
-    pieceCount: number;
-    /** Bytes it fetched. */
-    bytesFetched: number;
-    /** Change pieces it replayed. */
-    changesApplied: number;
-    /** Log frames those pieces held. */
-    framesApplied: number;
-    /** Batches it replayed them in, each one folded into the database by a checkpoint of its own. */
-    batchCount: number;
-    /** Epoch milliseconds the restore started. */
-    startedAt: number;
-    /** Epoch milliseconds it finished. */
-    finishedAt: number;
-    /** Milliseconds it took. */
-    durationMs: number;
-}
-
 /**
  * Rebuilds a database from the moment you name and leaves it at a path of your
  * choosing.
@@ -148,4 +70,4 @@ interface BackupRestoreReport {
  */
 declare function restoreBackup(options: BackupRestoreOptions): Promise<BackupRestoreReport>;
 
-export { type AssembleResult, BackupDestination, type BackupRestoreOptions, type BackupRestoreProgress, type BackupRestoreReport, BackupRunReport, assembleFromDestination, restoreBackup };
+export { type AssembleResult, BackupDestination, BackupRestoreOptions, BackupRestoreReport, BackupRunReport, assembleFromDestination, restoreBackup };

package/dist/backup/index.mjs

@@ -1,586 +1,8 @@
-import { planBackupRestore } from '../chunk-YNTDOFTN.mjs';
+export { assembleFromDestination, restoreBackup } from '../chunk-P53I2G6J.mjs';
 export { backupPiecesSafeToDelete, planBackupRestore } from '../chunk-YNTDOFTN.mjs';
-import { checkpointLog, LOG_HEADER_BYTES, LOG_FRAME_HEADER_BYTES, readLogHeader, foldLogChecksum, MAGIC_WITH_LITTLE_ENDIAN_CONTENT, LOG_FORMAT_VERSION } from '../chunk-72I5UI5C.mjs';
-import { destinationWithDeadline, DEFAULT_DESTINATION_TIMEOUT_MS } from '../chunk-GBM4AU24.mjs';
-import { readBackupChains, DEFAULT_CHAIN_NAME } from '../chunk-YVF2ZJTE.mjs';
+export { verifyBackupRecord } from '../chunk-CR6HTXSC.mjs';
+import '../chunk-KSYFFYAP.mjs';
+import '../chunk-GBM4AU24.mjs';
 export { DEFAULT_CHAIN_NAME, chainLogName, readBackupChains } from '../chunk-YVF2ZJTE.mjs';
-import { randomHex } from '../chunk-V5FUJEYY.mjs';
-import { SirannonError } from '../chunk-PBRXXISQ.mjs';
-import { rename, open, rm, stat } from 'fs/promises';
-import { createHash } from 'crypto';
-
-function destinationError(message, err) {
-  if (err instanceof SirannonError) return err;
-  const detail = err instanceof Error ? `: ${err.message}` : "";
-  return new SirannonError(`${message}${detail}`, "BACKUP_DESTINATION_ERROR");
-}
-function assertNoPieceIsMissing(pieces, file) {
-  if (pieces.length === 0) {
-    throw destinationError(`The destination holds no pieces named '${file.name}'`);
-  }
-  for (let expected = 0; expected < file.pieceCount; expected++) {
-    if (pieces[expected]?.index !== expected) {
-      throw destinationError(
-        `The destination is missing piece ${expected} of '${file.name}', so the file cannot be assembled`
-      );
-    }
-  }
-  if (pieces.length > file.pieceCount) {
-    throw destinationError(
-      `The destination holds ${pieces.length} pieces of '${file.name}' where the run wrote ${file.pieceCount}, so a later piece belongs to a different run`
-    );
-  }
-}
-async function listStoredFilePieces(destination, file) {
-  let listed;
-  try {
-    listed = [...await destination.listPieces(file.name)];
-  } catch (err) {
-    throw destinationError(`The destination could not list the pieces of '${file.name}'`, err);
-  }
-  listed.sort((left, right) => left.index - right.index);
-  assertNoPieceIsMissing(listed, file);
-  return listed;
-}
-async function fetchStoredFile(destination, file, pieces, take) {
-  const digest = file.fingerprint === void 0 ? null : createHash("sha256");
-  let bytesFetched = 0;
-  for (const piece of pieces) {
-    let bytes;
-    try {
-      bytes = await destination.readPiece(file.name, piece.index);
-    } catch (err) {
-      throw destinationError(`The destination could not return piece ${piece.index} of '${file.name}'`, err);
-    }
-    digest?.update(bytes);
-    bytesFetched += bytes.byteLength;
-    await take(piece.index, bytes);
-  }
-  const fingerprint = digest?.digest("hex");
-  if (bytesFetched !== file.bytesWritten) {
-    throw destinationError(
-      `The pieces of '${file.name}' hold ${bytesFetched} bytes where the run wrote ${file.bytesWritten}`
-    );
-  }
-  if (fingerprint !== void 0 && fingerprint !== file.fingerprint) {
-    throw destinationError(`The pieces of '${file.name}' do not match the fingerprint the run recorded`);
-  }
-  return { bytesFetched, pieceCount: pieces.length, ...fingerprint === void 0 ? {} : { fingerprint } };
-}
-
-// src/core/backup/write-fully.ts
-async function writeFully(handle, path, bytes, byteLength, offset) {
-  let written = 0;
-  while (written < byteLength) {
-    const result = await handle.write(bytes, written, byteLength - written, offset + written);
-    if (result.bytesWritten === 0) {
-      throw new SirannonError(
-        `Writing to '${path}' stopped after ${written} of ${byteLength} bytes. Check the free space and the permissions on that directory.`,
-        "BACKUP_ERROR"
-      );
-    }
-    written += result.bytesWritten;
-  }
-}
-
-// src/core/backup/assemble.ts
-async function assembleStoredFile(destination, file, destPath, onPiece) {
-  const pieces = await listStoredFilePieces(destination, file);
-  try {
-    const handle = await open(destPath, "w");
-    let piecesRead = 0;
-    let bytesWritten = 0;
-    try {
-      const fetched = await fetchStoredFile(destination, file, pieces, async (index, bytes) => {
-        await writeFully(handle, destPath, bytes, bytes.byteLength, index * file.pieceBytes);
-        piecesRead++;
-        bytesWritten += bytes.byteLength;
-        onPiece?.(piecesRead, bytesWritten);
-      });
-      return {
-        bytesWritten: fetched.bytesFetched,
-        pieceCount: fetched.pieceCount,
-        ...fetched.fingerprint === void 0 ? {} : { fingerprint: fetched.fingerprint }
-      };
-    } finally {
-      await handle.close();
-    }
-  } catch (err) {
-    await rm(destPath, { force: true }).catch(() => {
-    });
-    throw err;
-  }
-}
-function assembleFromDestination(destination, report, destPath) {
-  return assembleStoredFile(destination, { ...report, name: report.destinationName }, destPath);
-}
-var DATABASE_HEADER_BYTES = 100;
-var PAGE_SIZE_OFFSET = 16;
-var PAGE_SIZE_FOR_65536 = 1;
-var SMALLEST_PAGE_BYTES = 512;
-var LARGEST_PAGE_BYTES = 65536;
-var WRITE_FORMAT_OFFSET = 18;
-var WRITE_AHEAD_LOGGING_FORMAT = 2;
-var CHECKSUM_SEED = { first: 0, second: 0 };
-function restoreError(message) {
-  return new SirannonError(message, "BACKUP_CHAIN_BROKEN");
-}
-async function readDatabaseHeader(path) {
-  const handle = await open(path, "r");
-  try {
-    const buffer = Buffer.allocUnsafe(DATABASE_HEADER_BYTES);
-    const { bytesRead } = await handle.read(buffer, 0, DATABASE_HEADER_BYTES, 0);
-    if (bytesRead < DATABASE_HEADER_BYTES) {
-      throw restoreError(`The full copy assembled into '${path}' is too short to be a SQLite database`);
-    }
-    const stated = buffer.readUInt16BE(PAGE_SIZE_OFFSET);
-    const pageSize = stated === PAGE_SIZE_FOR_65536 ? LARGEST_PAGE_BYTES : stated;
-    if (pageSize < SMALLEST_PAGE_BYTES || pageSize > LARGEST_PAGE_BYTES || (pageSize & pageSize - 1) !== 0) {
-      throw restoreError(
-        `The full copy assembled into '${path}' states a page size of ${pageSize}, which no SQLite database has`
-      );
-    }
-    return {
-      pageSize,
-      walMode: buffer.readUInt8(WRITE_FORMAT_OFFSET) === WRITE_AHEAD_LOGGING_FORMAT
-    };
-  } finally {
-    await handle.close();
-  }
-}
-function logHeaderBytes(pageSize, logSequence, salt1, salt2) {
-  const header = new Uint8Array(LOG_HEADER_BYTES);
-  const view = new DataView(header.buffer);
-  view.setUint32(0, MAGIC_WITH_LITTLE_ENDIAN_CONTENT, false);
-  view.setUint32(4, LOG_FORMAT_VERSION, false);
-  view.setUint32(8, pageSize, false);
-  view.setUint32(12, logSequence, false);
-  view.setUint32(16, salt1, false);
-  view.setUint32(20, salt2, false);
-  const checksum = foldLogChecksum(view, 0, 24, false, CHECKSUM_SEED);
-  view.setUint32(24, checksum.first, false);
-  view.setUint32(28, checksum.second, false);
-  return header;
-}
-function describeHeaderMismatch(captured, expected) {
-  if (captured.pageSize !== expected.pageSize) {
-    return `of ${captured.pageSize}-byte pages where its record says ${expected.pageSize}`;
-  }
-  if (captured.logSequence !== expected.logSequence) {
-    return `at checkpoint sequence ${captured.logSequence} where its record says ${expected.logSequence}`;
-  }
-  if (captured.salt1 !== expected.salt1 || captured.salt2 !== expected.salt2) {
-    return `salted ${captured.salt1} and ${captured.salt2} where its record says ${expected.salt1} and ${expected.salt2}`;
-  }
-  return void 0;
-}
-function randomSalt() {
-  return Number.parseInt(randomHex(4), 16);
-}
-var RestoreLogWriter = class _RestoreLogWriter {
-  constructor(handle, path, pageSize, salt1, salt2, checksum) {
-    this.handle = handle;
-    this.path = path;
-    this.pageSize = pageSize;
-    this.salt1 = salt1;
-    this.salt2 = salt2;
-    this.checksum = checksum;
-  }
-  carry = new Uint8Array(0);
-  checksum;
-  offset = LOG_HEADER_BYTES;
-  framesWritten = 0;
-  lastDatabasePages = 0;
-  skipRemaining = 0;
-  skipped = new Uint8Array(0);
-  expected;
-  closed = false;
-  /**
-   * Opens the log beside a restored database and writes its header.
-   *
-   * @param path - Path of the log file.
-   * @param pageSize - Size of one page of the database being restored, in bytes.
-   * @param logSequence - Checkpoint sequence number to record in the header.
-   * @returns The writer, ready for the first piece.
-   */
-  static async create(path, pageSize, logSequence) {
-    const salt1 = randomSalt();
-    const salt2 = randomSalt();
-    const header = logHeaderBytes(pageSize, logSequence, salt1, salt2);
-    const view = new DataView(header.buffer);
-    const checksum = { first: view.getUint32(24, false), second: view.getUint32(28, false) };
-    const handle = await open(path, "w");
-    try {
-      await writeFully(handle, path, header, header.byteLength, 0);
-    } catch (err) {
-      await handle.close();
-      throw err;
-    }
-    return new _RestoreLogWriter(handle, path, pageSize, salt1, salt2, checksum);
-  }
-  /** Bytes one frame takes, being its header plus one page. */
-  get frameBytes() {
-    return LOG_FRAME_HEADER_BYTES + this.pageSize;
-  }
-  /**
-   * Starts a new change piece, naming how many bytes of log header stand in
-   * front of its first frame.
-   *
-   * Where the piece begins with a header, this reads it and checks it against
-   * the record that named the piece. A record claiming a page size the frames
-   * were never written at would otherwise have SQLite read every frame at the
-   * wrong length.
-   *
-   * @param headerBytes - Bytes of log header in front of the frames.
-   * @param expected - What the piece's chain record says that header holds.
-   */
-  beginPiece(headerBytes, expected) {
-    if (this.carry.byteLength > 0) {
-      throw restoreError(
-        `The change piece before this one left ${this.carry.byteLength} bytes of a frame unwritten in '${this.path}', so the two would be joined into a frame neither of them holds`
-      );
-    }
-    this.skipRemaining = headerBytes;
-    this.skipped = new Uint8Array(0);
-    this.expected = expected;
-  }
-  /**
-   * Stamps every whole frame in the bytes given and appends them to the log.
-   * Where a frame is split across two pieces, this keeps the first part until
-   * the second one is added.
-   *
-   * @param bytes - The next run of bytes of the change piece.
-   */
-  async add(bytes) {
-    let arriving = bytes;
-    if (this.skipRemaining > 0) {
-      const dropped = Math.min(this.skipRemaining, arriving.byteLength);
-      this.keepSkipped(arriving.subarray(0, dropped));
-      this.skipRemaining -= dropped;
-      arriving = arriving.subarray(dropped);
-      if (this.skipRemaining === 0) this.checkCapturedHeader();
-    }
-    if (arriving.byteLength === 0) return;
-    const working = new Uint8Array(this.carry.byteLength + arriving.byteLength);
-    working.set(this.carry, 0);
-    working.set(arriving, this.carry.byteLength);
-    const wholeFrames = Math.floor(working.byteLength / this.frameBytes);
-    if (wholeFrames === 0) {
-      this.carry = working;
-      return;
-    }
-    const stampedBytes = wholeFrames * this.frameBytes;
-    this.stamp(working, wholeFrames);
-    await writeFully(this.handle, this.path, working, stampedBytes, this.offset);
-    this.offset += stampedBytes;
-    this.carry = working.slice(stampedBytes);
-  }
-  keepSkipped(bytes) {
-    const kept = new Uint8Array(this.skipped.byteLength + bytes.byteLength);
-    kept.set(this.skipped, 0);
-    kept.set(bytes, this.skipped.byteLength);
-    this.skipped = kept;
-  }
-  checkCapturedHeader() {
-    const expected = this.expected;
-    if (!expected) return;
-    const captured = readLogHeader(this.skipped);
-    if (!captured) {
-      throw restoreError(
-        "The 32 bytes in front of the frames of a change piece are no log header SQLite wrote, so that piece reached the destination damaged"
-      );
-    }
-    const mismatch = describeHeaderMismatch(captured, expected);
-    if (mismatch) {
-      throw restoreError(
-        `A change piece was captured from a log ${mismatch}, so its record describes a different database and SQLite would read its frames at the wrong length`
-      );
-    }
-  }
-  stamp(working, wholeFrames) {
-    const view = new DataView(working.buffer, working.byteOffset, working.byteLength);
-    for (let frame = 0; frame < wholeFrames; frame++) {
-      const at = frame * this.frameBytes;
-      view.setUint32(at + 8, this.salt1, false);
-      view.setUint32(at + 12, this.salt2, false);
-      const overHeader = foldLogChecksum(view, at, 8, false, this.checksum);
-      const checksum = foldLogChecksum(view, at + LOG_FRAME_HEADER_BYTES, this.pageSize, false, overHeader);
-      view.setUint32(at + 16, checksum.first, false);
-      view.setUint32(at + 20, checksum.second, false);
-      this.checksum = checksum;
-      this.lastDatabasePages = view.getUint32(at + 4, false);
-      this.framesWritten++;
-    }
-  }
-  /**
-   * Closes the log and reports what it holds.
-   *
-   * @returns The frames the log holds, and the size the database reaches once SQLite replays them.
-   * @throws A `BACKUP_CHAIN_BROKEN` where the pieces ended part-way through a frame, or where the last frame commits nothing.
-   */
-  async finish() {
-    await this.close();
-    if (this.carry.byteLength > 0) {
-      throw restoreError(
-        `The change pieces written into '${this.path}' end ${this.carry.byteLength} bytes into a frame of ${this.frameBytes}, so the chain is missing the rest of it`
-      );
-    }
-    if (this.lastDatabasePages === 0) {
-      throw restoreError(
-        `The last frame written into '${this.path}' commits no transaction, so SQLite would replay none of the batch`
-      );
-    }
-    return { frameCount: this.framesWritten, databasePages: this.lastDatabasePages };
-  }
-  /** Closes the log without checking it, which is what a failed batch calls before it removes the file. */
-  async abandon() {
-    await this.close().catch(() => {
-    });
-  }
-  async close() {
-    if (this.closed) return;
-    this.closed = true;
-    await this.handle.close();
-  }
-};
-
-// src/core/backup/restore-apply.ts
-function chainError(message) {
-  return new SirannonError(message, "BACKUP_CHAIN_BROKEN");
-}
-function headerBytesOf(change) {
-  return change.position.firstFrame === 1 ? LOG_HEADER_BYTES : 0;
-}
-function expectedLogHeaderOf(change, pageSize) {
-  if (change.position.firstFrame !== 1) return void 0;
-  return {
-    pageSize,
-    logSequence: change.position.logSequence,
-    salt1: change.position.salt1,
-    salt2: change.position.salt2
-  };
-}
-function assertChangePiecesRunOn(changes, chainId) {
-  let previous;
-  for (const change of changes) {
-    if (previous === void 0) {
-      assertStartsAt(change, chainId, 1, "the full copy underneath it");
-      previous = change;
-      continue;
-    }
-    const sameRun = previous.position.logSequence === change.position.logSequence && previous.position.salt1 === change.position.salt1 && previous.position.salt2 === change.position.salt2;
-    const expected = sameRun ? previous.position.lastFrame + 1 : 1;
-    const follows = `change piece ${previous.sequence}, which ends at frame ${previous.position.lastFrame}`;
-    assertStartsAt(change, chainId, expected, follows);
-    previous = change;
-  }
-}
-function assertStartsAt(change, chainId, expected, follows) {
-  if (change.position.firstFrame === expected) return;
-  throw chainError(
-    `Change piece ${change.sequence} of chain '${chainId}' starts at frame ${change.position.firstFrame} where it has to start at frame ${expected} to follow ${follows}, so the frames in between are in no backup`
-  );
-}
-function assertPieceFits(change, chainId, frameBytes) {
-  const expected = headerBytesOf(change) + change.frameCount * frameBytes;
-  if (change.bytesWritten !== expected) {
-    throw chainError(
-      `Change piece ${change.sequence} of chain '${chainId}' holds ${change.bytesWritten} bytes where ${change.frameCount} frames of a database with ${frameBytes - LOG_FRAME_HEADER_BYTES}-byte pages come to ${expected}, so it was taken from a different database`
-    );
-  }
-}
-async function readPageCount(conn) {
-  const stmt = await conn.prepare("PRAGMA page_count");
-  const row = await stmt.get();
-  return row ? Number(row.page_count) : 0;
-}
-async function countDatabasePages(driver, destPath) {
-  const conn = await driver.open(destPath, { walMode: false, walAutoCheckpoint: 0 });
-  try {
-    return await readPageCount(conn);
-  } finally {
-    await conn.close();
-  }
-}
-async function foldLogIntoDatabase(driver, destPath, databasePages) {
-  const conn = await driver.open(destPath, { walMode: false, walAutoCheckpoint: 0 });
-  try {
-    const reached = await readPageCount(conn);
-    if (reached !== databasePages) {
-      throw chainError(
-        `Replaying the change pieces left '${destPath}' at ${reached} pages where the last frame of the batch commits ${databasePages}, so SQLite read none of those frames`
-      );
-    }
-    const checkpoint = await checkpointLog(conn);
-    if (!checkpoint.emptied) {
-      throw new SirannonError(
-        `The checkpoint after a batch left ${checkpoint.framesInLog} frames in the log beside '${destPath}', so the restore stopped rather than let the log grow`,
-        "BACKUP_ERROR"
-      );
-    }
-  } finally {
-    await conn.close();
-  }
-}
-async function applyChangeBatch(request) {
-  const logPath = `${request.destPath}-wal`;
-  await rm(`${request.destPath}-shm`, { force: true });
-  const writer = await RestoreLogWriter.create(logPath, request.pageSize, request.logSequence);
-  try {
-    for (const change of request.batch) {
-      assertPieceFits(change, change.chainId, writer.frameBytes);
-      const pieces = await listStoredFilePieces(request.destination, change);
-      writer.beginPiece(headerBytesOf(change), expectedLogHeaderOf(change, request.pageSize));
-      await fetchStoredFile(request.destination, change, pieces, async (_index, bytes) => {
-        await writer.add(bytes);
-        request.onPiece(bytes.byteLength);
-      });
-    }
-    const written = await writer.finish();
-    await foldLogIntoDatabase(request.driver, request.destPath, written.databasePages);
-    return written.frameCount;
-  } catch (err) {
-    await writer.abandon();
-    await rm(logPath, { force: true }).catch(() => {
-    });
-    throw err;
-  }
-}
-
-// src/core/backup/restore-options.ts
-var DEFAULT_RESTORE_BATCH_SIZE = 16;
-
-// src/core/backup/restore.ts
-function assertBatchSize(batchSize) {
-  if (!Number.isInteger(batchSize) || batchSize < 1) {
-    throw new SirannonError(
-      `A restore replays at least one change piece per batch, and the batch size given was ${batchSize}`,
-      "BACKUP_ERROR"
-    );
-  }
-}
-var BUILD_SUFFIX = ".restoring";
-async function removeLogBeside(path) {
-  await rm(`${path}-wal`, { force: true }).catch(() => {
-  });
-  await rm(`${path}-shm`, { force: true }).catch(() => {
-  });
-}
-async function removeDatabaseAndLog(path) {
-  await rm(path, { force: true }).catch(() => {
-  });
-  await removeLogBeside(path);
-}
-async function foldLogIntoDatabase2(driver, path) {
-  const existing = await stat(path).catch(() => void 0);
-  if (!existing) return true;
-  const log = await stat(`${path}-wal`).catch(() => void 0);
-  if (!log || log.size === 0) return true;
-  const conn = await driver.open(path, { walMode: false, walAutoCheckpoint: 0 }).catch(() => void 0);
-  if (!conn) return false;
-  const folded = await checkpointLog(conn).catch(() => void 0);
-  await conn.close().catch(() => void 0);
-  return folded?.emptied === true;
-}
-async function assertPathIsFree(destPath, replaceExisting) {
-  if (replaceExisting) return;
-  const existing = await stat(destPath).catch(() => void 0);
-  if (!existing) return;
-  throw new SirannonError(
-    `A restore would replace '${destPath}', and its write-ahead log with it. Pass replaceExisting to say that is what you want, or name a path this process holds nothing at.`,
-    "BACKUP_ERROR"
-  );
-}
-function batchesOf(changes, batchSize) {
-  const batches = [];
-  for (let start = 0; start < changes.length; start += batchSize) {
-    batches.push(changes.slice(start, start + batchSize));
-  }
-  return batches;
-}
-async function restoreBackup(options) {
-  const startedAt = Date.now();
-  const batchSize = options.batchSize ?? DEFAULT_RESTORE_BATCH_SIZE;
-  assertBatchSize(batchSize);
-  const destination = destinationWithDeadline(
-    options.destination,
-    options.destinationTimeoutMs ?? DEFAULT_DESTINATION_TIMEOUT_MS
-  );
-  const chains = await readBackupChains(destination, options.chainName ?? DEFAULT_CHAIN_NAME);
-  const plan = planBackupRestore(chains, options.moment ?? Date.now());
-  assertChangePiecesRunOn(plan.changes, plan.chainId);
-  const destPath = options.destPath;
-  await assertPathIsFree(destPath, options.replaceExisting === true);
-  const buildPath = `${destPath}${BUILD_SUFFIX}`;
-  await removeDatabaseAndLog(buildPath);
-  let piecesFetched = 0;
-  let bytesFetched = 0;
-  let changesApplied = 0;
-  let framesApplied = 0;
-  const batches = batchesOf(plan.changes, batchSize);
-  const reportProgress = (phase) => options.onProgress?.({
-    phase,
-    piecesFetched,
-    bytesFetched,
-    changesApplied,
-    changesTotal: plan.changes.length
-  });
-  try {
-    await assembleStoredFile(destination, plan.base, buildPath, (pieces, bytes) => {
-      piecesFetched = pieces;
-      bytesFetched = bytes;
-      reportProgress("full-copy");
-    });
-    const header = await readDatabaseHeader(buildPath);
-    if (!header.walMode && plan.changes.length > 0) {
-      throw new SirannonError(
-        `The full copy assembled into '${buildPath}' records no write-ahead log, so SQLite would ignore the change pieces rather than replay them`,
-        "BACKUP_CHAIN_BROKEN"
-      );
-    }
-    let logSequence = 0;
-    for (const batch of batches) {
-      logSequence++;
-      framesApplied += await applyChangeBatch({
-        destination,
-        driver: options.driver,
-        destPath: buildPath,
-        pageSize: header.pageSize,
-        logSequence,
-        batch,
-        onPiece: (byteLength) => {
-          piecesFetched++;
-          bytesFetched += byteLength;
-          reportProgress("changes");
-        }
-      });
-      changesApplied += batch.length;
-      reportProgress("changes");
-    }
-    await countDatabasePages(options.driver, buildPath);
-    const logFoldedIn = await foldLogIntoDatabase2(options.driver, destPath);
-    if (logFoldedIn) await removeLogBeside(destPath);
-    else await removeDatabaseAndLog(destPath);
-    await rename(buildPath, destPath);
-  } catch (err) {
-    await removeDatabaseAndLog(buildPath);
-    throw err;
-  }
-  const finishedAt = Date.now();
-  return {
-    chainId: plan.chainId,
-    destPath,
-    baseName: plan.base.name,
-    restoresTo: plan.restoresTo,
-    pieceCount: piecesFetched,
-    bytesFetched,
-    changesApplied,
-    framesApplied,
-    batchCount: batches.length,
-    startedAt,
-    finishedAt,
-    durationMs: finishedAt - startedAt
-  };
-}
-
-export { assembleFromDestination, restoreBackup };
+import '../chunk-V5FUJEYY.mjs';
+import '../chunk-PBRXXISQ.mjs';