@jarenjs/db 0.46.5 → 0.56.0

package/dist/types/derive.d.ts

@@ -1,250 +0,0 @@
-/**
- * @file Derived index columns: the one place a declared
- * `indexes[].derive` becomes a value. A spatial member is an array of
- * numbers or an object, and a generated column must be a scalar, so a
- * geohash cell or a bounding-box edge is what actually gets indexed;
- * an embedding is an array of hundreds of numbers, and what gets
- * stored is its packed, l2-normalized Float32 form.
- *
- * Every cell and every box comes from `@jarenjs/core/geo`, and every
- * normalization and packing from `@jarenjs/core/vector`; nothing here
- * computes arithmetic of its own. The spatial functions serve BOTH
- * physical mappings — registered as deterministic SQL functions inside
- * a virtual generated column's expression where the driver can index
- * them, and called directly on the write path where it cannot — so
- * the two branches cannot drift into different answers. The vector
- * kind has ONE mapping, stored everywhere (`DERIVE_MAPPING`), and
- * registers no function at all: a whole array re-derived per row as a
- * host call is the cost the spatial work measured at 150×, a stored
- * column is readable without any registration, and bun has no
- * function API — one mapping is the only way every driver agrees.
- *
- * It is also this package's ONLY seam onto `@jarenjs/core/geo` (D1 —
- * one home for spatial arithmetic, grep-proven by test) and onto
- * `@jarenjs/core/vector` (the same rule, one home for vector
- * arithmetic): the planner's probe geometry — the box of a literal or
- * bound region, the box of a bounded-distance circle, a cell's
- * neighbourhood — and the k-nearest plan's probe vector and column
- * score are computed by the helpers below rather than by an import of
- * their own.
- *
- * The switches over the kind are EXHAUSTIVE: a kind with no rule
- * throws, here and in the dialect, so that adding a kind without
- * teaching both is a failure at the first call rather than a bbox
- * edge of the first two floats and `jaren_bbox_undefined(...)` SQL.
- *
- * Determinism is the contract, not a convenience: a value here is a
- * pure function of the document bytes. Nothing reads the clock, a
- * random source or store state, because an INDEX over a function that
- * did would make the database unreadable from a connection whose
- * function answered differently — and unreadable, not merely wrong:
- * a connection that has not registered the function at all cannot even
- * SELECT the table (probed). That hazard is why the mapping is
- * capability-gated rather than always-on.
- */
-/** The closed set of derive kinds. */
-export declare const DERIVE_KINDS: Set<string>;
-/**
- * The per-kind PHYSICAL MAPPING override. A spatial kind takes the
- * mapping the driver's capability selects (`null` here); the vector
- * kind is `'stored'` on every driver, for the three reasons in the
- * file header, and never joins `registerDeriveFunctions`.
- * @type {Readonly<Record<string, 'stored' | null>>}
- */
-export declare const DERIVE_MAPPING: Readonly<Record<string, 'stored' | null>>;
-/**
- * The physical mapping one derived column takes: the kind's override
- * where it has one, the driver's mapping otherwise.
- * @param {string} kind
- * @param {'virtual' | 'stored'} driverMapping
- * @returns {'virtual' | 'stored'}
- */
-export declare function derivedMappingFor(kind: string, driverMapping: 'virtual' | 'stored'): 'virtual' | 'stored';
-/**
- * The closed set of PHYSICAL realizations a `derive: 'bbox'` index may
- * ask for. `'columns'` is the default and what an absent member means:
- * four generated columns under one B-tree. `'rtree'` is the same four
- * columns (they stay the box's one definition) beside a SQLite R\*Tree
- * virtual table kept in sync by declared triggers, with no B-tree over
- * them. The LOGICAL meaning of `derive: 'bbox'` is identical either
- * way — same rows, same answers — which is the whole point of naming
- * the shape separately from the derivation.
- */
-export declare const PHYSICAL_KINDS: Set<string>;
-/** A bbox index's four columns, in the order they are declared —
- * `[west, south, east, north]`, the order the kernel's boxes carry. */
-export declare const BBOX_COMPONENTS: readonly string[];
-/**
- * The order a bbox index COVERS its four columns, which is not the
- * order they are declared in: an intersection test reads
- * `w <= ? AND e >= ? AND s <= ? AND n >= ?`, so the two longitude
- * bounds sit together at the front of the index where a leading-column
- * range can use them. `(a,b)` and `(b,a)` are different indexes.
- */
-export declare const BBOX_INDEX_ORDER: readonly string[];
-/** The declared geohash precision range (characters). */
-export declare const PRECISION_MIN = 1;
-export declare const PRECISION_MAX = 12;
-/** The declared vector width range (components). */
-export declare const DIMS_MIN = 1;
-export declare const DIMS_MAX = 8192;
-/**
- * The geohash cell of a value at a precision, or null when the value
- * carries no bounded position.
- * @param {any} value
- * @param {number} precision
- * @returns {string | null}
- */
-export declare function deriveGeohash(value: any, precision: number): string | null;
-/**
- * One edge of a value's bounding box, or null when it has none —
- * including the D6 case where a non-finite coordinate refuses the box
- * rather than producing one that does not bound its input.
- * @param {any} value
- * @param {string} component - `'w'`, `'s'`, `'e'` or `'n'`
- * @returns {number | null}
- */
-export declare function deriveBboxEdge(value: any, component: string): number | null;
-/**
- * The value of a `derive: 'vector'` column for a document member — the
- * ONE seam from this package onto `@jarenjs/core/vector`. The member
- * round-trips through its stored form first, exactly as the spatial
- * kinds do: a `Float32Array` in the document is held as an object and
- * a `NaN` as `null`, and the column must be a function of what is
- * held, so that a write, a migration backfill and a second open can
- * never disagree about one row.
- * @param {any} member - the value at the index path, or `undefined`
- * @param {number} dims - the declared width
- * @returns {Uint8Array | null} `4·dims` bytes, or `null` when the
- *   member is not a vector of that width
- */
-export declare function deriveVector(member: any, dims: number): Uint8Array | null;
-/**
- * A member as the database will hold it. A derived value must be a
- * function of the STORED document, not of the object handed to the
- * write: JSON has no `NaN` and no `Infinity`, so a non-finite
- * coordinate becomes `null` on the way in and is no longer a position
- * at all. Computing from the in-memory value would make the two
- * physical mappings answer differently for the same document, which is
- * the one thing they may never do.
- *
- * Only the indexed MEMBER round-trips, not the whole document — it is
- * the only part a derived column reads.
- * @param {any} member
- * @returns {any} the member as stored, or `undefined` when there is none
- */
-export declare function storedMemberForm(member: any): any;
-/**
- * The value of one derived column for a document member, which the
- * caller hands over in its STORED form (`storedMemberForm`): the write
- * path round-trips it, and a migration backfill reads it from the row.
- * Exhaustive over the kind — see the file header.
- * @param {{ derive: string, precision?: number, component?: string,
- *   dims?: number }} column
- * @param {any} member - the stored value at the index path, or `undefined`
- * @returns {string | number | Uint8Array | null}
- */
-export declare function derivedValue(column: {
-    derive: string;
-    precision?: number;
-    component?: string;
-    dims?: number;
-}, member: any): string | number | Uint8Array | null;
-/**
- * Read the member one derived column is computed from, walking the
- * same typed segments the physical mapping was planned over.
- * @param {any} doc
- * @param {import('./dialect.js').JsonPathSegment[]} segments
- * @returns {any} the member, or `undefined`
- */
-export declare function memberAt(doc: any, segments: import('./dialect.js').JsonPathSegment[]): any;
-/**
- * Register the deterministic functions the virtual generated columns
- * call. Idempotent per connection by SQLite's own semantics (a second
- * registration replaces the first with the identical implementation),
- * and a no-op where the driver cannot index a registered function —
- * that branch stores the columns instead.
- *
- * The four bbox edges share a one-entry memo of the last text they
- * were asked about, because they are called back to back with the same
- * argument for one row and the box costs a full walk of the geometry.
- * The memo is keyed on the argument itself, so it changes no answer.
- * @param {any} connection
- * @returns {any} value-or-promise
- */
-export declare function registerDeriveFunctions(connection: any): any;
-/**
- * The bounding box of a probe value, or `null` when it has none — the
- * D6 refusal included, which is what makes an unbounded probe divert to
- * the full scan instead of narrowing with a box that does not bound it.
- * @param {any} value - a GeoJSON value or a `[lon, lat]` position
- * @returns {number[] | null} `[west, south, east, north]`
- */
-export declare function probeBox(value: any): number[] | null;
-/**
- * The representative position §8.14 measures a probe value by — the
- * same rule the derived columns use, so the pushed filter and the
- * engine cannot disagree about where a value IS. `null` when it has no
- * bounded position.
- * @param {any} value
- * @returns {number[] | null}
- */
-export declare function probePosition(value: any): number[] | null;
-/**
- * The bounding box of the circle of `metres` around a position — the
- * box a `$distance <= r` predicate narrows with, on the same sphere and
- * the same radius constant the engine measures with. `null` when the
- * radius is not a finite non-negative number, or when the circle
- * reaches a pole, where there is no longitude bound to give.
- * @param {number[]} position
- * @param {number} metres
- * @returns {number[] | null} `[west, south, east, north]`, NOT wrapped
- *   into `[-180, 180]`: a circle spanning the antimeridian answers a
- *   west below -180, which is how the planner detects it
- */
-export declare function probeCircleBox(position: number[], metres: number): number[] | null;
-/**
- * A cell and its neighbours, the nine-cell probe D7 requires — a single
- * prefix is bucketing, never proximity.
- * @param {string} cell
- * @returns {string[]} up to nine cells (fewer past a pole)
- */
-export declare function cellNeighbourhood(cell: string): string[];
-/**
- * The value one DERIVED parameter slot binds: an axis of a bound
- * external's bounding box, computed at bind time because a GeoJSON
- * object is not a value any database can bind. `null` when the value
- * has no box, which is what tells the caller to divert.
- * @param {{ kind: string, external: string, axis: string }} derived
- * @param {any} value - the bound external
- * @returns {number | null}
- */
-export declare function derivedSlotValue(derived: {
-    kind: string;
-    external: string;
-    axis: string;
-}, value: any): number | null;
-/**
- * The probe a k-nearest plan scores the column against: a literal or
- * bound vector, l2-normalized once, so that its dot product with the
- * column's normalized form IS the cosine of the raw vectors. `null`
- * when the value is not a vector of exactly `dims` finite numbers —
- * the binder's signal to divert the call to the residual, where the
- * engine answers what it answers everywhere for such a probe (empty
- * keys for another width, its own refusal for a non-array).
- * @param {unknown} value
- * @param {number} dims - the column's declared width
- * @returns {Float32Array | null}
- */
-export declare function probeVector(value: unknown, dims: number): Float32Array | null;
-/**
- * One row's column score against a prepared probe: the packed column
- * unpacked at the declared width and dotted with the probe. `null` for
- * a row whose column holds no vector — SQL `NULL`, or bytes of another
- * length — because such a row is unrankable and 0 is a real score.
- * @param {unknown} bytes - the column value as the driver returns it
- * @param {number} dims
- * @param {Float32Array} probe - from {@link probeVector}
- * @returns {number | null}
- */
-export declare function columnScore(bytes: unknown, dims: number, probe: Float32Array): number | null;

package/dist/types/dialect.d.ts

@@ -1,149 +0,0 @@
-/**
- * @file The dialect seam: the ONLY place SQL text is produced. A
- * dialect is data plus a small emitter — a spelling spec (how to quote
- * an identifier, reference a parameter, extract a JSON member, open a
- * savepoint) composed by {@link createDialect} into the DDL and DML
- * statement builders the store consumes. Nothing outside a dialect
- * concatenates SQL; that costs one indirection now, and without it a
- * second backend is a rewrite.
- *
- * Deliberately NOT in the dialect, because they are behavioural rather
- * than syntactic: whether functions can be registered per connection,
- * whether change capture exists and in what form, and whether tables
- * can be restructured in place. Those are capabilities on the
- * connection.
- */
-export type JsonPathSegment = {
-    name: string;
-} | {
-    index: number;
-};
-/**
- * A typed member path into the JSON document column: name segments for
- * object members, index segments for array positions. Produced by the
- * DDL planner (from analyzed index paths) and the patch translator
- * (from pointers discriminated against the live document).
- * @typedef {{ name: string } | { index: number }} JsonPathSegment
- */
-/**
- * Compose a dialect from its spelling spec. Every statement the store
- * ever runs is built here from the spec's primitives, so a spec with
- * different quoting or parameter style produces correspondingly
- * different SQL from the same model — the property the test-double
- * dialect pins.
- * @param {{
- *   name: string,
- *   capabilities: Record<string, any>,
- *   tableSuffix: string,
- *   docColumnType: string,
- *   packedVectorType: string,
- *   quoteIdentifier: (s: string) => string,
- *   parameterRef: (i: number, name: string) => string,
- *   stringLiteral: (s: string) => string,
- *   booleanLiteral: (b: boolean) => string,
- *   typeFor: (schemaType: string | undefined, hint: string) => string,
- *   limitClause: (limit: number, offset?: number) => string,
- *   jsonPathText: (segments: JsonPathSegment[]) => string | null,
- *   jsonExtract: (columnSql: string, pathText: string) => string,
- *   derivedExpression?: (memberSql: string, column: { derive: string,
- *     precision?: number, component?: string, dims?: number }) => string,
- *   jsonSet: (exprSql: string, pathText: string, valueSql: string) => string,
- *   jsonRemove: (exprSql: string, pathText: string) => string,
- *   jsonAppend: (exprSql: string, arrayPathText: string, valueSql: string) => string,
- *   jsonEncode: (paramSql: string) => string,
- *   jsonText: (columnSql: string) => string,
- *   jsonAgg: (exprSql: string) => string,
- *   jsonTypeOf: (columnSql: string, pathText: string) => string,
- *   valueTypeOf: (paramSql: string) => string,
- *   strStartsWith: (valueSql: string, lowerParamSql: string, upperParamSql: string) => string,
- *   strStartsWithExact: (valueSql: string, patternA: string, patternB: string) => string,
- *   strEndsWith: (valueSql: string, patternA: string, patternB: string, patternC: string) => string,
- *   strContains: (valueSql: string, patternSql: string) => string,
- *   orderNulls: (nullsFirst: boolean) => string,
- *   rowIdentity: () => string,
- *   identityIn: (identitySql: string, paramSqls: string[]) => string,
- *   rtree?: { module: string, columns: readonly string[] },
- *   explainQuery: (sql: string) => string,
- *   excludedRef: (columnSql: string) => string,
- *   tx: { begin: string, beginImmediate: string, commit: string,
- *     rollback: string,
- *     savepoint: (n: string) => string, release: (n: string) => string,
- *     rollbackTo: (n: string) => string },
- *   pragma: { busyTimeout: (ms: number) => string,
- *     journalMode: (mode: string) => string,
- *     foreignKeys: (on: boolean) => string },
- *   introspect: { version: () => string, compileOptions: () => string,
- *     tableExists: () => string, columns: (table: string) => string,
- *     indexes: (table: string) => string,
- *     indexColumns: (index: string) => string,
- *     foreignKeysOn: () => string,
- *     foreignKeyList: (table: string) => string },
- * }} spec
- * @returns {any} the frozen dialect
- */
-export declare function createDialect(spec: {
-    name: string;
-    capabilities: Record<string, any>;
-    tableSuffix: string;
-    docColumnType: string;
-    packedVectorType: string;
-    quoteIdentifier: (s: string) => string;
-    parameterRef: (i: number, name: string) => string;
-    stringLiteral: (s: string) => string;
-    booleanLiteral: (b: boolean) => string;
-    typeFor: (schemaType: string | undefined, hint: string) => string;
-    limitClause: (limit: number, offset?: number) => string;
-    jsonPathText: (segments: JsonPathSegment[]) => string | null;
-    jsonExtract: (columnSql: string, pathText: string) => string;
-    derivedExpression?: (memberSql: string, column: {
-        derive: string;
-        precision?: number;
-        component?: string;
-        dims?: number;
-    }) => string;
-    jsonSet: (exprSql: string, pathText: string, valueSql: string) => string;
-    jsonRemove: (exprSql: string, pathText: string) => string;
-    jsonAppend: (exprSql: string, arrayPathText: string, valueSql: string) => string;
-    jsonEncode: (paramSql: string) => string;
-    jsonText: (columnSql: string) => string;
-    jsonAgg: (exprSql: string) => string;
-    jsonTypeOf: (columnSql: string, pathText: string) => string;
-    valueTypeOf: (paramSql: string) => string;
-    strStartsWith: (valueSql: string, lowerParamSql: string, upperParamSql: string) => string;
-    strStartsWithExact: (valueSql: string, patternA: string, patternB: string) => string;
-    strEndsWith: (valueSql: string, patternA: string, patternB: string, patternC: string) => string;
-    strContains: (valueSql: string, patternSql: string) => string;
-    orderNulls: (nullsFirst: boolean) => string;
-    rowIdentity: () => string;
-    identityIn: (identitySql: string, paramSqls: string[]) => string;
-    rtree?: {
-        module: string;
-        columns: readonly string[];
-    };
-    explainQuery: (sql: string) => string;
-    excludedRef: (columnSql: string) => string;
-    tx: {
-        begin: string;
-        beginImmediate: string;
-        commit: string;
-        rollback: string;
-        savepoint: (n: string) => string;
-        release: (n: string) => string;
-        rollbackTo: (n: string) => string;
-    };
-    pragma: {
-        busyTimeout: (ms: number) => string;
-        journalMode: (mode: string) => string;
-        foreignKeys: (on: boolean) => string;
-    };
-    introspect: {
-        version: () => string;
-        compileOptions: () => string;
-        tableExists: () => string;
-        columns: (table: string) => string;
-        indexes: (table: string) => string;
-        indexColumns: (index: string) => string;
-        foreignKeysOn: () => string;
-        foreignKeyList: (table: string) => string;
-    };
-}): any;

package/dist/types/dialects/sqlite.d.ts

@@ -1,9 +0,0 @@
-/**
- * @file The SQLite dialect — the first spelling of the dialect
- * contract, not the only conceivable one. Documents are stored JSONB
- * in a BLOB column of a STRICT table; indexed paths become virtual
- * generated columns over `jsonb_extract`; reads render back to text
- * through `json()`. Parameters are positional (`?`) because every
- * binding this package ships binds arrays.
- */
-export declare const sqliteDialect: any;

package/dist/types/driver.d.ts

@@ -1,110 +0,0 @@
-/**
- * @file The driver seam: the contract every binding satisfies, the
- * capability probe that runs once at open, and the sync-capable-async
- * helpers the store composes with.
- *
- * A driver is `{ name, dialect, open(path, options) }`; `open` returns
- * a `Connection` or a promise of one. Every connection method may
- * return a value or a promise — the store never assumes either, and
- * composes through {@link chain}, which does not allocate a promise
- * when the driver answered with a value. That is what keeps the public
- * asynchronous surface from paying twice while the synchronous fast
- * path stays exact.
- *
- * The runtime builtin behind a binding is imported LAZILY inside
- * `open()` via {@link lazyOpen} — never at module scope — because the
- * packed-consumer gate imports every export subpath under Node *and*
- * Bun, Bun ships no `node:sqlite`, and Node cannot resolve `bun:`
- * specifiers. `open()` is where "this driver does not exist here"
- * becomes the coded `JD0003` instead of a module-load crash.
- *
- * `capabilities` is read once at open — from the library's version
- * report, its compile options and the binding's declaration — and is
- * the single source of truth for feature gating; never a `typeof`
- * sniff at a call site. Two slots are deliberately EMPTY on every
- * SQLite driver: `statementTimeout` (no interrupt or progress handler
- * exists to build one on) and `rowEstimates` (the query plan is prose,
- * not numbers). They exist so a driver that has the facts can fill
- * them without a contract change; pretending SQLite has them is the
- * silent degradation this suite refuses.
- */
-import { isThenable, chain, toPromise } from '@jarenjs/core/function';
-/** The minimum SQLite the store accepts, asserted at open. */
-export declare const SQLITE_FLOOR = "3.45.0";
-/**
- * How long work may wait for an open transaction to settle before it is
- * rejected with `JD0012`. Matches the store's default busy timeout: the
- * question "has this waited unreasonably long?" has one answer per
- * connection whether the contention is another process (SQLite's own
- * busy timeout) or another transaction on this one.
- */
-export declare const DEFAULT_QUEUE_TIMEOUT = 5000;
-export { isThenable, chain, toPromise };
-/**
- * Compare two dotted version strings numerically.
- * @param {string} a
- * @param {string} b
- * @returns {number} negative when a < b, zero when equal
- */
-export declare function compareVersions(a: string, b: string): number;
-/**
- * Load a runtime builtin lazily and hand it to the binding's adapter.
- * A failed import — the specifier does not exist on this runtime —
- * becomes `JD0003` carrying the loader's error as `cause`.
- * @param {string} specifier - The builtin module specifier
- * @param {string} reason - The `JD0003` reason for this binding
- * @param {(mod: any, ...args: any[]) => any} use - The binding's
- *   module-to-connection adapter (a named export so the suite can
- *   exercise it with a substitute module on any runtime)
- * @param {any[]} args - Extra arguments forwarded to `use`
- * @returns {Promise<any>}
- */
-export declare function lazyOpen(specifier: string, reason: string, use: (mod: any, ...args: any[]) => any, args: any[]): Promise<any>;
-/**
- * Normalize a raw statement to the contract shape. A binding without a
- * native `iterate` gets one composed over `all` — eager, but the same
- * rows in the same order.
- * @param {{ run: Function, get: Function, all: Function,
- *   iterate?: Function }} statement
- * @returns {{ run: Function, get: Function, all: Function,
- *   iterate: Function }}
- */
-export declare function wrapStatement(statement: {
-    run: Function;
-    get: Function;
-    all: Function;
-    iterate?: Function;
-}): {
-    run: Function;
-    get: Function;
-    all: Function;
-    iterate: Function;
-};
-/**
- * Finish a raw binding into the connection contract: probe the library
- * once, assert the version floor, freeze the capability table, and
- * attach the savepoint-nested `transaction`.
- *
- * The raw shape a binding supplies:
- * `{ exec(sql), prepare(sql) -> { run, get, all, iterate? }, close(),
- *   registerFunction?, registerAggregate?, session? }` — every method
- * value-or-promise.
- *
- * @param {any} raw
- * @param {{ dialect: any, synchronous?: boolean, queueTimeout?: number,
- *   declared?: { sessions?: boolean, userFunctions?: boolean,
- *     deterministicIndexableFunctions?: boolean,
- *     aggregateFunctions?: boolean } }} options
- * @returns {any} a Connection, or a promise of one
- */
-export declare function openConnection(raw: any, options: {
-    dialect: any;
-    synchronous?: boolean;
-    queueTimeout?: number;
-    declared?: {
-        sessions?: boolean;
-        userFunctions?: boolean;
-        deterministicIndexableFunctions?: boolean;
-        aggregateFunctions?: boolean;
-    };
-}): any;

package/dist/types/drivers/bun.d.ts

@@ -1,47 +0,0 @@
-/**
- * @file The Bun binding: `bun:sqlite` behind the driver contract. The
- * builtin is imported lazily inside `open()` — never at module scope —
- * so this module itself loads under any runtime; on a runtime that
- * cannot resolve `bun:` specifiers the open fails with the coded
- * `JD0003`.
- *
- * Probed reality this binding declares rather than papers over:
- * `bun:sqlite`'s `Database` exposes no `function`, no `aggregate` and
- * no `createSession` — on Bun the UDF hatch does not exist and there
- * is no session-based change capture. The capability table says so.
- *
- * What it DOES expose is a native lazy row iterator, forwarded below.
- * Without it the driver's generic fallback composes a cursor over
- * `all()`, which materialises every row first — so a query that streams
- * on Node would spike memory in a compiled Bun binary, on the same code
- * and the same data. A cursor that is not lazy is not a cursor.
- */
-/**
- * Adapt an already-constructed `bun:sqlite` `Database` (or any object
- * with its shape) into a probed connection. Exported so the adapter is
- * exercisable without the builtin.
- * @param {any} db - A Bun `Database`-shaped database
- * @param {{ queueTimeout?: number }} [options]
- * @returns {any} a Connection, or a promise of one
- */
-export declare function adaptBunDatabase(db: any, options?: {
-    queueTimeout?: number;
-}): any;
-/**
- * Construct and adapt the database from a loaded `bun:sqlite` module.
- * Exported so the whole open path runs under any runtime with a
- * substitute module.
- * @param {any} mod - The `bun:sqlite` module (or a substitute)
- * @param {string} path
- * @param {{ readOnly?: boolean, queueTimeout?: number }} [options]
- * @returns {any}
- */
-export declare function fromBunModule(mod: any, path: string, options?: {
-    readOnly?: boolean;
-    queueTimeout?: number;
-}): any;
-/**
- * The Bun driver: `{ name, dialect, open }` over `bun:sqlite`.
- * @returns {any}
- */
-export declare function bunDriver(): any;

package/dist/types/drivers/node.d.ts

@@ -1,37 +0,0 @@
-/**
- * @file The Node binding: `node:sqlite` behind the driver contract.
- * The builtin is imported lazily inside `open()` — never at module
- * scope — so this module itself loads under any runtime; on a runtime
- * without `node:sqlite` the open fails with the coded `JD0003`.
- */
-/**
- * Adapt an already-constructed `node:sqlite` `DatabaseSync` (or any
- * object with its shape) into a probed connection. Exported so the
- * adapter is exercisable without the builtin.
- * @param {any} db - A `DatabaseSync`-shaped database
- * @param {{ queueTimeout?: number }} [options]
- * @returns {any} a Connection, or a promise of one
- */
-export declare function adaptNodeDatabase(db: any, options?: {
-    queueTimeout?: number;
-}): any;
-/**
- * Construct and adapt the database from a loaded `node:sqlite` module.
- * The seam {@link nodeDriver} feeds through `lazyOpen`; exported so the
- * whole open path runs under any runtime with a substitute module.
- * @param {any} mod - The `node:sqlite` module (or a substitute)
- * @param {string} path
- * @param {{ timeout?: number, readOnly?: boolean,
- *   queueTimeout?: number }} [options]
- * @returns {any}
- */
-export declare function fromNodeModule(mod: any, path: string, options?: {
-    timeout?: number;
-    readOnly?: boolean;
-    queueTimeout?: number;
-}): any;
-/**
- * The Node driver: `{ name, dialect, open }` over `node:sqlite`.
- * @returns {any}
- */
-export declare function nodeDriver(): any;

package/dist/types/drivers/wasm.d.ts

@@ -1,65 +0,0 @@
-/**
- * @file The wasm binding: an INJECTED handle behind the driver
- * contract. This module imports no runtime builtin at all — the host
- * (a browser, a worker) supplies the SQLite build, and this driver
- * only adapts it. Every handle method may return a value or a promise;
- * a main-thread OPFS-backed build is asynchronous and that is exactly
- * why the public store surface is.
- *
- * The injected contract:
- *
- *   handle = {
- *     open(path, options) -> raw | Promise<raw>,
- *     synchronous?: boolean,           // default false
- *     declares?: { userFunctions?, deterministicIndexableFunctions?,
- *                  sessions? }         // default all false
- *   }
- *   raw = { exec(sql), prepare(sql) -> { run, get, all, iterate? },
- *           close(), registerFunction?, registerAggregate?, session? }
- *
- * Capability truth still comes from the probe: whatever the handle
- * declares is intersected with what the loaded library actually
- * compiled in.
- */
-/**
- * Adapt an already-constructed `sqlite3.oo1` database (the official
- * SQLite wasm build's object API) into the raw contract. The oo1 API
- * is SYNCHRONOUS — wasm SQLite computes in place and the SAH-pool
- * OPFS VFS does synchronous I/O inside a dedicated worker — which is
- * exactly what keeps journal capture, live queries and the job queue
- * working unchanged in a browser.
- *
- * Statements are REUSED by the store's prepared caches: every
- * operation ends in `reset()`, never `finalize()`. oo1 user functions
- * receive a context pointer first — stripped here — and register
- * variadic (`arity: -1`), matching the engine's fragment shapes.
- * @param {any} sqlite3 - the loaded sqlite3 module (for `capi`)
- * @param {any} db - an `sqlite3.oo1.DB`-shaped database
- * @returns {any} the raw binding for {@link openConnection}
- */
-export declare function adaptOo1Database(sqlite3: any, db: any): any;
-/**
- * Build the injected HANDLE from a loaded sqlite3 module — the D6
- * recipe: the host loads the wasm build and picks the database class
- * (`sqlite3.oo1.DB` for `:memory:`, the SAH-pool util's `OpfsSAHPoolDb`
- * for OPFS persistence), and this package only adapts it.
- *
- * `sessions` is deliberately NOT declared even though the canonical
- * wasm build compiles `ENABLE_SESSION`: this adapter does not yet map
- * the session C API, so capture runs in the journal mode — stated in
- * the capability matrix, adapting it is a roadmap item.
- * @param {any} sqlite3 - the loaded sqlite3 module
- * @param {{ DbClass?: any }} [handleOptions] - the database class to
- *   construct (default `sqlite3.oo1.DB`)
- * @returns {any} a handle for {@link wasmDriver}
- */
-export declare function sqlite3Handle(sqlite3: any, handleOptions?: {
-    DbClass?: any;
-}): any;
-/**
- * The wasm driver over an injected handle.
- * @param {any} handle - The host-supplied SQLite handle (see the file
- *   header for the contract)
- * @returns {any}
- */
-export declare function wasmDriver(handle: any): any;