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

package/dist/database-BLQvqjsw.d.ts

@@ -1,917 +0,0 @@
-import { D as DatabaseBackupController, B as BackupCapabilities, a as BackupChainLocation, b as BackupRestorePlan, c as BackupSafeToDeleteOptions } from './database-backup-B7oszQ2n.js';
-import { S as SQLiteDriver, U as SynchronousLevel, an as WorkerHostOptions, I as SQLiteConnection, T as Transaction, ao as WriterContext, M as Migration, W as MigrationResult, X as RollbackResult, ai as QueryHookContext, a3 as ConnectionHookContext, a0 as BeforeSubscribeHook, $ as BeforeSnapshotHook, a8 as HookConfig, aa as MetricsConfig, aj as QueryMetrics, a4 as ConnectionMetrics, a1 as CDCMetrics, D as DatabaseOptions, p as BackupFileReport, y as BackupToDestinationOptions, f as BackupRunReport, O as BackupScheduleOptions, g as BackupChain, o as BackupCycleStatus, z as BackupVerifyResult, k as BackupChainRecord, b as BeforeQueryHook, A as AfterQueryHook } from './types-DPSmjU54.js';
-import { C as ChangeTracker } from './change-tracker-CjRFuZdB.js';
-import { C as ChangeEvent, d as SubscriptionOptions, S as Subscription, c as SubscriptionBuilder, P as Params, Q as QueryOptions, E as ExecuteResult } from './query-types-p1liOP-b.js';
-import { H as HLCTimestamp, c as ReplicationChange, C as ConflictResolver, A as ApplyResult, R as ReplicationBatch } from './types-CjhxcjhA.js';
-import { A as AppliedMigrationRow, c as BulkLoadOptions, a as BulkLoadResult } from './server-options-Bj5iJnjx.js';
-import { L as LiveQueryOptions, a as LiveQuery } from './types-DTO4CYhW.js';
-
-/**
- * Settings a connection pool opens its writer and readers with.
- *
- * @internal
- */
-interface ConnectionPoolOptions {
-    driver: SQLiteDriver;
-    path: string;
-    readOnly?: boolean;
-    readPoolSize?: number;
-    walMode?: boolean;
-    synchronous?: SynchronousLevel;
-    walAutoCheckpoint?: number;
-    useWriterWorker?: boolean;
-    workerHostOptions?: WorkerHostOptions;
-}
-/**
- * Holds one writer connection and a rotating set of reader connections for a single database file.
- *
- * @internal
- */
-declare class ConnectionPool {
-    private readonly writer;
-    private readonly readers;
-    private readerIndex;
-    private closed;
-    private constructor();
-    static create(options: ConnectionPoolOptions): Promise<ConnectionPool>;
-    acquireReader(): SQLiteConnection;
-    acquireWriter(): SQLiteConnection;
-    /** Returns the writer and every reader, for an operation that must apply to the whole pool. */
-    connections(): readonly SQLiteConnection[];
-    get readerCount(): number;
-    get isReadOnly(): boolean;
-    close(): Promise<void>;
-}
-
-declare class SubscriptionManager {
-    private nextId;
-    private readonly subscriptions;
-    private readonly byTable;
-    private readonly batchEndListeners;
-    subscribe(table: string, filter: Record<string, unknown> | undefined, callback: (event: ChangeEvent) => void, options?: SubscriptionOptions): Subscription;
-    dispatch(events: ChangeEvent[]): void;
-    reportError(error: Error): void;
-    addBatchEndListener(listener: (atTxBoundary: boolean) => void): () => void;
-    endBatch(atTxBoundary: boolean): void;
-    get size(): number;
-    subscriberCount(table: string): number;
-}
-
-/**
- * Hybrid Logical Clock (HLC) for causal ordering of events across nodes.
- *
- * Each timestamp is encoded as `{wallMs hex}-{logical hex}-{nodeId}`, which
- * is directly comparable with string comparison while preserving both
- * wall-clock proximity and causal ordering guarantees. The wall-clock
- * component tracks real time (milliseconds since epoch), the logical counter
- * disambiguates events that occur within the same millisecond, and the nodeId
- * ties the timestamp to its origin.
- *
- * Call `now()` before persisting a local write to generate a monotonically
- * increasing timestamp. Call `receive(remote)` when processing a remote
- * change to merge the remote clock into the local state, ensuring the local
- * clock is never behind any observed timestamp.
- *
- * @public
- */
-declare class HLC {
-    private wallMs;
-    private logical;
-    private readonly nodeId;
-    constructor(nodeId: string);
-    /**
-     * Generate a new HLC timestamp, advancing the clock.
-     *
-     * @internal
-     */
-    now(): string;
-    /**
-     * Merge a remote HLC timestamp into the local clock and return the updated value.
-     *
-     * @internal
-     */
-    receive(remote: string): string;
-    /** Lexicographic comparison of two encoded HLC strings. Returns -1, 0, or 1. */
-    static compare(a: string, b: string): number;
-    /** Parse an encoded HLC string into its wall-clock, logical, and nodeId components. */
-    static decode(hlc: string): HLCTimestamp;
-    /**
-     * Builds the string form of a clock reading, which sorts in the same order as the reading itself.
-     *
-     * @param wallMs - Wall-clock milliseconds since the Unix epoch.
-     * @param logical - Counter that orders events sharing one millisecond.
-     * @param nodeId - Identifier of the node taking the reading.
-     * @returns The encoded stamp.
-     */
-    static encode(wallMs: number, logical: number, nodeId: string): string;
-}
-
-interface StampStatement {
-    sql: string;
-    params: unknown[];
-    trusted: true;
-}
-declare class SyncStamper {
-    readonly nodeId: string;
-    readonly hlc: HLC;
-    private readonly changesTable;
-    private constructor();
-    static init(conn: SQLiteConnection, changesTable?: string): Promise<SyncStamper>;
-    stampStatements(options?: {
-        persistClock?: boolean;
-    }): StampStatement[];
-    applyStamps(txConn: SQLiteConnection): Promise<void>;
-}
-
-type RunExclusive$1 = <T>(op: () => Promise<T>) => Promise<T>;
-declare class DatabaseCdcController {
-    private readonly runExclusive;
-    private readonly acquireWriter;
-    private readonly pollInterval;
-    private readonly retention;
-    private readonly openSnapshotConnection;
-    private tracker;
-    private subscriptionManager;
-    private liveConnRequest;
-    private stopPolling;
-    private stamper;
-    private epochRequest;
-    constructor(runExclusive: RunExclusive$1, acquireWriter: () => SQLiteConnection, pollInterval: number, retention: number, openSnapshotConnection: (() => Promise<SQLiteConnection>) | null);
-    ensureEpoch(): Promise<string>;
-    readAtPositionWith<T>(read: (conn: SQLiteConnection) => Promise<T>): Promise<{
-        value: T;
-        position: string;
-        seq: bigint;
-    }>;
-    liveConnection(): Promise<{
-        conn: SQLiteConnection;
-        run: RunExclusive$1;
-    }>;
-    closeLiveConnection(): Promise<void>;
-    get subscriptions(): SubscriptionManager | null;
-    get changeTracker(): ChangeTracker | null;
-    watch(table: string): Promise<void>;
-    ensureStamper(): Promise<SyncStamper>;
-    ensureStamping(): Promise<void>;
-    stampStatements(options?: {
-        persistClock?: boolean;
-    }): readonly StampStatement[] | null;
-    applyStamps(txConn: SQLiteConnection): Promise<void>;
-    unwatch(table: string): Promise<void>;
-    on(table: string): SubscriptionBuilder;
-    runTransaction<T>(writer: SQLiteConnection, fn: (tx: Transaction) => Promise<T>): Promise<T>;
-    stop(): void;
-    private ensure;
-    private ensurePolling;
-}
-
-declare class WriterLock {
-    private tail;
-    private readonly context;
-    constructor(context?: WriterContext);
-    run<T>(operation: () => Promise<T>): Promise<T>;
-    isHeld(): boolean;
-    settle(): Promise<void>;
-    detached<T>(operation: () => T): T;
-}
-
-interface DatabaseMigrationDeps {
-    pool: ConnectionPool;
-    writerLock: WriterLock;
-    changeTracker: () => ChangeTracker | null;
-}
-declare class DatabaseMigrationController {
-    private readonly deps;
-    constructor(deps: DatabaseMigrationDeps);
-    migrate(migrations: Migration[]): Promise<MigrationResult>;
-    rollback(migrations: Migration[], version?: number): Promise<RollbackResult>;
-    applied(): Promise<AppliedMigrationRow[]>;
-}
-
-/**
- * Names of the lifecycle points a hook can attach to.
- *
- * @internal
- */
-type HookEvent = 'beforeQuery' | 'afterQuery' | 'beforeConnect' | 'databaseOpen' | 'databaseClose' | 'beforeSubscribe' | 'beforeSnapshot';
-/**
- * Context a subscribe hook receives.
- *
- * @internal
- */
-type SubscribeHookContext = Parameters<BeforeSubscribeHook>[0];
-/**
- * Context a snapshot hook receives.
- *
- * @internal
- */
-type SnapshotHookContext = Parameters<BeforeSnapshotHook>[0];
-/**
- * Maps each lifecycle point to the context its hooks receive.
- *
- * @internal
- */
-interface HookEventContextMap {
-    beforeQuery: QueryHookContext;
-    afterQuery: QueryHookContext & {
-        durationMs: number;
-    };
-    beforeConnect: ConnectionHookContext;
-    databaseOpen: ConnectionHookContext;
-    databaseClose: ConnectionHookContext;
-    beforeSubscribe: SubscribeHookContext;
-    beforeSnapshot: SnapshotHookContext;
-}
-/**
- * Function a hook registration stores for one lifecycle point.
- *
- * @internal
- */
-type HookHandler<E extends HookEvent> = (ctx: HookEventContextMap[E]) => void | Promise<void>;
-/**
- * Removes the hook it was returned for, and changes nothing when called again.
- *
- * @public
- */
-type HookDispose = () => void;
-
-/**
- * Holds the lifecycle hooks a database or registry has registered and invokes them in order.
- *
- * @internal
- */
-declare class HookRegistry {
-    private hooks;
-    constructor(config?: HookConfig);
-    register<E extends HookEvent>(event: E, hook: HookHandler<E>): HookDispose;
-    invoke<E extends HookEvent>(event: E, ctx: HookEventContextMap[E]): Promise<void>;
-    invokeSync<E extends HookEvent>(event: E, ctx: HookEventContextMap[E]): void;
-    has(event: HookEvent): boolean;
-    count(event: HookEvent): number;
-    clear(event?: HookEvent): void;
-    private addHook;
-    private loadConfig;
-}
-
-/**
- * Times queries and reports connection and change-capture activity to the configured metrics callbacks.
- *
- * @internal
- */
-declare class MetricsCollector {
-    private config;
-    constructor(config?: MetricsConfig);
-    trackQuery<T>(fn: () => Promise<T>, context: Omit<QueryMetrics, 'durationMs' | 'error'>): Promise<T>;
-    trackConnection(metrics: ConnectionMetrics): void;
-    trackCDCEvent(metrics: CDCMetrics): void;
-    get active(): boolean;
-}
-
-interface ObservedStatement {
-    sql: string;
-    params?: Params;
-}
-declare class DatabaseObserver {
-    private readonly databaseId;
-    private readonly localHooks;
-    private readonly parentHooks;
-    private readonly metrics;
-    constructor(databaseId: string, localHooks: HookRegistry, parentHooks: HookRegistry | null, metrics: MetricsCollector | null);
-    get observesQueries(): boolean;
-    withQueryHooks<T>(sql: string, params: Params | undefined, options: QueryOptions | undefined, op: () => Promise<T>): Promise<T>;
-    track<T>(sql: string, op: () => Promise<T>): Promise<T>;
-    withTransactionHooks(statements: readonly ObservedStatement[], op: () => Promise<ExecuteResult[]>): Promise<ExecuteResult[]>;
-    private trackEach;
-    private fireBefore;
-    private fireAfter;
-}
-
-interface DatabaseReadDeps {
-    pool: ConnectionPool;
-    writerLock: WriterLock;
-    observer: DatabaseObserver;
-}
-
-interface StagedRecovery {
-    resumeSeq: bigint | null;
-    appliedSeq: bigint | null;
-    /**
-     * The failure that stopped the recovery apply, or null. The staged rows
-     * are untouched by the failure and the resume watermark still covers
-     * them, so the caller opens the subscription anyway: a schema-gate refusal
-     * there is what tells a device it must migrate before this apply can
-     * succeed. The caller must then retry the recovery, because the resume
-     * watermark is past the transaction this apply left unapplied, so the
-     * server sends nothing that would prompt another try.
-     */
-    applyError: unknown | null;
-}
-
-/**
- * How far a device has pulled from its server, and which sequence space that
- * position belongs to.
- *
- * @public
- */
-interface DeviceSyncPullState {
-    /** Highest server change-log position this device has applied. */
-    seq: bigint;
-    /** Sequence space that position came from. */
-    epoch: string | undefined;
-}
-/**
- * What a device's local database offers the sync loop: it stages and applies
- * what the server sends, reads what the device still owes the server, and
- * keeps both cursors. Take one from {@link Database.deviceSync}.
- *
- * @public
- */
-interface DeviceSyncPort {
-    /** Returns the identifier this device stamps its own changes with. */
-    identity(): Promise<{
-        nodeId: string;
-    }>;
-    /** Applies one pulled transaction and advances the pull cursor in the same write. */
-    applyPulledTransaction(changes: readonly ReplicationChange[], pullSeq: bigint, resolver?: ConflictResolver | ((table: string) => ConflictResolver)): Promise<ApplyResult>;
-    /** Stores pulled changes durably without applying them, so an interrupted device resumes from disk. */
-    stagePulledChanges(events: readonly ChangeEvent[]): Promise<bigint | null>;
-    /** Applies whatever is staged and returns the position reached. */
-    applyStagedPull(resolver?: ConflictResolver | ((table: string) => ConflictResolver), onChange?: (event: ChangeEvent) => void): Promise<bigint | null>;
-    /** Applies what a previous run left staged, and reports the failure that stopped it. */
-    recoverStagedPull(resolver?: ConflictResolver | ((table: string) => ConflictResolver), onChange?: (event: ChangeEvent) => void): Promise<StagedRecovery>;
-    /** Reads the next run of local changes the device still owes the server. */
-    readOutboxBatch(afterSeq: bigint, limit: number): Promise<ReplicationBatch | null>;
-    /** Counts the local changes the device still owes the server. */
-    countOutboxPending(afterSeq: bigint): Promise<number>;
-    /** Reads how far the device has pushed. */
-    getPushCursor(): Promise<bigint>;
-    /** Records how far the device has pushed. */
-    setPushCursor(seq: bigint): Promise<void>;
-    /** Reads how far the device has pulled, or null before it has pulled anything. */
-    getPullState(): Promise<DeviceSyncPullState | null>;
-    /** Reports whether the server has told this device to download a fresh snapshot. */
-    getResyncRequired(): Promise<boolean>;
-    /** Records whether the device must download a fresh snapshot. */
-    setResyncRequired(required: boolean): Promise<void>;
-    /** Records how far the device has pulled, and the sequence space it came from. */
-    setPullState(seq: bigint, epoch?: string): Promise<void>;
-    /** Keeps changes above a position out of pruning until the server has accepted them. */
-    protectUnpushedChanges(pushedSeq: bigint): void;
-    /** Reports whether a snapshot download was interrupted and still has to finish. */
-    snapshotLoadPending(): Promise<boolean>;
-    /** Clears the named tables and opens the database for a snapshot download. */
-    beginSnapshotLoad(tables: readonly string[]): Promise<void>;
-    /** Applies the schema statements a snapshot carries. */
-    applySnapshotSchema(schema: readonly string[]): Promise<void>;
-    /** Writes one page of snapshot rows into a table. */
-    loadSnapshotPage(table: string, rows: readonly Record<string, unknown>[]): Promise<void>;
-    /** Replaces the local migration history with the server's. */
-    replaceMigrationHistory(rows: readonly AppliedMigrationRow[]): Promise<void>;
-    /** Closes a completed snapshot download and reopens the database for normal use. */
-    endSnapshotLoad(tables: readonly string[]): Promise<void>;
-    /** Abandons a snapshot download, leaving the database marked as needing another. */
-    abortSnapshotLoad(): Promise<void>;
-}
-
-type RunExclusive = <T>(op: () => Promise<T>) => Promise<T>;
-
-declare class DatabaseSyncController {
-    private readonly runExclusive;
-    private readonly acquireWriter;
-    private readonly cdc;
-    private pkResolver;
-    private tablesReady;
-    private metaReady;
-    private outboxReader;
-    private localPruneBoundary;
-    private snapshotGate;
-    private readonly defaultResolver;
-    constructor(runExclusive: RunExclusive, acquireWriter: () => SQLiteConnection, cdc: DatabaseCdcController);
-    applyChanges(batch: ReplicationBatch, resolver?: ConflictResolver | ((table: string) => ConflictResolver)): Promise<ApplyResult>;
-    devicePort(): DeviceSyncPort;
-    get snapshotLoadBlocked(): boolean;
-    seedSnapshotGate(): void;
-    private applyPulledTransaction;
-    private stagePulled;
-    private applyStagedPull;
-    private recoverStagedPullState;
-    private stagedApplyOptions;
-    private replaceMigrationHistory;
-    private beginSnapshotLoad;
-    private endSnapshotLoad;
-    private applyLocalPruneBoundary;
-    private readOutboxBatch;
-    private countOutboxPending;
-    private getResyncRequired;
-    private setResyncRequired;
-    private getPullState;
-    private setPullState;
-    private getMetaSeq;
-    private setMetaSeq;
-    private ensureMeta;
-    private ensureSyncTables;
-    private ensureOutboxReader;
-    private ensureApplier;
-    private catchUpLocalColumnVersions;
-    private lastAppliedSeq;
-}
-
-/**
- * Runs a read on one connection and returns the rows with their values decoded.
- *
- * @internal
- */
-declare function query<T = Record<string, unknown>>(conn: SQLiteConnection, sql: string, params?: Params): Promise<T[]>;
-/**
- * Runs a read on one connection and returns the first row, or undefined when there is none.
- *
- * @internal
- */
-declare function queryOne<T = Record<string, unknown>>(conn: SQLiteConnection, sql: string, params?: Params): Promise<T | undefined>;
-/**
- * Runs one write on a connection and returns the change count and last inserted row id.
- *
- * @internal
- */
-declare function execute(conn: SQLiteConnection, sql: string, params?: Params, trusted?: boolean): Promise<ExecuteResult>;
-interface GroupStatement {
-    sql: string;
-    params?: Params;
-    trusted?: boolean;
-}
-/**
- * Runs one statement over many parameter sets on a connection and returns a result per set.
- *
- * @internal
- */
-declare function executeBatch(conn: SQLiteConnection, sql: string, paramsBatch: Params[]): Promise<ExecuteResult[]>;
-
-interface GroupCommitterHooks {
-    acquireWriter: () => SQLiteConnection;
-    afterCommit: (writer: SQLiteConnection, sql: string) => Promise<void>;
-    stampStatements: (options?: {
-        persistClock?: boolean;
-    }) => readonly GroupStatement[] | null;
-}
-declare class GroupCommitter {
-    private readonly writerLock;
-    private readonly hooks;
-    private readonly maxGroup;
-    private readonly pending;
-    private running;
-    private scheduled;
-    private loopPromise;
-    constructor(writerLock: WriterLock, hooks: GroupCommitterHooks, maxGroup?: number);
-    submit(sql: string, params?: Params): Promise<ExecuteResult>;
-    submitTransaction(statements: readonly GroupStatement[]): Promise<ExecuteResult[]>;
-    drain(): Promise<void>;
-    runUngrouped(sql: string, params?: Params): Promise<ExecuteResult>;
-    private schedule;
-    private runLoop;
-    private takeBatch;
-    private flush;
-    private needsStamp;
-    private runSingle;
-    private runStampedAlone;
-    private runGroup;
-}
-
-declare class WriteGate {
-    private readonly limit;
-    private readonly retryAfterMs;
-    private inFlight;
-    constructor(limit: number, retryAfterMs: number);
-    run<T>(op: () => Promise<T>): Promise<T>;
-}
-
-interface DatabaseWriteDeps {
-    pool: ConnectionPool;
-    writeGate: WriteGate;
-    writerLock: WriterLock;
-    groupCommitter: GroupCommitter;
-    cdc: DatabaseCdcController;
-    observer: DatabaseObserver;
-    synchronous: SynchronousLevel;
-    walMode: boolean;
-    capturesChangeLog: boolean;
-}
-declare class DatabaseWriteController {
-    private readonly deps;
-    constructor(deps: DatabaseWriteDeps);
-    execute(sql: string, params?: Params, options?: QueryOptions): Promise<ExecuteResult>;
-    executeBatch(sql: string, paramsBatch: Params[], options?: QueryOptions): Promise<ExecuteResult[]>;
-    bulkLoad(sql: string, paramsBatch: Params[], options?: BulkLoadOptions): Promise<BulkLoadResult>;
-    executeTransaction(statements: readonly {
-        sql: string;
-        params?: Params;
-    }[]): Promise<ExecuteResult[]>;
-    transaction<T>(fn: (tx: Transaction) => Promise<T>): Promise<T>;
-    drain(): Promise<void>;
-    private runStatementsAlone;
-    private runInTransaction;
-}
-
-interface DatabaseInternals {
-    parentHooks?: HookRegistry;
-    metrics?: MetricsCollector;
-}
-interface DatabaseRuntime {
-    pool: ConnectionPool;
-    writeGate: WriteGate;
-    writerLock: WriterLock;
-    hookRegistry: HookRegistry;
-    observer: DatabaseObserver;
-    backups: DatabaseBackupController;
-    cdc: DatabaseCdcController;
-    sync: DatabaseSyncController;
-    groupCommitter: GroupCommitter;
-    writes: DatabaseWriteController;
-    reads: DatabaseReadDeps;
-    migrations: DatabaseMigrationController;
-    loadExtension: (extensionPath: string) => Promise<void>;
-}
-
-/**
- * What every open database carries whatever statements run on it: which file
- * it is, the runtime behind it, the guards each member runs before it touches
- * that runtime, and the members that close it.
- *
- * Open a database through {@link Sirannon.open}, which hands back a
- * {@link Database} built on this.
- *
- * @public
- */
-declare class DatabaseLifecycle {
-    /** Identifier this database was opened under. */
-    readonly id: string;
-    /** File path of the SQLite database. */
-    readonly path: string;
-    /** Whether this database refuses writes. */
-    readonly readOnly: boolean;
-    /**
-     * Pool, locks, and controllers this database runs its work through.
-     *
-     * @internal
-     */
-    protected readonly runtime: DatabaseRuntime;
-    /**
-     * Functions that run while this database closes.
-     *
-     * @internal
-     */
-    protected readonly closeListeners: (() => void | Promise<void>)[];
-    private closing;
-    protected constructor(id: string, path: string, runtime: DatabaseRuntime, options?: DatabaseOptions);
-    /**
-     * Registers a function that runs while this database closes.
-     *
-     * @param fn - Called during {@link DatabaseLifecycle.close}.
-     *
-     * @internal
-     */
-    addCloseListener(fn: () => void | Promise<void>): void;
-    /**
-     * Closes every connection this database holds and ends its subscriptions.
-     */
-    close(): Promise<void>;
-    /**
-     * Whether this database has been closed.
-     */
-    get closed(): boolean;
-    /**
-     * Number of read connections the pool holds.
-     */
-    get readerCount(): number;
-    /**
-     * Refuses the call when this database is closed, is loading a snapshot, or refuses writes.
-     *
-     * @internal
-     */
-    protected ensureWritable(): void;
-    /**
-     * Refuses the call when this database is closed or is loading a snapshot.
-     *
-     * @internal
-     */
-    protected ensureOpen(): void;
-    /**
-     * Refuses the call when this database is closed.
-     *
-     * @internal
-     */
-    protected ensureNotClosed(): void;
-}
-
-/**
- * Everything an open database does about its backups: one-off copies, the cron
- * schedule, the cycle that captures its change log, and the questions its chain
- * of backups can answer.
- *
- * Open a database through {@link Sirannon.open}. What you get back is a
- * {@link Database}, which is built on this.
- *
- * @public
- */
-declare class DatabaseBackups extends DatabaseLifecycle {
-    /**
-     * Copies this database to a file while it stays open for reads and writes.
-     *
-     * SQLite moves the pages in steps on the connection that writes, so a write
-     * runs in the gap between two steps rather than waiting for the whole copy.
-     *
-     * @param destPath - Path the copy is written to.
-     * @returns The run identifier, the timings, the pages it moved, and the bytes the file holds.
-     */
-    backup(destPath: string): Promise<BackupFileReport>;
-    /**
-     * Copies this database to a destination you supply, in fixed-size pieces,
-     * while it stays open for reads and writes.
-     *
-     * Sirannon carries no storage client, so the destination is where you
-     * connect object storage or anything else that moves bytes.
-     *
-     * The pieces reach the destination as SQLite writes them where this runtime
-     * carries the compiled streaming extension, so the run needs no local disk.
-     * Every other runtime writes one local file first and needs local disk equal
-     * to the backup. {@link DatabaseBackups.backupCapabilities} states which of
-     * the two this one does.
-     *
-     * @param options - Destination, naming, piece size, and progress reporting.
-     * @returns The run identifier, the timings, what the run wrote, and how often the copy restarted.
-     */
-    backupTo(options: BackupToDestinationOptions): Promise<BackupRunReport>;
-    /**
-     * Reports which backup operations this database's runtime supports, so you
-     * learn before a run rather than when one fails.
-     *
-     * @returns What this runtime copies, whether it needs local disk, and whether it schedules.
-     */
-    backupCapabilities(): BackupCapabilities;
-    /**
-     * Starts repeating backups on a cron schedule, keeping a bounded number of files.
-     *
-     * @param options - Cron expression, destination directory, retention, and time zone, along with the callbacks Sirannon calls after each finished copy and after each failure.
-     */
-    scheduleBackup(options: BackupScheduleOptions): void;
-    /**
-     * Runs one turn of the checkpoint cycle now instead of waiting for its
-     * interval. A turn sends any capture still waiting, reads the log frames
-     * written since the previous turn, and then checkpoints the log.
-     *
-     * A database needs the `backups` option to have a cycle at all. On a node its
-     * replication group backs up from somewhere else, the turn writes nothing and
-     * reports a skip through `onSkip`.
-     *
-     * @returns What the turn wrote, or undefined where it wrote nothing.
-     */
-    captureBackupChanges(): Promise<BackupRunReport | undefined>;
-    /**
-     * Lists what the backup destination holds.
-     *
-     * @returns One entry per chain, newest first, each with its full copy and its change pieces in order.
-     */
-    backupChain(): Promise<BackupChain[]>;
-    /**
-     * Reads what this database's backup cycle is doing at this moment, and what
-     * its recent turns produced.
-     *
-     * A caller that triggers a turn with {@link DatabaseBackups.captureBackupChanges}
-     * without waiting on it would read this until that turn finishes. A full copy
-     * of a large database reports its pages as SQLite moves them.
-     *
-     * @returns Whether a turn is under way, how far it has got, and the last run, skip, and failure.
-     */
-    backupStatus(): BackupCycleStatus;
-    /**
-     * Reads one of this database's backups 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 name the backup here beforehand. Sirannon then fetches every
-     * piece in order and folds a SHA-256 over the bytes as they arrive, and it
-     * compares that digest and the byte count against the record. Only one piece
-     * is in memory at any moment, 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`.
-     *
-     * @param name - Name the backup is stored under, which every entry {@link DatabaseBackups.backupChain} returns states.
-     * @returns The pieces read, the bytes they add up to, and the digest where the backup recorded one.
-     */
-    verifyBackup(name: string): Promise<BackupVerifyResult>;
-    /**
-     * Reads where this database's backups are stored.
-     *
-     * `restoreBackup` accepts what you get back, and it then rebuilds this
-     * database from its own backups at whatever path you name.
-     *
-     * @returns The destination, the name its chains are listed under, and the directory Sirannon stages captures in.
-     */
-    backupLocation(): BackupChainLocation;
-    /**
-     * Works out what a restore to a given moment has to read.
-     *
-     * The result also tells you the moment it would actually reach, which is when
-     * the last piece was captured. One piece covers every write in the interval
-     * it was taken over, so a restore arrives at a piece boundary, not at the
-     * exact millisecond you named.
-     *
-     * @param moment - Epoch milliseconds you want back.
-     * @returns The full copy, the change pieces to apply in order, and the moment the result reflects.
-     */
-    backupRestorePlan(moment: number): Promise<BackupRestorePlan>;
-    /**
-     * Tells you which backups no restore still needs, so you can delete them
-     * knowing exactly what you give up. Name the earliest moment you still want
-     * to reach and the answer also covers the older chains a newer full copy
-     * already spans.
-     *
-     * Sirannon lists them and deletes nothing. The destination is yours.
-     *
-     * @param options - How far back you still want to be able to restore.
-     * @returns The records you may delete, oldest first.
-     */
-    backupPiecesSafeToDelete(options?: BackupSafeToDeleteOptions): Promise<BackupChainRecord[]>;
-}
-
-/**
- * One open SQLite database, with its reads, writes, transactions, migrations, change subscriptions, and live queries.
- *
- * Open one through {@link Sirannon.open} rather than constructing it.
- *
- * @public
- */
-declare class Database extends DatabaseBackups {
-    /** @internal */
-    static create(id: string, path: string, driver: SQLiteDriver, options?: DatabaseOptions, internals?: DatabaseInternals): Promise<Database>;
-    /** @internal */
-    applyChanges(batch: ReplicationBatch, resolver?: ConflictResolver | ((table: string) => ConflictResolver)): Promise<ApplyResult>;
-    /**
-     * Returns the device-sync port for this database, which reads and advances
-     * the cursors a `SyncController` keeps against a server.
-     *
-     * @returns The port, which `downloadDatabaseSnapshot` also accepts.
-     */
-    deviceSync(): DeviceSyncPort;
-    /**
-     * Runs a read and returns every row.
-     *
-     * @param sql - The statement to run.
-     * @param params - Values bound to the statement, named or positional.
-     * @param options - Read concern for this statement.
-     * @returns The rows the statement produced.
-     */
-    query<T = Record<string, unknown>>(sql: string, params?: Params, options?: QueryOptions): Promise<T[]>;
-    /** @internal */
-    queryForWire(sql: string, params?: Params, options?: QueryOptions): Promise<unknown[]>;
-    /**
-     * Runs a read and returns its first row.
-     *
-     * @param sql - The statement to run.
-     * @param params - Values bound to the statement, named or positional.
-     * @param options - Read concern for this statement.
-     * @returns The first row, or undefined when the statement produced none.
-     */
-    queryOne<T = Record<string, unknown>>(sql: string, params?: Params, options?: QueryOptions): Promise<T | undefined>;
-    /**
-     * Runs one write.
-     *
-     * @param sql - The statement to run.
-     * @param params - Values bound to the statement, named or positional.
-     * @param options - Write concern for this statement.
-     * @returns How many rows changed, and the last inserted row id.
-     */
-    execute(sql: string, params?: Params, options?: QueryOptions): Promise<ExecuteResult>;
-    /**
-     * Runs one statement over many parameter sets inside a single transaction.
-     *
-     * @param sql - The statement to run for each parameter set.
-     * @param paramsBatch - One parameter set per run.
-     * @param options - Write concern for the transaction.
-     * @returns One result per parameter set, in order.
-     */
-    executeBatch(sql: string, paramsBatch: Params[], options?: QueryOptions): Promise<ExecuteResult[]>;
-    /**
-     * Imports many rows with relaxed writer durability, then restores the configured level.
-     *
-     * Use this for a load you can re-run from scratch, because
-     * {@link Database.executeBatch} keeps full durability. The load holds the
-     * writer lock throughout and restores the configured level before this
-     * resolves, whether it succeeds or fails. One transaction covers the whole
-     * batch, and the rows are summed rather than returned one by one to bound
-     * memory on a large load. Like {@link Database.execute}, this writes only to
-     * the local database; under replication the server routes loads through the
-     * engine instead.
-     *
-     * @param sql - The statement to run for each parameter set.
-     * @param paramsBatch - One parameter set per row.
-     * @param options - Durability during the load, and whether it ends with a checkpoint.
-     * @returns How many rows the load applied and how many rows changed.
-     */
-    bulkLoad(sql: string, paramsBatch: Params[], options?: BulkLoadOptions): Promise<BulkLoadResult>;
-    /**
-     * Runs a fixed list of statements in one transaction so that several callers can share one commit.
-     *
-     * This takes the statements up front rather than a callback, because a group
-     * cannot wait on an arbitrary caller-supplied callback without delaying every
-     * transaction beside it.
-     *
-     * @param statements - The statements to run, in order, each with its own parameters.
-     * @returns One result per statement, in order.
-     */
-    executeTransaction(statements: readonly {
-        sql: string;
-        params?: Params;
-    }[]): Promise<ExecuteResult[]>;
-    /**
-     * Runs a function inside one transaction, committing when it returns and rolling back when it throws.
-     *
-     * @param fn - Receives the transaction and runs statements on it.
-     * @returns Whatever the function returned.
-     */
-    transaction<T>(fn: (tx: Transaction) => Promise<T>): Promise<T>;
-    /**
-     * Starts recording changes to a table so that subscribers and replication see them.
-     *
-     * @param table - Name of the table to watch.
-     */
-    watch(table: string): Promise<void>;
-    /**
-     * Stops recording changes to a table.
-     *
-     * @param table - Name of the table to stop watching.
-     */
-    unwatch(table: string): Promise<void>;
-    /**
-     * Runs a CDC maintenance write (change-log pruning) on the shared writer
-     * under the writer lock. Serialising it with application writes keeps it
-     * from becoming a second writer that contends for SQLite's single write
-     * lock and stalls the event loop on `busy_timeout`.
-     *
-     * @internal
-     */
-    runCdcMaintenance(op: (writer: SQLiteConnection) => Promise<unknown>): Promise<void>;
-    /** @internal */
-    ensureChangeStamping(): Promise<void>;
-    /**
-     * Begins a change subscription on a watched table.
-     *
-     * @param table - Name of the watched table.
-     * @returns A builder you narrow with a filter and then subscribe to.
-     */
-    on(table: string): SubscriptionBuilder;
-    /**
-     * Opens a live query that keeps a registered read's rows current as the tables behind it change.
-     *
-     * @param operation - Name of the registered read, or a reference built by {@link operationRef}.
-     * @param args - Arguments the operation takes.
-     * @param options - Re-read jitter and the transaction size above which the query re-reads.
-     * @returns The live query, already subscribed.
-     */
-    live<T = Record<string, unknown>>(sql: string, params?: Params, options?: LiveQueryOptions): Promise<LiveQuery<T>>;
-    /**
-     * Applies every migration this database has not yet applied, in ascending version order.
-     *
-     * @param migrations - The full set of migrations for this database.
-     * @returns Which migrations this call applied, and how many it skipped.
-     */
-    migrate(migrations: Migration[]): Promise<MigrationResult>;
-    /**
-     * Lists the migrations this database has applied.
-     *
-     * @returns One entry per applied migration, with its version, name, and checksum.
-     */
-    appliedMigrations(): Promise<AppliedMigrationRow[]>;
-    /**
-     * Undoes applied migrations, newest first.
-     *
-     * @param migrations - The full set of migrations so that the runner finds each down statement.
-     * @param version - Lowest version to keep. Without it, only the newest migration is undone.
-     * @returns Which migrations this call undid.
-     */
-    rollback(migrations: Migration[], version?: number): Promise<RollbackResult>;
-    /**
-     * Loads a SQLite extension into this database.
-     *
-     * @param extensionPath - Path to the extension, which the driver resolves to an absolute path.
-     */
-    loadExtension(extensionPath: string): Promise<void>;
-    /**
-     * Registers a hook that runs before each statement on this database. Throw from it to refuse the statement.
-     *
-     * @param hook - Receives the statement, its parameters, and the concerns it carries.
-     * @returns A function that removes the hook.
-     */
-    onBeforeQuery(hook: BeforeQueryHook): HookDispose;
-    /**
-     * Registers a hook that runs after each statement on this database.
-     *
-     * @param hook - Receives the statement and how long it took.
-     * @returns A function that removes the hook.
-     */
-    onAfterQuery(hook: AfterQueryHook): HookDispose;
-}
-
-export { ConnectionPool as C, Database as D, HookRegistry as H, MetricsCollector as M, type SnapshotHookContext as S, type HookDispose as a, type ConnectionPoolOptions as b, DatabaseBackups as c, DatabaseLifecycle as d, type HookEvent as e, type HookEventContextMap as f, type HookHandler as g, type SubscribeHookContext as h, execute as i, executeBatch as j, queryOne as k, type DeviceSyncPort as l, HLC as m, query as q };