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

package/dist/query-types-p1liOP-b.d.ts

@@ -1,127 +0,0 @@
-/** Query parameter types: named (object) or positional (array).
- * @public
- */
-type Params = Record<string, unknown> | unknown[];
-/** How many nodes must acknowledge a write before it returns.
- * @public
- */
-type WriteConcernLevel = 'local' | 'majority' | 'all';
-/** How many nodes must acknowledge a write, and how long the caller waits for them.
- * @public
- */
-interface WriteConcern {
-    /** Number of acknowledgements the write waits for. */
-    level: WriteConcernLevel;
-    /** Milliseconds to wait for those acknowledgements before the write fails. */
-    timeoutMs?: number;
-}
-/** How current a read has to be before the node will serve it.
- * @public
- */
-type ReadConcernLevel = 'local' | 'majority' | 'linearizable';
-/** How current a read has to be before the node will serve it.
- * @public
- */
-interface ReadConcern {
-    /** Currency the node must prove before it answers. */
-    level: ReadConcernLevel;
-}
-/** Per-statement settings you pass alongside the SQL and its parameters.
- * @public
- */
-interface QueryOptions {
-    /** Acknowledgements a write waits for. Coordinator mode applies 'majority' when you omit it. */
-    writeConcern?: WriteConcern;
-    /** Currency a read requires. Coordinator mode enforces it and static mode ignores it. */
-    readConcern?: ReadConcern;
-}
-/** Result returned by mutation statements (INSERT, UPDATE, DELETE).
- * @public
- */
-interface ExecuteResult {
-    /** Number of rows the statement inserted, updated, or deleted. */
-    changes: number;
-    /** Row id SQLite assigned to the last inserted row. */
-    lastInsertRowId: number | bigint;
-}
-/** CDC operation type.
- * @public
- */
-type ChangeOperation = 'insert' | 'update' | 'delete';
-/** Event emitted when a watched table row changes.
- * @public
- */
-interface ChangeEvent<T = Record<string, unknown>> {
-    /** Whether the row was inserted, updated, or deleted. */
-    type: ChangeOperation;
-    /** Table the row belongs to. */
-    table: string;
-    /** The row as it stands after the change. A delete carries an empty object here and the previous row in {@link ChangeEvent.oldRow}. */
-    row: T;
-    /** The row as it stood before an update or a delete. */
-    oldRow?: T;
-    /** Position of this change in the database's change log. Subscribers resume from it. */
-    seq: bigint;
-    /** Milliseconds since the Unix epoch, taken when the change was recorded. */
-    timestamp: number;
-    /** Hybrid logical clock stamp the writing node gave this change. */
-    hlc?: string;
-    /** Identifier of the node that authored the change. */
-    origin?: string;
-    /** Primary key of the changed row, encoded as a string. */
-    rowId?: string;
-    /** Identifier of the transaction that produced this change. */
-    txId?: string;
-    /** Set on the last change of a transaction, so a consumer applies the whole transaction at once. */
-    txEnd?: boolean;
-}
-/** Builder for creating CDC subscriptions with optional filters.
- * @public
- */
-interface SubscriptionBuilder {
-    /**
-     * Narrows the subscription to rows whose columns equal the given values.
-     *
-     * The filter reports membership of the matching set, so an update that moves a row
-     * into the set arrives as an insert carrying no `oldRow`, and one that moves a row
-     * out arrives as a delete carrying the old row and an empty `row`. An update that
-     * leaves the row in the set arrives unchanged, and one that never touches the set
-     * is not delivered. A synthesised event is indistinguishable from a real insert or
-     * delete, so read `type` as the row's arrival or departure from the filter.
-     */
-    filter(conditions: Record<string, unknown>): SubscriptionBuilder;
-    /**
-     * Starts the subscription and calls back on each change.
-     *
-     * The subscription never waits for what your callback returns, so two calls to an
-     * asynchronous callback can overlap. Chain the work onto one promise where each change
-     * has to finish before the next one starts. A throw, and a rejection of what the callback
-     * returns, both arrive at `options.onError`, and every other subscriber on this table
-     * still receives the change.
-     *
-     * @typeParam T - Shape of the rows this table holds, which types `row` and `oldRow`.
-     * @param callback - Receives each change this subscription matches.
-     * @param options - Carries `onError`, which receives a failure of the callback or of the change-log poll.
-     * @returns A handle whose `unsubscribe` ends the subscription.
-     */
-    subscribe<T = Record<string, unknown>>(callback: (event: ChangeEvent<T>) => void, options?: SubscriptionOptions): Subscription;
-}
-/** Reporters a change subscription attaches when it starts.
- * @public
- */
-interface SubscriptionOptions {
-    /**
-     * Receives the failure of a change callback, and the failure that stops the change-log
-     * poll after repeated errors. Sirannon drops whatever this reporter itself throws.
-     */
-    onError?: (error: Error) => void;
-}
-/** Handle for an active subscription.
- * @public
- */
-interface Subscription {
-    /** Ends the subscription, so the callback receives no further events. */
-    unsubscribe(): void;
-}
-
-export type { ChangeEvent as C, ExecuteResult as E, Params as P, QueryOptions as Q, ReadConcern as R, Subscription as S, WriteConcern as W, ReadConcernLevel as a, ChangeOperation as b, SubscriptionBuilder as c, SubscriptionOptions as d, WriteConcernLevel as e };

package/dist/restore-options-CksYsH1l.d.ts

@@ -1,83 +0,0 @@
-import { B as BackupDestination, S as SQLiteDriver } from './types-DPSmjU54.js';
-
-/** How far one restore has got, reported after every piece it fetches.
- * @public
- */
-interface BackupRestoreProgress {
-    /** Whether the restore is fetching the full copy or replaying the change pieces on top of it. */
-    phase: 'full-copy' | 'changes';
-    /** Pieces the restore has fetched. */
-    piecesFetched: number;
-    /** Bytes it has fetched. */
-    bytesFetched: number;
-    /** Change pieces it has replayed. */
-    changesApplied: number;
-    /** Change pieces the plan holds altogether. */
-    changesTotal: number;
-}
-/**
- * How Sirannon rebuilds a database from a moment you name.
- *
- * @public
- */
-interface BackupRestoreOptions {
-    /** Where the backups and their records are stored. */
-    destination: BackupDestination;
-    /** Driver the restore opens the rebuilt database through, so it can fold each batch of changes in. */
-    driver: SQLiteDriver;
-    /** Path Sirannon writes the rebuilt database to. A file already there stops the restore unless you set {@link BackupRestoreOptions.replaceExisting}. */
-    destPath: string;
-    /**
-     * Whether to replace a database already at that path. It defaults to false,
-     * because a restore removes the write-ahead log beside the path it writes to
-     * and any commit that log still held would go with it. Set this where you
-     * mean to restore over a database you no longer want.
-     */
-    replaceExisting?: boolean;
-    /** Epoch milliseconds you want back. Defaults to now, which reaches the newest backup the destination holds. */
-    moment?: number;
-    /** Name the list of chains is stored under. Defaults to `sirannon-backup-chain`. */
-    chainName?: string;
-    /**
-     * How many change pieces to replay between one checkpoint and the next.
-     * Defaults to 16, and 4096 is the most it accepts. This is what bounds the
-     * log the restore writes beside the database, so lower it where disk is tight
-     * and raise it where a long chain takes too many checkpoints.
-     */
-    batchSize?: number;
-    /** Milliseconds one call to the destination may take before the restore stops with an error. Defaults to 10 minutes, and zero leaves the calls unbounded. */
-    destinationTimeoutMs?: number;
-    /** Called after every piece the restore fetches. */
-    onProgress?: (progress: BackupRestoreProgress) => void;
-}
-/** What one finished restore produced.
- * @public
- */
-interface BackupRestoreReport {
-    /** The chain the restore read. */
-    chainId: string;
-    /** Path of the rebuilt database. */
-    destPath: string;
-    /** Name the full copy underneath it is stored under. */
-    baseName: string;
-    /** Epoch milliseconds the rebuilt database reflects, which is when the last piece replayed was captured. */
-    restoresTo: number;
-    /** Pieces the restore fetched, counting the full copy and every change piece. */
-    pieceCount: number;
-    /** Bytes it fetched. */
-    bytesFetched: number;
-    /** Change pieces it replayed. */
-    changesApplied: number;
-    /** Log frames those pieces held. */
-    framesApplied: number;
-    /** Batches it replayed them in, each one folded into the database by a checkpoint of its own. */
-    batchCount: number;
-    /** Epoch milliseconds the restore started. */
-    startedAt: number;
-    /** Epoch milliseconds it finished. */
-    finishedAt: number;
-    /** Milliseconds it took. */
-    durationMs: number;
-}
-
-export type { BackupRestoreOptions as B, BackupRestoreReport as a, BackupRestoreProgress as b };

package/dist/server-options-Bj5iJnjx.d.ts

@@ -1,292 +0,0 @@
-import { a as OperationRegistry } from './operation-registry-oiPuSYI6.js';
-import { R as ReplicationBatch, C as ConflictResolver, A as ApplyResult } from './types-CjhxcjhA.js';
-import { N as NodeHealth, T as Transaction, H as ClusterStatusInfo } from './types-DPSmjU54.js';
-import { P as Params, Q as QueryOptions, E as ExecuteResult } from './query-types-p1liOP-b.js';
-
-/**
- * One migration a database has already applied, as its catalogue records it.
- *
- * @public
- */
-interface AppliedMigrationRow {
-    /** Version number the migration carries. */
-    version: number;
-    /** Name the migration carries. */
-    name: string;
-    /** Hash of the SQL that applied it, and null where a function applied it or the database predates checksums. */
-    checksum: string | null;
-}
-
-/** Context passed to the authenticate hook.
- * @public
- */
-interface RequestContext {
-    /** Request headers, with every name lower-cased. */
-    headers: Record<string, string>;
-    /** HTTP method of the request, or the method of a WebSocket upgrade. */
-    method: string;
-    /** Path the request arrived on. */
-    path: string;
-    /** Identifier of the database the route addresses. */
-    databaseId?: string;
-    /** Address the request came from. */
-    remoteAddress: string;
-}
-/**
- * Identifies the caller behind a request. Return the identity registered
- * operations then read, and throw a {@link RequestDeniedError} to refuse the
- * request with a status of your own.
- *
- * @public
- */
-type AuthenticateHook<Identity = unknown> = (ctx: RequestContext) => Identity | undefined | Promise<Identity | undefined>;
-/** Reports whether a caller may read the addresses of every node in the group.
- * @public
- */
-type ClusterStatusAuthorizer = (ctx: RequestContext) => boolean | Promise<boolean>;
-/**
- * Durability level in force while a bulk load runs. SQLite sanctions 'off' for
- * a from-scratch load that the operator can re-run after a power loss; 'off'
- * gives up corruption safety, so it fits only a load that starts from nothing.
- * 'normal' keeps WAL-mode corruption safety and suits loads into a database
- * that already holds data the operator cannot afford to lose.
- *
- * @public
- */
-type BulkLoadDurability = 'off' | 'normal';
-/** Settings for one bulk load.
- * @public
- */
-interface BulkLoadOptions {
-    /** Durability during the load. Default: 'off'. */
-    durability?: BulkLoadDurability;
-    /**
-     * Whether this load ends with a WAL checkpoint. Default: true. Set it false
-     * on every load but the last of a multi-batch import so the one fsyncing
-     * checkpoint is paid once at the end instead of once per batch; the
-     * configured durability is still restored after each batch regardless, so an
-     * abandoned import never leaves the writer at the relaxed level.
-     */
-    checkpoint?: boolean;
-}
-/** Aggregate outcome of a bulk load. Summed rather than per-row so a
- * million-row load never holds a million result objects in memory.
- * @public
- */
-interface BulkLoadResult {
-    /** Number of parameter sets the load applied. */
-    rowsLoaded: number;
-    /** Number of rows the load inserted, updated, or deleted. */
-    changes: number;
-}
-/**
- * What the server runs statements against for one database. A local
- * `Database` satisfies it, and so does a proxy that forwards to another node.
- *
- * @public
- */
-interface ServerExecutionTarget {
-    /** Runs a read and returns the rows. */
-    query<T = Record<string, unknown>>(sql: string, params?: Params, options?: QueryOptions): Promise<T[]>;
-    /**
-     * Optional single-pass read that returns rows already encoded for the wire
-     * (safe-range integers as plain numbers, larger integers and BLOBs as tagged
-     * envelopes). When present the server uses it instead of {@link ServerExecutionTarget.query}
-     * followed by a separate tag-encoding walk. A target that omits it stays
-     * correct: the server falls back to encoding {@link ServerExecutionTarget.query} rows itself.
-     */
-    queryForWire?(sql: string, params?: Params, options?: QueryOptions): Promise<unknown[]>;
-    /** Runs one write and returns the change count and last inserted row id. */
-    execute(sql: string, params?: Params, options?: QueryOptions): Promise<ExecuteResult>;
-    /** Runs a function inside one transaction. */
-    transaction<T>(fn: (tx: Transaction) => Promise<T>, options?: QueryOptions): Promise<T>;
-    /**
-     * Optional entry point for a transaction whose statements are all known
-     * before it starts, which lets concurrent transactions share one commit. A
-     * target that omits it stays correct: the server falls back to
-     * {@link ServerExecutionTarget.transaction} and runs the statements one at a time.
-     */
-    executeTransaction?(statements: readonly {
-        sql: string;
-        params?: Params;
-    }[], options?: QueryOptions): Promise<ExecuteResult[]>;
-    /**
-     * Optional bulk-load entry point. Targets that proxy to a remote primary
-     * may omit it; the server rejects load requests for such targets instead
-     * of silently degrading to per-statement writes.
-     */
-    bulkLoad?(sql: string, paramsBatch: Params[], options?: BulkLoadOptions): Promise<BulkLoadResult>;
-    /** Optional device-sync entry point that applies a batch of changes a device pushed. */
-    applyChanges?(batch: ReplicationBatch, resolver?: ConflictResolver | ((table: string) => ConflictResolver)): Promise<ApplyResult>;
-    /** Optional listing of the migrations this database has applied. */
-    appliedMigrations?(): Promise<AppliedMigrationRow[]>;
-}
-/**
- * Finds what the server should run a database's statements against.
- *
- * @public
- */
-type ServerExecutionTargetResolver = (databaseId: string) => ServerExecutionTarget | null | undefined | Promise<ServerExecutionTarget | null | undefined>;
-/** Options for the standalone HTTP + WS server.
- * @public
- */
-interface ServerOptions<Identity = unknown> {
-    /** Address the server binds to. Default: '127.0.0.1'. */
-    host?: string;
-    /** Port the server binds to. Default: 9876. */
-    port?: number;
-    /** Cross-origin rules the server answers browser requests with. */
-    cors?: boolean | CorsOptions;
-    /**
-     * Maximum HTTP request body and WebSocket message size in bytes. Applied
-     * identically to both transports. Must be a positive, finite integer no
-     * larger than 4_294_967_295 (the unsigned 32-bit ceiling uWebSockets.js can
-     * store; larger values would silently wrap modulo 2^32).
-     * Default: 1_048_576 (1 MB), matching the general web default and acting as
-     * a denial-of-service guard on a memory-limited server.
-     */
-    maxBodyBytes?: number;
-    /**
-     * Maximum bytes buffered per WebSocket connection before the server stops
-     * absorbing backpressure. A single frame can be as large as `maxBodyBytes`,
-     * so this must hold several of them; the resolved value is raised to at
-     * least `maxBodyBytes` and, like `maxBodyBytes`, must not exceed
-     * 4_294_967_295. When the buffer is exceeded the server closes the
-     * connection so the client reconnects rather than losing a frame silently.
-     * Default: the larger of 16 MB and `maxBodyBytes`.
-     */
-    maxWebSocketBackpressureBytes?: number;
-    /**
-     * How long, in milliseconds, change events are retained for WebSocket CDC
-     * subscriptions. Retention bounds both on-disk growth of the change log and
-     * how far back a reconnecting subscriber can resume. Default: 3_600_000
-     * (one hour).
-     */
-    cdcRetentionMs?: number;
-    /** How long, in milliseconds, a device's sync cursor is kept after its last contact. */
-    deviceCursorRetentionMs?: number;
-    /** Changes a device may leave unacknowledged before the server stops sending more. */
-    maxUnacknowledgedChanges?: number;
-    /** Runs before every database route and every WebSocket upgrade, and names the caller. */
-    authenticate?: AuthenticateHook<Identity>;
-    /** Statements callers may invoke by name. Without these, only SQL routes serve reads and writes. */
-    operations?: OperationRegistry<Identity>;
-    /** Opens the five statement routes and their WebSocket messages. Default: false. */
-    acceptSql?: boolean;
-    /**
-     * Opens the route that rebuilds a database from its backups. A restore
-     * replaces the database that is serving traffic, so the route stays shut
-     * until you open it here, and a server that opens it without an
-     * `authenticate` hook refuses to start. Default: false.
-     */
-    acceptBackupRestore?: boolean;
-    /** Finds what the server runs a database's statements against. */
-    resolveExecutionTarget?: ServerExecutionTargetResolver;
-    /** Supplies the replication figures the readiness endpoint reports. */
-    getReplicationStatus?: () => ReplicationStatusInfo | null;
-    /** Supplies what `GET /db/{id}/cluster` reports for one database. */
-    getClusterStatus?: (databaseId: string) => ClusterStatusInfo | null;
-    /** Reports whether a caller may read the addresses of every node in the group. */
-    authorizeClusterStatus?: ClusterStatusAuthorizer;
-}
-/** Replication figures one node reports through its readiness endpoint.
- * @public
- */
-interface ReplicationStatusInfo {
-    /** Whether this node accepts writes or serves reads. */
-    role: string;
-    /** Whether this node forwards writes to the primary. */
-    writeForwarding: boolean;
-    /** Number of peers the node is connected to. */
-    peers: number;
-    /** Highest change-log position this node has recorded locally. */
-    localSeq: bigint;
-    /** What the node can do right now, and the condition behind it. */
-    health: NodeHealth;
-    /** Identifier of the replication group the node belongs to. */
-    replicationGroupId?: string;
-    /** The primary term this node reports as current. */
-    primaryTerm?: bigint;
-    /** Identifier of the primary this node reports as current. */
-    currentPrimary?: string;
-    /** Whether the node reaches its cluster coordinator, and whether it holds write authority. */
-    coordinator?: {
-        connected: boolean;
-        authority: boolean;
-    };
-    /** Whether this node runs the group's controller loop. */
-    controller?: {
-        state: 'disabled' | 'standby' | 'active' | 'lost';
-    };
-    /** Identifiers of the replicas the group counts as in sync. */
-    inSyncReplicas?: string[];
-    /** Identifiers of the replicas that have fallen behind. */
-    laggingReplicas?: string[];
-    /** Where this node stands in first sync. */
-    syncState?: string;
-}
-/** CORS configuration.
- * @public
- */
-interface CorsOptions {
-    /** Origins the server allows. */
-    origin?: string | string[];
-    /** Methods the server allows. */
-    methods?: string[];
-    /** Request headers the server allows. */
-    headers?: string[];
-}
-/**
- * Options for the mountable WebSocket handler.
- *
- * @internal
- */
-interface WSHandlerOptions<Identity = unknown> {
-    /** Maximum message size in bytes. Default: 1_048_576 (1 MB). */
-    maxPayloadLength?: number;
-    /** Outbound bytes a socket may hold before a device stream pauses itself. Default: 16 MB. */
-    maxBackpressureBytes?: number;
-    /** Change-log retention for CDC subscriptions in milliseconds. Default: 3_600_000. */
-    cdcRetentionMs?: number;
-    deviceCursorRetentionMs?: number;
-    maxUnacknowledgedChanges?: number;
-    acceptSql?: boolean;
-    operations?: OperationRegistry<Identity>;
-    resolveExecutionTarget?: ServerExecutionTargetResolver;
-}
-/** Options for the client SDK.
- * @public
- */
-interface ClientOptions {
-    /** Transport to use. Default: 'websocket'. */
-    transport?: 'websocket' | 'http';
-    /**
-     * Custom headers for HTTP requests, and for the WebSocket upgrade in a
-     * runtime whose WebSocket carries a handshake header, which Node and Bun do
-     * and a browser does not. Constructing a WebSocket-transport client with
-     * headers and no {@link ClientOptions.webSocketProtocols} in a runtime that
-     * carries none fails with `INVALID_ARGUMENT`. Pass both when a browser client
-     * needs each one, and the headers still reach every HTTP request.
-     */
-    headers?: Record<string, string>;
-    /**
-     * WebSocket subprotocols offered during the handshake, which is how a browser
-     * carries a short-lived credential. The client offers the `sirannon.v1`
-     * identifier alongside them and the server selects that identifier, so the
-     * credential never comes back in the handshake response.
-     */
-    webSocketProtocols?: string | string[];
-    /** Reconnect on WebSocket disconnect. Default: true. */
-    autoReconnect?: boolean;
-    /** Reconnect interval in ms. Default: 1000. */
-    reconnectInterval?: number;
-    /**
-     * Per-request timeout in milliseconds for the WebSocket transport. A bulk
-     * load or batch of tens of millions of rows can legitimately run longer than
-     * the default, so raise this for large writes. Set to 0 to wait indefinitely.
-     * Default: 30000.
-     */
-    requestTimeout?: number;
-}
-
-export type { AppliedMigrationRow as A, BulkLoadDurability as B, ClientOptions as C, RequestContext as R, ServerOptions as S, WSHandlerOptions as W, BulkLoadResult as a, AuthenticateHook as b, BulkLoadOptions as c, ClusterStatusAuthorizer as d, CorsOptions as e, ReplicationStatusInfo as f, ServerExecutionTarget as g, ServerExecutionTargetResolver as h };

package/dist/sirannon-BPxC5tC2.d.ts

@@ -1,178 +0,0 @@
-import { H as HookRegistry, D as Database, a as HookDispose } from './database-BLQvqjsw.js';
-import { a as SirannonOptions, S as SQLiteDriver, D as DatabaseOptions, M as Migration, b as BeforeQueryHook, A as AfterQueryHook, c as BeforeConnectHook, d as DatabaseOpenHook, e as DatabaseCloseHook } from './types-DPSmjU54.js';
-
-/** What one database taken out of service produced.
- * @internal
- */
-type OfflineOutcome<T> = {
-    /** True where the action returned. */
-    ok: true;
-    /** What the action produced. */
-    value: T;
-    /** What the reopen threw, where it threw. The action's own result still stands. */
-    reopenFailure?: unknown;
-} | {
-    /** False where the action threw. */
-    ok: false;
-    /** What the action threw. */
-    failure: unknown;
-    /** What the reopen threw, where it threw. */
-    reopenFailure?: unknown;
-};
-
-/**
- * A registry of open SQLite databases, keyed by identifier.
- *
- * It opens each database through one driver, applies shared hooks, metrics, and migrations, and closes idle databases when you configure a lifecycle.
- *
- * @public
- */
-declare class Sirannon {
-    private readonly dbs;
-    private readonly openedWith;
-    private readonly offline;
-    private readonly offlineWork;
-    private readonly opening;
-    private readonly resolving;
-    private _shutdown;
-    private readonly _driver;
-    private readonly _hookRegistry;
-    private readonly metricsCollector;
-    private readonly lifecycleManager;
-    private readonly migrations;
-    /** The driver, hooks, metrics, lifecycle, migrations, and writer-worker default this registry was built with. */
-    readonly options: SirannonOptions;
-    /**
-     * Builds a registry.
-     *
-     * @param options - Driver, hooks, metrics, lifecycle, migrations, and the writer-worker default.
-     */
-    constructor(options: SirannonOptions);
-    /** @internal */
-    get driver(): SQLiteDriver;
-    /** @internal */
-    get hookRegistry(): HookRegistry;
-    /**
-     * Opens a database and registers it under an identifier.
-     *
-     * @param id - Identifier callers reach this database by.
-     * @param path - File path of the SQLite database.
-     * @param options - Pool size, journal mode, durability, and change-capture settings.
-     * @returns The open database.
-     * @throws When the identifier is already registered.
-     */
-    open(id: string, path: string, options?: DatabaseOptions): Promise<Database>;
-    private withRegistryDefaults;
-    /**
-     * Closes one database and removes it from the registry.
-     *
-     * @param id - Identifier of the database to close.
-     */
-    close(id: string): Promise<void>;
-    /**
-     * Closes one database, calls an action against the file behind it, and then
-     * opens that database again under the same identifier with the settings it
-     * had before.
-     *
-     * A restore rebuilds a database at the path it already occupies, so no
-     * connection may be open on that file while Sirannon replaces its bytes. The
-     * identifier answers nothing until that database is open again, though an
-     * action that failed still leaves a database open at the end.
-     *
-     * @param id - Identifier of the database to take offline.
-     * @param action - Runs with the database closed, and receives its file path.
-     * @returns Whether the action returned, what it produced or threw, and what a failed reopen threw.
-     * @throws When no database is open under the identifier, when it refuses writes, or when the close fails.
-     *
-     * @internal
-     */
-    withDatabaseOffline<T>(id: string, action: (path: string) => Promise<T>): Promise<OfflineOutcome<T>>;
-    /**
-     * Returns an already-open database.
-     *
-     * @param id - Identifier of the database.
-     * @returns The database, or undefined when none is open under that identifier.
-     */
-    get(id: string): Database | undefined;
-    /**
-     * Returns an open database, opening it through the lifecycle resolver where it is not open yet.
-     *
-     * This is the call an in-process application makes for a database the registry opens on first
-     * use through the `lifecycle.autoOpen` resolver, such as one file per tenant. Concurrent calls
-     * for the same unopened identifier share one open, so each receives the same database or the
-     * same error.
-     *
-     * @param id - Identifier of the database.
-     * @returns The database, or undefined when none is open and the resolver names no path for it.
-     */
-    resolve(id: string): Promise<Database | undefined>;
-    /**
-     * Returns the registry migration set every database applies as it opens.
-     *
-     * Where the set came from a function, the registry calls that function once and
-     * caches what it returned, so this reports the same list on every call.
-     *
-     * @returns The migrations declared in `SirannonOptions.migrations`, or an empty list where none are.
-     */
-    registryMigrations(): Promise<Migration[]>;
-    /**
-     * Reports whether a database is open under an identifier.
-     *
-     * @param id - Identifier to check.
-     * @returns True when the registry holds an open database under it.
-     */
-    has(id: string): boolean;
-    /**
-     * Returns every database this registry currently holds open.
-     *
-     * @returns The open databases, keyed by identifier.
-     */
-    databases(): Map<string, Database>;
-    /**
-     * Closes every open database and stops the lifecycle timers.
-     *
-     * A database whose file Sirannon is replacing delays the shutdown until that
-     * work finishes, since a process that exits part-way through would leave the
-     * path with no database on it at all.
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Registers a hook that runs before each statement on every database in this registry. 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 every database in this registry.
-     *
-     * @param hook - Receives the statement and how long it took.
-     * @returns A function that removes the hook.
-     */
-    onAfterQuery(hook: AfterQueryHook): HookDispose;
-    /**
-     * Registers a hook that runs before a database connection opens.
-     *
-     * @param hook - Receives the database identifier and its file path.
-     * @returns A function that removes the hook.
-     */
-    onBeforeConnect(hook: BeforeConnectHook): HookDispose;
-    /**
-     * Registers a hook that runs once a database is open.
-     *
-     * @param hook - Receives the database identifier and its file path.
-     * @returns A function that removes the hook.
-     */
-    onDatabaseOpen(hook: DatabaseOpenHook): HookDispose;
-    /**
-     * Registers a hook that runs once a database is closed.
-     *
-     * @param hook - Receives the database identifier and its file path.
-     * @returns A function that removes the hook.
-     */
-    onDatabaseClose(hook: DatabaseCloseHook): HookDispose;
-    private ensureRunning;
-    private ensureOpenAllowed;
-}
-
-export { Sirannon as S };