browser-sqlite 1.0.0-rc.3 → 1.0.0-rc.5

package/dist/inspect.d.ts

@@ -0,0 +1,96 @@
+import type { LockEntries, Locks } from './locks';
+import type { SQLiteVFS } from './types';
+export declare const resolveRealmId: (locks: Locks, snapshot: LockEntries, ownMarkerName?: string) => Promise<string>;
+/** One live client on a database. */
+export type DatabaseClient = {
+    readonly id: string;
+    readonly name: string;
+    /** The realm holding it. Every client in one tab reports the same value. */
+    readonly tab: string;
+    /** That realm is the caller's. A same-origin iframe is another tab here. */
+    readonly sameTab: boolean;
+    /** Four VFS share the `opfs` namespace, and therefore the file. */
+    readonly vfs: SQLiteVFS;
+};
+export type InspectionBase = {
+    readonly file: string;
+    readonly vfs: SQLiteVFS;
+    /** Distinct realms among the clients. */
+    readonly tabs: number;
+    readonly write: {
+        /** The realm writing now, never the client. `null` when nobody writes. */
+        readonly tab: string | null;
+        /** Always false when `tab` is null. */
+        readonly sameTab: boolean;
+        /** Writers queued behind it, across the whole origin. */
+        readonly waiting: number;
+    };
+};
+export type DatabaseInspection = InspectionBase & {
+    readonly clients: readonly DatabaseClient[];
+};
+export type ClientInspection = InspectionBase & {
+    /**
+     * This client, or `null` when this client's own marker is not in the
+     * snapshot — the brief window before its Web Locks grant has landed, or when
+     * the grant could not be taken at all.
+     */
+    readonly self: DatabaseClient | null;
+    readonly siblings: readonly DatabaseClient[];
+};
+/**
+ * The census, given locks that are already known to work.
+ *
+ * One `entries()` call supplies the roster, the writer and the queue together,
+ * so those three always describe the same instant and cannot compose a state
+ * that never existed. The one exception: a realm whose id has never been
+ * resolved and that was given no marker pays one extra query to read its own
+ * `clientId` back — once, and never again for that realm's lifetime.
+ */
+export declare const inspectWith: (locks: Locks, file: string, vfs: SQLiteVFS, ownMarkerName?: string) => Promise<DatabaseInspection>;
+/**
+ * Whether any OTHER client of this library holds `file` on `vfs`.
+ *
+ * The discriminator behind the `openTimeout` message: a slot that never became
+ * ready is usually blamed on another tab, and that is often false — a page
+ * reloaded without `close()` leaves a dead context holding the database, and
+ * no live client to find. One `entries()` call tells the two apart.
+ *
+ * Deliberately NOT `inspectWith`: this runs while the pool is half-open, so it
+ * resolves no realm id (which would take a lock), touches nothing the client
+ * owns, and never throws. `undefined` is "could not be answered" — Web Locks
+ * missing, a VFS whose pages never leave their worker, a registry that rejects,
+ * or one that does not answer within `deadlineMs`. A caller that reads
+ * `undefined` as `false` would state the opposite of what was observed.
+ *
+ * `false` means no client of THIS library holds it — never that nobody does.
+ * Another library, another origin's tooling and native code are all invisible
+ * to the Web Locks registry.
+ */
+export declare const libraryClientsHold: (locks: Locks, file: string, vfs: SQLiteVFS, ownId: string, deadlineMs?: number) => Promise<boolean | undefined>;
+export type InspectDatabaseOptions = {
+    /**
+     * The VFS the database was created with. Required, and not defaulted: four
+     * VFS share one underlying file, and the others are separate stores
+     * entirely, so guessing would report on a different database.
+     */
+    vfs: SQLiteVFS;
+};
+/**
+ * Who is live on a database, without opening it.
+ *
+ * This is a snapshot, stale the instant it resolves. It informs a UI; it never
+ * authorizes an action — `deleteDatabase` raising `DATABASE_IN_USE` is the only
+ * authority on whether a database can be removed.
+ *
+ * Takes `file` positionally like `createSQLiteClient` and `deleteDatabase`:
+ * every root export of this library names the database the same way.
+ *
+ * @throws {SQLiteError} `INVALID_OPTION` when `vfs` is missing, unknown, or a
+ *   memory VFS, where two clients are two databases and the question has no
+ *   meaning.
+ * @throws {SQLiteError} `UNSUPPORTED` where the Web Locks API is unavailable.
+ *   Reporting zero there would be indistinguishable from a database nobody
+ *   holds.
+ */
+export declare const inspectDatabase: (file: string, options: InspectDatabaseOptions) => Promise<DatabaseInspection>;

package/dist/locks.d.ts

@@ -0,0 +1,172 @@
+/**
+ * A thin wrapper over `navigator.locks`, used by `output()` to make its staging
+ * tables collectable across tabs (D3).
+ *
+ * The staging lock is NOT mutual exclusion — nothing contends for its name. It
+ * is a liveness marker: a lock held for as long as a staging table exists is
+ * what lets another tab's sweep tell an in-flight table from an orphan. A tab
+ * that is killed has its locks released by the browser, so its orphans become
+ * collectable immediately, with no timestamp and no grace period.
+ */
+import type { SQLiteVFS } from './types';
+/** One entry in the lock registry as returned by `query()`. */
+type QueriedLock = {
+    name?: string;
+    mode?: string;
+    clientId?: string;
+};
+/** The slice of the Web Locks API this module uses. */
+type LockManager = {
+    request: (name: string, optionsOrCallback: any, callback?: (lock: unknown) => Promise<unknown>) => Promise<unknown>;
+    query: () => Promise<{
+        held?: QueriedLock[];
+        pending?: QueriedLock[];
+    }>;
+};
+export type Locks = {
+    /** False when the Web Locks API is missing; every method then no-ops. */
+    readonly available: boolean;
+    /**
+     * Acquires `name` and resolves with the function that releases it.
+     *
+     * `mode: 'shared'` is what the epoch marker uses: many realms may hold the
+     * same name at once, so publishing never waits and two realms can never
+     * collide on one epoch number. `signal` aborts the WAIT — never the hold —
+     * and makes the request reject with `AbortError`.
+     *
+     * `ifAvailable: true` mirrors `tryWithLock`'s semantics: the real API hands
+     * the callback `null` rather than waiting when the lock is held elsewhere.
+     * Resolves with `undefined` in that case instead of waiting. Never waits —
+     * that is the point for the connection guard.
+     */
+    hold(name: string, options?: {
+        mode?: 'exclusive' | 'shared';
+        signal?: AbortSignal;
+    }): Promise<() => void>;
+    hold(name: string, options: {
+        mode?: 'exclusive' | 'shared';
+        signal?: AbortSignal;
+        ifAvailable: true;
+    }): Promise<(() => void) | undefined>;
+    /** Runs `fn` while holding `name` exclusively. */
+    withLock: <T>(name: string, fn: () => Promise<T>) => Promise<T>;
+    /**
+     * Runs `fn` while holding `name`, or skips it entirely when the lock is held
+     * elsewhere. Never waits — which is the point: the staging sweep is
+     * opportunistic, and awaiting this lock inside an open transaction would
+     * hold SQLite's write lock while waiting on a holder that may itself be
+     * waiting for that write lock.
+     *
+     * Resolves `true` if `fn` ran, `false` if it was skipped.
+     */
+    tryWithLock: (name: string, fn: () => Promise<unknown>) => Promise<boolean>;
+    /** Names currently held anywhere in this origin — every tab included. */
+    heldNames: () => Promise<string[]>;
+    /**
+     * The origin's whole lock registry: held AND pending, each with the realm
+     * holding or awaiting it.
+     *
+     * `heldNames()` answers a different, cheaper question and keeps its own
+     * shape — `epochsFor` only ever needs names.
+     */
+    entries: () => Promise<LockEntries>;
+};
+/** One entry of the origin's lock registry, held or pending. */
+export type LockEntry = {
+    readonly name: string;
+    readonly mode: 'exclusive' | 'shared';
+    readonly clientId: string;
+};
+export type LockEntries = {
+    readonly held: readonly LockEntry[];
+    readonly pending: readonly LockEntry[];
+};
+export declare const stagingTableName: (uuid: string) => string;
+export declare const isStagingTable: (table: string) => boolean;
+export declare const stagingLockName: (file: string, table: string) => string;
+export declare const sweepLockName: (file: string) => string;
+/**
+ * The marker a client holds to publish that it is alive on a database.
+ *
+ * Held in SHARED mode and contended by NOBODY: like `bsq:staging` this is a
+ * liveness marker, not mutual exclusion. `bsq:conn` stays the only occupancy
+ * detector `deleteDatabase` rests on — a second one would diverge from it.
+ *
+ * The label is `encodeURIComponent`d, which escapes `:` as `%3A`. That is what
+ * makes the tail split unambiguously into exactly three segments whatever the
+ * consumer names their client. The FILE may itself contain a colon, which is
+ * why the reader rebuilds the exact prefix instead of scanning for separators —
+ * the same trap `epochsFor` documents.
+ */
+export declare const clientMarkerName: (vfs: SQLiteVFS, file: string, id: string, clientName: string) => string;
+export type ClientMarker = {
+    readonly id: string;
+    readonly vfs: SQLiteVFS;
+    readonly name: string;
+};
+/**
+ * Reads one of our markers, or `undefined` for anything else.
+ *
+ * Every rejection below is deliberate: a marker this version does not
+ * understand — a future one carrying more segments, say — must be SKIPPED, not
+ * guessed at. Guessing is how a reader reports another database's state.
+ */
+export declare const parseClientMarker: (lockName: string, vfs: SQLiteVFS, file: string) => ClientMarker | undefined;
+/**
+ * The storage namespace a VFS writes into — derived from `layout`, NEVER from
+ * the VFS name.
+ *
+ * `OPFSAdaptiveVFS`, `OPFSAnyContextVFS`, `OPFSCoopSyncVFS` and
+ * `OPFSWriteAheadVFS` all walk from `navigator.storage.getDirectory()` and open
+ * `getFileHandle(filename)`, so one database name is ONE file for all four. A
+ * per-VFS key would let two of them write the same bytes without ever
+ * excluding each other: a missed conflict corrupts, an invented one only slows.
+ *
+ * `idb-store` goes finer than its layout on purpose — its two VFS each own an
+ * IndexedDB database named after their class, so grouping them would invent a
+ * conflict for free. `opfs-pool` and `memory` are alone in their layout, so the
+ * VFS name is already the namespace.
+ *
+ * `worker/worker.ts:627` gates on `layout` for the same reason, in those words.
+ */
+export declare const namespaceFor: (vfs: SQLiteVFS) => string;
+/**
+ * Whether two clients on this VFS can reach the same bytes at all.
+ *
+ * False for the memory VFS: its pages live in the worker that opened them and
+ * `maxPoolSize` is 1, so two clients on one name are two independent
+ * databases. Locking them against each other would be wrong as well as slow —
+ * an origin round trip charged to the VFS chosen for speed. `delete.ts:79`
+ * skips the same layout, for the same reason.
+ */
+export declare const sharesStorage: (vfs: SQLiteVFS) => boolean;
+/** Serializes database opening across the pool — replaces the SAB init mutex. */
+export declare const initLockName: (vfs: SQLiteVFS, file: string) => string;
+/**
+ * Serializes WRITERS across every client and tab in the origin. Exclusive, so
+ * at most one is held per database at any instant however many clients exist.
+ */
+export declare const writeLockName: (vfs: SQLiteVFS, file: string) => string;
+/**
+ * Origin-wide exclusive connection lock for VFS that cannot safely share a
+ * database across clients (`exclusiveConnection: true` in `VFS_CAPABILITIES`).
+ *
+ * Held for the client's lifetime. A second `createSQLiteClient` that tries to
+ * open the same database will fail its first query with `BUSY` instead of
+ * silently reading a broken, frozen view — the failure mode measured as
+ * AHP-2TAB (2026-09-01) where `SELECT 1` passes and `SELECT count(*) FROM
+ * sqlite_master` returns 0 on an unfixable connection.
+ *
+ * The key uses `namespaceFor(vfs)` for the same reason `writeLockName` does:
+ * the gate is by layout declaration, not by VFS name.
+ */
+export declare const connectionLockName: (vfs: SQLiteVFS, file: string) => string;
+/**
+ * Which staging tables no live `output()` is using — pure, so it is driven by
+ * Node tests rather than by two browser tabs.
+ */
+export declare const staleStagingTables: (tables: string[], heldNames: string[], file: string) => string[];
+/** The no-op Locks value for environments where the Web Locks API is absent. */
+export declare const noOpLocks: Locks;
+export declare const createLocks: (manager?: LockManager | undefined) => Locks;
+export {};

package/dist/logger.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The prefixed logger the `debug` option turns on.
+ *
+ * Lifecycle events only — worker created, ready, open-error, crash, restart,
+ * worker loss, close, skipped sweep. A line per query would be illegible under
+ * real load and would put user values on the console; query throughput belongs
+ * in `db.debug`, not here.
+ */
+export type Logger = {
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+    /**
+     * Always writes through the sink regardless of the `enabled` flag.
+     * Use for events that must be visible even when debug logging is off —
+     * permanent pool shrinkage being the primary case.
+     */
+    always: {
+        warn: (message: string) => void;
+    };
+};
+type Sink = Pick<Console, 'debug' | 'warn' | 'error'>;
+export declare const createLogger: (prefix: string, enabled: boolean, sink?: Sink) => Logger;
+export {};

package/dist/pool.d.ts

@@ -0,0 +1,191 @@
+import { SQLiteError, type SQLiteErrorCode } from './errors';
+import type { Logger } from './logger';
+import type { SQLiteResultCode } from './sqlite-codes';
+import type { PlatformFeature, SavepointOp, SQLiteBuild, SQLiteVFS, WasmLocation } from './types';
+/**
+ * Query execution options forwarded to a pool worker.
+ */
+export type PoolWorkerQueryOptions = {
+    chunkSize?: number | undefined;
+    credits?: number | undefined;
+    timeout?: number | undefined;
+    /** Forwarded to the worker so it installs the async progress handler (§4 D2). */
+    abortable?: boolean | undefined;
+    /**
+     * When true, the query's completion does not call `deps.onServed`. Set for
+     * the commit-propagation barrier: it is a synthetic probe, not user work, and
+     * must not reset the supervisor's restart counter.
+     * `createQueryDebugState` is intentionally NOT suppressed: barrier statements
+     * still appear in the debug request tree, and a browser test counts them there
+     * to prove the barrier stays conditional.
+     */
+    noServed?: boolean;
+    /**
+     * Read exactly once, when the query is POSTED — below the reuse guard,
+     * never when the query is created. A transaction hands its pending savepoint
+     * conclusion over in here, so a query the guard refuses must not consume it
+     * (spec 2026-09-11, §4).
+     */
+    savepoint?: (() => SavepointOp | undefined) | undefined;
+};
+/**
+ * A Worker extended with pool-specific properties.
+ *
+ * Note: no `available` field — availability lives in the Scheduler, not on
+ * the worker itself. This makes it impossible to republish a borrowed worker
+ * from outside the scheduler (the root cause of B1).
+ */
+export type PoolWorker = Worker & {
+    index: number;
+    /** Lifecycle label for the debug surface. Replaces the SAB status byte. */
+    status: string;
+    /**
+     * The commit epoch this connection has absorbed. Starts at -1: a worker
+     * opens the file — and reads page 1 — BEFORE it enters the pool, and a
+     * commit can land in between. At poolSize 2 that is the nominal startup
+     * ordering, not a rare race, so a new worker is always treated as behind and
+     * pays exactly one barrier statement in its lifetime.
+     */
+    seen: number;
+    /** The epoch captured when the current lease was granted. */
+    epochTarget: number;
+    /**
+     * Whether the connection was inside a transaction when its last query
+     * ended, as the worker read it (`sqlite3_get_autocommit`). `undefined` until
+     * a query has reported it.
+     *
+     * CONNECTION state, not availability: nothing schedules on it and nothing
+     * may. Availability lives in `scheduler.ts` alone — see the `available`
+     * declaration there — and a flag on this object that the pool consulted would
+     * reopen B1. Its one reader is `transaction.ts`, which asks it whether a
+     * ROLLBACK is still owed and whether its transaction is still alive.
+     */
+    inTransaction?: boolean | undefined;
+    query: <T extends Record<string, unknown> = Record<string, unknown>>(sql: string, params?: unknown[], options?: PoolWorkerQueryOptions) => AsyncGenerator<T[] | number>;
+    /**
+     * Ask the worker to stop. Also settles a `next()` already in flight, which
+     * is what lets the consumer's queued `return()` reach the generator's
+     * finally instead of waiting behind a chunk that may be minutes away.
+     *
+     * `on` is the transport iterator being stopped, and it is REQUIRED: the call
+     * is a no-op unless the worker is still serving that transport, which is what
+     * keeps a late stop off an unrelated query. It was briefly optional, and an
+     * omitted argument meant "stop whatever is running" — the exact semantics that
+     * let an abandoned generator's late cleanup truncate a healthy query. Nothing
+     * needs that form, so nothing may ask for it.
+     */
+    interrupt: (on: object) => void;
+    /** Resolves when no query is in flight on this worker. */
+    quiesce: () => Promise<void>;
+    /**
+     * Resolves when this worker will accept another query — at `done`, which is
+     * earlier than `quiesce()`. Use it to wait for the WORKER; use `quiesce()`
+     * to wait for a statement to have been fully settled and judged.
+     */
+    free: () => Promise<void>;
+    /** Posts `close`, awaits the `closed` reply, then the caller must terminate. */
+    close: () => Promise<void>;
+    /**
+     * Stops the thread AND the transport — never the browser's `terminate()`
+     * alone.
+     *
+     * `PoolWorker` IS the native `Worker`, so this used to be the engine's own
+     * method: it killed the thread and told the transport nothing. A request
+     * posted afterwards waited for a reply that could never come — a
+     * transaction's next statement, and its fallback `ROLLBACK`, which carries no
+     * signal by design and so could not even be aborted. Overriding the method,
+     * rather than adding one beside it, is deliberate: there are several
+     * terminate sites and one added later must not be able to forget this.
+     *
+     * `reason` is what in-flight and later requests reject with. It reports
+     * nothing to the client: whoever terminates has already decided this worker's
+     * fate, and going through `onDeath` here would re-enter that decision.
+     */
+    terminate: (reason?: SQLiteError) => void;
+};
+/** What `createPoolWorker` settles with when its worker declined to open. */
+export type DeclinedWorker = {
+    declined: PlatformFeature;
+};
+/**
+ * Returns a SQLiteError('BUSY', …) when data carries a lock-conflict result
+ * code (5 or 6), else undefined. Shared by `statementError` and `startupError`
+ * so the BUSY_CODES decision lives in exactly one place. The extended code
+ * travels with it when it is a subtype (`subtypeOf`) — a query sends one, an
+ * open does not.
+ */
+export declare const busyFromCode: (data: {
+    message: string;
+    cause?: unknown;
+    sqliteCode?: SQLiteResultCode;
+    sqliteExtendedCode?: number;
+}) => SQLiteError | undefined;
+/**
+ * What a query's `error` message becomes (spec 2026-09-14 §5.3): a code the
+ * worker minted; else `BUSY` for a lock conflict; else `STATEMENT_FAILED` for
+ * any other code SQLite reported; else — a failure SQLite did not report, such
+ * as a JS exception in the worker — a plain Error, as before. `BUSY` and
+ * `STATEMENT_FAILED` carry `sqliteCode`, and `sqliteExtendedCode` when it is a
+ * subtype (`subtypeOf`).
+ */
+export declare const statementError: (data: {
+    message: string;
+    cause?: unknown;
+    sqliteCode?: SQLiteResultCode;
+    sqliteExtendedCode?: number;
+    errorCode?: SQLiteErrorCode;
+}) => Error;
+/**
+ * What a failed open or delete becomes: `BUSY` for a lock conflict, else
+ * `WORKER_CRASHED` — the slot dies either way — carrying SQLite's primary code
+ * when there is one (spec 2026-09-14, D2). No extended code: when
+ * `sqlite3_open_v2` itself fails there is no connection to ask (D7).
+ */
+export declare const startupError: (data: {
+    message: string;
+    cause?: unknown;
+    sqliteCode?: SQLiteResultCode;
+}) => SQLiteError;
+/**
+ * The single `new Worker(new URL(…))` expression in this package.
+ *
+ * It must stay one literal, in one place: bundlers find the worker by static
+ * analysis of exactly this shape, and a second copy would have them emit a
+ * second, untransformed worker bundle. `pool.ts:191` records what that cost
+ * when the expression was written a second time for an error message.
+ */
+export declare const spawnWorker: (name: string) => Worker;
+/**
+ * Creates a new pool worker and registers it in the pool array.
+ * Sets up message routing via callId for query responses.
+ *
+ * Moved verbatim from `createWorker` in client.ts, with three changes:
+ *  1. Closure variables become explicit `deps` parameters.
+ *  2. Both `available` assignments are deleted (availability lives in the Scheduler).
+ *  3. `worker.available = false/true` in the `query` generator are deleted.
+ */
+export declare const createPoolWorker: (deps: {
+    index: number;
+    pool: (PoolWorker | undefined)[];
+    clientName: string;
+    file: string;
+    vfs: SQLiteVFS;
+    build: SQLiteBuild;
+    /** Already resolved and absolute; relayed to the worker, never read here. */
+    wasm?: WasmLocation | undefined;
+    pragmas?: Record<string, string> | undefined;
+    statementCacheSize?: number | undefined;
+    statementCacheBytes?: number | undefined;
+    onDeath?: (index: number, error: SQLiteError) => void;
+    onServed?: (index: number) => void;
+    drainTimeout: number;
+    createWorkerDebugState?: ((index: number, name: string) => any) | undefined;
+    createQueryDebugState?: ((index: number, sql: string, params?: unknown[]) => any) | undefined;
+    logger: Logger;
+    abortSlots?: SharedArrayBuffer | undefined;
+    declineWithout?: readonly PlatformFeature[] | undefined;
+    /** Sent to slot 0 where exclusivity depends on a feature (spec 2026-09-15). */
+    probeFirst?: readonly PlatformFeature[] | undefined;
+    /** Worker 0's probe answer, with the function that lets it open. */
+    onProbed?: ((missing: PlatformFeature | null, proceed: () => void) => void) | undefined;
+}) => Promise<PoolWorker | DeclinedWorker>;

package/dist/queries.d.ts

@@ -0,0 +1,65 @@
+import { type AbandonRegistry } from './abandon';
+import type { SQLiteChunkOptions, SQLiteQueryOptions } from './api';
+import type { PoolWorker } from './pool';
+/**
+ * Wires an AbortSignal into a promise that rejects the instant the signal
+ * fires, and returns a teardown that removes the listener. The rejection sink
+ * (`aborted?.catch`) suppresses the unhandled-rejection when the query ends
+ * normally and nobody is racing the promise any more.
+ *
+ * This is the only place in the module that reads an AbortSignal; both
+ * `chunk()` and `writeWorker()` delegate here.
+ */
+export declare const makeAbortRace: (signal: AbortSignal | undefined) => {
+    aborted: Promise<never> | undefined;
+    teardown: () => void;
+};
+/**
+ * `SQLiteChunkOptions` plus what only this library passes. `registry` is
+ * TEST-ONLY and unsupported; it exists so the abandonment path can be driven
+ * without a garbage collection.
+ */
+export type InternalChunkOptions = SQLiteChunkOptions & {
+    credits?: number;
+    /** The owning layer's teardown, run if the generator is abandoned. */
+    onAbandon?: (() => void) | undefined;
+    /**
+     * Handed the transport iterator, synchronously, before the factory returns.
+     *
+     * An owner that must close this generator from the outside needs it: a
+     * method call on an async generator queues behind a `next()` already in
+     * flight, so `return()` alone parks until a chunk arrives — which on an
+     * `ORDER BY` is the whole sort. `worker.interrupt(transport)` is what
+     * settles that `next()`, and it is a no-op unless the worker still serves
+     * that transport, so only its true owner can be handed it. `src/transaction.ts`
+     * is the only caller; the client path drops its generator instead of
+     * closing it and needs nothing here.
+     */
+    onTransport?: ((iterator: AsyncGenerator<unknown>) => void) | undefined;
+    registry?: AbandonRegistry;
+};
+/**
+ * The single query primitive. Every other read path is a thin derivation, and
+ * abort is implemented here exactly once.
+ *
+ * **A factory, not a generator function**, so that the transport iterator
+ * exists before the generator does and can be handed to the abandonment
+ * registry. Building it early costs nothing: `worker.query()` runs no code
+ * until its first `next()`, so the query message and the reuse guard still
+ * happen when the consumer first pulls.
+ */
+export declare const chunk: <T extends Record<string, unknown> = Record<string, unknown>>(worker: PoolWorker, sql: string, params?: unknown[], options?: InternalChunkOptions) => AsyncGenerator<T[]>;
+export declare const streamRows: <T extends Record<string, unknown> = Record<string, unknown>>(worker: PoolWorker, sql: string, params?: unknown[], options?: InternalChunkOptions) => AsyncGenerator<T>;
+export declare const readWorker: <T extends Record<string, unknown> = Record<string, unknown>>(worker: PoolWorker, sql: string, params?: unknown[], options?: SQLiteChunkOptions) => Promise<T[]>;
+/**
+ * First row, then stop. This BREAKS rather than aborting: a break triggers the
+ * generator's return path, which runs chunk()'s finally and the transport's
+ * stop-and-drain — the same worker-stop routine, reached without an exception.
+ * That is why there is no internal AbortController here and no need to tell an
+ * internal abort from the caller's.
+ */
+export declare const firstWorker: <T extends Record<string, unknown> = Record<string, unknown>>(worker: PoolWorker, sql: string, params?: unknown[], options?: SQLiteQueryOptions) => Promise<T | undefined>;
+export declare const writeWorker: <T extends Record<string, unknown> = Record<string, unknown>>(worker: PoolWorker, sql: string, params?: unknown[], options?: SQLiteQueryOptions) => Promise<{
+    result: T[];
+    affected: number;
+}>;