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

package/dist/database-backup-DcLhxoa1.d.ts

@@ -0,0 +1,143 @@
+import { h as BackupChainBase, i as BackupChainChange, g as BackupChain, k as BackupChainRecord, B as BackupDestination, I as SQLiteConnection, P as DriverCapabilities, Q as BackupEngine, p as BackupFileReport, y as BackupToDestinationOptions, f as BackupRunReport, O as BackupScheduleOptions, n as BackupCycleOptions, o as BackupCycleStatus, z as BackupVerifyResult } from './types-Dc8oWlxj.js';
+
+/**
+ * The backup operations that one runtime supports, so that a caller can check
+ * them before it starts a backup. A runtime whose driver lacks a stepped copy
+ * reports `fullCopy` as false, along with every operation that depends on it.
+ *
+ * @public
+ */
+interface BackupCapabilities {
+    /** Whether this runtime can copy an open database while writes continue. */
+    fullCopy: boolean;
+    /** Whether this runtime can send a full copy to the destination without writing a local file. */
+    streamedCopy: boolean;
+    /** Whether this runtime can write a full copy to a local file and then send that file to the destination. */
+    stagedCopy: boolean;
+    /** The local disk space that a full copy needs, which is `'equal-to-backup'` when only the staged route is available. */
+    localDiskRequired: 'none' | 'equal-to-backup';
+    /** Whether this runtime can repeat a full copy on a schedule. */
+    schedule: boolean;
+}
+
+/** The records that one restore reads, and the moment that the restored database reflects.
+ * @public
+ */
+interface BackupRestorePlan {
+    /** The chain that the restore reads from. */
+    chainId: string;
+    /** The full copy to start from. */
+    base: BackupChainBase;
+    /** The change pieces to apply on top of it, oldest first. */
+    changes: BackupChainChange[];
+    /**
+     * The moment, in epoch milliseconds, that the restored database reflects.
+     * It is the capture time of the last change piece in the plan, or the finish
+     * time of the full copy where the plan holds no change piece, so it falls at
+     * or before the moment that you ask for.
+     */
+    restoresTo: number;
+}
+/** The earliest moment that a restore must still reach.
+ * @public
+ */
+interface BackupSafeToDeleteOptions {
+    /**
+     * The earliest moment, in epoch milliseconds, that a restore must still
+     * reach. When you leave it out, the answer lists only the records that no
+     * restore can use.
+     */
+    restorableFrom?: number;
+}
+/**
+ * Returns what a restore to a given moment reads: the newest full copy that
+ * finished at or before that moment, and every change piece of its chain that
+ * Sirannon captured up to it.
+ *
+ * The plan also states the moment that the restored database reflects, which
+ * is the capture time of its last piece. Each change piece holds every write
+ * from one capture interval, so a restore stops at a piece boundary, which can
+ * fall before the exact millisecond that you name.
+ *
+ * This throws `BACKUP_CHAIN_BROKEN` where no full copy finished at or before
+ * the moment. It throws the same code, naming the missing piece, where the
+ * chain has a gap before that moment, since a restore that stopped at the gap
+ * would lose every write after it.
+ *
+ * @param chains - The chains at a destination, as {@link readBackupChains} returns them.
+ * @param moment - The moment to restore to, in epoch milliseconds.
+ * @returns The full copy, the change pieces to apply, and the moment that the restored database reflects.
+ *
+ * @public
+ */
+declare function planBackupRestore(chains: readonly BackupChain[], moment: number): BackupRestorePlan;
+/**
+ * Returns the backup records that no restore needs any longer, so that you can
+ * delete them from the destination yourself.
+ *
+ * The list always includes the change pieces of a chain whose full copy is
+ * gone, and every change piece after a gap in a chain, since a restore can
+ * replay nothing past the gap. When you pass `restorableFrom`, the list also
+ * includes every chain whose full copy finished before the full copy that a
+ * restore to that moment would start from.
+ *
+ * @param chains - The chains at a destination, as {@link readBackupChains} returns them.
+ * @param options - The earliest moment that a restore must still reach.
+ * @returns The records that you can delete, oldest chain first.
+ *
+ * @public
+ */
+declare function backupPiecesSafeToDelete(chains: readonly BackupChain[], options?: BackupSafeToDeleteOptions): BackupChainRecord[];
+
+type RunExclusive = (op: () => Promise<void>) => Promise<void>;
+/** The destination and chain name under which Sirannon stores one database's backups, with the directory where it stages each capture.
+ * @public
+ */
+interface BackupChainLocation {
+    /** The destination that Sirannon sends the backup pieces and chain records to. */
+    destination: BackupDestination;
+    /** The name that Sirannon lists this database's chains under at the destination. */
+    chainName: string;
+    /** The directory where the backup cycle writes each capture before it sends that capture to the destination. */
+    stagingDir: string;
+    /** The deadline, in milliseconds, that the operator set on each call to the destination, when the operator set one. */
+    destinationTimeoutMs?: number;
+}
+declare class DatabaseBackupController {
+    private readonly runExclusive;
+    private readonly acquireWriter;
+    private readonly driverCapabilities;
+    private readonly databaseId;
+    private readonly sourcePath;
+    private readonly engine?;
+    private readonly cancellers;
+    private cycle;
+    private cycleOptions;
+    private cycleStarted;
+    constructor(runExclusive: RunExclusive, acquireWriter: () => SQLiteConnection, driverCapabilities: DriverCapabilities, databaseId: string, sourcePath: string, engine?: BackupEngine | undefined);
+    private require;
+    private requireCycle;
+    capabilities(): BackupCapabilities;
+    backup(destPath: string): Promise<BackupFileReport>;
+    backupTo(options: BackupToDestinationOptions): Promise<BackupRunReport>;
+    schedule(options: BackupScheduleOptions): void;
+    /**
+     * Builds the backup cycle and starts it without awaiting the first turn, which
+     * copies the whole database, so that the open can return first. When the start
+     * fails, this method passes the error to the `onError` callback in the cycle
+     * options.
+     */
+    startCycle(options: BackupCycleOptions): void;
+    captureChanges(): Promise<BackupRunReport | undefined>;
+    chains(): Promise<BackupChain[]>;
+    status(): BackupCycleStatus;
+    location(): BackupChainLocation;
+    verify(name: string): Promise<BackupVerifyResult>;
+    restorePlan(moment: number): Promise<BackupRestorePlan>;
+    piecesSafeToDelete(options?: BackupSafeToDeleteOptions): Promise<BackupChainRecord[]>;
+    /** Stops the backup cycle after one last capture, which sends the writes made since the previous turn to the destination. */
+    stopCycle(): Promise<void>;
+    cancelAll(): void;
+}
+
+export { type BackupCapabilities as B, DatabaseBackupController as D, type BackupChainLocation as a, type BackupRestorePlan as b, type BackupSafeToDeleteOptions as c, backupPiecesSafeToDelete as d, planBackupRestore as p };

package/dist/driver/better-sqlite3.d.ts

@@ -1,5 +1,5 @@
-import { S as SQLiteDriver } from '../types-DPSmjU54.js';
-import '../query-types-p1liOP-b.js';
+import { S as SQLiteDriver } from '../types-Dc8oWlxj.js';
+import '../query-types-5B02ixH0.js';
 
 /**
  * Settings for the better-sqlite3 driver.
@@ -8,22 +8,23 @@ import '../query-types-p1liOP-b.js';
  */
 interface BetterSqlite3Options {
     /**
-     * Milliseconds a statement waits for the write lock before it fails.
+     * The number of milliseconds that SQLite waits for the database lock before it returns a busy error, which defaults to 5000.
      */
     busyTimeout?: number;
     /**
-     * Path to the compiled extension that streams a backup to a caller-supplied
-     * destination. It defaults to the binary the install fetched for this
-     * platform, and naming one here is how a host with no published binary
-     * streams a copy from an extension it built itself.
+     * The path to the compiled extension that Sirannon uses to stream a backup
+     * to a destination that the caller supplies. It defaults to the library in
+     * the `@delali/sirannon-vfs-*` package for this platform, when that package
+     * is installed. Set it on a platform without a published binary, so that
+     * Sirannon streams backups through an extension that you build yourself.
      */
     vfsExtensionPath?: string;
 }
 /**
- * Builds a driver on better-sqlite3, which is the fastest option on Node.
+ * Returns a driver that opens SQLite databases on Node through the `better-sqlite3` native module.
  *
- * @param driverOptions - How long a statement waits for the write lock.
- * @returns The driver, ready to pass to a `Sirannon` registry.
+ * @param driverOptions - The busy timeout and the path to the backup streaming extension.
+ * @returns The driver, which you can pass to a `Sirannon` registry.
  *
  * @public
  */

package/dist/driver/better-sqlite3.mjs

@@ -1,17 +1,17 @@
-import { nodeResolveExtensionPath, nodeWriterContext, nodeBackupEngine, nodeStreamingSupport, WriterWorker, createStatementCache, loadThroughRuntime, narrowSafeBigInt, narrowRowIntegers, narrowRowsIntegers } from '../chunk-W4EUTJNT.mjs';
-import '../chunk-7SC2TZAS.mjs';
-import '../chunk-JQWGHSEH.mjs';
-import { defineDriver } from '../chunk-LXCGPZPA.mjs';
+import { nodeResolveExtensionPath, nodeWriterContext, nodeBackupEngine, nodeStreamingSupport, WriterWorker, createStatementCache, loadThroughRuntime, narrowSafeBigInt, narrowRowIntegers, narrowRowsIntegers } from '../chunk-NZGSDALX.mjs';
+import '../chunk-DX4WGJL7.mjs';
+import '../chunk-NVSQ2T5Q.mjs';
+import { defineDriver } from '../chunk-IEKIYO4V.mjs';
 import '../chunk-W67A4H2E.mjs';
 import '../chunk-MVSES6MS.mjs';
-import '../chunk-KDAHYFW7.mjs';
-import '../chunk-U445A3C4.mjs';
-import '../chunk-E6IMX7RS.mjs';
-import '../chunk-GYCEJNU4.mjs';
-import { synchronousPragmaValue } from '../chunk-OUSWVNWT.mjs';
-import '../chunk-YVF2ZJTE.mjs';
+import '../chunk-6AOJCNRU.mjs';
+import '../chunk-QGVRRKB2.mjs';
+import '../chunk-KJLNYOOL.mjs';
+import '../chunk-R7GBXNTO.mjs';
+import { synchronousPragmaValue } from '../chunk-YCMB6GR4.mjs';
+import '../chunk-CZL4D3BM.mjs';
 import '../chunk-QBBLSQHQ.mjs';
-import { BackupError } from '../chunk-PBRXXISQ.mjs';
+import { BackupError } from '../chunk-KINDFBQP.mjs';
 
 // src/drivers/better-sqlite3/copy.ts
 var OPEN_TRANSACTION_MESSAGE = "A stepped copy cannot start while a transaction is open on the same connection, because SQLite copies no pages and reports success";

package/dist/driver/bun.d.ts

@@ -1,5 +1,5 @@
-import { S as SQLiteDriver } from '../types-DPSmjU54.js';
-import '../query-types-p1liOP-b.js';
+import { S as SQLiteDriver } from '../types-Dc8oWlxj.js';
+import '../query-types-5B02ixH0.js';
 
 /**
  * Settings for the driver built on Bun's built-in SQLite.
@@ -8,18 +8,19 @@ import '../query-types-p1liOP-b.js';
  */
 interface BunSqliteOptions {
     /**
-     * Milliseconds a statement waits for the write lock before it fails as busy. Default: 5000.
+     * The number of milliseconds that SQLite waits for the database lock before it returns a busy error, which defaults to 5000.
      */
     busyTimeout?: number;
 }
 /**
- * Builds a driver that runs SQLite through `bun:sqlite`, which is built into the Bun runtime.
+ * Returns a driver that opens SQLite databases through `bun:sqlite`, which is built into the Bun runtime.
  *
- * It reads every integer as a BigInt and narrows the safe ones back, so a
- * value beyond `Number.MAX_SAFE_INTEGER` survives the round trip.
+ * The driver opens each connection with `safeIntegers`, so SQLite returns every
+ * integer as a `bigint`, and the driver converts each one within the safe range
+ * back to a `number`. A value beyond `Number.MAX_SAFE_INTEGER` therefore stays exact.
  *
- * @param driverOptions - How long a statement waits for the write lock.
- * @returns The driver, ready to pass to a `Sirannon` registry running under Bun.
+ * @param driverOptions - The busy timeout for each connection.
+ * @returns The driver, which you can pass to a `Sirannon` registry under Bun.
  *
  * @public
  */

package/dist/driver/expo.d.ts

@@ -1,14 +1,13 @@
-import { S as SQLiteDriver } from '../types-DPSmjU54.js';
-import '../query-types-p1liOP-b.js';
+import { S as SQLiteDriver } from '../types-Dc8oWlxj.js';
+import '../query-types-5B02ixH0.js';
 
 /**
- * Builds a driver that runs SQLite on a device through `expo-sqlite`.
+ * Returns a driver that opens SQLite databases on a device through `expo-sqlite`.
  *
- * Expo opens one connection per database, so this driver reports no support
- * for multiple connections and Sirannon serves every read and write over that
- * single connection.
+ * The driver sets `multipleConnections` to `false`, so Sirannon opens no reader
+ * pool and sends every read and write for a database through one connection.
  *
- * @returns The driver, ready to pass to a `Sirannon` registry in a React Native app.
+ * @returns The driver, which you can pass to a `Sirannon` registry in a React Native app.
  *
  * @public
  */

package/dist/driver/node.d.ts

@@ -1,5 +1,5 @@
-import { S as SQLiteDriver } from '../types-DPSmjU54.js';
-import '../query-types-p1liOP-b.js';
+import { S as SQLiteDriver } from '../types-Dc8oWlxj.js';
+import '../query-types-5B02ixH0.js';
 
 /**
  * Settings for the driver built on Node's own SQLite module.
@@ -8,22 +8,23 @@ import '../query-types-p1liOP-b.js';
  */
 interface NodeSqliteOptions {
     /**
-     * Milliseconds a statement waits for the write lock before it fails.
+     * The number of milliseconds that SQLite waits for the database lock before it returns a busy error, which defaults to 5000.
      */
     busyTimeout?: number;
     /**
-     * Path to the compiled extension that streams a backup to a caller-supplied
-     * destination. It defaults to the binary the install fetched for this
-     * platform, and naming one here is how a host with no published binary
-     * streams a copy from an extension it built itself.
+     * The path to the compiled extension that Sirannon uses to stream a backup
+     * to a destination that the caller supplies. It defaults to the library in
+     * the `@delali/sirannon-vfs-*` package for this platform, when that package
+     * is installed. Set it on a platform without a published binary, so that
+     * Sirannon streams backups through an extension that you build yourself.
      */
     vfsExtensionPath?: string;
 }
 /**
- * Builds a driver on Node's own SQLite module, which needs no native dependency.
+ * Returns a driver that opens SQLite databases through Node's built-in `node:sqlite` module, so your project installs no native dependency.
  *
- * @param driverOptions - How long a statement waits for the write lock.
- * @returns The driver, ready to pass to a `Sirannon` registry.
+ * @param driverOptions - The busy timeout and the path to the backup streaming extension.
+ * @returns The driver, which you can pass to a `Sirannon` registry.
  *
  * @public
  */

package/dist/driver/node.mjs

@@ -1,24 +1,26 @@
-import { nodeResolveExtensionPath, nodeWriterContext, createStatementCache, nodeBackupEngine, nodeStreamingSupport, WriterWorker, loadThroughRuntime, narrowSafeBigInt, narrowRowIntegers, narrowRowsIntegers } from '../chunk-W4EUTJNT.mjs';
-import '../chunk-7SC2TZAS.mjs';
-import '../chunk-JQWGHSEH.mjs';
-import { defineDriver } from '../chunk-LXCGPZPA.mjs';
+import { nodeResolveExtensionPath, nodeWriterContext, createStatementCache, nodeBackupEngine, nodeStreamingSupport, WriterWorker, loadThroughRuntime, narrowSafeBigInt, narrowRowIntegers, narrowRowsIntegers } from '../chunk-NZGSDALX.mjs';
+import '../chunk-DX4WGJL7.mjs';
+import '../chunk-NVSQ2T5Q.mjs';
+import { defineDriver } from '../chunk-IEKIYO4V.mjs';
 import '../chunk-W67A4H2E.mjs';
 import '../chunk-MVSES6MS.mjs';
-import '../chunk-KDAHYFW7.mjs';
-import '../chunk-U445A3C4.mjs';
-import '../chunk-E6IMX7RS.mjs';
-import '../chunk-GYCEJNU4.mjs';
-import { synchronousPragmaValue } from '../chunk-OUSWVNWT.mjs';
-import '../chunk-YVF2ZJTE.mjs';
+import '../chunk-6AOJCNRU.mjs';
+import '../chunk-QGVRRKB2.mjs';
+import '../chunk-KJLNYOOL.mjs';
+import '../chunk-R7GBXNTO.mjs';
+import { synchronousPragmaValue } from '../chunk-YCMB6GR4.mjs';
+import '../chunk-CZL4D3BM.mjs';
 import '../chunk-QBBLSQHQ.mjs';
-import { ExtensionError, BackupError } from '../chunk-PBRXXISQ.mjs';
+import { ExtensionError, BackupError, SirannonError } from '../chunk-KINDFBQP.mjs';
 import { createRequire } from 'module';
 
 // src/drivers/node/copy.ts
 var OPEN_TRANSACTION_MESSAGE = "A stepped copy cannot start while a transaction is open on the same connection, because SQLite copies no pages and reports success";
+var NO_NODE_SQLITE_BACKUP_MESSAGE = "This Node.js build provides no backup function in node:sqlite, so the Node driver cannot copy a database. Upgrade Node.js to a release whose node:sqlite exports backup.";
 async function copyDatabaseWithNodeSqlite(db, request) {
   if (db.isTransaction) throw new BackupError(OPEN_TRANSACTION_MESSAGE);
   const { backup } = await import('node:sqlite');
+  if (typeof backup !== "function") throw new SirannonError(NO_NODE_SQLITE_BACKUP_MESSAGE, "BACKUP_UNSUPPORTED");
   let totalPages = 0;
   const pageCount = await backup(db, request.destPath, {
     rate: request.pagesPerStep,

package/dist/driver/wa-sqlite.d.ts

@@ -1,5 +1,5 @@
-import { S as SQLiteDriver } from '../types-DPSmjU54.js';
-import '../query-types-p1liOP-b.js';
+import { S as SQLiteDriver } from '../types-Dc8oWlxj.js';
+import '../query-types-5B02ixH0.js';
 
 /**
  * Settings for the browser driver built on wa-sqlite.
@@ -8,15 +8,15 @@ import '../query-types-p1liOP-b.js';
  */
 interface WaSqliteOptions {
     /**
-     * Where the browser stores the database. Default: 'IDBBatchAtomicVFS'.
+     * The virtual file system that stores the database in the browser, which defaults to `IDBBatchAtomicVFS`.
      */
     vfs?: 'IDBBatchAtomicVFS' | 'AccessHandlePoolVFS';
 }
 /**
- * Builds a driver that runs SQLite in the browser through WebAssembly.
+ * Returns a driver that opens SQLite databases in the browser through the wa-sqlite WebAssembly build.
  *
- * @param driverOptions - Where the browser stores the database.
- * @returns The driver, ready to pass to a `Sirannon` registry.
+ * @param driverOptions - The virtual file system that stores the database.
+ * @returns The driver, which you can pass to a `Sirannon` registry.
  *
  * @public
  */

package/dist/errors-CJUkQ-KL.d.ts

@@ -0,0 +1,199 @@
+/**
+ * The base class for every sirannon-db error, which has a machine-readable
+ * {@link SirannonError.code}. Extend it to define an error of your own.
+ *
+ * @public
+ */
+declare class SirannonError extends Error {
+    /**
+     * The machine-readable code that the server maps to an HTTP status.
+     */
+    readonly code: string;
+    constructor(message: string, 
+    /**
+     * The machine-readable code that the server maps to an HTTP status.
+     */
+    code: string);
+}
+/**
+ * Thrown when the registry has no open database under an identifier, because
+ * the database was never opened or is already closed.
+ *
+ * @public
+ */
+declare class DatabaseNotFoundError extends SirannonError {
+    constructor(id: string);
+}
+/**
+ * Thrown when a caller opens a database under an identifier that the registry
+ * already uses, since each identifier names one database.
+ *
+ * @public
+ */
+declare class DatabaseAlreadyExistsError extends SirannonError {
+    constructor(id: string);
+}
+/**
+ * Thrown when a caller writes to a database that is open in read-only mode.
+ *
+ * @public
+ */
+declare class ReadOnlyError extends SirannonError {
+    constructor(id: string);
+}
+/**
+ * Thrown when SQLite fails to execute a statement, with that statement in
+ * {@link QueryError.sql} for your logs.
+ *
+ * @public
+ */
+declare class QueryError extends SirannonError {
+    /**
+     * The statement that failed.
+     */
+    readonly sql: string;
+    constructor(message: string, 
+    /**
+     * The statement that failed.
+     */
+    sql: string);
+}
+/**
+ * Sirannon raises this error when SQLite refuses to commit a transaction whose
+ * statements all succeeded, such as on a deferred foreign key; `cause` holds
+ * SQLite's own error. The server responds to its `TRANSACTION_ERROR` code with status 400.
+ *
+ * @public
+ */
+declare class TransactionError extends SirannonError {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * Thrown when a migration fails, with the version of that migration in
+ * {@link MigrationError.version}.
+ *
+ * @public
+ */
+declare class MigrationError extends SirannonError {
+    /**
+     * The version of the migration that failed.
+     */
+    readonly version: number;
+    constructor(message: string, 
+    /**
+     * The version of the migration that failed.
+     */
+    version: number, code?: string);
+}
+/**
+ * An error that a before-hook can throw to reject an operation, which the
+ * server responds to with status 403. The message includes the optional
+ * `reason`, so that a caller can tell one hook policy from another.
+ *
+ * @public
+ */
+declare class HookDeniedError extends SirannonError {
+    constructor(hookName: string, reason?: string);
+}
+/**
+ * Rejects one request with a status of your own; throw it from an authenticate hook or a registered operation.
+ *
+ * @public
+ */
+declare class RequestDeniedError extends SirannonError {
+    /**
+     * The HTTP status that the server responds to the rejected request with.
+     */
+    readonly status: number;
+    constructor(status: number, code: string, message: string);
+}
+/**
+ * Thrown when change capture cannot proceed, for example when a caller watches
+ * a table that does not exist, when Sirannon cannot read the change-log epoch
+ * or the node identity, or when a live query uses a statement that Sirannon
+ * cannot keep current.
+ *
+ * @public
+ */
+declare class CDCError extends SirannonError {
+    constructor(message: string);
+}
+/**
+ * Thrown when a statement through the query API names a `_sirannon` table,
+ * modifies a `sqlite_` table, contains ATTACH or DETACH, or sets
+ * `PRAGMA writable_schema`. Sirannon rejects these statements to keep its
+ * change log, its replication ledger, and SQLite's schema catalogue out of the
+ * caller's reach.
+ *
+ * @public
+ */
+declare class ForbiddenSqlError extends SirannonError {
+    constructor(message: string);
+}
+/**
+ * Thrown when a copy to a file or a scheduled backup fails, or when its path,
+ * cron expression, or time zone is invalid.
+ *
+ * @public
+ */
+declare class BackupError extends SirannonError {
+    constructor(message: string);
+}
+/**
+ * Thrown when a caller asks a closed or empty connection pool for a connection, asks a
+ * read-only pool for the writer, or closes a pool and one of its connections
+ * fails to close.
+ *
+ * @public
+ */
+declare class ConnectionPoolError extends SirannonError {
+    constructor(message: string);
+}
+/**
+ * Thrown when the lifecycle resolver would open a database past `maxOpen`, and
+ * evicting the least recently used database frees no slot. Close a database
+ * before you open another one.
+ *
+ * @public
+ */
+declare class MaxDatabasesError extends SirannonError {
+    constructor(max: number);
+}
+/**
+ * Thrown when more writes are pending than the writer-worker limit allows, so
+ * that the database sheds load. The server responds to it with status 503 and
+ * a `Retry-After` header.
+ *
+ * @public
+ */
+declare class WriteOverloadError extends SirannonError {
+    /**
+     * The number of pending writes that the database accepts before it rejects more.
+     */
+    readonly limit: number;
+    /**
+     * The number of milliseconds that the caller should wait before it retries.
+     */
+    readonly retryAfterMs: number;
+    constructor(
+    /**
+     * The number of pending writes that the database accepts before it rejects more.
+     */
+    limit: number, 
+    /**
+     * The number of milliseconds that the caller should wait before it retries.
+     */
+    retryAfterMs: number);
+}
+/**
+ * Thrown when Sirannon cannot load a compiled SQLite extension. The message
+ * names the extension path, and the optional `cause` gives the reason that
+ * SQLite or Sirannon reported.
+ *
+ * @public
+ */
+declare class ExtensionError extends SirannonError {
+    constructor(path: string, cause?: string);
+}
+
+export { BackupError as B, CDCError as C, DatabaseAlreadyExistsError as D, ExtensionError as E, ForbiddenSqlError as F, HookDeniedError as H, MaxDatabasesError as M, QueryError as Q, ReadOnlyError as R, SirannonError as S, TransactionError as T, WriteOverloadError as W, ConnectionPoolError as a, DatabaseNotFoundError as b, MigrationError as c, RequestDeniedError as d };