@delali/sirannon-db 0.2.3-next.32 → 0.2.3-next.34

package/dist/backup/index.d.ts

@@ -1,6 +1,6 @@
-import { e as BackupDestination, f as BackupRunReport } from '../types-CwIiWpVr.js';
-export { g as BackupChain, h as BackupChainBase, i as BackupChainChange, j as BackupChainPosition, k as BackupChainRecord, l as BackupCycle, m as BackupCycleOptions, n as BackupPiece, o as BackupProgress, p as BackupToDestinationOptions, q as DEFAULT_CHAIN_NAME, r as chainLogName, s as readBackupChains } from '../types-CwIiWpVr.js';
-export { B as BackupCapabilities, a as BackupRestorePlan, b as BackupSafeToDeleteOptions, c as backupPiecesSafeToDelete, p as planBackupRestore } from '../chain-queries-CL_R_DuV.js';
+import { e as BackupDestination, f as BackupRunReport } from '../types-GuxbxlwL.js';
+export { g as BackupChain, h as BackupChainBase, i as BackupChainChange, j as BackupChainPosition, k as BackupChainRecord, l as BackupCycle, m as BackupCycleOptions, n as BackupPiece, o as BackupProgress, p as BackupToDestinationOptions, q as DEFAULT_CHAIN_NAME, r as chainLogName, s as readBackupChains } from '../types-GuxbxlwL.js';
+export { B as BackupCapabilities, a as BackupRestorePlan, b as BackupSafeToDeleteOptions, c as backupPiecesSafeToDelete, p as planBackupRestore } from '../chain-queries-BFRYrmNE.js';
 import '../query-types-Cv8N7pXj.js';
 
 /** What one assembled file took to build.

package/dist/backup-scheduler/index.d.ts

@@ -1,9 +1,22 @@
-import { t as SQLiteConnection, u as BackupRunRequest, f as BackupRunReport, v as BackupScheduleOptions } from '../types-CwIiWpVr.js';
+import { t as SQLiteConnection, u as BackupRunRequest, f as BackupRunReport, v as BackupScheduleOptions } from '../types-GuxbxlwL.js';
 import '../query-types-Cv8N7pXj.js';
 
+/** What one runtime needs before a copy can reach a destination without a local file.
+ * @internal
+ */
+interface BackupStreamingSupport {
+    /** Absolute path of the compiled extension that carries the bytes. */
+    extensionPath: string;
+    /** Opens the connection the extension's statements run on. */
+    openConnection(): Promise<SQLiteConnection>;
+}
+
 declare class BackupManager {
+    private readonly streaming?;
+    constructor(streaming?: BackupStreamingSupport | undefined);
     backup(conn: SQLiteConnection, destPath: string, onFirstStep?: () => void): Promise<void>;
     copyToDestination(conn: SQLiteConnection, request: BackupRunRequest): Promise<BackupRunReport>;
+    streamsToDestination(): boolean;
     generateFilename(): string;
     rotate(dir: string, maxFiles: number): void;
 }

package/dist/backup-scheduler/index.mjs

@@ -1,4 +1,4 @@
-export { BackupScheduler } from '../chunk-MZM74XYK.mjs';
+export { BackupScheduler } from '../chunk-7HVBKOII.mjs';
 import '../chunk-W67A4H2E.mjs';
 import '../chunk-V5FUJEYY.mjs';
 import '../chunk-PBRXXISQ.mjs';

package/dist/{chain-queries-CL_R_DuV.d.ts → chain-queries-BFRYrmNE.d.ts}

@@ -1,4 +1,4 @@
-import { h as BackupChainBase, i as BackupChainChange, g as BackupChain, k as BackupChainRecord } from './types-CwIiWpVr.js';
+import { h as BackupChainBase, i as BackupChainChange, g as BackupChain, k as BackupChainRecord } from './types-GuxbxlwL.js';
 
 /**
  * What one runtime supports of the backup operations, so a caller learns

package/dist/{change-tracker-NPJjE1Sh.d.ts → change-tracker-DNisL4aw.d.ts}

@@ -1,4 +1,4 @@
-import { t as SQLiteConnection } from './types-CwIiWpVr.js';
+import { t as SQLiteConnection } from './types-GuxbxlwL.js';
 import { C as ChangeEvent } from './query-types-Cv8N7pXj.js';
 
 /**

package/dist/{chunk-MZM74XYK.mjs → chunk-7HVBKOII.mjs}

@@ -1,19 +1,64 @@
 import { startCopyWithoutHoldingWriter } from './chunk-W67A4H2E.mjs';
 import { randomHex } from './chunk-V5FUJEYY.mjs';
-import { BackupError, SirannonError } from './chunk-PBRXXISQ.mjs';
+import { SirannonError, BackupError } from './chunk-PBRXXISQ.mjs';
 import { existsSync, mkdirSync, rmSync, readdirSync, lstatSync } from 'fs';
 import { resolve, dirname, join } from 'path';
 import { open, mkdtemp, rm } from 'fs/promises';
 import { tmpdir } from 'os';
 import { createHash } from 'crypto';
 
-function destinationError(name, index, err) {
+// src/core/backup/destination-deadline.ts
+var DEFAULT_DESTINATION_TIMEOUT_MS = 6e5;
+async function withinDeadline(operation, action, timeoutMs) {
+  let timer = null;
+  const deadline = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      reject(
+        new SirannonError(
+          `The destination did not ${action} within ${timeoutMs}ms, so the run stopped`,
+          "BACKUP_DESTINATION_ERROR"
+        )
+      );
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([operation, deadline]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+function destinationWithDeadline(destination, timeoutMs) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
+    throw new SirannonError(
+      `The destination deadline must be a number of milliseconds that is zero or above, and it was ${timeoutMs}`,
+      "BACKUP_ERROR"
+    );
+  }
+  if (timeoutMs === 0) return destination;
+  return {
+    writePiece: (name, index, bytes) => withinDeadline(destination.writePiece(name, index, bytes), `store piece ${index} of '${name}'`, timeoutMs),
+    readPiece: (name, index) => withinDeadline(destination.readPiece(name, index), `return piece ${index} of '${name}'`, timeoutMs),
+    listPieces: (name) => withinDeadline(destination.listPieces(name), `list the pieces of '${name}'`, timeoutMs)
+  };
+}
+function destinationPieceError(name, index, err) {
   if (err instanceof SirannonError) return err;
   return new SirannonError(
     `The destination refused piece ${index} of '${name}': ${err instanceof Error ? err.message : String(err)}`,
     "BACKUP_DESTINATION_ERROR"
   );
 }
+async function fingerprintStoredPieces(destination, name, pieceCount) {
+  const digest = createHash("sha256");
+  for (let index = 0; index < pieceCount; index++) {
+    try {
+      digest.update(await destination.readPiece(name, index));
+    } catch (err) {
+      throw destinationPieceError(name, index, err);
+    }
+  }
+  return digest.digest("hex");
+}
 async function sendFileInPieces(sourcePath, destination, name, pieceBytes, fingerprint, report) {
   const file = await open(sourcePath, "r");
   const digest = fingerprint ? createHash("sha256") : null;
@@ -35,7 +80,7 @@ async function sendFileInPieces(sourcePath, destination, name, pieceBytes, finge
       try {
         await destination.writePiece(name, index, piece);
       } catch (err) {
-        throw destinationError(name, index, err);
+        throw destinationPieceError(name, index, err);
       }
       index++;
       bytesWritten += filled;
@@ -50,6 +95,22 @@ async function sendFileInPieces(sourcePath, destination, name, pieceBytes, finge
 
 // src/core/backup/report.ts
 var DEFAULT_PIECE_BYTES = 16 * 1024 * 1024;
+function defaultDestinationName() {
+  return `backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.db`;
+}
+function assertPieceBytes(pieceBytes) {
+  if (!Number.isInteger(pieceBytes) || pieceBytes <= 0) {
+    throw new SirannonError(
+      `Piece size must be a positive whole number of bytes, and it was ${pieceBytes}`,
+      "BACKUP_ERROR"
+    );
+  }
+}
+async function readPageSize(conn) {
+  const stmt = await conn.prepare("PRAGMA page_size");
+  const row = await stmt.get();
+  return row ? Number(row.page_size) : 0;
+}
 
 // src/core/backup/stepped-copy.ts
 var DEFAULT_PAGES_PER_STEP = 256;
@@ -88,6 +149,7 @@ async function copyDatabaseStepwise(conn, options) {
       "BACKUP_UNSUPPORTED"
     );
   }
+  const pagesPerStep = options.pagesPerStep ?? DEFAULT_PAGES_PER_STEP;
   const restartLimit = options.restartLimit ?? DEFAULT_RESTART_LIMIT;
   const stallTimeoutMs = options.stallTimeoutMs ?? DEFAULT_STALL_TIMEOUT_MS;
   const noProgressStepLimit = options.noProgressStepLimit ?? DEFAULT_NO_PROGRESS_STEP_LIMIT;
@@ -95,6 +157,7 @@ async function copyDatabaseStepwise(conn, options) {
   let restarts = 0;
   let furthestCopied = -1;
   let stepsWithoutProgress = 0;
+  let pausedPreviousStep = false;
   let stopped = null;
   let stallTimer = null;
   let reportStall = () => {
@@ -106,6 +169,10 @@ async function copyDatabaseStepwise(conn, options) {
     if (stallTimeoutMs <= 0) return;
     if (stallTimer) clearTimeout(stallTimer);
     stallTimer = setTimeout(() => {
+      if (options.pauseWhile?.() === true) {
+        armStall();
+        return;
+      }
       stopped = stallError(stallTimeoutMs, options.destPath);
       reportStall(stopped);
     }, stallTimeoutMs);
@@ -114,10 +181,16 @@ async function copyDatabaseStepwise(conn, options) {
   armStall();
   const copy = conn.copyDatabase({
     destPath: options.destPath,
-    pagesPerStep: options.pagesPerStep ?? DEFAULT_PAGES_PER_STEP,
+    pagesPerStep,
     onStep: (step) => {
       if (stopped) throw stopped;
       armStall();
+      const pausing = options.pauseWhile?.() === true;
+      if (pausedPreviousStep && previous !== null && copiedPages(step) === copiedPages(previous)) {
+        pausedPreviousStep = pausing;
+        return pausing ? 0 : pagesPerStep;
+      }
+      pausedPreviousStep = pausing;
       if (hasRestarted(step, previous)) {
         restarts++;
         if (restarts > restartLimit) {
@@ -134,6 +207,7 @@ async function copyDatabaseStepwise(conn, options) {
       }
       previous = step;
       options.onStep?.({ totalPages: step.totalPages, remainingPages: step.remainingPages, restarts });
+      return pausing ? 0 : pagesPerStep;
     }
   }).catch((err) => {
     if (stopped) throw stopped;
@@ -154,21 +228,11 @@ async function copyDatabaseStepwise(conn, options) {
 
 // src/core/backup/staged-copy.ts
 var STAGED_FILE_NAME = "copy.db";
-async function readPageSize(conn) {
-  const stmt = await conn.prepare("PRAGMA page_size");
-  const row = await stmt.get();
-  return row ? Number(row.page_size) : 0;
-}
 async function copyToDestinationStaged(conn, request) {
   const runId = randomHex(8);
-  const name = request.name ?? `backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.db`;
+  const name = request.name ?? defaultDestinationName();
   const pieceBytes = request.pieceBytes ?? DEFAULT_PIECE_BYTES;
-  if (!Number.isInteger(pieceBytes) || pieceBytes <= 0) {
-    throw new SirannonError(
-      `Piece size must be a positive whole number of bytes, and it was ${pieceBytes}`,
-      "BACKUP_ERROR"
-    );
-  }
+  assertPieceBytes(pieceBytes);
   const startedAt = Date.now();
   const stagingRoot = await mkdtemp(join(request.stagingDir ?? tmpdir(), "sirannon-backup-"));
   const stagedPath = join(stagingRoot, STAGED_FILE_NAME);
@@ -243,6 +307,336 @@ async function copyToDestinationStaged(conn, request) {
   }
 }
 
+// src/core/system-catalog/backup-stream-functions.ts
+var SELECT_NEW_STREAM_ID = "SELECT sirannon_stream_open(?, ?, ?) AS streamId";
+var SELECT_NEXT_PIECE = "SELECT sirannon_stream_take(?) AS piece";
+var SELECT_BYTES_WRITTEN = "SELECT sirannon_stream_written(?) AS bytes";
+var SELECT_FAILURE = "SELECT sirannon_stream_error(?) AS failure";
+var SELECT_FINISHED_BYTES = "SELECT sirannon_stream_finish(?) AS bytes";
+var SELECT_RELEASED_BYTES = "SELECT sirannon_stream_close(?) AS bytes";
+async function prepareBackupStreamStatements(conn) {
+  const [newStreamId, nextPiece, bytesWritten, failure, finishedBytes, releasedBytes] = await Promise.all([
+    conn.prepare(SELECT_NEW_STREAM_ID),
+    conn.prepare(SELECT_NEXT_PIECE),
+    conn.prepare(SELECT_BYTES_WRITTEN),
+    conn.prepare(SELECT_FAILURE),
+    conn.prepare(SELECT_FINISHED_BYTES),
+    conn.prepare(SELECT_RELEASED_BYTES)
+  ]);
+  const readBytes = async (stmt, streamId) => {
+    const row = await stmt.get(streamId);
+    return row ? Number(row.bytes) : 0;
+  };
+  return {
+    async selectNewStreamId(pieceBytes, maxQueuedPieces, waitWhenFull) {
+      const row = await newStreamId.get(pieceBytes, maxQueuedPieces, waitWhenFull);
+      return row ? Number(row.streamId) : 0;
+    },
+    async selectNextPiece(streamId) {
+      const row = await nextPiece.get(streamId);
+      return row?.piece ?? null;
+    },
+    selectBytesWritten: (streamId) => readBytes(bytesWritten, streamId),
+    async selectFailure(streamId) {
+      const row = await failure.get(streamId);
+      return row?.failure ?? null;
+    },
+    selectFinishedBytes: (streamId) => readBytes(finishedBytes, streamId),
+    selectReleasedBytes: (streamId) => readBytes(releasedBytes, streamId)
+  };
+}
+
+// src/core/backup/vfs/stream-host.ts
+var PIECE_HEADER_BYTES = 8;
+function decodePiece(framed) {
+  if (framed.byteLength < PIECE_HEADER_BYTES) {
+    throw new SirannonError(
+      `The streaming extension returned ${framed.byteLength} bytes for a piece, which is less than its ${PIECE_HEADER_BYTES}-byte header`,
+      "BACKUP_ERROR"
+    );
+  }
+  const header = new DataView(framed.buffer, framed.byteOffset, PIECE_HEADER_BYTES);
+  const index = header.getUint32(0, true);
+  const length = header.getUint32(4, true);
+  const carried = framed.byteLength - PIECE_HEADER_BYTES;
+  if (carried < length) {
+    throw new SirannonError(
+      `The streaming extension declared ${length} bytes for piece ${index} and returned ${carried}`,
+      "BACKUP_ERROR"
+    );
+  }
+  return { index, bytes: framed.subarray(PIECE_HEADER_BYTES, PIECE_HEADER_BYTES + length) };
+}
+var BackupStreamHost = class _BackupStreamHost {
+  constructor(connection, statements) {
+    this.connection = connection;
+    this.statements = statements;
+  }
+  /**
+   * Opens a connection, loads the compiled extension into it, and compiles the
+   * statements one run needs.
+   *
+   * @param openConnection - Opens the connection the statements run on.
+   * @param extensionPath - Absolute path of the compiled extension.
+   * @returns A host ready to open a stream.
+   */
+  static async start(openConnection, extensionPath) {
+    const connection = await openConnection();
+    try {
+      if (!connection.loadExtension) {
+        throw new SirannonError(
+          "This driver opens connections with no extension loading call, so it cannot stream a copy to a destination",
+          "BACKUP_UNSUPPORTED"
+        );
+      }
+      await connection.loadExtension(extensionPath);
+      return new _BackupStreamHost(connection, await prepareBackupStreamStatements(connection));
+    } catch (err) {
+      await connection.close().catch(() => void 0);
+      throw err;
+    }
+  }
+  /**
+   * Opens one stream and returns the identifier that names it in the
+   * destination URI.
+   *
+   * @param pieceBytes - Bytes one whole piece holds.
+   * @param maxQueuedPieces - Pieces the extension holds before it stops taking more.
+   * @param waitWhenFull - Whether the copy waits for the destination to catch up rather than queueing further pieces.
+   * @returns The identifier of the open stream.
+   */
+  async open(pieceBytes, maxQueuedPieces, waitWhenFull) {
+    const streamId = await this.statements.selectNewStreamId(pieceBytes, maxQueuedPieces, waitWhenFull ? 1 : 0);
+    if (streamId === 0) {
+      throw new SirannonError("The streaming extension opened no stream for this run", "BACKUP_ERROR");
+    }
+    return streamId;
+  }
+  /**
+   * Takes the next whole piece the copy has produced.
+   *
+   * @param streamId - Stream to take from.
+   * @returns The piece, or null where the copy has produced none since the last call.
+   */
+  async take(streamId) {
+    const framed = await this.statements.selectNextPiece(streamId);
+    return framed ? decodePiece(framed) : null;
+  }
+  /**
+   * Reports how many bytes of the copy have reached the extension.
+   *
+   * @param streamId - Stream to ask about.
+   * @returns Bytes SQLite has written to this stream.
+   */
+  written(streamId) {
+    return this.statements.selectBytesWritten(streamId);
+  }
+  /**
+   * Reports what stopped a stream, where anything did.
+   *
+   * @param streamId - Stream to ask about.
+   * @returns The failure the extension recorded, or null where it recorded none.
+   */
+  failure(streamId) {
+    return this.statements.selectFailure(streamId);
+  }
+  /**
+   * Closes the file to further writes and queues the pieces the extension was
+   * still holding, which are the first piece and the last one.
+   *
+   * @param streamId - Stream to finish.
+   * @returns Bytes the finished file holds.
+   */
+  finish(streamId) {
+    return this.statements.selectFinishedBytes(streamId);
+  }
+  /**
+   * Releases a stream and everything it still held.
+   *
+   * @param streamId - Stream to release.
+   */
+  async close(streamId) {
+    await this.statements.selectReleasedBytes(streamId);
+  }
+  /** Closes the connection the statements ran on. */
+  async stop() {
+    await this.connection.close();
+  }
+};
+
+// src/core/backup/streamed-copy.ts
+var VFS_NAME = "sirannon";
+var PIECE_BLOCK_BYTES = 512;
+var DRAIN_POLL_MS = 1;
+function destinationUri(streamId) {
+  return `file:sirannon-stream-${streamId}?vfs=${VFS_NAME}`;
+}
+function sizeTheSteps(requestedPagesPerStep, pieceBytes, pageSize) {
+  const pagesPerPiece = Math.max(1, Math.floor(pieceBytes / pageSize));
+  const pagesPerStep = Math.max(1, Math.min(requestedPagesPerStep, pagesPerPiece));
+  const piecesPerStep = Math.max(1, Math.ceil(pagesPerStep * pageSize / pieceBytes));
+  return { pagesPerStep, maxQueuedPieces: piecesPerStep + 1 };
+}
+function assertWholeBlocks(pieceBytes) {
+  if (pieceBytes % PIECE_BLOCK_BYTES !== 0) {
+    throw new SirannonError(
+      `A streamed copy hands SQLite whole ${PIECE_BLOCK_BYTES}-byte blocks, so its piece size must divide by ${PIECE_BLOCK_BYTES}, and it was ${pieceBytes}`,
+      "BACKUP_ERROR"
+    );
+  }
+}
+async function removeFilesNamedAfterTheUri(uri) {
+  const stray = join(process.cwd(), uri);
+  await rm(stray, { force: true }).catch(() => void 0);
+  await rm(`${stray}-journal`, { force: true }).catch(() => void 0);
+}
+async function assertTheStreamCarriedTheCopy(host, streamId, bytesStreamed, pageCount, uri) {
+  const failure = await recordedFailure(host, streamId);
+  if (failure) throw failure;
+  if (bytesStreamed === 0 && pageCount > 0) {
+    await removeFilesNamedAfterTheUri(uri);
+    throw new SirannonError(
+      "SQLite read the destination as an ordinary file name rather than as a URI, so the copy reached no destination. This runtime parses URI file names only where the operator sets SQLITE_USE_URI=1 in the environment before the SQLite module loads.",
+      "BACKUP_UNSUPPORTED"
+    );
+  }
+}
+async function recordedFailure(host, streamId) {
+  const failure = await host.failure(streamId).catch(() => null);
+  return failure ? new SirannonError(`The streamed copy stopped because ${failure}.`, "BACKUP_ERROR") : null;
+}
+async function copyToDestinationStreamed(conn, request, support) {
+  const runId = randomHex(8);
+  const name = request.name ?? defaultDestinationName();
+  const pieceBytes = request.pieceBytes ?? DEFAULT_PIECE_BYTES;
+  assertPieceBytes(pieceBytes);
+  assertWholeBlocks(pieceBytes);
+  const startedAt = Date.now();
+  const pageSize = await readPageSize(conn);
+  const { pagesPerStep, maxQueuedPieces } = sizeTheSteps(
+    request.pagesPerStep ?? DEFAULT_PAGES_PER_STEP,
+    pieceBytes,
+    pageSize
+  );
+  const host = await BackupStreamHost.start(support.openConnection, support.extensionPath);
+  let streamId;
+  try {
+    streamId = await host.open(pieceBytes, maxQueuedPieces, conn.copyRunsOffCallerThread === true);
+  } catch (err) {
+    await host.stop().catch(() => void 0);
+    throw err;
+  }
+  const uri = destinationUri(streamId);
+  let firstStepSeen = false;
+  let copyLeftRunning = null;
+  let writingPiece = false;
+  let copying = true;
+  let discarding = false;
+  let piecesWritten = 0;
+  let bytesWritten = 0;
+  let transferMs = 0;
+  let totalPages = 0;
+  let remainingPages = 0;
+  let restarts = 0;
+  let pumpFailure = null;
+  const emit = (progress) => request.onProgress?.({ runId, ...progress });
+  const pump = async () => {
+    for (; ; ) {
+      const piece = await host.take(streamId);
+      if (!piece) {
+        if (!copying) return;
+        await new Promise((resolve3) => setTimeout(resolve3, DRAIN_POLL_MS));
+        continue;
+      }
+      if (discarding) continue;
+      const writeStartedAt = Date.now();
+      writingPiece = true;
+      try {
+        await request.destination.writePiece(name, piece.index, piece.bytes);
+      } catch (err) {
+        pumpFailure = destinationPieceError(name, piece.index, err);
+        discarding = true;
+        continue;
+      } finally {
+        writingPiece = false;
+        transferMs += Date.now() - writeStartedAt;
+      }
+      piecesWritten++;
+      bytesWritten += piece.bytes.byteLength;
+      emit({ phase: "transfer", totalPages, remainingPages, restarts, piecesWritten, bytesWritten });
+    }
+  };
+  const pumping = pump().catch((err) => {
+    pumpFailure = err;
+  });
+  try {
+    const copyStartedAt = Date.now();
+    const copy = await copyDatabaseStepwise(conn, {
+      destPath: uri,
+      pagesPerStep,
+      ...request.restartLimit === void 0 ? {} : { restartLimit: request.restartLimit },
+      ...request.stallTimeoutMs === void 0 ? {} : { stallTimeoutMs: request.stallTimeoutMs },
+      ...request.noProgressStepLimit === void 0 ? {} : { noProgressStepLimit: request.noProgressStepLimit },
+      pauseWhile: () => writingPiece,
+      onCopyLeftRunning: (running) => {
+        copyLeftRunning = running;
+      },
+      onStep: (step) => {
+        if (pumpFailure) throw pumpFailure;
+        if (!firstStepSeen) {
+          firstStepSeen = true;
+          request.onFirstStep?.();
+        }
+        totalPages = step.totalPages;
+        remainingPages = step.remainingPages;
+        restarts = step.restarts;
+        emit({ phase: "copy", ...step, piecesWritten, bytesWritten });
+      }
+    });
+    const copyMs = Date.now() - copyStartedAt;
+    const bytesStreamed = await host.finish(streamId);
+    copying = false;
+    await pumping;
+    if (pumpFailure) throw pumpFailure;
+    await assertTheStreamCarriedTheCopy(host, streamId, bytesStreamed, copy.pageCount, uri);
+    const fingerprint = request.fingerprint === false ? void 0 : await fingerprintStoredPieces(request.destination, name, piecesWritten);
+    const finishedAt = Date.now();
+    return {
+      runId,
+      databaseId: request.databaseId,
+      sourcePath: request.sourcePath,
+      kind: "full",
+      chainId: request.chainId ?? randomHex(8),
+      route: "streamed",
+      destinationName: name,
+      startedAt,
+      finishedAt,
+      durationMs: finishedAt - startedAt,
+      copyMs,
+      transferMs,
+      pageCount: copy.pageCount,
+      pageSize,
+      bytesWritten,
+      pieceCount: piecesWritten,
+      pieceBytes,
+      restarts: copy.restarts,
+      ...fingerprint ? { fingerprint } : {}
+    };
+  } catch (err) {
+    throw await recordedFailure(host, streamId) ?? err;
+  } finally {
+    discarding = true;
+    const release = async () => {
+      copying = false;
+      await pumping;
+      await host.close(streamId).catch(() => void 0);
+      await host.stop().catch(() => void 0);
+    };
+    if (copyLeftRunning) void copyLeftRunning.then(release, release);
+    else await release();
+  }
+}
+
 // src/core/backup/backup.ts
 var BACKUP_FILE_PREFIX = "backup";
 function once(action) {
@@ -261,6 +655,9 @@ function hasControlCharacters(s) {
   return false;
 }
 var BackupManager = class {
+  constructor(streaming) {
+    this.streaming = streaming;
+  }
   async backup(conn, destPath, onFirstStep) {
     if (hasControlCharacters(destPath)) {
       throw new BackupError("Backup path contains invalid characters");
@@ -294,8 +691,18 @@ var BackupManager = class {
       throw new BackupError(`Backup to '${destPath}' failed: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
-  copyToDestination(conn, request) {
-    return copyToDestinationStaged(conn, request);
+  async copyToDestination(conn, request) {
+    const bounded = {
+      ...request,
+      destination: destinationWithDeadline(
+        request.destination,
+        request.destinationTimeoutMs ?? DEFAULT_DESTINATION_TIMEOUT_MS
+      )
+    };
+    return this.streaming ? copyToDestinationStreamed(conn, bounded, this.streaming) : copyToDestinationStaged(conn, bounded);
+  }
+  streamsToDestination() {
+    return this.streaming !== void 0;
   }
   generateFilename() {
     const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
@@ -731,4 +1138,4 @@ var BackupScheduler = class {
   }
 };
 
-export { BackupManager, BackupScheduler, DEFAULT_PIECE_BYTES, sendFileInPieces };
+export { BackupManager, BackupScheduler, DEFAULT_DESTINATION_TIMEOUT_MS, DEFAULT_PIECE_BYTES, destinationWithDeadline, sendFileInPieces };