@crvouga/mockingbird-service-sqlite 0.1.0

package/dist/errors/index.d.ts

@@ -0,0 +1,45 @@
+/** 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/mockingbird-service-sqlite";
+ *
+ * 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;
+    /** 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;
+export declare class TriggerRaiseError extends SqliteError {
+    readonly action: "IGNORE" | "ABORT" | "FAIL" | "ROLLBACK";
+    constructor(action: "IGNORE" | "ABORT" | "FAIL" | "ROLLBACK", message?: string);
+}

package/dist/executor/attach.d.ts

@@ -0,0 +1,5 @@
+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;

package/dist/executor/ddl.d.ts

@@ -0,0 +1,10 @@
+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;
+export declare function executeDropTable(stmt: DropTableStmt, env: ExecutionEnv): ResultSet;
+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;

package/dist/executor/dml.d.ts

@@ -0,0 +1,7 @@
+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;
+export declare function checkDeferredForeignKeys(env: ExecutionEnv): void;

package/dist/executor/env.d.ts

@@ -0,0 +1,66 @@
+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 Affinity, type SqlValue } from "../types/value.js";
+import type { ResultSet } from "./result.js";
+export interface Cell {
+    table: string | null;
+    tableLower?: string | null;
+    name: string;
+    nameLower?: string;
+    value: SqlValue;
+    affinity?: Affinity;
+    collate?: string | null;
+    /** Right-hand duplicate of a column merged by JOIN ... USING. */
+    hiddenByUsing?: boolean;
+}
+export declare function makeCell(table: string | null, name: string, value: SqlValue, extra?: Omit<Partial<Cell>, "table" | "name" | "value" | "tableLower" | "nameLower">): Cell;
+export interface ScopeRow {
+    cells: Cell[];
+    rowid?: Rowid;
+    /** Output name of the rowid pseudo-column (INTEGER PRIMARY KEY alias when present). */
+    rowidName?: string;
+    sourceTable?: string;
+    /** Set when WHERE MATCH succeeds for this row. */
+    ftsMatch?: import("../vtable/fts5.js").FtsMatchCursor | null;
+}
+export type SelectRunner = (stmt: SelectStmt, env: ExecutionEnv, parent?: EvalContext) => ResultSet;
+export interface ExecutionHooks {
+    now?: () => Date;
+    random?: () => bigint;
+    /** Raw xorshift64* output for `randomblob`. */
+    randomU64?: () => bigint;
+}
+export declare class ExecutionEnv {
+    readonly state: DatabaseState;
+    readonly transactions: TransactionManager;
+    readonly functions: FunctionRegistry;
+    readonly positional: SqlValue[];
+    readonly named: Map<string, SqlValue>;
+    readonly ctes: Map<string, ResultSet>;
+    readonly hooks: ExecutionHooks;
+    selectRunner?: SelectRunner;
+    /** Nesting depth while executing trigger programs. */
+    triggerDepth: number;
+    /** OLD/NEW column scope for the active trigger program. */
+    triggerScope: ScopeRow | null;
+    /** Cap SELECT output rows (used by Statement.get). */
+    maxRows: number;
+    /** When true, skip simple-select / simple-join fast paths (tests only). */
+    forceFullSelect: boolean;
+    /** When true, skip tryFastInsert (tests only). */
+    forceFullInsert: boolean;
+    includeNamedRows: boolean;
+    includeValues: boolean;
+    /** Source text of the statement currently executing (for sqlite_master.sql). */
+    statementSql: string | null;
+    constructor(state: DatabaseState, transactions: TransactionManager, params?: readonly unknown[], functions?: FunctionRegistry, hooks?: ExecutionHooks);
+    reset(params: readonly unknown[]): void;
+    getBoundParameter(name: string | number): SqlValue;
+    setNamed(name: string, value: unknown): void;
+    createEvalContext(row?: ScopeRow | null, parent?: EvalContext): EvalContext;
+}
+export declare function toSqlValue(value: unknown): SqlValue;

package/dist/executor/execute.d.ts

@@ -0,0 +1,4 @@
+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;

package/dist/executor/pragma-engine.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Shared PRAGMA query engine used by statement-form `PRAGMA …` and `pragma_*` TVFs.
+ */
+import type { Expr } from "../ast/nodes.js";
+import { type SqlValue } from "../types/value.js";
+import type { ExecutionEnv } from "./env.js";
+export interface PragmaQueryResult {
+    columns: string[];
+    rows: SqlValue[][];
+}
+/** Oracle-exposed pragma_* TVF base names (without the `pragma_` prefix). */
+export declare const PRAGMA_TVF_NAMES: readonly ["analysis_limit", "application_id", "auto_vacuum", "automatic_index", "busy_timeout", "cache_size", "cache_spill", "cell_size_check", "checkpoint_fullfsync", "collation_list", "compile_options", "count_changes", "data_version", "database_list", "default_cache_size", "defer_foreign_keys", "empty_result_callbacks", "encoding", "foreign_key_check", "foreign_key_list", "foreign_keys", "freelist_count", "full_column_names", "fullfsync", "function_list", "hard_heap_limit", "ignore_check_constraints", "index_info", "index_list", "index_xinfo", "integrity_check", "journal_mode", "journal_size_limit", "legacy_alter_table", "locking_mode", "max_page_count", "module_list", "optimize", "page_count", "page_size", "pragma_list", "query_only", "quick_check", "read_uncommitted", "recursive_triggers", "reverse_unordered_selects", "schema_version", "secure_delete", "short_column_names", "soft_heap_limit", "synchronous", "table_info", "table_list", "table_xinfo", "temp_store", "threads", "trusted_schema", "user_version", "writable_schema"];
+/** Full pragma name list for `pragma_pragma_list` (includes names without TVFs). */
+export declare const PRAGMA_LIST_NAMES: string[];
+export declare function isPragmaTvfName(name: string): boolean;
+/**
+ * Column names for a pragma_* TVF without evaluating arguments.
+ * Used by SELECT shape analysis so correlated args (e.g. `tl.name`) are not
+ * resolved before the outer row is bound.
+ */
+export declare function pragmaTvfColumns(name: string): string[] | null;
+/**
+ * Query a pragma by name with optional SQL values (TVF args or evaluated statement args).
+ * Read-only — writers stay in {@link executePragma}.
+ */
+export declare function queryPragma(name: string, args: readonly SqlValue[], env: ExecutionEnv): PragmaQueryResult;
+/** Evaluate a statement-form pragma argument expression to a SQL value list. */
+export declare function evalPragmaArgs(expr: Expr | null, env: ExecutionEnv): SqlValue[];
+export declare function evalPragmaSetValue(expr: Expr, env: ExecutionEnv): SqlValue;
+export declare function coercePragmaInt(value: SqlValue): number;
+export declare function coercePragmaTruthy(value: SqlValue): boolean;

package/dist/executor/pragma.d.ts

@@ -0,0 +1,4 @@
+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;

package/dist/executor/result.d.ts

@@ -0,0 +1,22 @@
+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[];
+    /** 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): 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[][];

package/dist/executor/select.d.ts

@@ -0,0 +1,7 @@
+import type { FromItem, SelectStmt, WithClause } 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 executeWith(withClause: WithClause, env: ExecutionEnv, parent?: EvalContext): void;
+export declare function scanFrom(item: FromItem, env: ExecutionEnv, parent?: EvalContext): ScopeRow[];

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

@@ -0,0 +1,9 @@
+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;

package/dist/executor/triggers.d.ts

@@ -0,0 +1,11 @@
+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" | "INSTEAD", table: Table, oldRow: Row, newValues: Map<string, SqlValue>, updatedColumns: Set<string>, env: ExecutionEnv): "ok" | "ignore";
+export declare function fireDeleteTriggers(timing: "BEFORE" | "AFTER" | "INSTEAD", table: Table, oldRow: Row, env: ExecutionEnv): "ok" | "ignore";

package/dist/executor/vtable.d.ts

@@ -0,0 +1,12 @@
+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;
+    lastInsertRowid: number | bigint;
+};
+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;

package/dist/expressions/context.d.ts

@@ -0,0 +1,30 @@
+import type { SelectStmt } from "../ast/nodes.js";
+import type { FunctionContext, FunctionRegistry } from "../functions/registry.js";
+import type { Affinity, 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;
+    /** Declared column affinity when available (for comparisons). */
+    resolveAffinity?(table: string | null, name: string): Affinity | null;
+    /** Declared column collation when available (for inheritance). */
+    resolveCollation?(table: string | null, name: string): string | null;
+    getParameter(name: string | number): SqlValue;
+    /** Execute a scalar, IN, or EXISTS subquery. */
+    executeSelect?(select: SelectStmt): {
+        columns: string[];
+        rows: SqlValue[][];
+    };
+    /** Evaluate FTS MATCH against the current row when available. */
+    matchFts?(table: string | null, column: string, query: string): boolean;
+    /** Active FTS MATCH cursor for auxiliary functions (bm25/highlight/snippet). */
+    ftsMatch?: FtsMatchCursor | null;
+    /** Context used to resolve correlated column references. */
+    /** When set, RAISE() is allowed in expression evaluation. */
+    raise?: (action: "IGNORE" | "ABORT" | "FAIL" | "ROLLBACK", message?: string) => never;
+    parent?: EvalContext;
+    /** Optional per-database function registry and database hooks. */
+    functions?: FunctionRegistry;
+    functionContext?: FunctionContext;
+}

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

@@ -0,0 +1,12 @@
+import type { Expr } from "../ast/nodes.js";
+import { type SqlValue } from "../types/value.js";
+import type { EvalContext } from "./context.js";
+/** COLLATE name on `expr`, if any (does not walk column inheritance). */
+export declare function explicitCollation(expr: Expr): string | null;
+/**
+ * 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;

package/dist/expressions/index.d.ts

@@ -0,0 +1,3 @@
+export type { EvalContext } from "./context.js";
+export { evalExpr } from "./eval.js";
+export { globMatch, likeMatch } from "./like.js";

package/dist/expressions/like.d.ts

@@ -0,0 +1,16 @@
+/**
+ * SQLite LIKE matching. ASCII letters are case-insensitive unless `caseSensitive`.
+ *
+ * @param text - Value to test.
+ * @param pattern - Pattern with `%` / `_` wildcards.
+ * @param escape - Optional single-character ESCAPE (or `null`).
+ * @param caseSensitive - When true, match like GLOB (SQLite `PRAGMA case_sensitive_like=ON`).
+ */
+export declare function likeMatch(text: string, pattern: string, escape?: string | null, caseSensitive?: boolean): boolean;
+/**
+ * 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;

package/dist/functions/aggregate.d.ts

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

package/dist/functions/datetime.d.ts

@@ -0,0 +1,2 @@
+import type { ScalarFunction } from "./registry.js";
+export declare const dateTimeFunctions: Readonly<Record<string, ScalarFunction>>;

package/dist/functions/extensions.d.ts

@@ -0,0 +1,7 @@
+import type { ScalarFunction } from "./registry.js";
+/**
+ * FTS auxiliary functions. When used with a MATCH cursor they compute real
+ * values; without MATCH they mirror SQLite's empty-cursor defaults.
+ */
+export declare const ftsAuxFunctions: Readonly<Record<string, ScalarFunction>>;
+export declare const rtreeAuxFunctions: Readonly<Record<string, ScalarFunction>>;

package/dist/functions/index.d.ts

@@ -0,0 +1,8 @@
+export { type AggregateAccumulator, type AggregateFactory, aggregateFunctions, createAggregate, } from "./aggregate.js";
+export { dateTimeFunctions } from "./datetime.js";
+export { jsonAggregateFunctions, jsonArrow, jsonScalarFunctions } from "./json.js";
+export { mathFunctions } from "./math.js";
+export { defaultFunctionRegistry, type FunctionContext, FunctionRegistry, isAggregateName, lookupAggregate, lookupScalar, type ScalarFunction, } from "./registry.js";
+export { castSqlValue, getScalarFunctions, invokeScalar } from "./scalar.js";
+export { evaluateTableFunction, listTableValuedFunctions, } from "./table-valued.js";
+export { denseRank, firstValue, lag, lastValue, lead, nthValue, type PartitionRow, rank, rowNumber, windowFunctions, } from "./window.js";

package/dist/functions/json.d.ts

@@ -0,0 +1,6 @@
+import { type SqlValue } from "../types/value.js";
+import type { AggregateFactory } from "./aggregate.js";
+import type { ScalarFunction } from "./registry.js";
+export declare function jsonArrow(left: SqlValue, right: SqlValue, mode: "->" | "->>"): SqlValue;
+export declare const jsonScalarFunctions: Readonly<Record<string, ScalarFunction>>;
+export declare const jsonAggregateFunctions: Readonly<Record<string, AggregateFactory>>;

package/dist/functions/math.d.ts

@@ -0,0 +1,2 @@
+import type { ScalarFunction } from "./registry.js";
+export declare const mathFunctions: Readonly<Record<string, ScalarFunction>>;

package/dist/functions/pragma-tvf.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Register all oracle-exposed `pragma_*` eponymous table-valued functions.
+ * Imported for side effects from table-valued / select.
+ */
+import { isPragmaTvfName } from "../executor/pragma-engine.js";
+/** Idempotent registration of every oracle `pragma_*` TVF. */
+export declare function ensurePragmaTvfsRegistered(): void;
+export { isPragmaTvfName };

package/dist/functions/registry.d.ts

@@ -0,0 +1,39 @@
+import type { SqlValue } from "../types/value.js";
+import { type AggregateAccumulator, type AggregateFactory } from "./aggregate.js";
+export interface FunctionContext {
+    changes?: () => number;
+    totalChanges?: () => number;
+    lastInsertRowid?: () => number | bigint;
+    /** Injectable clock — defaults to a fixed instant on Database. */
+    now?: () => Date;
+    /** Injectable SQLite `random()` source — defaults to a seeded PRNG on Database. */
+    random?: () => bigint;
+    /** Raw unsigned 64-bit PRNG draws for `randomblob`. */
+    randomU64?: () => bigint;
+    /** Active FTS MATCH cursor when evaluating projections with MATCH in WHERE. */
+    ftsMatch?: import("../vtable/fts5.js").FtsMatchCursor | null;
+    /** SQLite `PRAGMA case_sensitive_like` for LIKE / like(). */
+    caseSensitiveLike?: boolean;
+    /** Current rowid for FTS aux defaults when MATCH is absent. */
+    ftsRowid?: import("../storage/row.js").Rowid;
+    /** Source FTS table name for the current scan row. */
+    ftsSourceTable?: string;
+    /** Resolve FTS table by name for aux functions. */
+    getFtsTable?: (name: string) => import("../vtable/fts5.js").Fts5VirtualTable | null;
+}
+export type ScalarFunction = (args: SqlValue[], context: FunctionContext) => SqlValue;
+export declare class FunctionRegistry {
+    private readonly scalars;
+    private readonly aggregates;
+    constructor();
+    registerScalar(name: string, fn: ScalarFunction): void;
+    registerAggregate(name: string, factory: AggregateFactory): void;
+    lookupScalar(name: string): ScalarFunction | undefined;
+    lookupAggregate(name: string): AggregateFactory | undefined;
+    createAggregate(name: string): AggregateAccumulator | undefined;
+    isAggregateName(name: string): boolean;
+}
+export declare const defaultFunctionRegistry: FunctionRegistry;
+export declare function lookupScalar(name: string): ScalarFunction | undefined;
+export declare function lookupAggregate(name: string): AggregateFactory | undefined;
+export declare function isAggregateName(name: string): boolean;

package/dist/functions/scalar.d.ts

@@ -0,0 +1,9 @@
+import { type SqlValue, storageClassOf } from "../types/value.js";
+import type { FunctionContext, ScalarFunction } from "./registry.js";
+/** Match bun:sqlite / SQLite 3.51.0 for drop-in parity. */
+export declare const SQLITE_MEM_VERSION = "3.51.0";
+export declare const SQLITE_MEM_SOURCE_ID = "2025-06-12 13:14:41 f0ca7bba1c5e232e5d279fad6338121ab55af0c8c68c84cdfb18ba5114dcaapl";
+export declare function castSqlValue(value: SqlValue, typeName: string): SqlValue;
+export declare function getScalarFunctions(): Readonly<Record<string, ScalarFunction>>;
+export declare function invokeScalar(name: string, args: SqlValue[], context?: FunctionContext): SqlValue;
+export { storageClassOf };

package/dist/functions/table-valued-registry.d.ts

@@ -0,0 +1,11 @@
+import type { ExecutionEnv, ScopeRow } from "../executor/env.js";
+import type { SqlValue } from "../types/value.js";
+export interface TableValuedResult {
+    columns: string[];
+    rows: ScopeRow[];
+}
+export type TableValuedFn = (args: SqlValue[], alias: string | null, env: ExecutionEnv) => TableValuedResult;
+export declare function registerTableValuedFunction(name: string, fn: TableValuedFn): void;
+export declare function getTableValuedFunction(name: string): TableValuedFn | undefined;
+export declare function listRegisteredTableValuedFunctions(): string[];
+export declare function hasRegisteredTableValuedFunction(name: string): boolean;

package/dist/functions/table-valued.d.ts

@@ -0,0 +1,13 @@
+import type { Expr } from "../ast/nodes.js";
+import type { ExecutionEnv, ScopeRow } from "../executor/env.js";
+import { registerTableValuedFunction, type TableValuedResult } from "./table-valued-registry.js";
+export type { TableValuedResult };
+export { registerTableValuedFunction };
+/**
+ * Known output columns for a TVF without evaluating arguments.
+ * Prefer this for FROM-item shape analysis when args may be correlated.
+ */
+export declare function tableValuedColumns(name: string): string[] | null;
+export declare function evaluateTableFunction(name: string, args: Expr[], alias: string | null, env: ExecutionEnv, scope?: ScopeRow | null, parent?: import("../expressions/context.js").EvalContext): TableValuedResult;
+export declare function listTableValuedFunctions(): string[];
+export declare function hasTableValuedFunction(name: string): boolean;

package/dist/functions/window.d.ts

@@ -0,0 +1,23 @@
+import { type SqlValue } from "../types/value.js";
+export type PartitionRow = SqlValue[];
+export declare function rowNumber(_partition: PartitionRow[], index: number): number;
+export declare function rank(partition: PartitionRow[], index: number, orderKeys?: PartitionRow[]): number;
+export declare function denseRank(partition: PartitionRow[], index: number, orderKeys?: PartitionRow[]): number;
+export declare function lag(partition: PartitionRow[], index: number, valueIndex?: number, offset?: number, defaultValue?: SqlValue): SqlValue;
+export declare function lead(partition: PartitionRow[], index: number, valueIndex?: number, offset?: number, defaultValue?: SqlValue): SqlValue;
+export declare function firstValue(partition: PartitionRow[], valueIndex?: number, frameStart?: number): SqlValue;
+export declare function lastValue(partition: PartitionRow[], valueIndex?: number, frameEnd?: number): SqlValue;
+export declare function nthValue(partition: PartitionRow[], n: number, valueIndex?: number, frameStart?: number): SqlValue;
+export declare const windowFunctions: {
+    readonly row_number: typeof rowNumber;
+    readonly rank: typeof rank;
+    readonly dense_rank: typeof denseRank;
+    readonly lag: typeof lag;
+    readonly lead: typeof lead;
+    readonly first_value: typeof firstValue;
+    readonly last_value: typeof lastValue;
+    readonly nth_value: typeof nthValue;
+    readonly ntile: () => number;
+    readonly cume_dist: () => number;
+    readonly percent_rank: () => number;
+};

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @packageDocumentation
+ * Pure TypeScript in-memory SQLite. Import {@link Database} to get started.
+ *
+ * Deterministic by default (`random()` seed `1`, `'now'` = `2000-01-01T00:00:00.000Z`).
+ * Pass `{ random: "os" }` / `{ now: "system" }` for SQLite-like entropy and wall clock.
+ * Zero WASM, native bindings, or filesystem.
+ *
+ * Advanced / internal helpers live under `@crvouga/mockingbird-service-sqlite/unstable` and are
+ * exempt from semver.
+ *
+ * @example
+ * ```ts
+ * import { Database } from "@crvouga/mockingbird-service-sqlite";
+ *
+ * const db = new Database();
+ * db.exec("CREATE TABLE t (id INTEGER PRIMARY KEY, name TEXT)");
+ * db.prepare("INSERT INTO t (name) VALUES (?)").run("Ada");
+ * const rows = db.query<{ id: number; name: string }>("SELECT * FROM t");
+ * ```
+ *
+ * @module
+ */
+export { Database, type DatabaseOptions, Snapshot } from "./api/database.js";
+export { type RunResult, Statement } from "./api/statement.js";
+export { type ErrorCategory, SqliteError } from "./errors/index.js";
+export type { ResultSet } from "./executor/result.js";
+export type { BindValue, QueryRow, QueryValue } from "./types/value.js";