@orkestrel/database 0.0.1 → 0.0.2

package/dist/src/server/compilers.d.ts

@@ -1,169 +0,0 @@
-import type { ColumnType, Condition, Criteria, Order, TableSchema } from '@src/core';
-import type { CompiledSQL } from './types.js';
-/**
- * Escape `\`, `%`, and `_` (each with a leading `\`) so a `starts` / `ends`
- * operand is matched literally under the `LIKE … ESCAPE '\'` clause.
- *
- * @param text - The raw operand text
- * @returns The text with LIKE metacharacters escaped
- *
- * @example
- * ```ts
- * escapeLike('50%_off') // '50\\%\\_off'
- * ```
- */
-export declare function escapeLike(text: string): string;
-/**
- * The declared storage type of a flat (string) column, read from the schema.
- *
- * @param column - The column name
- * @param schema - The table's schema
- * @returns The column's {@link ColumnType}, or `undefined` if the schema does not carry it
- *
- * @example
- * ```ts
- * declaredType('age', schema) // 'integer'
- * ```
- */
-export declare function declaredType(column: string, schema: TableSchema): ColumnType | undefined;
-/**
- * The storage type a nested (`json_extract`) operand encodes as, derived from its
- * RUNTIME value — NOT `json`.
- *
- * @remarks
- * `json_extract` returns the unquoted, natively-typed scalar (a JSON boolean as
- * `1` / `0`, a number as-is, a string as-is), so the operand must encode to that
- * same scalar to compare. A boolean → `'boolean'` (→ `1` / `0`); a number →
- * `'integer'` / `'real'`; a bigint → `'integer'`; a string → `'text'`; `null` /
- * `undefined` → `'text'` (encodes to `null`); an object / array → `'json'` (the
- * edge of comparing against a json subtree).
- *
- * @param value - The runtime operand value
- * @returns The {@link ColumnType} to encode it as
- *
- * @example
- * ```ts
- * valueType(true) // 'boolean'
- * valueType(9) // 'integer'
- * ```
- */
-export declare function valueType(value: unknown): ColumnType;
-/**
- * Compile one condition to its `<column> <operator>` SQL fragment and the params
- * it binds.
- *
- * @remarks
- * Every operand is run through `encodeValue`, so a bound value matches the SQL
- * the column side compiles to. A flat column encodes operands with its DECLARED
- * schema type (a flat `json` column → `JSON.stringify`); a nested `FieldPath`
- * encodes each operand as the NATIVE scalar `json_extract` returns, derived from
- * the operand's runtime type (per-operand, since `between` / `any` / `none` can
- * mix types). `any` / `none` collapse an empty list to a constant (`0` matches
- * nothing, `1` matches all) with no params. A nested field with a null/undefined
- * operand under `equals` / `not` compiles to `IS NULL` / `IS NOT NULL` (no bound
- * param) instead of `= ?` / `!= ?`, matching the engine's treatment of a
- * present-but-null nested value.
- *
- * @param condition - The condition to compile
- * @param schema - The table's schema (for declared column types)
- * @returns The SQL fragment and its bound parameters
- *
- * @example
- * ```ts
- * fragment({ column: 'age', operator: 'above', values: [18], connector: 'and' }, schema)
- * // { sql: '"age" > ?', params: [18] }
- * ```
- */
-export declare function fragment(condition: Condition, schema: TableSchema): CompiledSQL;
-/**
- * Fold the conditions into one WHERE clause, parenthesizing progressively
- * left-to-right so the grouping matches the engine's `matchesCriteria` fold.
- *
- * @remarks
- * The first condition's connector is ignored, per the {@link Condition} types.
- *
- * @param conditions - The conditions to fold
- * @param schema - The table's schema
- * @returns The `WHERE …` clause and its bound parameters, or an empty clause for zero conditions
- *
- * @example
- * ```ts
- * compileWhere([{ column: 'age', operator: 'from', values: [18], connector: 'and' }], schema)
- * // { sql: 'WHERE "age" >= ?', params: [18] }
- * ```
- */
-export declare function compileWhere(conditions: readonly Condition[], schema: TableSchema): CompiledSQL;
-/**
- * Compile the ORDER BY clause from the order terms, always ending with the
- * primary key as the final determinant.
- *
- * @remarks
- * The native `records` read then resolves ties in key order, matching a
- * primary-key-ordered `scan` and the core engine's stable `sortRows` over a
- * key-ordered scan (and IndexedDB's key-ordered reads), so a native read equals
- * the scan path (AGENTS §21 / §22 native ↔ engine parity). SQLite without an
- * `ORDER BY` returns rowid (insertion) order, and an explicit order alone breaks
- * ties by rowid too — both diverge from every key-ordered backend. The
- * tie-breaker is ASCENDING regardless of the explicit directions: the engine's
- * stable sort runs over key-ascending input, so equal rows stay in
- * ascending-key order whichever way the explicit terms point. Skipped when the
- * primary is already an explicit order term (no double-append).
- *
- * @param order - The explicit order terms, or `undefined`
- * @param schema - The table's schema (for the primary key)
- * @returns The `ORDER BY …` clause, or an empty string when there is nothing to order by
- *
- * @example
- * ```ts
- * compileOrder([{ column: 'age', direction: 'descending' }], schema)
- * // 'ORDER BY "age" DESC, "id"'
- * ```
- */
-export declare function compileOrder(order: readonly Order[] | undefined, schema: TableSchema): string;
-/**
- * Compile the LIMIT / OFFSET clause.
- *
- * @remarks
- * An offset without a limit uses `LIMIT -1` (SQLite's "no limit") so OFFSET is
- * still honored.
- *
- * @param limit - The maximum row count, or `undefined`
- * @param offset - The row count to skip, or `undefined`
- * @returns The `LIMIT …` clause and its bound parameters, or an empty clause when neither is set
- *
- * @example
- * ```ts
- * compilePage(undefined, 5) // { sql: 'LIMIT -1 OFFSET ?', params: [5] }
- * ```
- */
-export declare function compilePage(limit: number | undefined, offset: number | undefined): CompiledSQL;
-/**
- * Compile a {@link Criteria} into the SQL clause that follows a table name, with
- * its bound parameters in clause order.
- *
- * @remarks
- * The driver's native `records` / `count` path: it assembles
- * `[where, orderBy, limitOffset]` (each possibly empty) into one clause so a
- * `SELECT * FROM <table> <clause>` runs the whole read in the engine instead of
- * over a JS `scan`. The WHERE fold is parenthesized **left-to-right** to mirror
- * the core engine's `matchesCriteria` (not SQL's native AND-over-OR precedence),
- * so a native and an engine read return identical rows. Each operand is encoded
- * via `encodeValue`: a flat column uses its declared schema type, while a nested
- * `FieldPath` (a `json_extract` read) encodes each operand as the native scalar
- * the extract returns — derived from the operand's runtime type — so it compares.
- * The 15 operators map per the databases guide's operator table, with
- * `starts` / `ends` using `LIKE … ESCAPE '\'` and an empty `any` / `none` list
- * collapsing to a constant. A `undefined` criteria (or one with no parts)
- * compiles to an empty clause.
- *
- * @param criteria - The read specification, or `undefined` for all rows
- * @param schema - The table's schema (column types for operand encoding)
- * @returns The SQL tail and its bound parameters
- *
- * @example
- * ```ts
- * compileCriteria({ conditions: [{ column: 'age', operator: 'from', values: [18], connector: 'and' }] }, schema)
- * // { sql: 'WHERE "age" >= ? ORDER BY "id"', params: [18] }
- * ```
- */
-export declare function compileCriteria(criteria: Criteria | undefined, schema: TableSchema): CompiledSQL;

package/dist/src/server/drivers/JSONDriver.d.ts

@@ -1,106 +0,0 @@
-import type { Criteria, DriverInterface, DriverMeta, Key, Migration, Row, TableSchema, TransactionInterface } from '@src/core';
-/**
- * A persistent {@link DriverInterface} backed by a single JSON file — the
- * reference {@link MemoryDriver} plus file load / flush.
- *
- * @remarks
- * A decorator, not a reimplementation: every primitive delegates to an inner
- * {@link MemoryDriver}, so querying, key-order `scan` / `keys`, and capture-replay
- * `snapshot` are inherited unchanged — this layer adds only persistence. `open`
- * loads the file into memory; every mutation (`write` / `delete` / `clear`) flushes
- * the whole store back. The file is one JSON object, `{ meta?: DriverMeta, tables: {
- * [name]: rows } }` — `meta` is present only once the store has been `stamp`ed
- * (an unstamped store serializes the old `{ tables }` shape, preserving
- * backward compatibility); a per-table array of rows, each row carrying its own
- * primary (the table contract), so the key is recovered on load with
- * {@link extractKey} and the file need not store it. The parsed JSON crosses the
- * boundary as `unknown` and is narrowed with {@link isRecord} / {@link extractKey},
- * never asserted (AGENTS §14): a missing, corrupt, or wrong-shaped file starts
- * empty rather than throwing, and a malformed row (or malformed `meta`) is
- * skipped/dropped rather than thrown on. It is scan-only — it implements none of
- * the optional native `records` / `count` / `aggregate` hooks, so the core engine
- * over `scan` answers every query. For development, small datasets, and portable /
- * inspectable data; for large or concurrent workloads reach for a SQLite-backed
- * driver.
- *
- * A failure in the write path ({@link JSONDriver.#serialize} — `mkdir` /
- * `writeFile` / `rename`) is wrapped and rethrown as `DatabaseError` `DRIVER`,
- * carrying the target `path` in its context; the read path ({@link
- * JSONDriver.#load}) tolerance above is a separate, deliberate contract and is
- * never touched by this wrapping.
- */
-export declare class JSONDriver implements DriverInterface {
-    #private;
-    constructor(path: string);
-    open(schema: readonly TableSchema[]): Promise<void>;
-    close(): Promise<void>;
-    read(table: string, key: Key): Promise<Row | undefined>;
-    write(table: string, key: Key, row: Row): Promise<void>;
-    delete(table: string, key: Key): Promise<boolean>;
-    keys(table: string): Promise<readonly Key[]>;
-    scan(table: string): AsyncIterable<Row>;
-    /**
-     * Natively filtered lazy iteration — delegates to the inner {@link MemoryDriver}.
-     *
-     * @remarks
-     * Semantics are the memory driver's own: `criteria.conditions` filters, `offset`
-     * / `limit` page lazily, and `criteria.order` is ignored (streaming yields key
-     * order; sorted output is `records()`'s job).
-     *
-     * @param table - The table to stream
-     * @param criteria - The filter / offset / limit to apply lazily
-     */
-    stream(table: string, criteria: Criteria): AsyncIterable<Row>;
-    clear(table: string): Promise<void>;
-    /**
-     * Begin a native transaction — flush-coalescing over the inner {@link MemoryDriver}.
-     *
-     * @remarks
-     * Single-writer: throws `DatabaseError` `CONFLICT` if a transaction is already
-     * active — this driver does not support nesting. On begin, captures the inner
-     * memory rollback thunk via `#memory.snapshot()` and suppresses per-mutation
-     * `#flush` — `write` / `delete` / `clear` still mutate memory but no longer
-     * touch the file, so N mutations under the handle cost ONE file write instead
-     * of N. `commit()` releases the suppression and performs that one atomic
-     * `#flush()`, persisting the transaction's net state. `rollback()` restores
-     * memory via the captured snapshot thunk, then `#flush()`s so the file reflects
-     * the restored state. Outside a transaction, behavior is unchanged — every
-     * mutation flushes on its own. Calling `commit` / `rollback` a second time (on
-     * either method, in either order) throws `DatabaseError` `CONFLICT`.
-     *
-     * @returns A {@link TransactionInterface} handle to `commit` or `rollback`
-     */
-    transaction(): Promise<TransactionInterface>;
-    snapshot(tables?: readonly string[]): Promise<() => Promise<void>>;
-    meta(): Promise<DriverMeta | undefined>;
-    /**
-     * Persist `meta` verbatim for a later `meta()` to return.
-     *
-     * @remarks
-     * Respects the same defer-flush suppression as `write` / `delete` / `clear`
-     * (see {@link JSONDriver.transaction} @remarks) — stamping inside an active
-     * transaction updates memory but does not flush until the transaction settles.
-     *
-     * @param meta - The {@link DriverMeta} to persist
-     */
-    stamp(meta: DriverMeta): Promise<void>;
-    /**
-     * Apply a {@link Migration} plan by delegating to the inner {@link MemoryDriver},
-     * then persist the migrated state.
-     *
-     * @remarks
-     * The inner `MemoryDriver.migrate` applies each step (adding/removing tables,
-     * adding/removing columns from stored rows, no-op index steps) and throws
-     * `DatabaseError` `MIGRATION` for a step referencing an unknown table — that
-     * error propagates untouched. `table.add` / `table.remove` steps also update
-     * this driver's own declared `#schema`, mirroring the bookkeeping `open` does,
-     * so a subsequent `#flush` / `#load` round-trip includes (or drops) the table.
-     * A successful migration ends with one atomic `#flush()` so the new state
-     * survives a close and reopen. A multi-step plan applies its steps
-     * sequentially and is NOT atomic — a failure partway through a plan leaves
-     * the earlier steps already applied.
-     *
-     * @param plan - The migration plan to apply
-     */
-    migrate(plan: Migration): Promise<void>;
-}

package/dist/src/server/factories.d.ts

@@ -1,31 +0,0 @@
-import type { DriverInterface } from '@src/core';
-/**
- * Create a persistent JSON-file {@link DriverInterface} for the core database layer.
- *
- * @remarks
- * Pass it to `createDatabase` from `@src/core` to run the whole typed database +
- * relations stack against a single JSON file instead of memory — the `Database` /
- * `Table` / `Query` / relations API is unchanged; only where the bytes live changes.
- * The driver is the reference `MemoryDriver` plus JSON-file persistence: `open` loads
- * the file, every mutation flushes the whole store back, and querying runs through
- * the core engine over `scan` (it is scan-only — no native `records` / `count` /
- * `aggregate`). A missing, corrupt, or wrong-shaped file starts empty rather than
- * throwing.
- *
- * @param path - The JSON file path data is loaded from and flushed to
- * @returns A {@link DriverInterface} backed by a JSON file
- *
- * @example
- * ```ts
- * import { createDatabase } from '@orkestrel/database'
- * import { stringShape } from '@orkestrel/contract'
- * import { createJSONDriver } from '@orkestrel/database/server'
- *
- * const db = createDatabase({
- * 	driver: createJSONDriver('data/app.json'),
- * 	tables: { users: { id: stringShape(), name: stringShape() } },
- * })
- * await db.table('users').set({ id: 'u1', name: 'Ada' }) // persisted to app.json
- * ```
- */
-export declare function createJSONDriver(path: string): DriverInterface;

package/dist/src/server/helpers.d.ts

@@ -1,222 +0,0 @@
-import type { AggregateFunction, ColumnType, Row, TableSchema } from '@src/core';
-import type { FieldPath } from '@orkestrel/contract';
-import type { SQLiteRow, SQLiteValue } from './types.js';
-/**
- * Generate a fresh unique key — a v4 UUID string, backed by `node:crypto`.
- *
- * @remarks
- * Supply this as {@link import('@src/core').DatabaseOptions.key} so a table mints
- * a key when a written row lacks its primary-key value. Strings work as keys on
- * every backend; supply your own key values directly to use numeric keys instead.
- *
- * @returns A new UUID string
- *
- * @example
- * ```ts
- * const db = createDatabase({ driver, tables, key: generateKey })
- * ```
- */
-export declare function generateKey(): string;
-/**
- * Map a portable {@link ColumnType} to its SQLite column type.
- *
- * @remarks
- * `text` / `json` → `TEXT` (JSON is stored as text and read back with
- * `json_extract` for nested-field queries); `integer` / `boolean` → `INTEGER`
- * (a boolean stores `1` / `0`); `real` → `REAL`; `blob` → `BLOB`. No `NOT NULL`
- * is ever emitted — the contract validates required-ness; the database is just
- * storage (AGENTS §14, the typed layer above imposes the shape).
- *
- * @param type - The portable column type
- * @returns The SQLite column type keyword
- *
- * @example
- * ```ts
- * columnSQL('integer') // 'INTEGER'
- * columnSQL('json') // 'TEXT'
- * ```
- */
-export declare function columnSQL(type: ColumnType): string;
-/**
- * Quote a SQL identifier (a table or column name) so any characters are literal.
- *
- * @remarks
- * Wraps the name in double quotes and doubles any embedded quote — the standard
- * SQL identifier-quoting that lets a column named `order` or `from` be referenced
- * safely. Identifiers cannot be bound as parameters, so they are quoted instead.
- *
- * @param identifier - The raw identifier
- * @returns The double-quoted identifier
- *
- * @example
- * ```ts
- * quote('order') // '"order"'
- * ```
- */
-export declare function quote(identifier: string): string;
-/**
- * Compile a {@link FieldPath} to the SQL expression that reads it.
- *
- * @remarks
- * A single string is ONE column — `quote(path)`. An array descends a JSON column:
- * the first element is the (quoted) column, the rest a `json_extract` path
- * (`json_extract("payload", '$.user.id')`), matching the guide's nested-field
- * examples (simple identifier keys). The string's value is never split on `.`
- * (AGENTS — `FieldPath` semantics): a dotted string is one column literally.
- *
- * @param path - The field path (a column, or a column + nested keys)
- * @returns The SQL expression selecting the value
- *
- * @example
- * ```ts
- * fieldColumn('payload') // '"payload"'
- * fieldColumn(['payload', 'user', 'id']) // 'json_extract("payload", \'$.user.id\')'
- * ```
- */
-export declare function fieldColumn(path: FieldPath): string;
-/**
- * Compile an {@link AggregateFunction} over a {@link FieldPath} to its SQL
- * aggregate expression — the SELECT body the SQLite driver's native `aggregate`
- * runs.
- *
- * @remarks
- * `count` → `COUNT(*)` (counting all matched ROWS, not non-null column values —
- * mirroring the engine's `computeAggregate('count')`, which is `rows.length`); the
- * numeric aggregates wrap the column's read expression (a flat column, or a nested
- * `json_extract` path) in `SUM` / `AVG` / `MIN` / `MAX`. Over zero matched rows
- * `COUNT(*)` is `0` and the numeric aggregates are SQL `NULL` (→ `undefined`),
- * matching the engine.
- *
- * @param operation - The aggregate to compute
- * @param column - The column (or nested path) to aggregate
- * @returns The SQL aggregate expression
- *
- * @example
- * ```ts
- * aggregateSQL('count', 'age') // 'COUNT(*)'
- * aggregateSQL('sum', 'age') // 'SUM("age")'
- * aggregateSQL('average', ['payload', 'score']) // 'AVG(json_extract("payload", \'$.score\'))'
- * ```
- */
-export declare function aggregateSQL(operation: AggregateFunction, column: FieldPath): string;
-/**
- * Encode a JS value to its stored {@link SQLiteValue} for a column's type.
- *
- * @remarks
- * The forward half of the bridge, total (AGENTS §14): a value that does not fit
- * its column's storage type encodes to `null` rather than throwing. A `boolean`
- * column stores `1` / `0` (and `null` / `undefined` → `null`); a `json` column
- * stores `JSON.stringify` (or `null` for `null` / `undefined`); `integer` /
- * `real` keep a `number` / `bigint`, else `null`; `text` keeps a `string`, else
- * `null`; `blob` keeps a `Uint8Array`, else `null`. Narrowed with `typeof` /
- * `instanceof`, never `as`.
- *
- * @param value - The JS value to store
- * @param type - The column's portable storage type
- * @returns The value SQLite stores
- *
- * @example
- * ```ts
- * encodeValue(true, 'boolean') // 1
- * encodeValue({ a: 1 }, 'json') // '{"a":1}'
- * ```
- */
-export declare function encodeValue(value: unknown, type: ColumnType): SQLiteValue;
-/**
- * Decode a stored {@link SQLiteValue} back to its JS value for a column's type —
- * the exact inverse of {@link encodeValue}.
- *
- * @remarks
- * A `boolean` column reads `1` / `0` back to `true` / `false` (a stored `null`
- * → `undefined`); a `json` column `JSON.parse`s a string (anything else →
- * `undefined`); every other type passes the value through, mapping a stored
- * `NULL` to `undefined`. NULL decodes to `undefined` so {@link decodeRow} can
- * omit absent columns.
- *
- * @param value - The stored SQLite value
- * @param type - The column's portable storage type
- * @returns The decoded JS value (`undefined` for a stored `NULL`)
- *
- * @example
- * ```ts
- * decodeValue(1, 'boolean') // true
- * decodeValue('{"a":1}', 'json') // { a: 1 }
- * ```
- */
-export declare function decodeValue(value: SQLiteValue, type: ColumnType): unknown;
-/**
- * Encode a whole {@link Row} to a {@link SQLiteRow} by its table's schema.
- *
- * @remarks
- * Encodes each declared column's value with {@link encodeValue}; columns the row
- * does not carry encode from `undefined` (so they store `null`). Only the
- * schema's columns appear in the result — an extra row key is dropped.
- *
- * @param row - The JS row to store
- * @param schema - The table's schema
- * @returns The storable SQLite row
- *
- * @example
- * ```ts
- * encodeRow({ id: 'u1', active: true }, schema) // { id: 'u1', active: 1, ... }
- * ```
- */
-export declare function encodeRow(row: Row, schema: TableSchema): SQLiteRow;
-/**
- * Decode a stored {@link SQLiteRow} back to a {@link Row} by its table's schema.
- *
- * @remarks
- * Decodes each declared column with {@link decodeValue} and **omits** any column
- * whose decoded value is `undefined` — so an absent / `NULL` optional column does
- * not surface as `{ bio: undefined }`, matching how the contract's optional
- * columns expect absence. A known, documented edge: a non-optional `nullableShape`
- * column storing `null` round-trips to absent (a `null` cell decodes to
- * `undefined`, and an `undefined` value is omitted).
- *
- * @param row - The stored SQLite row
- * @param schema - The table's schema
- * @returns The decoded JS row (absent columns omitted)
- *
- * @example
- * ```ts
- * decodeRow({ id: 'u1', active: 1, bio: null }, schema) // { id: 'u1', active: true }
- * ```
- */
-export declare function decodeRow(row: SQLiteRow, schema: TableSchema): Row;
-/**
- * Project a {@link TableSchema} to the `CREATE TABLE IF NOT EXISTS` statement a
- * SQLite driver's `open` issues for it.
- *
- * @remarks
- * Each column compiles to `<quoted name> <columnSQL(type)>`; the statement ends
- * with `PRIMARY KEY (<quoted primary>)`. No `NOT NULL` is emitted — the contract
- * validates required-ness, the database is just storage (AGENTS §14).
- *
- * @param schema - The table's schema
- * @returns The `CREATE TABLE IF NOT EXISTS …` statement
- *
- * @example
- * ```ts
- * schemaToTable(schema)
- * // 'CREATE TABLE IF NOT EXISTS "users" ("id" TEXT, "age" INTEGER, PRIMARY KEY ("id"))'
- * ```
- */
-export declare function schemaToTable(schema: TableSchema): string;
-/**
- * Project a {@link TableSchema} to the `CREATE INDEX IF NOT EXISTS` statements a
- * SQLite driver's `open` issues for its declared indexes.
- *
- * @remarks
- * One statement per index group; the index name is `idx_<table>_<columns joined
- * by _>`, matching the driver's naming so a repeated `open` is idempotent.
- *
- * @param schema - The table's schema
- * @returns One `CREATE INDEX IF NOT EXISTS …` statement per declared index
- *
- * @example
- * ```ts
- * schemaToIndexes(schema)
- * // ['CREATE INDEX IF NOT EXISTS "idx_users_name" ON "users" ("name")']
- * ```
- */
-export declare function schemaToIndexes(schema: TableSchema): readonly string[];

package/dist/src/server/types.d.ts

@@ -1,36 +0,0 @@
-/**
- * The value domain a SQLite binding accepts as a bound parameter and returns
- * from a row.
- *
- * @remarks
- * Mirrors SQLite's storage classes (`NULL`, `INTEGER`, `REAL`, `TEXT`, `BLOB`)
- * at the TypeScript boundary: `null`, `number` / `bigint` for integer and
- * floating-point values, `string` for text, and `Uint8Array` for blobs. This
- * type is pure — it names the shape a value must have to cross the binding,
- * independent of any concrete sqlite package (`node:sqlite`, `better-sqlite3`,
- * etc.), so a driver can encode/decode against it without importing one.
- */
-export type SQLiteValue = null | number | bigint | string | Uint8Array;
-/**
- * One row as a SQLite binding returns it — a plain object keyed by column name.
- *
- * @remarks
- * Every column value is a {@link SQLiteValue}. The SQLite driver decodes each
- * raw row into this shape before handing it to the core query engine; nothing
- * above the driver ever sees SQLite's native row representation directly.
- */
-export type SQLiteRow = Record<string, SQLiteValue>;
-/**
- * A parameterized SQL fragment or statement plus its bind values.
- *
- * @remarks
- * Produced by the pure SQL compilers (`compilers.ts`) that turn a core
- * `Criteria` (or a table definition) into SQL text with `?` placeholders, and
- * consumed by the SQLite driver, which runs `sql` with `params` bound in
- * order — no further assembly. Keeping `sql` and `params` together prevents
- * the two from drifting apart across compile and execute.
- */
-export interface CompiledSQL {
-    readonly sql: string;
-    readonly params: readonly SQLiteValue[];
-}