@delali/sirannon-db 0.3.4-next.62 → 0.3.4

package/dist/types-DPSmjU54.d.ts

@@ -1,1518 +0,0 @@
-import { P as Params, W as WriteConcern, R as ReadConcern, b as ChangeOperation, E as ExecuteResult, a as ReadConcernLevel } from './query-types-p1liOP-b.js';
-
-/** One piece of a backup that a destination holds.
- * @public
- */
-interface BackupPiece {
-    /** Position of this piece in the file, counted in whole pieces from zero. */
-    index: number;
-    /** Bytes this piece holds. */
-    byteLength: number;
-}
-/**
- * Where Sirannon puts backup bytes and reads them back from. Sirannon carries
- * no storage client, so a caller supplies these three operations and connects
- * object storage, another machine, or anything else that moves bytes. Pieces
- * are fixed in size and arrive in any order, because SQLite writes page one
- * last. A backup chain uses more than one name, since its full copy, each
- * change piece, and its own log are each stored under a name of their own.
- *
- * @public
- */
-interface BackupDestination {
-    /**
-     * Stores one piece of a named file. A second write to the same name and index
-     * must replace the piece already there, because a run that stops between
-     * storing a piece and recording it stores that piece again when it resumes.
-     */
-    writePiece(name: string, index: number, bytes: Uint8Array): Promise<void>;
-    /**
-     * Stores one piece only where that name and index hold none, and reports
-     * whether this call is the one that stored it. Sirannon claims each place in
-     * its list of chains through this, so two nodes writing at once keep both
-     * chains. Leave it out and Sirannon writes the record and reads it back
-     * instead, which loses a chain where the other node's write lands between
-     * those two calls.
-     */
-    writePieceIfAbsent?(name: string, index: number, bytes: Uint8Array): Promise<boolean>;
-    /** Returns one piece of a named file. */
-    readPiece(name: string, index: number): Promise<Uint8Array>;
-    /** Returns every piece a named file has, in any order. */
-    listPieces(name: string): Promise<BackupPiece[]>;
-}
-
-/** Name a destination stores the list of chains under, unless you set another.
- * @public
- */
-declare const DEFAULT_CHAIN_NAME = "sirannon-backup-chain";
-/** The stretch of a database's write-ahead log that one change piece covers.
- * @public
- */
-interface BackupChainPosition {
-    /** Checkpoint sequence of the log these frames came from. SQLite adds one to it at every restart of the log. */
-    logSequence: number;
-    /** First salt of that log. The two salts together tell one run of the log from the next. */
-    salt1: number;
-    /** Second salt of it. */
-    salt2: number;
-    /** First frame in the piece, counted from one. */
-    firstFrame: number;
-    /** Last frame in it. */
-    lastFrame: number;
-}
-/**
- * The full copy at the head of a chain. A restore starts from this copy and
- * replays the change pieces on top of it.
- *
- * @public
- */
-interface BackupChainBase {
-    /** Which kind of record this is. */
-    kind: 'full';
-    /** The chain this copy begins. */
-    chainId: string;
-    /** Name its pieces are stored under at the destination. */
-    name: string;
-    /** Identifier the run reported its progress under. */
-    runId: string;
-    /** Epoch milliseconds the copy finished. Any earlier moment needs an older chain. */
-    finishedAt: number;
-    /** How many pieces the copy came to. */
-    pieceCount: number;
-    /** Size of one whole piece, in bytes. */
-    pieceBytes: number;
-    /** How many bytes reached the destination. */
-    bytesWritten: number;
-    /** SHA-256 of the copy, unless fingerprinting was turned off. */
-    fingerprint?: string;
-}
-/**
- * One capture: the log frames a database wrote between the piece before this
- * one and this one.
- *
- * @public
- */
-interface BackupChainChange {
-    /** Which kind of record this is. */
-    kind: 'change';
-    /** The chain this piece extends, which names the full copy underneath it. */
-    chainId: string;
-    /** Name it is stored under at the destination. */
-    name: string;
-    /** Identifier the capture reported its progress under. */
-    runId: string;
-    /** Where this piece comes in its chain, counted from one. */
-    sequence: number;
-    /** The stretch of log it covers. */
-    position: BackupChainPosition;
-    /** Epoch milliseconds the capture took the frames. A restore aims at moments like this one. */
-    capturedAt: number;
-    /** How many frames it holds. */
-    frameCount: number;
-    /** How many pieces the transfer came to. */
-    pieceCount: number;
-    /** Size of one whole piece, in bytes. */
-    pieceBytes: number;
-    /** How many bytes reached the destination. */
-    bytesWritten: number;
-    /** Whether the checkpoint after this capture emptied the log. */
-    checkpointed: boolean;
-    /** SHA-256 of the frames, unless fingerprinting was turned off. */
-    fingerprint?: string;
-}
-/** Either the full copy at the head of a chain or one change piece along it.
- * @public
- */
-type BackupChainRecord = BackupChainBase | BackupChainChange;
-/** One full copy and every change piece taken from it.
- * @public
- */
-interface BackupChain {
-    /** Identifier of this chain. */
-    chainId: string;
-    /** Epoch milliseconds it started. */
-    startedAt: number;
-    /** The chain this one replaced, where it replaced one. */
-    previousChainId?: string;
-    /**
-     * The full copy underneath. Once someone deletes that record the field is
-     * absent, and no restore can use the chain any more.
-     */
-    base?: BackupChainBase;
-    /** The change pieces, oldest first. */
-    changes: BackupChainChange[];
-}
-/**
- * Names the file one chain stores its own records under. Each chain gets a name
- * of its own, so deleting an old chain leaves the rest of the destination
- * alone.
- *
- * @param chainName - Name the list of chains is stored under.
- * @param chainId - Identifier of the chain.
- * @returns The name to read and write that chain's records under.
- *
- * @public
- */
-declare function chainLogName(chainName: string, chainId: string): string;
-/**
- * Tells you what a destination holds: every chain, its full copy, and every
- * change piece taken from it. This reads nothing but the destination, so a
- * restore on a fresh machine can call it before any database exists.
- *
- * @param destination - Where the backups and their records are stored.
- * @param chainName - Name the list of chains is stored under. Defaults to `sirannon-backup-chain`.
- * @returns The chains, newest first, each with its own records oldest first.
- *
- * @public
- */
-declare function readBackupChains(destination: BackupDestination, chainName?: string): Promise<BackupChain[]>;
-
-/**
- * Which node of a replication group takes its backups.
- *
- * `'replica'` prefers a replica and falls back to the primary where the group
- * has no other node to offer. `'primary'` puts the backups on the node the
- * group names primary, and leaves them to no node at all while that node is out
- * of service. An object names one node outright. A node matching itself against that name
- * needs no coordinator to answer.
- *
- * @public
- */
-type BackupNodePreference = 'replica' | 'primary' | {
-    nodeId: string;
-};
-/**
- * Who a replication group names primary, and which of its nodes hold data
- * current enough to back up.
- *
- * @public
- */
-interface BackupGroupMembership {
-    /** Identifier of the primary, or null while the group names none. */
-    primaryNodeId: string | null;
-    /** Identifiers of the nodes eligible to take the backup. */
-    nodeIds: string[];
-}
-/**
- * Where the cycle reads this node's identity and its replication group's
- * membership. A database opened without one backs itself up every turn, which
- * is the answer a single-node deployment wants.
- *
- * `coordinatorBackupGroup` in the replication entry builds one of these over a
- * cluster coordinator. Write your own where the membership you trust lives
- * somewhere else.
- *
- * @public
- */
-interface BackupGroupSource {
-    /** Identifier this node is known by inside the group. */
-    readonly nodeId: string;
-    /**
-     * Reads the group's membership as it stands right now.
-     *
-     * @returns Who the group names primary, and which nodes are eligible.
-     */
-    readMembership(): Promise<BackupGroupMembership>;
-}
-/**
- * Why one turn of the cycle wrote nothing.
- *
- * `'not-preferred'` means another node takes this group's backups.
- * `'group-unavailable'` means this node could not read the membership it
- * decides from. `'previous-run-active'` means the turn before this one had yet
- * to finish.
- *
- * @public
- */
-type BackupSkipReason = 'not-preferred' | 'group-unavailable' | 'previous-run-active';
-/**
- * One turn the cycle skipped, and what it skipped for.
- *
- * @public
- */
-interface BackupSkip {
-    /** Which of the three conditions held. */
-    reason: BackupSkipReason;
-    /** What happened, in a sentence an operator can read in a log. */
-    message: string;
-    /** Identifier of this node, where a group source named one. */
-    nodeId?: string;
-    /** Identifier of the node whose turn it was, where the group named one. */
-    preferredNodeId?: string;
-    /**
-     * How many bytes of write-ahead log this node was holding when it skipped.
-     * Alert on this figure rising and you hear about a node holding its log long
-     * before `maxUncapturedLogBytes` ends its chain.
-     */
-    uncapturedLogBytes?: number;
-}
-
-/**
- * Where a database's write-ahead log had reached at one moment.
- *
- * A full copy states this, so you can tell which run of the log the database
- * was on when that copy finished. SQLite stamps a fresh pair of salts on the
- * log at every restart, and a checkpoint that empties the log restarts it.
- *
- * The checkpoint cycle checkpoints after each capture, and no checkpoint falls
- * between a full copy and the first change piece extending its chain, so those
- * two state the same salts. A change piece states later salts than the piece
- * before it whenever the checkpoint between the two emptied the log. A reader
- * can hold a checkpoint off, which leaves the log on the run it was already on,
- * so two consecutive change pieces may state the same salts.
- *
- * @public
- */
-interface BackupLogPosition {
-    /** Checkpoint sequence of the log. SQLite adds one to it at every restart of the log. */
-    logSequence: number;
-    /** First salt of that log. The two salts together tell one run of the log from the next. */
-    salt1: number;
-    /** Second salt of it. */
-    salt2: number;
-    /** The last frame that commits a transaction, counted from one. A log holding none reports zero. */
-    lastFrame: number;
-}
-/** How far one backup run has moved, reported at step resolution.
- * @public
- */
-interface BackupProgress {
-    /** Identifier of the run this progress belongs to. */
-    runId: string;
-    /** Whether the run is copying pages or sending pieces. */
-    phase: 'copy' | 'transfer';
-    /** Pages the copy has to move in total. A change piece reports the number of log frames it covers. */
-    totalPages: number;
-    /** Pages the copy has yet to move. Every report of the transfer phase states zero, since the copy has finished by then. */
-    remainingPages: number;
-    /** Times the copy has returned to page one. A change piece reports zero, since it reads the log and copies no pages. */
-    restarts: number;
-    /** Pieces the run has stored at the destination. */
-    piecesWritten: number;
-    /** Bytes the run has stored at the destination. */
-    bytesWritten: number;
-}
-/** What one finished backup run produced.
- * @public
- */
-interface BackupRunReport {
-    /** Identifier this run reports its progress under. */
-    runId: string;
-    /** Database the copy was taken from. */
-    databaseId: string;
-    /** File the copy was taken from. */
-    sourcePath: string;
-    /** What the run wrote: the whole database, or the log frames written since the run before it. */
-    kind: 'full' | 'change';
-    /** The chain this run belongs to. A full copy begins one, and every change piece after it extends the same one. */
-    chainId: string;
-    /** Whether the bytes reached the destination through a local file or without one. */
-    route: 'staged' | 'streamed';
-    /**
-     * Name the pieces are stored under at the destination. A run writes this one
-     * name and no other, because the journal SQLite opens beside a copy stays on
-     * local disk.
-     */
-    destinationName: string;
-    /** Epoch milliseconds the run started at. */
-    startedAt: number;
-    /** Epoch milliseconds the run finished at. */
-    finishedAt: number;
-    /** Milliseconds the whole run took. */
-    durationMs: number;
-    /** Milliseconds SQLite spent copying pages. */
-    copyMs: number;
-    /** Milliseconds the pieces took to reach the destination. */
-    transferMs: number;
-    /** Pages the copy moved. */
-    pageCount: number;
-    /** Bytes one page holds. */
-    pageSize: number;
-    /** Bytes the run stored at the destination. */
-    bytesWritten: number;
-    /** Pieces the run stored at the destination. */
-    pieceCount: number;
-    /** Bytes one whole piece holds. */
-    pieceBytes: number;
-    /** Times the copy returned to page one. */
-    restarts: number;
-    /** The stretch of log a change piece covers. A full copy has none. */
-    position?: BackupChainPosition;
-    /**
-     * Where the write-ahead log had reached when a full copy finished. Sirannon
-     * reads the log after the copy has moved every page, so a writer committing
-     * between those two steps would put a frame here that the copy does not hold.
-     * A change piece states the stretch of log it holds in
-     * {@link BackupRunReport.position}, and a database that keeps no write-ahead
-     * log states neither.
-     */
-    logPosition?: BackupLogPosition;
-    /** SHA-256 of the copied file, unless the caller turned it off. */
-    fingerprint?: string;
-}
-/** What one finished copy to a local file produced.
- * @public
- */
-interface BackupFileReport {
-    /** Identifier this run is known by. */
-    runId: string;
-    /** Database the copy was taken from. */
-    databaseId: string;
-    /** File the copy was taken from. */
-    sourcePath: string;
-    /** Absolute path of the file the copy was written to. */
-    destPath: string;
-    /** Epoch milliseconds the copy started at. */
-    startedAt: number;
-    /** Epoch milliseconds it finished at. */
-    finishedAt: number;
-    /** Milliseconds it took. */
-    durationMs: number;
-    /** Pages it moved. */
-    pageCount: number;
-    /** Bytes one page holds. */
-    pageSize: number;
-    /** Bytes the file it wrote holds. */
-    byteLength: number;
-    /** Times the copy returned to page one. */
-    restarts: number;
-}
-/**
- * What one copy to a local file produced. The controller that owns the database
- * adds its identifier and its path to build a {@link BackupFileReport}.
- *
- * @internal
- */
-type BackupFileCopy = Omit<BackupFileReport, 'databaseId' | 'sourcePath'>;
-/** How Sirannon runs one backup to a caller-supplied destination.
- * @public
- */
-interface BackupToDestinationOptions {
-    /** Where the pieces go and where a restore reads them from. */
-    destination: BackupDestination;
-    /** Name the pieces are stored under. Defaults to a timestamped name. */
-    name?: string;
-    /** The chain this copy begins. Defaults to an identifier the run mints for itself. */
-    chainId?: string;
-    /**
-     * Bytes one whole piece holds. Defaults to 16 MiB. A streamed copy hands
-     * SQLite whole 512-byte blocks, so it needs a size that divides by 512.
-     */
-    pieceBytes?: number;
-    /** Pages SQLite moves in one step. */
-    pagesPerStep?: number;
-    /** Restarts the copy survives before it stops with an error. */
-    restartLimit?: number;
-    /** Milliseconds the copy may move no pages before it stops with an error. */
-    stallTimeoutMs?: number;
-    /** Milliseconds one call to the destination may take before the run stops with an error. Defaults to 10 minutes, and zero leaves the calls unbounded. */
-    destinationTimeoutMs?: number;
-    /** Steps the copy may take without moving a page it had not already moved. */
-    noProgressStepLimit?: number;
-    /** Directory the staged route writes its local file in. Defaults to the system temporary directory. */
-    stagingDir?: string;
-    /**
-     * Whether the run fingerprints what it wrote. Defaults to true. A streamed
-     * copy reads every piece back from the destination to compute it, because it
-     * never holds the whole file, so a run to remote storage pays for that read.
-     */
-    fingerprint?: boolean;
-    /** Called at step resolution while the run proceeds. */
-    onProgress?: (progress: BackupProgress) => void;
-}
-/** What one backup run needs beyond the caller's own options.
- * @internal
- */
-interface BackupRunRequest extends BackupToDestinationOptions {
-    /** Database the copy is taken from. */
-    databaseId: string;
-    /** File the copy is taken from. */
-    sourcePath: string;
-    /** Called once the copy's first step is done, so the writer lock can be handed back. */
-    onFirstStep?: () => void;
-}
-
-/**
- * How Sirannon runs the cycle that captures a database's change log and then
- * checkpoints it.
- *
- * A database given these options takes checkpointing away from SQLite. It has
- * to: a checkpoint lets SQLite overwrite log frames nothing has captured yet,
- * and it reports success either way.
- *
- * @public
- */
-interface BackupCycleOptions {
-    /** Where the full copy, the change pieces, and the chain records go. */
-    destination: BackupDestination;
-    /**
-     * How long to wait between captures, in milliseconds. Defaults to 60000. The
-     * shorter this is, the smaller the log grows and the fewer writes an unclean
-     * stop leaves uncaptured. At zero the cycle runs only when you ask it to.
-     */
-    intervalMs?: number;
-    /**
-     * How long a chain runs before a fresh full copy starts a new one, in
-     * milliseconds. Defaults to 24 hours. Restoring means replaying every piece
-     * since the full copy, so this is what bounds how long that takes.
-     */
-    fullCopyIntervalMs?: number;
-    /** Name to store the list of chains under. Defaults to `sirannon-backup-chain`. */
-    chainName?: string;
-    /** What to name the backups after at the destination. Defaults to `sirannon-backup`. */
-    namePrefix?: string;
-    /** Size of one whole piece, in bytes. Defaults to 16 MiB. */
-    pieceBytes?: number;
-    /** Whether to fingerprint each backup. Defaults to true. */
-    fingerprint?: boolean;
-    /**
-     * Where to stage a capture before it goes out, and where the full copy writes
-     * its own local file. Defaults to a directory beside the database file, so a
-     * capture that has yet to go out is still there after a restart.
-     */
-    stagingDir?: string;
-    /** How many pages SQLite moves in one step of the full copy. */
-    pagesPerStep?: number;
-    /** How many restarts the full copy tolerates before it gives up. */
-    restartLimit?: number;
-    /** How long the full copy may move no pages at all, in milliseconds, before it gives up. */
-    stallTimeoutMs?: number;
-    /** How long one call to the destination may take, in milliseconds, before the cycle gives up on it. Defaults to 10 minutes, and zero leaves the calls unbounded. */
-    destinationTimeoutMs?: number;
-    /**
-     * How large the write-ahead log may grow while the cycle captures nothing, in
-     * bytes. It is unlimited by default, which keeps the chain whole and lets the
-     * log grow for as long as the stall lasts.
-     *
-     * Set it where the disk matters more than the chain. Sirannon measures the
-     * log after any turn that captured nothing. Past this figure it empties that
-     * log and reports `BACKUP_CHAIN_BROKEN`, so the writes the log held reach no
-     * backup and the next turn that can run starts a fresh chain with a full
-     * copy.
-     */
-    maxUncapturedLogBytes?: number;
-    /** How many steps the full copy may take without reaching a page it had not already copied. */
-    noProgressStepLimit?: number;
-    /**
-     * Where this node reads its own identity and its replication group's
-     * membership. Every node of a group carries the same cycle, and this is what
-     * one turn asks before it copies anything. Leave it out on a single-node
-     * deployment, where every turn belongs to the only node there is.
-     */
-    replicationGroup?: BackupGroupSource;
-    /**
-     * Which node of that group takes its backups. Defaults to `'replica'`, so
-     * the node serving writes keeps serving them. A group with no other node
-     * falls back to its primary.
-     */
-    preferredNode?: BackupNodePreference;
-    /** Called with the report of every backup the cycle finishes. */
-    onRun?: (report: BackupRunReport) => void;
-    /**
-     * Called at step resolution while a turn proceeds, with the counters that
-     * turn has reached. A caller sending a large full copy to remote storage
-     * drives its own reporting from these. The cycle also records the latest
-     * figures as they arrive, so take this callback where you want every step,
-     * and read the cycle's status where you want the figure as it stands.
-     */
-    onProgress?: (progress: BackupProgress) => void;
-    /**
-     * Called with every turn the cycle passed over, and what it passed it over
-     * for. A node that takes none of its group's backups reports one of these
-     * each turn.
-     */
-    onSkip?: (skip: BackupSkip) => void;
-    /**
-     * Called when a capture, a transfer, or a checkpoint fails. Set this one. A
-     * cycle that stops running while writes carry on lets the log grow without
-     * bound, and without a callback here nothing reports that.
-     */
-    onError?: (error: Error) => void;
-}
-/** What the cycle needs beyond the operator's own options.
- * @internal
- */
-interface BackupCycleRequest extends BackupCycleOptions {
-    /** Identifier of the database to capture from. */
-    databaseId: string;
-    /** Path of its file. */
-    sourcePath: string;
-    /** Runs an operation with nothing else holding the writer. */
-    runExclusive: (op: () => Promise<void>) => Promise<void>;
-    /** Hands back the connection that writes. No other connection may checkpoint. */
-    acquireWriter: () => SQLiteConnection;
-    /** Copies the whole database to the destination. Every chain starts with one of these. */
-    fullCopy: (options: BackupToDestinationOptions) => Promise<BackupRunReport>;
-}
-
-/** A failure one turn of the cycle raised.
- * @public
- */
-interface BackupCycleError {
-    /** Code the failure states, which is what a caller matches on. */
-    code: string;
-    /** What happened, in a sentence an operator can read in a log. */
-    message: string;
-    /** Epoch milliseconds the cycle raised it. */
-    at: number;
-    /** Milliseconds from the start of the turn to the failure. */
-    durationMs: number;
-    /** The chain the cycle was extending, where it held one. */
-    chainId?: string;
-    /**
-     * How far the run had got when it failed. A turn that fails before its copy
-     * begins states none. A turn that fails part-way through states the run
-     * identifier, the pages it still had to move, and the pieces and bytes that
-     * had already reached the destination.
-     */
-    progress?: BackupProgress;
-}
-/** What the cycle is doing now, and what its recent turns produced.
- * @public
- */
-interface BackupCycleStatus {
-    /** Whether a turn is under way. */
-    running: boolean;
-    /** The chain the cycle is extending, where it has one. */
-    chainId?: string;
-    /** How far the turn under way has got. It is absent between turns. */
-    progress?: BackupProgress;
-    /** What the most recent turn that wrote anything produced. */
-    lastRun?: BackupRunReport;
-    /** The most recent turn the cycle passed over, and what it passed that turn over for. */
-    lastSkip?: BackupSkip;
-    /** The most recent failure a turn raised. */
-    lastError?: BackupCycleError;
-}
-
-/** What Sirannon found when it read one stored backup back out of a destination.
- * @public
- */
-interface BackupVerifyResult {
-    /** Name the pieces are stored under. */
-    name: string;
-    /** The chain this record belongs to. */
-    chainId: string;
-    /** Whether this is the full copy at the head of that chain or one change piece along it. */
-    kind: 'full' | 'change';
-    /** How many pieces the destination stored. */
-    pieceCount: number;
-    /** How many bytes those pieces add up to. */
-    bytesRead: number;
-    /** The SHA-256 Sirannon computed over what it read, where the backup recorded one to compare it against. */
-    fingerprint?: string;
-}
-/**
- * Reads one backup back out of the destination and compares it against the
- * record the backup that wrote it left behind.
- *
- * A restore would fail on a damaged piece only once that restore had already
- * begun, so an operator calls this beforehand. Sirannon fetches every piece in
- * order and folds a SHA-256 over the bytes as they arrive, then compares that
- * digest and the byte count against the record. Only one piece is in memory at
- * any moment, and Sirannon writes none of them to disk, so a check over a large
- * full copy needs no local storage of its own.
- *
- * A missing piece, a byte count that differs from the recorded one, and a
- * digest that differs from the recorded one will each fail with
- * `BACKUP_DESTINATION_ERROR`. Where the backup turned fingerprinting off, the
- * piece listing and the byte count are the whole comparison, and the result
- * reports no fingerprint.
- *
- * @param destination - Where the pieces are stored.
- * @param chains - The chains that destination stores, as `readBackupChains` returns them.
- * @param name - Name the backup is stored under, which every chain record states.
- * @returns The pieces read, the bytes they add up to, and the digest where the backup recorded one.
- *
- * @public
- */
-declare function verifyBackupRecord(destination: BackupDestination, chains: readonly BackupChain[], name: string): Promise<BackupVerifyResult>;
-
-/**
- * Captures a database's write-ahead log and then checkpoints it, in that order,
- * on the interval the operator sets.
- *
- * The order is the whole point. A checkpoint lets SQLite overwrite frames
- * nothing has captured yet, and it reports success either way. That is why a
- * capture that fails also stops the checkpoint behind it.
- *
- * A database opens its cycle through the `backups` option. Nobody builds one
- * of these by hand.
- *
- * @public
- */
-declare class BackupCycle {
-    private readonly chainName;
-    private readonly namePrefix;
-    private readonly stagingDir;
-    private readonly logPath;
-    private readonly intervalMs;
-    private readonly fullCopyIntervalMs;
-    private readonly preferredNode;
-    private readonly timer;
-    private state;
-    private queued;
-    private readonly turns;
-    private started;
-    private verified;
-    private busy;
-    private captured;
-    private sendRefused;
-    private stopped;
-    private readonly request;
-    private readonly turnLog;
-    /** @internal */
-    constructor(request: BackupCycleRequest);
-    /**
-     * Picks a chain up where the previous run left it, or starts a new one with a
-     * full copy, and then repeats on the interval. A chain picked up takes an
-     * ordinary turn, so the frames written while this node was down reach the
-     * destination rather than waiting for the first interval.
-     */
-    start(): Promise<void>;
-    /**
-     * Takes one turn now. A turn sends any capture still waiting, reads the
-     * frames written since the previous turn, and then checkpoints the log.
-     *
-     * One turn waits at a time. A call made while a turn is under way queues one
-     * behind it, and every call after that joins the queued turn, which reads the
-     * log once it begins and so covers their writes as well. Without that bound,
-     * a caller asking repeatedly during a long full copy would build a queue of
-     * turns with nothing left for any of them to capture.
-     *
-     * A turn on a node whose group backs up from somewhere else writes nothing
-     * and reports a skip.
-     *
-     * @returns What the turn wrote, or undefined where it wrote nothing.
-     */
-    runOnce(): Promise<BackupRunReport | undefined>;
-    /**
-     * Stops the cycle. It captures the log one final time first, so the writes
-     * made since the previous turn reach the destination before the database
-     * closes behind it.
-     */
-    stop(): Promise<void>;
-    /**
-     * Lists what the destination holds.
-     *
-     * @returns Every chain, newest first, each with its full copy and its change pieces.
-     */
-    chains(): Promise<BackupChain[]>;
-    /**
-     * Reads what the cycle is doing at this moment, and what its recent turns
-     * produced.
-     *
-     * A caller following a long full copy reads this without having to wait on
-     * the turn, and it answers between turns as well.
-     *
-     * @returns Whether a turn is under way, how far it has got, and the last run, skip, and failure.
-     */
-    status(): BackupCycleStatus;
-    /**
-     * Reads one of this chain's backups back out of the destination and compares
-     * it against the record the backup that wrote it left behind.
-     *
-     * @param name - Name the backup is stored under.
-     * @returns The pieces read, the bytes they add up to, and the digest where the backup recorded one.
-     */
-    verify(name: string): Promise<BackupVerifyResult>;
-    /**
-     * 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.
-     */
-    private runTurn;
-    /** What the stand-down path needs of this cycle to let go of its chain. */
-    private get standDownRequest();
-    /** Empties a log this turn captured nothing from, past the operator's limit. */
-    private releaseLogPastLimit;
-    /**
-     * Asks whether this node takes the turn it is starting. A node the group
-     * backs up from somewhere else stands down from its chain and empties its
-     * log instead. A node that could not read its group holds everything where
-     * it is, because the frames it has yet to capture are still in no backup.
-     */
-    private takesTheTurn;
-    /** Passes a skipped turn on, where the cycle has a reason to give for it. */
-    private reportSkip;
-    private tick;
-    private verifyChain;
-    private discardState;
-    /**
-     * 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.
-     */
-    private turnOrStartOver;
-    private turn;
-    /**
-     * 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.
-     */
-    private report;
-    /** Records a failure against a chain the cycle may already have let go of. */
-    private reportAgainstChain;
-    private replaceChain;
-    private captureAndCheckpoint;
-    /**
-     * Sends the capture staged against the chain this cycle holds. A turn offers
-     * a capture the destination has already refused no second time, because that
-     * second offer waits out the destination deadline again and delays every turn
-     * behind it.
-     */
-    private sendWaitingCapture;
-}
-
-/** Context passed to query hooks.
- * @public
- */
-interface QueryHookContext {
-    /** Identifier of the database the statement runs against. */
-    databaseId: string;
-    /** The statement about to run, or the one that just ran. */
-    sql: string;
-    /** Parameters bound to the statement. */
-    params?: Params;
-    /** Values a caller attached to the request for its own hooks to read. */
-    metadata?: Record<string, unknown>;
-    /** Acknowledgements this write waits for. */
-    writeConcern?: WriteConcern;
-    /** Currency this read requires. */
-    readConcern?: ReadConcern;
-}
-/** Hook invoked before a query is executed. Throw to deny.
- * @public
- */
-type BeforeQueryHook = (ctx: QueryHookContext) => void | Promise<void>;
-/** Context passed to the after-query hook, which is the query context plus how long the statement took.
- * @public
- */
-interface AfterQueryHookContext extends QueryHookContext {
-    /** Milliseconds the statement took, measured from the moment it was sent to the moment it returned. */
-    durationMs: number;
-}
-/** Hook invoked after a query is executed.
- * @public
- */
-type AfterQueryHook = (ctx: AfterQueryHookContext) => void | Promise<void>;
-/** Context passed to connection hooks.
- * @public
- */
-interface ConnectionHookContext {
-    /** Identifier of the database being opened or closed. */
-    databaseId: string;
-    /** File path of the SQLite database. */
-    path: string;
-}
-/** Hook invoked before a database connection is established.
- * @public
- */
-type BeforeConnectHook = (ctx: ConnectionHookContext) => void | Promise<void>;
-/** Hook invoked when a database is opened.
- * @public
- */
-type DatabaseOpenHook = (ctx: ConnectionHookContext) => void | Promise<void>;
-/** Hook invoked when a database is closed.
- * @public
- */
-type DatabaseCloseHook = (ctx: ConnectionHookContext) => void | Promise<void>;
-/** Hook invoked before a subscription is created. Throw to deny.
- * @public
- */
-type BeforeSubscribeHook = (ctx: {
-    /** Identifier of the database the subscription reads. */
-    databaseId: string;
-    /** Table the subscription watches. */
-    table: string;
-    /** Column values a change must carry to reach the subscriber. */
-    filter?: Record<string, unknown>;
-    /** Whoever the `authenticate` hook returned for the connection, and undefined where that connection carries no identity. */
-    identity?: unknown;
-}) => void | Promise<void>;
-/** Hook invoked before a served snapshot reads a table. Throw to deny.
- * @public
- */
-type BeforeSnapshotHook = (ctx: {
-    /** Identifier of the database the snapshot copies. */
-    databaseId: string;
-    /** Table the snapshot is about to read. */
-    table: string;
-    /** Whoever the `authenticate` hook returned for the request, and undefined where that request carries no identity. */
-    identity?: unknown;
-}) => void | Promise<void>;
-/** Aggregated hook configuration.
- * @public
- */
-interface HookConfig {
-    /** Runs before each statement. Throw to refuse it. */
-    onBeforeQuery?: BeforeQueryHook | BeforeQueryHook[];
-    /** Runs after each statement, with the time it took. */
-    onAfterQuery?: AfterQueryHook | AfterQueryHook[];
-    /** Runs before a database connection opens. */
-    onBeforeConnect?: BeforeConnectHook | BeforeConnectHook[];
-    /** Runs once a database is open. */
-    onDatabaseOpen?: DatabaseOpenHook | DatabaseOpenHook[];
-    /** Runs once a database is closed. */
-    onDatabaseClose?: DatabaseCloseHook | DatabaseCloseHook[];
-    /** Runs before a change subscription starts. Throw to refuse it. */
-    onBeforeSubscribe?: BeforeSubscribeHook | BeforeSubscribeHook[];
-    /** Runs before a served snapshot reads a table. Throw to refuse the snapshot. */
-    onBeforeSnapshot?: BeforeSnapshotHook | BeforeSnapshotHook[];
-}
-
-/** Metrics emitted after a query completes.
- * @public
- */
-interface QueryMetrics {
-    /** Identifier of the database the statement ran against. */
-    databaseId: string;
-    /** The statement that ran. */
-    sql: string;
-    /** How long the statement took, in milliseconds. */
-    durationMs: number;
-    /** Number of rows a read returned. */
-    rowsReturned?: number;
-    /** Number of rows a write changed. */
-    changes?: number;
-    /** Set when the statement threw. */
-    error?: boolean;
-}
-/** Metrics emitted when a connection opens or closes.
- * @public
- */
-interface ConnectionMetrics {
-    /** Identifier of the database whose connection opened or closed. */
-    databaseId: string;
-    /** File path of the SQLite database. */
-    path: string;
-    /** Number of read connections the pool holds. */
-    readerCount: number;
-    /** Whether the connection opened or closed. */
-    event: 'open' | 'close';
-}
-/** Metrics emitted when a CDC event is dispatched.
- * @public
- */
-interface CDCMetrics {
-    /** Identifier of the database the change came from. */
-    databaseId: string;
-    /** Table the changed row belongs to. */
-    table: string;
-    /** Whether the row was inserted, updated, or deleted. */
-    operation: ChangeOperation;
-    /** Number of subscribers the event reached. */
-    subscriberCount: number;
-}
-/** Callbacks for metrics collection.
- * @public
- */
-interface MetricsConfig {
-    /** Called once each statement finishes, whether it succeeded or threw. */
-    onQueryComplete?: (metrics: QueryMetrics) => void;
-    /** Called when a database connection opens. */
-    onConnectionOpen?: (metrics: ConnectionMetrics) => void;
-    /** Called when a database connection closes. */
-    onConnectionClose?: (metrics: ConnectionMetrics) => void;
-    /** Called each time a change event reaches its subscribers. */
-    onCDCEvent?: (metrics: CDCMetrics) => void;
-}
-
-/**
- * Runs statements inside one transaction. A function passed to {@link Database.transaction} receives it.
- *
- * @public
- */
-declare class Transaction {
-    private readonly conn;
-    private _lastInsertRowId;
-    constructor(conn: SQLiteConnection);
-    /**
-     * Runs a read inside this transaction.
-     *
-     * @param sql - The statement to run.
-     * @param params - Values bound to the statement, named or positional.
-     * @returns The rows the statement produced.
-     */
-    query<T = Record<string, unknown>>(sql: string, params?: Params): Promise<T[]>;
-    /**
-     * Runs one write inside this transaction.
-     *
-     * @param sql - The statement to run.
-     * @param params - Values bound to the statement, named or positional.
-     * @returns How many rows changed, and the last inserted row id.
-     */
-    execute(sql: string, params?: Params): Promise<ExecuteResult>;
-    /**
-     * Runs one statement over many parameter sets inside this transaction.
-     *
-     * @param sql - The statement to run for each parameter set.
-     * @param paramsBatch - One parameter set per run.
-     * @returns One result per parameter set, in order.
-     */
-    executeBatch(sql: string, paramsBatch: Params[]): Promise<ExecuteResult[]>;
-    /**
-     * Row id SQLite assigned to the last row this transaction inserted.
-     */
-    get lastInsertRowId(): number | bigint;
-    /** @internal */
-    static run<T>(conn: SQLiteConnection, fn: (tx: Transaction) => Promise<T>): Promise<T>;
-}
-
-/** Characters a migration name may use: letters, digits, and underscores.
- * @public
- */
-declare const MIGRATION_NAME_RE: RegExp;
-/**
- * Marks a migration as the point an existing database starts from, so the
- * runner records every earlier version as applied without running it.
- *
- * @public
- */
-interface MigrationBaseline {
-    /** Highest version this baseline covers. */
-    through: number;
-}
-/** One schema change, with the statements that apply it and the statements that undo it.
- * @public
- */
-interface Migration {
-    /** Version number. The runner applies migrations in ascending order. */
-    version: number;
-    /** Name of the migration, using letters, digits, and underscores. */
-    name: string;
-    /** SQL that applies the change, or a function that runs it inside the migration's transaction. */
-    up: string | ((tx: Transaction) => void | Promise<void>);
-    /** SQL that undoes the change, or a function that runs it. A migration without this cannot roll back. */
-    down?: string | ((tx: Transaction) => void | Promise<void>);
-    /** Marks this migration as the point an existing database starts from. */
-    baseline?: MigrationBaseline;
-}
-/** Migrations to apply, either as an array or as a function that produces one.
- * @public
- */
-type MigrationSource = Migration[] | (() => Migration[] | Promise<Migration[]>);
-/** One migration named in a migration or rollback result.
- * @public
- */
-interface AppliedMigrationEntry {
-    /** Version number of the migration. */
-    version: number;
-    /** Name of the migration. */
-    name: string;
-}
-/** What one call to migrate did.
- * @public
- */
-interface MigrationResult {
-    /** Migrations this call applied, in the order it applied them. */
-    applied: AppliedMigrationEntry[];
-    /** Number of migrations the database had already applied. */
-    skipped: number;
-}
-/** What one call to roll back did.
- * @public
- */
-interface RollbackResult {
-    /** Migrations this call undid, newest first. */
-    rolledBack: AppliedMigrationEntry[];
-}
-
-/** One node a client can read from, and the read concerns it currently serves.
- * @public
- */
-interface ClusterReadEndpointInfo {
-    /** Identifier of the node behind this endpoint. */
-    nodeId: string;
-    /** Address a client sends its reads to. */
-    endpoint: string;
-    /** Read concerns this node meets right now. */
-    readConcerns: ReadConcernLevel[];
-}
-/** Every value a node reports as its health state.
- * @public
- */
-declare const NODE_HEALTH_STATES: readonly ["healthy", "degraded", "failing_over", "repairing", "syncing", "unavailable"];
-/** The single word describing what a node can do right now.
- * @public
- */
-type NodeHealthState = (typeof NODE_HEALTH_STATES)[number];
-/** The condition that produced a {@link NodeHealthState}.
- * @public
- */
-type NodeHealthReason = (typeof NODE_HEALTH_REASONS)[number];
-/** Every value a node reports as the reason behind its health state.
- * @public
- */
-declare const NODE_HEALTH_REASONS: readonly ["in-sync", "lagging", "coordinator-unreachable", "draining", "repairing", "faulted", "sync-pending", "no-group-state"];
-/**
- * The health of one node, covering only the node that reports it.
- *
- * `canRead` and `canWrite` are what that node will accept at this moment;
- * `state` and `reason` name the condition behind them.
- *
- * @public
- */
-interface NodeHealth {
-    /** What the node can do right now. */
-    state: NodeHealthState;
-    /** The condition behind that state. */
-    reason: NodeHealthReason;
-    /** Whether the node serves reads at this moment. */
-    canRead: boolean;
-    /** Whether the node accepts writes at this moment. */
-    canWrite: boolean;
-}
-/** What one node reports about its replication group, as served by `GET /db/{id}/cluster`.
- * @public
- */
-interface ClusterStatusInfo {
-    /** Identifier of the database this status describes. */
-    databaseId: string;
-    /** Identifier of the replication group the node belongs to. */
-    replicationGroupId?: string;
-    /** Whether this node accepts writes or serves reads. */
-    role?: 'primary' | 'replica';
-    /** The primary this node reports as current, or null when it has none. */
-    currentPrimary?: {
-        nodeId: string;
-        endpoint?: string;
-    } | null;
-    /** The primary term this node reports as current. */
-    primaryTerm?: bigint;
-    /** Every node a client can read from, with the read concerns each one serves. */
-    readEndpoints?: ClusterReadEndpointInfo[];
-    /** What this node can do right now. */
-    health: NodeHealthState;
-    /** The condition behind that health. */
-    healthReason: NodeHealthReason;
-}
-/** Configuration for automatic database lifecycle management.
- * @public
- */
-interface LifecycleConfig {
-    /** Opens a database the first time someone asks for an identifier the registry has not seen. */
-    autoOpen?: {
-        resolver: (id: string) => {
-            path: string;
-            options?: DatabaseOptions;
-        } | undefined;
-    };
-    /** Milliseconds before an idle database is closed. 0 = disabled. */
-    idleTimeout?: number;
-    /** Maximum number of concurrently open databases. 0 = unlimited. */
-    maxOpen?: number;
-}
-/** Options for opening a single database.
- * @public
- */
-interface DatabaseOptions {
-    /** Open the database in read-only mode. */
-    readOnly?: boolean;
-    /** Number of read connections in the pool. Default: 4. */
-    readPoolSize?: number;
-    /** Enable WAL mode. Default: true. */
-    walMode?: boolean;
-    /**
-     * Writer durability (`PRAGMA synchronous`). Default: 'normal'. This is the
-     * level restored after every bulk load, whatever the load relaxed it to.
-     */
-    synchronous?: SynchronousLevel;
-    /** CDC polling interval in milliseconds. Default: 50. */
-    cdcPollInterval?: number;
-    /** CDC retention period in milliseconds. Default: 3_600_000 (1 hour). */
-    cdcRetention?: number;
-    /**
-     * Run writes on a dedicated worker thread so disk flushes never block the
-     * thread serving connections; reads stay on the calling thread. Requires a
-     * driver with a worker entry (the `better-sqlite3` and `node` drivers have
-     * one), otherwise opening throws. Default: off.
-     */
-    writerWorker?: boolean | WriterWorkerOptions;
-    /**
-     * Capture this database's write-ahead log to a destination you supply, on an
-     * interval. A backup then costs what changed since the last one, not what the
-     * database holds, so a terabyte that changed by 200 MB pays for 200 MB.
-     *
-     * A database given this option takes checkpointing away from SQLite and runs
-     * it itself. It has to: a checkpoint lets SQLite overwrite log frames nothing
-     * has captured yet. Default: off.
-     */
-    backups?: BackupCycleOptions;
-}
-/** Limits and recovery settings for the thread that runs writes.
- * @public
- */
-interface WriterWorkerOptions {
-    /** Writes allowed in flight before new writes are rejected with a busy signal. Default: 1024. */
-    maxPendingWrites?: number;
-    /** Per-operation deadline in ms; when an operation stalls past it, its caller is rejected loudly while the worker keeps running, so a stalled write's outcome is indeterminate. 0 disables it. Default: 30000. */
-    writeTimeoutMs?: number;
-    /** Restarts the worker this many times after it crashes on its own before writes fail permanently. Default: 5. */
-    maxRestarts?: number;
-}
-/** Top-level options for the Sirannon database registry.
- * @public
- */
-interface SirannonOptions {
-    /** SQLite driver every database in this registry opens through. */
-    driver: SQLiteDriver;
-    /** Lifecycle hooks that run for every database in this registry. */
-    hooks?: HookConfig;
-    /** Callbacks that receive statement, connection, and change-capture metrics. */
-    metrics?: MetricsConfig;
-    /** Automatic opening, idle eviction, and the limit on concurrently open databases. */
-    lifecycle?: LifecycleConfig;
-    /** Migrations every database in this registry applies when it opens. */
-    migrations?: MigrationSource;
-    /** Default writer-worker setting for the databases this registry opens. */
-    writerWorker?: boolean | WriterWorkerOptions;
-}
-/** Options for scheduled backups.
- * @public
- */
-interface BackupScheduleOptions {
-    /** Cron expression (e.g., '0 * * * *' for hourly). */
-    cron: string;
-    /** Directory to store backup files. */
-    destDir: string;
-    /** Maximum number of backup files to keep. Default: 5. */
-    maxFiles?: number;
-    /**
-     * Sirannon evaluates the cron expression in this IANA time zone (e.g. 'America/New_York').
-     * When omitted, it uses the host's local time zone, which also sets the daylight saving rules that apply.
-     */
-    timezone?: string;
-    /**
-     * Called after every copy the schedule finishes, with the file it wrote and
-     * what that copy moved. Use it to send the file somewhere durable, or to
-     * record that the schedule is still running.
-     *
-     * Sirannon waits for the promise this returns, and it clears the older files
-     * only once that promise settles, so it deletes no copy your upload is still
-     * reading. Sirannon passes a failure to
-     * {@link BackupScheduleOptions.onError}, which is where it reports a failed
-     * copy as well. The deadline in
-     * {@link BackupScheduleOptions.onBackupTimeoutMs} bounds that wait.
-     */
-    onBackup?: (report: BackupFileReport) => void | Promise<void>;
-    /**
-     * Milliseconds {@link BackupScheduleOptions.onBackup} may take before
-     * Sirannon gives up waiting on it. It defaults to ten minutes, and zero
-     * leaves the wait unbounded.
-     *
-     * Sirannon clears the older files and takes the next copy once this callback
-     * settles or this deadline passes. Without a deadline, a callback left waiting
-     * on a socket would hold the schedule still for good. Past the deadline
-     * Sirannon reports the timeout through
-     * {@link BackupScheduleOptions.onError} and goes on with the schedule. Your
-     * callback keeps running while Sirannon counts that copy among the files it
-     * may delete, so set this longer than your slowest upload takes.
-     */
-    onBackupTimeoutMs?: number;
-    /** Called when a scheduled backup fails. Without this, errors are silently discarded. */
-    onError?: (error: Error) => void;
-}
-
-/** Runs a backup while nothing else holds the writer, so that the copy never shares the writer connection with another write.
- * @public
- */
-type RunExclusive = (op: () => Promise<void>) => Promise<void>;
-/**
- * What one repeating backup needs beyond the caller's own options, so that
- * every report it produces names the database the copy came from.
- *
- * @public
- */
-interface BackupScheduleRequest extends BackupScheduleOptions {
-    /** Database the copies are taken from. Defaults to the name of the file SQLite has open. */
-    databaseId?: string;
-    /** File the copies are taken from. Defaults to the file SQLite has open on the connection. */
-    sourcePath?: string;
-    /** Runs each copy with nothing else holding the writer. Defaults to running it with no lock of its own. */
-    runExclusive?: RunExclusive;
-}
-
-interface WorkerHostOptions {
-    writeTimeoutMs?: number;
-    maxRestarts?: number;
-}
-
-/** What one write reports back through the driver.
- * @public
- */
-interface RunResult {
-    /** Number of rows the statement inserted, updated, or deleted. */
-    changes: number;
-    /** Row id SQLite assigned to the last inserted row. */
-    lastInsertRowId: number | bigint;
-}
-/**
- * Tells a caller running inside the operation that holds the writer from one
- * merely waiting on it. A runtime without async context tracking cannot answer
- * this, and answering it wrongly runs one caller's writes inside another
- * caller's transaction.
- */
-interface WriterContext {
-    /** Runs an operation marked as the one holding the writer. */
-    run<T>(operation: () => T): T;
-    /** Reports whether the caller is the operation holding the writer. */
-    isActive(): boolean;
-    /** Runs an operation outside the held writer, so its writes stay out of that transaction. */
-    exit<T>(operation: () => T): T;
-}
-/**
- * Copies a database to a file, and repeats that copy on a schedule.
- *
- * @internal
- */
-interface BackupEngine {
-    /** Copies the database behind a connection to a destination path. */
-    backup(conn: SQLiteConnection, destPath: string, onFirstStep?: () => void): Promise<BackupFileCopy>;
-    /** Copies the database behind a connection to a caller-supplied destination. */
-    copyToDestination(conn: SQLiteConnection, request: BackupRunRequest): Promise<BackupRunReport>;
-    /** Reports whether a full copy reaches the destination without a local file. */
-    streamsToDestination(): boolean;
-    /** Builds the cycle that captures the write-ahead log and then checkpoints it. */
-    createCycle(request: BackupCycleRequest): BackupCycle;
-    /** Starts a repeating backup and returns a function that stops it. */
-    schedule(conn: SQLiteConnection, request: BackupScheduleRequest): () => void;
-}
-/** What one step of a stepped database copy reported.
- * @public
- */
-interface DatabaseCopyStep {
-    /** Pages the copy has to move in total. */
-    totalPages: number;
-    /** Pages the copy has yet to move. */
-    remainingPages: number;
-}
-/** What Sirannon asks a driver to copy, and how finely.
- * @public
- */
-interface DatabaseCopyRequest {
-    /** Path the copy is written to. */
-    destPath: string;
-    /** Pages the driver moves in one step. */
-    pagesPerStep: number;
-    /**
-     * Called after every step with that step's counters. It returns the pages for
-     * the next step, and a driver whose runtime takes a fresh count on each step
-     * passes that number on. Zero holds the copy still while the caller catches
-     * up.
-     */
-    onStep?: (step: DatabaseCopyStep) => number;
-    /**
-     * Milliseconds the copy may report no step before the caller stops waiting
-     * for it. A driver that steps the copy on another thread waits this long for
-     * that thread, so a caller who allows a long stall keeps the copy running.
-     * Zero leaves that wait unbounded.
-     */
-    stallTimeoutMs?: number;
-}
-/** Totals for one statement applied over many parameter sets.
- * @public
- */
-interface BatchSummary {
-    /** Number of parameter sets the driver applied. */
-    rowsLoaded: number;
-    /** Number of rows those statements inserted, updated, or deleted. */
-    changes: number;
-}
-/** One prepared statement a driver hands back, ready to run many times.
- * @public
- */
-interface SQLiteStatement {
-    /** Runs the statement and returns every row. */
-    all<T = unknown>(...params: unknown[]): Promise<T[]>;
-    /** Runs the statement and returns the first row, or undefined when there is none. */
-    get<T = unknown>(...params: unknown[]): Promise<T | undefined>;
-    /** Runs the statement as a write and reports what it changed. */
-    run(...params: unknown[]): Promise<RunResult>;
-    /**
-     * Like {@link SQLiteStatement.all} but skips the safe-range BigInt narrowing, leaving every
-     * integer as a BigInt. The server wire path narrows and tags in one pass, so
-     * feeding it raw rows avoids a second walk. Optional: a driver that omits it
-     * falls back to {@link SQLiteStatement.all}, still correct but with the extra narrowing walk.
-     */
-    allRaw?<T = unknown>(...params: unknown[]): Promise<T[]>;
-}
-/**
- * Why one unit of a grouped run failed.
- *
- * @internal
- */
-interface GroupRunError {
-    /** Message SQLite or the driver raised. */
-    message: string;
-    /** Name of the error class. */
-    name?: string;
-    /** Machine-readable code, where the driver supplies one. */
-    code?: string;
-}
-/**
- * What one unit of a grouped run produced.
- *
- * @internal
- */
-type GroupRunOutcome = {
-    ok: true;
-    results: RunResult[];
-} | {
-    ok: false;
-    error: GroupRunError;
-};
-/** One open connection to a SQLite database.
- * @public
- */
-interface SQLiteConnection {
-    /** Runs one or more statements and returns no rows. */
-    exec(sql: string): Promise<void>;
-    /** Compiles a statement so the caller can run it many times. */
-    prepare(sql: string): Promise<SQLiteStatement>;
-    /** Runs a function inside one transaction, committing when it returns and rolling back when it throws. */
-    transaction<T>(fn: (conn: SQLiteConnection) => Promise<T>): Promise<T>;
-    /** Closes the connection. */
-    close(): Promise<void>;
-    /**
-     * Loads a compiled SQLite extension into this connection through the
-     * runtime's own loading call, so a query on this connection can call the
-     * extension's functions. SQLite scopes a loaded extension to the connection
-     * that loaded it, so a caller that needs it everywhere loads it on every
-     * connection. Where the runtime carries no loading call, this rejects with an
-     * error that names that runtime.
-     */
-    loadExtension?(extensionPath: string): Promise<void>;
-    /**
-     * Copies this connection's database to a file through SQLite's stepped
-     * backup interface, one step at a time, so writes on this connection run in
-     * the gaps between steps. SQLite restarts a copy whose source is written
-     * through any other connection, so the copy must run on the connection that
-     * writes. A copy started while a transaction is already open on this
-     * connection produces nothing, so the caller starts one only when no
-     * transaction is open. Where the runtime carries no stepped backup call,
-     * this rejects with an error that names that runtime.
-     */
-    copyDatabase?(request: DatabaseCopyRequest): Promise<DatabaseCopyStep>;
-    /**
-     * Whether the runtime steps this connection's copy on a thread other than the
-     * caller's. A copy on its own thread can wait for the caller to catch up, and
-     * a copy on the caller's thread would stop the only thread there is.
-     */
-    readonly copyRunsOffCallerThread?: boolean;
-    /** Optional fast path that applies one statement over many parameter sets. */
-    runBatch?(sql: string, paramsBatch: readonly unknown[][]): Promise<RunResult[]>;
-    /** Optional fast path that applies one statement over many parameter sets and returns only the totals. */
-    runBatchSummary?(sql: string, paramsBatch: readonly unknown[][]): Promise<BatchSummary>;
-    /**
-     * Runs several independent units in one transaction, one outcome per unit in
-     * order. A unit is one write or one whole transaction, and a unit that fails
-     * must not disturb the others.
-     */
-    runGroup?(units: readonly {
-        statements: readonly {
-            sql: string;
-            params?: readonly unknown[];
-            trusted?: boolean;
-        }[];
-    }[]): Promise<GroupRunOutcome[]>;
-}
-/**
- * SQLite `PRAGMA synchronous` level applied to a connection. `normal` is safe
- * from corruption in WAL mode but can lose the most recent commits on power
- * loss; `full` fsyncs every commit; `extra` adds a directory sync after the
- * rollback journal is unlinked in DELETE journal mode and equals `full` in
- * WAL mode; `off` hands writes to the OS without syncing and is sanctioned
- * only for re-runnable bulk loads.
- *
- * @public
- */
-type SynchronousLevel = 'off' | 'normal' | 'full' | 'extra';
-/** How a driver opens one database file.
- * @public
- */
-interface OpenOptions {
-    /** Opens the file for reads only. */
-    readonly?: boolean;
-    /** Puts the database in write-ahead logging mode. */
-    walMode?: boolean;
-    /** Writer durability the connection runs at. */
-    synchronous?: SynchronousLevel;
-    /**
-     * How many frames the write-ahead log may reach before SQLite checkpoints it
-     * on its own. Zero turns that off, which a database capturing its own log
-     * needs: a checkpoint lets SQLite overwrite frames nothing has captured yet.
-     *
-     * SQLite holds this per connection, so a driver applies it every time it
-     * opens one, including after a writer worker restarts.
-     */
-    walAutoCheckpoint?: number;
-}
-/** What a driver's runtime supports.
- * @public
- */
-interface DriverCapabilities {
-    /** Whether the runtime opens more than one connection to the same file. */
-    multipleConnections: boolean;
-    /** Whether the runtime loads SQLite extensions. */
-    extensions: boolean;
-    /** Whether the runtime copies an open database through SQLite's stepped backup interface. */
-    steppedCopy: boolean;
-}
-/**
- * Lets a worker thread rebuild the driver, since the driver's `open` function
- * cannot cross the thread boundary. `specifier` must be importable from the
- * worker and `config` must survive a structured clone; the worker imports the
- * module and calls its `exportName` factory (default export otherwise) with it.
- *
- * @public
- */
-interface DriverWorkerEntry {
-    /** Module the worker imports to rebuild the driver. */
-    specifier: string;
-    /** Named export the worker calls, or the default export when absent. */
-    exportName?: string;
-    /** Value passed to that factory, which must survive a structured clone. */
-    config?: unknown;
-}
-/** How Sirannon opens SQLite on one runtime.
- * @public
- */
-interface SQLiteDriver {
-    /** What this driver's runtime supports. */
-    readonly capabilities: DriverCapabilities;
-    /** Opens a database file and returns a connection to it. */
-    open(path: string, options?: OpenOptions): Promise<SQLiteConnection>;
-    /** How a worker thread rebuilds this driver. */
-    readonly worker?: DriverWorkerEntry;
-    /**
-     * Offloads writes to a worker thread. Only a driver whose runtime has
-     * threads implements this, which is what keeps the thread machinery out of
-     * bundles built for runtimes that do not.
-     */
-    startWriterHost?(path: string, options: OpenOptions, hostOptions?: WorkerHostOptions): Promise<SQLiteConnection>;
-    /** Builds the tracker that tells the caller holding the writer from one waiting on it. */
-    createWriterContext?(): WriterContext;
-    /**
-     * Builds the engine that copies a database to a file. The driver is passed
-     * back so the engine can open a connection of its own, which a streamed copy
-     * needs for the extension that carries the bytes.
-     */
-    createBackupEngine?(driver: SQLiteDriver): BackupEngine;
-    /**
-     * Makes an extension path absolute. Passing a bare name to `load_extension`
-     * would let the dynamic linker search its own paths and open a different
-     * library than the operator named.
-     */
-    resolveExtensionPath?(extensionPath: string): string;
-}
-
-export { type BeforeSnapshotHook as $, type AfterQueryHook as A, type BackupDestination as B, DEFAULT_CHAIN_NAME as C, type DatabaseOptions as D, chainLogName as E, readBackupChains as F, verifyBackupRecord as G, type ClusterStatusInfo as H, type SQLiteConnection as I, type BackupFileCopy as J, type BackupRunRequest as K, type BackupScheduleRequest as L, type Migration as M, type NodeHealth as N, type BackupScheduleOptions as O, type DriverCapabilities as P, type BackupEngine as Q, type RunExclusive as R, type SQLiteDriver as S, Transaction as T, type SynchronousLevel as U, type LifecycleConfig as V, type MigrationResult as W, type RollbackResult as X, type AfterQueryHookContext as Y, type AppliedMigrationEntry as Z, type BatchSummary as _, type SirannonOptions as a, type BeforeSubscribeHook as a0, type CDCMetrics as a1, type ClusterReadEndpointInfo as a2, type ConnectionHookContext as a3, type ConnectionMetrics as a4, type DatabaseCopyRequest as a5, type DatabaseCopyStep as a6, type DriverWorkerEntry as a7, type HookConfig as a8, MIGRATION_NAME_RE as a9, type MetricsConfig as aa, type MigrationBaseline as ab, type MigrationSource as ac, NODE_HEALTH_REASONS as ad, NODE_HEALTH_STATES as ae, type NodeHealthReason as af, type NodeHealthState as ag, type OpenOptions as ah, type QueryHookContext as ai, type QueryMetrics as aj, type RunResult as ak, type SQLiteStatement as al, type WriterWorkerOptions as am, type WorkerHostOptions as an, type WriterContext as ao, type BeforeQueryHook as b, type BeforeConnectHook as c, type DatabaseOpenHook as d, type DatabaseCloseHook as e, type BackupRunReport as f, type BackupChain as g, type BackupChainBase as h, type BackupChainChange as i, type BackupChainPosition as j, type BackupChainRecord as k, BackupCycle as l, type BackupCycleError as m, type BackupCycleOptions as n, type BackupCycleStatus as o, type BackupFileReport as p, type BackupGroupMembership as q, type BackupGroupSource as r, type BackupLogPosition as s, type BackupNodePreference as t, type BackupPiece as u, type BackupProgress as v, type BackupSkip as w, type BackupSkipReason as x, type BackupToDestinationOptions as y, type BackupVerifyResult as z };