@crvouga/sqlite-mem 0.1.0 → 1.0.0

package/compat/requirements.json

@@ -1,5 +1,5 @@
 {
-  "generatedAt": "2026-08-17T20:01:39.525Z",
+  "generatedAt": "2026-08-18T15:54:12.225Z",
   "sourceUrl": "https://www.sqlite.org/requirements.html",
   "count": 3487,
   "requirements": [

package/dist/api/database.d.ts

@@ -1,26 +1,111 @@
-import { type Clock, type DatabaseOptions, Prng } from "../runtime/index.ts";
-import { DatabaseState } from "../storage/database-state.ts";
-import { TransactionManager } from "../transactions/manager.ts";
-import { Statement } from "./statement.ts";
+import { type DatabaseOptions } from "../runtime/index.js";
+import type { BindValue, QueryRow } from "../types/value.js";
+import { Statement } from "./statement.js";
+/**
+ * Pure TypeScript in-memory SQLite database.
+ *
+ * Deterministic by default: `random()` / `randomblob()` use a seeded PRNG
+ * (`seed` defaults to `1`) and `date('now')` / friends use a fixed clock
+ * (`2000-01-01T00:00:00.000Z`). There is no filesystem or WASM.
+ *
+ * @example
+ * ```ts
+ * import { Database } from "@crvouga/sqlite-mem";
+ *
+ * const db = new Database();
+ * db.exec("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT NOT NULL)");
+ * db.prepare("INSERT INTO users (name) VALUES (?)").run("Alice");
+ * const users = db.query<{ id: number; name: string }>("SELECT * FROM users");
+ * ```
+ */
 export declare class Database {
-    readonly state: DatabaseState;
+    /** Seed used to construct the PRNG. */
     readonly seed: number | bigint;
-    readonly prng: Prng;
-    now: Clock;
-    readonly transactions: TransactionManager;
     private closed;
     private transactionSequence;
+    /** Depth of active {@link transaction} callbacks (not SQL BEGIN). */
+    private apiTransactionDepth;
+    /**
+     * Create an empty in-memory database.
+     *
+     * @param options - Determinism knobs. See {@link DatabaseOptions}.
+     */
     constructor(options?: DatabaseOptions);
-    exec(sql: string, params?: unknown[]): void;
-    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): T[];
+    /**
+     * Execute SQL for its side effects (DDL/DML). Multiple statements are allowed.
+     *
+     * Does not accept bind parameters — use {@link prepare} or {@link query}.
+     *
+     * @param sql - SQL to run (semicolon-separated statements are ok).
+     * @throws {SqliteError} If the database is closed, extra arguments are passed, or the SQL fails.
+     */
+    exec(sql: string): void;
+    /**
+     * Execute a single-statement query and return all rows as objects keyed by column name.
+     *
+     * @typeParam T - Row shape. Defaults to {@link QueryRow}.
+     * @param sql - A single SQL statement (trailing `;` is fine).
+     * @param params - Bound parameters for `?` / `:name` placeholders.
+     * @returns All result rows.
+     * @throws {SqliteError} If the database is closed, `sql` is not a single statement, or execution fails.
+     */
+    query<T = QueryRow>(sql: string, params?: readonly BindValue[]): T[];
+    /**
+     * Compile a single SQL statement into a reusable {@link Statement}.
+     *
+     * @param sql - A single SQL statement (trailing `;` is fine). Multi-statement scripts are rejected.
+     * @throws {SqliteError} If the database is closed or `sql` cannot be prepared as one statement.
+     */
     prepare(sql: string): Statement;
+    /**
+     * Run `fn` inside a transaction. Commits on success; rolls back if `fn` throws.
+     *
+     * Nested calls use SAVEPOINTs so an inner failure does not abort the outer
+     * transaction. Calling {@link close} from inside `fn` throws `misuse`.
+     *
+     * @param fn - Work to run while the transaction is open.
+     * @returns The value returned by `fn`.
+     * @throws {SqliteError} If the database is closed. Re-throws whatever `fn` throws after rollback.
+     */
     transaction<T>(fn: () => T): T;
+    /**
+     * Serialize schema, rows, PRNG state, and clock into a custom snapshot blob.
+     *
+     * This is not a `.sqlite` file. Restore it with {@link restore}.
+     *
+     * @throws {SqliteError} If the database is closed.
+     */
     snapshot(): Uint8Array;
+    /**
+     * Replace this database's contents with a blob from {@link snapshot}.
+     *
+     * Restores PRNG state and the clock when the snapshot includes them (v2).
+     * Newer library versions can restore older snapshots; older libraries cannot
+     * restore newer format versions.
+     *
+     * @param snapshot - Bytes previously returned by {@link snapshot}.
+     * @throws {SqliteError} If the database is closed, a transaction is open, or the blob is invalid.
+     */
     restore(snapshot: Uint8Array): void;
+    /**
+     * Close the database. Further SQL throws {@link SqliteError}. Idempotent.
+     *
+     * Rolls back an open SQL transaction, if any. Throws if called from inside
+     * a {@link transaction} callback.
+     */
     close(): void;
+    /**
+     * Rows changed by the most recent INSERT / UPDATE / DELETE (SQLite `changes()`).
+     *
+     * @throws {SqliteError} If the database is closed.
+     */
     get changes(): number;
+    /**
+     * Rowid of the most recent INSERT (SQLite `last_insert_rowid()`).
+     *
+     * @throws {SqliteError} If the database is closed.
+     */
     get lastInsertRowid(): number | bigint;
-    assertOpen(): void;
+    private prepareSingle;
 }
 export type { DatabaseOptions };
-//# sourceMappingURL=database.d.ts.map

package/dist/api/statement.d.ts

@@ -1,27 +1,74 @@
-import type { Statement as AstStatement } from "../ast/nodes.ts";
-import { ExecutionEnv } from "../executor/env.ts";
-import type { ResultSet } from "../executor/result.ts";
-import type { Database } from "./database.ts";
+import type { ResultSet } from "../executor/result.js";
+import type { BindValue, QueryRow } from "../types/value.js";
+/** Mutation counters returned by {@link Statement.run}. */
+export interface RunResult {
+    /** Rows changed by this execution (SQLite `changes()`). */
+    changes: number;
+    /** Rowid of the most recent INSERT in this execution. */
+    lastInsertRowid: number | bigint;
+}
+/**
+ * Prepared SQL statement bound to a {@link Database}.
+ *
+ * Create with {@link Database.prepare}. Pass bind values as rest arguments to
+ * {@link run}, {@link all}, {@link get}, or {@link result} on each call
+ * (stateless — there is no sticky `bind()`).
+ *
+ * @example
+ * ```ts
+ * import { Database } from "@crvouga/sqlite-mem";
+ *
+ * const db = new Database();
+ * db.exec("CREATE TABLE t (id INTEGER PRIMARY KEY, name TEXT)");
+ * const insert = db.prepare("INSERT INTO t (name) VALUES (?)");
+ * insert.run("Ada");
+ * const row = db.prepare("SELECT id, name FROM t WHERE id = ?").get<{ id: number; name: string }>(1);
+ * ```
+ */
 export declare class Statement {
     private readonly database;
     private readonly sql;
-    private readonly statements;
-    private bound;
     private namedPlan;
     private env;
-    constructor(database: Database, sql: string, statements: AstStatement[]);
-    bind(...params: unknown[]): Statement;
-    run(...params: unknown[]): {
-        changes: number;
-        lastInsertRowid: number | bigint;
-    };
-    all<T>(...params: unknown[]): T[];
-    /** Full result including column names (needed for empty result-set metadata). */
-    result(...params: unknown[]): ResultSet;
-    get<T>(...params: unknown[]): T | undefined;
+    private statements;
+    private schemaVersion;
+    private constructor();
+    /**
+     * Execute for side effects (INSERT / UPDATE / DELETE / DDL).
+     *
+     * @param params - Bind values for this call only.
+     * @returns Mutation counters for this execution.
+     * @throws {SqliteError} If the database is closed, the statement is empty, or execution fails.
+     */
+    run(...params: BindValue[]): RunResult;
+    /**
+     * Execute and return every result row as an object keyed by column name.
+     *
+     * @typeParam T - Row shape. Defaults to {@link QueryRow}.
+     * @param params - Bind values for this call only.
+     * @throws {SqliteError} If the database is closed, the statement is empty, or execution fails.
+     */
+    all<T = QueryRow>(...params: BindValue[]): T[];
+    /**
+     * Execute and return the full {@link ResultSet}, including column names.
+     *
+     * Use this when you need metadata for an empty result (column names with zero rows).
+     * {@link all} only returns row objects.
+     *
+     * @param params - Bind values for this call only.
+     * @throws {SqliteError} If the database is closed, the statement is empty, or execution fails.
+     */
+    result(...params: BindValue[]): ResultSet;
+    /**
+     * Execute and return the first row, or `undefined` if there are no rows.
+     *
+     * @typeParam T - Row shape. Defaults to {@link QueryRow}.
+     * @param params - Bind values for this call only.
+     * @throws {SqliteError} If the database is closed, the statement is empty, or execution fails.
+     */
+    get<T = QueryRow>(...params: BindValue[]): T | undefined;
     private execute;
     private obtainEnv;
+    private reprepareIfSchemaChanged;
     private bindNamed;
 }
-export declare function bindNamedParameters(env: ExecutionEnv, sql: string, params: readonly unknown[]): void;
-//# sourceMappingURL=statement.d.ts.map

package/dist/ast/nodes.d.ts

@@ -1,6 +1,7 @@
-import type { SqlValue } from "../types/value.ts";
+import type { SqlValue } from "../types/value.js";
 export type BinaryOp = "+" | "-" | "*" | "/" | "%" | "||" | "=" | "==" | "!=" | "<>" | "<" | "<=" | ">" | ">=" | "AND" | "OR" | "IS" | "IS NOT" | "IS DISTINCT FROM" | "IS NOT DISTINCT FROM" | "LIKE" | "NOT LIKE" | "GLOB" | "NOT GLOB" | "IN" | "NOT IN" | "MATCH" | "->" | "->>" | "&" | "|" | "<<" | ">>";
 export type UnaryOp = "+" | "-" | "~" | "NOT";
+/** Parsed SQL expression AST (literals, operators, functions, subqueries, …). */
 export type Expr = LiteralExpr | NullExpr | ColumnRefExpr | UnaryExpr | BinaryExpr | BetweenExpr | InExpr | LikeExpr | FunctionExpr | AggregateExpr | WindowExpr | CaseExpr | CastExpr | ExistsExpr | SubqueryExpr | ParameterExpr | RowExpr | CollateExpr;
 export interface LiteralExpr {
     type: "literal";
@@ -78,6 +79,7 @@ export interface FrameSpec {
     type: "ROWS" | "RANGE" | "GROUPS";
     start: FrameBound;
     end: FrameBound;
+    exclude: "no_others" | "current_row" | "group" | "ties" | null;
 }
 export type FrameBound = {
     kind: "unbounded_preceding";
@@ -231,6 +233,7 @@ export interface InsertStmt {
 }
 export interface UpsertClause {
     targetColumns: string[] | null;
+    targetExprs: Expr[] | null;
     targetWhere: Expr | null;
     action: "nothing" | {
         set: SetItem[];
@@ -269,6 +272,7 @@ export interface CreateTableStmt {
     constraints: TableConstraint[];
     asSelect: SelectStmt | null;
     withoutRowid: boolean;
+    strict: boolean;
 }
 export interface ColumnDef {
     name: string;
@@ -301,6 +305,8 @@ export type ColumnConstraint = {
     columns: string[] | null;
     onDelete: FkAction | null;
     onUpdate: FkAction | null;
+    deferrable: boolean;
+    initiallyDeferred: boolean;
 } | {
     type: "generated";
     expr: Expr;
@@ -327,11 +333,15 @@ export type TableConstraint = {
     onDelete: FkAction | null;
     onUpdate: FkAction | null;
     name: string | null;
+    deferrable: boolean;
+    initiallyDeferred: boolean;
 };
 export interface IndexedColumn {
     name: string;
     collate: string | null;
     order: "ASC" | "DESC" | null;
+    /** Present when the index key is an expression rather than a bare column. */
+    expr?: Expr | null;
 }
 export type ConflictAction = "ROLLBACK" | "ABORT" | "FAIL" | "IGNORE" | "REPLACE";
 export type FkAction = "SET NULL" | "SET DEFAULT" | "CASCADE" | "RESTRICT" | "NO ACTION";
@@ -448,4 +458,3 @@ export interface ExplainStmt {
     queryPlan: boolean;
     statement: Statement;
 }
-//# sourceMappingURL=nodes.d.ts.map

package/dist/constraints/check.d.ts

@@ -1,12 +1,11 @@
-import type { Expr } from "../ast/nodes.ts";
-import type { IndexStore } from "../indexes/index.ts";
-import type { Row, Rowid } from "../storage/row.ts";
-import type { ColumnInfo, Table } from "../storage/table.ts";
-import type { SqlValue } from "../types/value.ts";
+import type { Expr } from "../ast/nodes.js";
+import type { IndexStore } from "../indexes/index.js";
+import type { Row, Rowid } from "../storage/row.js";
+import type { ColumnInfo, Table } from "../storage/table.js";
+import type { SqlValue } from "../types/value.js";
 export type CheckEvaluator = (expr: Expr, row: Row) => SqlValue;
 export declare function checkNotNull(columns: readonly ColumnInfo[], row: Row, tableName?: string): void;
 export declare function checkPrimaryKey(columns: readonly ColumnInfo[], row: Row, tableName?: string): void;
 export declare function checkUnique(index: IndexStore, values: readonly SqlValue[], rowid?: Rowid): void;
 export declare function checkExpressions(expressions: readonly Expr[], row: Row, evaluate: CheckEvaluator, constraintName?: string): void;
 export declare function checkTableConstraints(table: Table, row: Row, evaluate: CheckEvaluator): void;
-//# sourceMappingURL=check.d.ts.map

package/dist/errors/index.d.ts

@@ -1,7 +1,41 @@
-export type ErrorCategory = "syntax" | "no_such_table" | "no_such_column" | "constraint_unique" | "constraint_primary" | "constraint_notnull" | "constraint_check" | "constraint_foreign" | "constraint" | "transaction" | "datatype_mismatch" | "unsupported" | "misuse" | "other";
+/** Coarse classification of {@link SqliteError} for catch-site branching.
+ *
+ * New categories may be added in minor releases. Consumers that switch on
+ * `category` must include a default case.
+ */
+export type ErrorCategory = "syntax" | "no_such_table" | "no_such_column" | "constraint_unique" | "constraint_primary" | "constraint_notnull" | "constraint_check" | "constraint_foreign" | "constraint" | "transaction" | "datatype_mismatch" | "unsupported" | "misuse" | "snapshot_version" | "other" | (string & {});
+/**
+ * Engine error. `name` is always `"SqliteError"`.
+ *
+ * `sqliteCode` and Node's conventional `code` property are always set (default
+ * `"SQLITE_ERROR"` when no more specific code applies).
+ *
+ * @example
+ * ```ts
+ * import { Database, SqliteError } from "@crvouga/sqlite-mem";
+ *
+ * const db = new Database();
+ * try {
+ *   db.exec("SELECT * FROM missing");
+ * } catch (err) {
+ *   if (err instanceof SqliteError && err.category === "no_such_table") {
+ *     // handle
+ *   }
+ * }
+ * ```
+ */
 export declare class SqliteError extends Error {
+    /** Coarse error class (constraint vs syntax vs missing object, …). */
     readonly category: ErrorCategory;
-    readonly sqliteCode?: string;
+    /** SQLite result-code name such as `SQLITE_CONSTRAINT_UNIQUE`. */
+    readonly sqliteCode: string;
+    /** Same value as {@link sqliteCode} (Node `err.code` convention). */
+    readonly code: string;
+    /**
+     * @param message - Human-readable error text.
+     * @param category - Coarse class; defaults to `"other"`.
+     * @param sqliteCode - SQLite result-code name; defaults to `"SQLITE_ERROR"`.
+     */
     constructor(message: string, category?: ErrorCategory, sqliteCode?: string);
 }
 export declare function unsupported(feature: string): never;
@@ -9,4 +43,3 @@ export declare class TriggerRaiseError extends SqliteError {
     readonly action: "IGNORE" | "ABORT" | "FAIL" | "ROLLBACK";
     constructor(action: "IGNORE" | "ABORT" | "FAIL" | "ROLLBACK", message?: string);
 }
-//# sourceMappingURL=index.d.ts.map

package/dist/executor/attach.d.ts

@@ -1,6 +1,5 @@
-import type { AttachStmt, DetachStmt } from "../ast/nodes.ts";
-import type { ExecutionEnv } from "./env.ts";
-import { type ResultSet } from "./result.ts";
+import type { AttachStmt, DetachStmt } from "../ast/nodes.js";
+import type { ExecutionEnv } from "./env.js";
+import { type ResultSet } from "./result.js";
 export declare function executeAttach(stmt: AttachStmt, env: ExecutionEnv): ResultSet;
 export declare function executeDetach(stmt: DetachStmt, env: ExecutionEnv): ResultSet;
-//# sourceMappingURL=attach.d.ts.map

package/dist/executor/ddl.d.ts

@@ -1,6 +1,6 @@
-import type { AlterTableStmt, CreateIndexStmt, CreateTableStmt, CreateViewStmt, DropIndexStmt, DropTableStmt, DropViewStmt } from "../ast/nodes.ts";
-import type { ExecutionEnv } from "./env.ts";
-import { type ResultSet } from "./result.ts";
+import type { AlterTableStmt, CreateIndexStmt, CreateTableStmt, CreateViewStmt, DropIndexStmt, DropTableStmt, DropViewStmt } from "../ast/nodes.js";
+import type { ExecutionEnv } from "./env.js";
+import { type ResultSet } from "./result.js";
 export declare function executeCreateTable(stmt: CreateTableStmt, env: ExecutionEnv): ResultSet;
 export declare function executeCreateIndex(stmt: CreateIndexStmt, env: ExecutionEnv): ResultSet;
 export declare function executeAlterTable(stmt: AlterTableStmt, env: ExecutionEnv): ResultSet;
@@ -8,4 +8,3 @@ export declare function executeDropTable(stmt: DropTableStmt, env: ExecutionEnv)
 export declare function executeDropIndex(stmt: DropIndexStmt, env: ExecutionEnv): ResultSet;
 export declare function executeCreateView(stmt: CreateViewStmt, env: ExecutionEnv): ResultSet;
 export declare function executeDropView(stmt: DropViewStmt, env: ExecutionEnv): ResultSet;
-//# sourceMappingURL=ddl.d.ts.map

package/dist/executor/dml.d.ts

@@ -1,7 +1,7 @@
-import type { DeleteStmt, InsertStmt, UpdateStmt } from "../ast/nodes.ts";
-import type { ExecutionEnv } from "./env.ts";
-import { type ResultSet } from "./result.ts";
+import type { DeleteStmt, InsertStmt, UpdateStmt } from "../ast/nodes.js";
+import type { ExecutionEnv } from "./env.js";
+import { type ResultSet } from "./result.js";
 export declare function executeInsert(stmt: InsertStmt, env: ExecutionEnv): ResultSet;
 export declare function executeUpdate(stmt: UpdateStmt, env: ExecutionEnv): ResultSet;
 export declare function executeDelete(stmt: DeleteStmt, env: ExecutionEnv): ResultSet;
-//# sourceMappingURL=dml.d.ts.map
+export declare function checkDeferredForeignKeys(env: ExecutionEnv): void;

package/dist/executor/env.d.ts

@@ -1,12 +1,11 @@
-import type { SelectStmt } from "../ast/nodes.ts";
-import type { EvalContext } from "../expressions/context.ts";
-import { type FunctionRegistry } from "../functions/registry.ts";
-import type { DatabaseState } from "../storage/database-state.ts";
-import type { Rowid } from "../storage/row.ts";
-import type { TransactionManager } from "../transactions/manager.ts";
-import type { SqlValue } from "../types/value.ts";
-import { type Affinity } from "../types/value.ts";
-import type { ResultSet } from "./result.ts";
+import type { SelectStmt } from "../ast/nodes.js";
+import type { EvalContext } from "../expressions/context.js";
+import { type FunctionRegistry } from "../functions/registry.js";
+import type { DatabaseState } from "../storage/database-state.js";
+import type { Rowid } from "../storage/row.js";
+import type { TransactionManager } from "../transactions/manager.js";
+import type { ResultSet } from "./result.js";
+import { type Affinity, type SqlValue } from "../types/value.js";
 export interface Cell {
     table: string | null;
     tableLower?: string | null;
@@ -26,7 +25,7 @@ export interface ScopeRow {
     rowidName?: string;
     sourceTable?: string;
     /** Set when WHERE MATCH succeeds for this row. */
-    ftsMatch?: import("../vtable/fts5.ts").FtsMatchCursor | null;
+    ftsMatch?: import("../vtable/fts5.js").FtsMatchCursor | null;
 }
 export type SelectRunner = (stmt: SelectStmt, env: ExecutionEnv, parent?: EvalContext) => ResultSet;
 export interface ExecutionHooks {
@@ -59,4 +58,3 @@ export declare class ExecutionEnv {
     createEvalContext(row?: ScopeRow | null, parent?: EvalContext): EvalContext;
 }
 export declare function toSqlValue(value: unknown): SqlValue;
-//# sourceMappingURL=env.d.ts.map

package/dist/executor/execute.d.ts

@@ -1,5 +1,4 @@
-import type { Statement } from "../ast/nodes.ts";
-import type { ExecutionEnv } from "./env.ts";
-import { type ResultSet } from "./result.ts";
+import type { Statement } from "../ast/nodes.js";
+import type { ExecutionEnv } from "./env.js";
+import { type ResultSet } from "./result.js";
 export declare function executeStatement(stmt: Statement, env: ExecutionEnv): ResultSet;
-//# sourceMappingURL=execute.d.ts.map

package/dist/executor/pragma.d.ts

@@ -1,5 +1,4 @@
-import type { Expr } from "../ast/nodes.ts";
-import type { ExecutionEnv } from "./env.ts";
-import { type ResultSet } from "./result.ts";
+import type { Expr } from "../ast/nodes.js";
+import type { ExecutionEnv } from "./env.js";
+import { type ResultSet } from "./result.js";
 export declare function executePragma(name: string, expr: Expr | null, env: ExecutionEnv): ResultSet;
-//# sourceMappingURL=pragma.d.ts.map

package/dist/executor/result.d.ts

@@ -1,18 +1,22 @@
-import { type SqlValue } from "../types/value.ts";
+import { type QueryRow, type QueryValue, type SqlValue } from "../types/value.js";
+/** Query result returned by {@link Statement.result}. */
 export interface ResultSet {
+    /** Result-column names, in SELECT order. Present even when `rows` is empty. */
     columns: string[];
-    rows: Record<string, SqlValue>[];
-    /** Positional rows preserve duplicate result-column names for internal use. */
-    values?: SqlValue[][];
+    /** Named rows. Duplicate column names keep the last value. */
+    rows: QueryRow[];
+    /** Positional rows; always present (empty array when there are zero rows). */
+    values: QueryValue[][];
+    /** Rows changed by the most recent mutating statement in this execution. */
     changes: number;
+    /** Rowid of the most recent INSERT in this execution. */
     lastInsertRowid: number | bigint;
 }
 export declare function emptyResult(changes?: number, lastInsertRowid?: number | bigint): ResultSet;
 /** Export engine values to the public JS surface (SqlReal → number, SqlJsonText → string). */
-export declare function exportSqlValue(value: SqlValue): SqlValue;
+export declare function exportSqlValue(value: SqlValue): QueryValue;
 export declare function valuesToResult(columns: string[], values: SqlValue[][], changes?: number, lastInsertRowid?: number | bigint, options?: {
     named?: boolean;
     keepValues?: boolean;
 }): ResultSet;
 export declare function resultValues(result: ResultSet): SqlValue[][];
-//# sourceMappingURL=result.d.ts.map

package/dist/executor/select.d.ts

@@ -1,7 +1,6 @@
-import type { FromItem, SelectStmt } from "../ast/nodes.ts";
-import type { EvalContext } from "../expressions/context.ts";
-import type { ExecutionEnv, ScopeRow } from "./env.ts";
-import { type ResultSet } from "./result.ts";
+import type { FromItem, SelectStmt } from "../ast/nodes.js";
+import type { EvalContext } from "../expressions/context.js";
+import type { ExecutionEnv, ScopeRow } from "./env.js";
+import { type ResultSet } from "./result.js";
 export declare function executeSelect(stmt: SelectStmt, env: ExecutionEnv, parent?: EvalContext): ResultSet;
 export declare function scanFrom(item: FromItem, env: ExecutionEnv, parent?: EvalContext): ScopeRow[];
-//# sourceMappingURL=select.d.ts.map

package/dist/executor/simple-select.d.ts

@@ -1,10 +1,9 @@
-import type { SelectStmt } from "../ast/nodes.ts";
-import type { ExecutionEnv } from "./env.ts";
-import { type ResultSet } from "./result.ts";
+import type { SelectStmt } from "../ast/nodes.js";
+import type { ExecutionEnv } from "./env.js";
+import { type ResultSet } from "./result.js";
 /**
  * Tight path for `SELECT cols FROM table WHERE col = ?` (no join/group/order).
  * Skips ScopeRow / evalExpr and honors maxRows during the scan.
  */
 export declare function tryExecuteSimpleSelect(stmt: SelectStmt, env: ExecutionEnv): ResultSet | null;
 export declare function tryExecuteSimpleJoin(stmt: SelectStmt, env: ExecutionEnv): ResultSet | null;
-//# sourceMappingURL=simple-select.d.ts.map

package/dist/executor/triggers.d.ts

@@ -1,12 +1,11 @@
-import type { CreateTriggerStmt, DropTriggerStmt } from "../ast/nodes.ts";
-import type { Row } from "../storage/row.ts";
-import type { Table } from "../storage/table.ts";
-import { type SqlValue } from "../types/value.ts";
-import type { ExecutionEnv } from "./env.ts";
-import { type ResultSet } from "./result.ts";
+import type { CreateTriggerStmt, DropTriggerStmt } from "../ast/nodes.js";
+import type { Row } from "../storage/row.js";
+import type { Table } from "../storage/table.js";
+import { type SqlValue } from "../types/value.js";
+import type { ExecutionEnv } from "./env.js";
+import { type ResultSet } from "./result.js";
 export declare function executeCreateTrigger(stmt: CreateTriggerStmt, env: ExecutionEnv): ResultSet;
 export declare function executeDropTrigger(stmt: DropTriggerStmt, env: ExecutionEnv): ResultSet;
 export declare function fireInsertTriggers(timing: "BEFORE" | "AFTER" | "INSTEAD", table: Table, values: Map<string, SqlValue>, oldRow: Row | null, env: ExecutionEnv): "ok" | "ignore";
 export declare function fireUpdateTriggers(timing: "BEFORE" | "AFTER", table: Table, oldRow: Row, newValues: Map<string, SqlValue>, updatedColumns: Set<string>, env: ExecutionEnv): "ok" | "ignore";
 export declare function fireDeleteTriggers(timing: "BEFORE" | "AFTER", table: Table, oldRow: Row, env: ExecutionEnv): "ok" | "ignore";
-//# sourceMappingURL=triggers.d.ts.map

package/dist/executor/vtable.d.ts

@@ -1,8 +1,8 @@
-import type { CreateVirtualTableStmt } from "../ast/nodes.ts";
-import type { SqlValue } from "../types/value.ts";
-import type { Fts5VirtualTable } from "../vtable/fts5.ts";
-import type { ExecutionEnv } from "./env.ts";
-import { type ResultSet } from "./result.ts";
+import type { CreateVirtualTableStmt } from "../ast/nodes.js";
+import type { SqlValue } from "../types/value.js";
+import type { Fts5VirtualTable } from "../vtable/fts5.js";
+import type { ExecutionEnv } from "./env.js";
+import { type ResultSet } from "./result.js";
 export declare function executeCreateVirtualTable(stmt: CreateVirtualTableStmt, env: ExecutionEnv): ResultSet;
 export declare function executeFtsInsert(table: Fts5VirtualTable, columnNames: string[], sourceRows: SqlValue[][], env: ExecutionEnv): {
     changes: number;
@@ -10,4 +10,3 @@ export declare function executeFtsInsert(table: Fts5VirtualTable, columnNames: s
 };
 export declare function executeFtsUpdate(table: Fts5VirtualTable, updates: Map<string, SqlValue>, rowids: Iterable<number | bigint>): number;
 export declare function executeFtsDelete(table: Fts5VirtualTable, rowids: Iterable<number | bigint>): number;
-//# sourceMappingURL=vtable.d.ts.map

package/dist/expressions/context.d.ts

@@ -1,7 +1,8 @@
-import type { SelectStmt } from "../ast/nodes.ts";
-import type { FunctionContext, FunctionRegistry } from "../functions/registry.ts";
-import type { SqlValue, StorageClass } from "../types/value.ts";
-import type { FtsMatchCursor } from "../vtable/fts5.ts";
+import type { SelectStmt } from "../ast/nodes.js";
+import type { FunctionContext, FunctionRegistry } from "../functions/registry.js";
+import type { SqlValue, StorageClass } from "../types/value.js";
+import type { FtsMatchCursor } from "../vtable/fts5.js";
+/** Column / parameter / function resolution used by {@link evalExpr}. */
 export interface EvalContext {
     resolveColumn(table: string | null, name: string): SqlValue;
     resolveStorageClass?(table: string | null, name: string): StorageClass;
@@ -25,4 +26,3 @@ export interface EvalContext {
     functions?: FunctionRegistry;
     functionContext?: FunctionContext;
 }
-//# sourceMappingURL=context.d.ts.map

package/dist/expressions/equals.d.ts

@@ -0,0 +1,3 @@
+import type { Expr } from "../ast/nodes.js";
+/** Structural equality for matching WHERE expressions to index expressions. */
+export declare function exprEquals(left: Expr, right: Expr): boolean;

package/dist/expressions/eval.d.ts

@@ -1,5 +1,10 @@
-import type { Expr } from "../ast/nodes.ts";
-import { type SqlValue } from "../types/value.ts";
-import type { EvalContext } from "./context.ts";
+import type { Expr } from "../ast/nodes.js";
+import { type SqlValue } from "../types/value.js";
+import type { EvalContext } from "./context.js";
+/**
+ * Evaluate a parsed SQL expression against `ctx` (columns, parameters, functions).
+ *
+ * @param expr - Expression AST node from {@link parse}.
+ * @param ctx - Column / parameter / function resolution.
+ */
 export declare function evalExpr(expr: Expr, ctx: EvalContext): SqlValue;
-//# sourceMappingURL=eval.d.ts.map

package/dist/expressions/index.d.ts

@@ -1,4 +1,3 @@
-export type { EvalContext } from "./context.ts";
-export { evalExpr } from "./eval.ts";
-export { globMatch, likeMatch } from "./like.ts";
-//# sourceMappingURL=index.d.ts.map
+export type { EvalContext } from "./context.js";
+export { evalExpr } from "./eval.js";
+export { globMatch, likeMatch } from "./like.js";

package/dist/expressions/like.d.ts

@@ -1,5 +1,15 @@
-/** SQLite LIKE matching. ASCII letters are case-insensitive. */
+/**
+ * SQLite LIKE matching. ASCII letters are case-insensitive.
+ *
+ * @param text - Value to test.
+ * @param pattern - Pattern with `%` / `_` wildcards.
+ * @param escape - Optional single-character ESCAPE (or `null`).
+ */
 export declare function likeMatch(text: string, pattern: string, escape?: string | null): boolean;
-/** SQLite GLOB matching. GLOB is case-sensitive and uses Unix wildcards. */
+/**
+ * SQLite GLOB matching. GLOB is case-sensitive and uses Unix `*` / `?` wildcards.
+ *
+ * @param text - Value to test.
+ * @param pattern - GLOB pattern.
+ */
 export declare function globMatch(text: string, pattern: string): boolean;
-//# sourceMappingURL=like.d.ts.map

package/dist/functions/aggregate.d.ts

@@ -1,4 +1,4 @@
-import { type SqlValue } from "../types/value.ts";
+import { type SqlValue } from "../types/value.js";
 export interface AggregateAccumulator {
     step(args: SqlValue[]): void;
     finalize(): SqlValue;
@@ -6,4 +6,3 @@ export interface AggregateAccumulator {
 export type AggregateFactory = () => AggregateAccumulator;
 export declare const aggregateFunctions: Readonly<Record<string, AggregateFactory>>;
 export declare function createAggregate(name: string): AggregateAccumulator | undefined;
-//# sourceMappingURL=aggregate.d.ts.map

package/dist/functions/datetime.d.ts

@@ -1,3 +1,2 @@
-import type { ScalarFunction } from "./registry.ts";
+import type { ScalarFunction } from "./registry.js";
 export declare const dateTimeFunctions: Readonly<Record<string, ScalarFunction>>;
-//# sourceMappingURL=datetime.d.ts.map