@crvouga/sqlite-mem 0.2.0 → 1.1.0

package/dist/index.js

@@ -2,18 +2,21 @@
 var SqliteError = class extends Error {
   /** Coarse error class (constraint vs syntax vs missing object, …). */
   category;
-  /** Optional SQLite result-code name such as `SQLITE_CONSTRAINT`. */
+  /** SQLite result-code name such as `SQLITE_CONSTRAINT_UNIQUE`. */
   sqliteCode;
+  /** Same value as {@link sqliteCode} (Node `err.code` convention). */
+  code;
   /**
    * @param message - Human-readable error text.
    * @param category - Coarse class; defaults to `"other"`.
-   * @param sqliteCode - Optional SQLite result-code name.
+   * @param sqliteCode - SQLite result-code name; defaults to `"SQLITE_ERROR"`.
    */
-  constructor(message, category = "other", sqliteCode) {
+  constructor(message, category = "other", sqliteCode = "SQLITE_ERROR") {
     super(message);
     this.name = "SqliteError";
     this.category = category;
     this.sqliteCode = sqliteCode;
+    this.code = sqliteCode;
   }
 };
 var TriggerRaiseError = class extends SqliteError {
@@ -2396,17 +2399,6 @@ var Prng = class _Prng {
     return copy;
   }
 };
-function deriveSeed(...parts) {
-  let hash = 2166136261;
-  for (const part of parts) {
-    const text2 = String(part);
-    for (let i = 0; i < text2.length; i++) {
-      hash ^= text2.charCodeAt(i);
-      hash = Math.imul(hash, 16777619);
-    }
-  }
-  return hash | 0;
-}
 
 // src/types/value.ts
 var SqlReal = class {
@@ -8733,7 +8725,7 @@ function decodeDatabaseState(snapshot) {
     throw new SqliteError("invalid sqlite-mem snapshot magic", "other");
   const version = reader.u32();
   if (version !== VERSION && version !== VERSION_V1) {
-    throw new SqliteError(`unsupported sqlite-mem snapshot version: ${version}`, "unsupported");
+    throw new SqliteError(`unsupported sqlite-mem snapshot version: ${version}`, "snapshot_version", "SQLITE_FORMAT");
   }
   const state = new DatabaseState();
   state.foreignKeysEnabled = reader.u8() !== 0;
@@ -8989,16 +8981,14 @@ var ExecutionEnv = class {
   }
   getBoundParameter(name) {
     if (typeof name === "number") {
-      if (name < 1 || name > this.positional.length)
-        throw new SqliteError(`binding parameter ${name} is not supplied`, "misuse");
+      if (name < 1 || name > this.positional.length) return null;
       return this.positional[name - 1];
     }
     const key = name.toLowerCase();
-    const value = this.named.get(key);
-    if (value === void 0 && !this.named.has(key)) {
-      throw new SqliteError(`binding parameter :${name} is not supplied`, "misuse");
+    if (!this.named.has(key)) {
+      return null;
     }
-    return value ?? null;
+    return this.named.get(key) ?? null;
   }
   setNamed(name, value) {
     this.named.set(name.toLowerCase(), toSqlValue(value));
@@ -9086,7 +9076,7 @@ var ExecutionEnv = class {
         const result = this.selectRunner(select, this, context);
         return {
           columns: result.columns,
-          rows: result.values?.map((row2) => [...row2]) ?? result.rows.map((record) => result.columns.map((column) => record[column] ?? null))
+          rows: result.values.length > 0 ? result.values.map((row2) => [...row2]) : result.rows.map((record) => result.columns.map((column) => record[column] ?? null))
         };
       },
       matchFts: (table, column, query) => {
@@ -9114,14 +9104,29 @@ function toSqlValue(value) {
   }
   if (typeof value === "boolean") return value ? 1 : 0;
   if (value instanceof SqlReal || value instanceof SqlJsonText) return value;
-  if (value instanceof Uint8Array) return new Uint8Array(value);
+  if (value instanceof Uint8Array) {
+    if (isSharedArrayBufferView(value)) {
+      throw new SqliteError("cannot bind SharedArrayBuffer-backed buffers; copy into a Uint8Array first", "misuse");
+    }
+    return new Uint8Array(value);
+  }
   if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  if (typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer) {
+    throw new SqliteError("cannot bind SharedArrayBuffer; copy into an ArrayBuffer or Uint8Array first", "misuse");
+  }
+  if (ArrayBuffer.isView(value)) {
+    const kind = Object.prototype.toString.call(value).slice(8, -1);
+    throw new SqliteError(`cannot bind ${kind}; only Uint8Array and ArrayBuffer are accepted as BLOB values`, "misuse");
+  }
   throw new SqliteError(`unsupported bind value: ${typeof value}`, "datatype_mismatch");
 }
+function isSharedArrayBufferView(view) {
+  return typeof SharedArrayBuffer !== "undefined" && view.buffer instanceof SharedArrayBuffer;
+}
 
 // src/executor/result.ts
 function emptyResult(changes = 0, lastInsertRowid = 0) {
-  return { columns: [], rows: [], changes, lastInsertRowid };
+  return { columns: [], rows: [], values: [], changes, lastInsertRowid };
 }
 function exportSqlValue(value) {
   if (isSqlReal(value)) return value.value;
@@ -9133,7 +9138,7 @@ function valuesToResult(columns, values, changes = 0, lastInsertRowid = 0, optio
   const keepValues = options?.keepValues !== false;
   return {
     columns,
-    values: keepValues ? values.map((row) => row.map(exportSqlValue)) : void 0,
+    values: keepValues ? values.map((row) => row.map(exportSqlValue)) : [],
     rows: named ? values.map((row) => {
       const object = {};
       for (let index = 0; index < columns.length; index++) {
@@ -9146,7 +9151,10 @@ function valuesToResult(columns, values, changes = 0, lastInsertRowid = 0, optio
   };
 }
 function resultValues(result) {
-  return result.values?.map((row) => [...row]) ?? result.rows.map((row) => result.columns.map((column) => row[column] ?? null));
+  if (result.values.length > 0 || result.rows.length === 0) {
+    return result.values.map((row) => [...row]);
+  }
+  return result.rows.map((row) => result.columns.map((column) => row[column] ?? null));
 }
 
 // src/executor/attach.ts
@@ -9182,8 +9190,579 @@ function executeDetach(stmt, env) {
   return emptyResult(0, env.state.lastInsertRowid);
 }
 
-// src/functions/table-valued.ts
+// src/functions/window.ts
+function rowsEqual(left, right) {
+  if (left.length !== right.length) return false;
+  return left.every((value, index) => {
+    const other = right[index];
+    return value === null && other === null || other !== void 0 && compareSql(value, other) === 0;
+  });
+}
+function rowNumber(_partition, index) {
+  return index + 1;
+}
+function rank(partition, index, orderKeys = partition) {
+  if (index <= 0) return 1;
+  let firstPeer = index;
+  while (firstPeer > 0 && rowsEqual(orderKeys[firstPeer], orderKeys[firstPeer - 1])) firstPeer--;
+  return firstPeer + 1;
+}
+function denseRank(partition, index, orderKeys = partition) {
+  if (index <= 0) return 1;
+  let result = 1;
+  for (let i = 1; i <= index; i++) {
+    if (!rowsEqual(orderKeys[i], orderKeys[i - 1])) result++;
+  }
+  return result;
+}
+function lag(partition, index, valueIndex = 0, offset = 1, defaultValue = null) {
+  const target = index - Math.max(0, Math.trunc(offset));
+  return target < 0 ? defaultValue : partition[target]?.[valueIndex] ?? null;
+}
+function lead(partition, index, valueIndex = 0, offset = 1, defaultValue = null) {
+  const target = index + Math.max(0, Math.trunc(offset));
+  return target >= partition.length ? defaultValue : partition[target]?.[valueIndex] ?? null;
+}
+function firstValue(partition, valueIndex = 0, frameStart = 0) {
+  return partition[frameStart]?.[valueIndex] ?? null;
+}
+function lastValue(partition, valueIndex = 0, frameEnd = partition.length - 1) {
+  return partition[frameEnd]?.[valueIndex] ?? null;
+}
+function nthValue(partition, n, valueIndex = 0, frameStart = 0) {
+  const offset = Math.trunc(n);
+  if (offset <= 0) return null;
+  return partition[frameStart + offset - 1]?.[valueIndex] ?? null;
+}
+var windowFunctions = {
+  row_number: rowNumber,
+  rank,
+  dense_rank: denseRank,
+  lag,
+  lead,
+  first_value: firstValue,
+  last_value: lastValue,
+  nth_value: nthValue,
+  ntile: () => 0,
+  cume_dist: () => 0,
+  percent_rank: () => 0
+};
+
+// src/executor/pragma-engine.ts
+var PRAGMA_TVF_NAMES = [
+  "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"
+];
+var PRAGMA_LIST_NAMES = [
+  "activate_extensions",
+  ...PRAGMA_TVF_NAMES,
+  "case_sensitive_like",
+  "hexkey",
+  "hexrekey",
+  "incremental_vacuum",
+  "key",
+  "lock_proxy_file",
+  "mmap_size",
+  "rekey",
+  "shrink_memory",
+  "temp_store_directory",
+  "textkey",
+  "textrekey",
+  "wal_autocheckpoint",
+  "wal_checkpoint"
+].sort((a, b) => a.localeCompare(b));
+var MEMORY_VTABLE_MODULES = [
+  "bytecode",
+  "dbstat",
+  "fts3",
+  "fts3tokenize",
+  "fts4",
+  "fts4aux",
+  "fts5",
+  "fts5vocab",
+  "json_each",
+  "json_tree",
+  "rtree",
+  "rtree_i32",
+  "tables_used"
+];
+var COMPILE_OPTIONS2 = [
+  "COMPILER=typescript",
+  "ENABLE_FTS3",
+  "ENABLE_FTS4",
+  "ENABLE_FTS5",
+  "ENABLE_JSON1",
+  "ENABLE_RTREE",
+  "THREADSAFE=0"
+];
+var STORAGE_DEFAULTS = {
+  analysis_limit: { column: "analysis_limit", value: 0 },
+  application_id: { column: "application_id", value: 0 },
+  auto_vacuum: { column: "auto_vacuum", value: 0 },
+  automatic_index: { column: "automatic_index", value: 1 },
+  busy_timeout: { column: "timeout", value: 0 },
+  cache_size: { column: "cache_size", value: 2e3 },
+  cache_spill: { column: "cache_spill", value: 2e4 },
+  cell_size_check: { column: "cell_size_check", value: 0 },
+  checkpoint_fullfsync: { column: "checkpoint_fullfsync", value: 1 },
+  count_changes: { column: "count_changes", value: 0 },
+  data_version: { column: "data_version", value: 1 },
+  default_cache_size: { column: "cache_size", value: 2e3 },
+  defer_foreign_keys: { column: "defer_foreign_keys", value: 0 },
+  empty_result_callbacks: { column: "empty_result_callbacks", value: 0 },
+  encoding: { column: "encoding", value: "UTF-8" },
+  freelist_count: { column: "freelist_count", value: 0 },
+  full_column_names: { column: "full_column_names", value: 0 },
+  fullfsync: { column: "fullfsync", value: 0 },
+  hard_heap_limit: { column: "hard_heap_limit", value: 0 },
+  ignore_check_constraints: { column: "ignore_check_constraints", value: 0 },
+  journal_mode: { column: "journal_mode", value: "memory" },
+  journal_size_limit: { column: "journal_size_limit", value: 32768 },
+  legacy_alter_table: { column: "legacy_alter_table", value: 1 },
+  locking_mode: { column: "locking_mode", value: "normal" },
+  max_page_count: { column: "max_page_count", value: 1073741823 },
+  page_size: { column: "page_size", value: 4096 },
+  query_only: { column: "query_only", value: 0 },
+  read_uncommitted: { column: "read_uncommitted", value: 0 },
+  recursive_triggers: { column: "recursive_triggers", value: 0 },
+  reverse_unordered_selects: { column: "reverse_unordered_selects", value: 0 },
+  secure_delete: { column: "secure_delete", value: 2 },
+  short_column_names: { column: "short_column_names", value: 1 },
+  soft_heap_limit: { column: "soft_heap_limit", value: 0 },
+  synchronous: { column: "synchronous", value: 2 },
+  temp_store: { column: "temp_store", value: 0 },
+  threads: { column: "threads", value: 0 },
+  trusted_schema: { column: "trusted_schema", value: 1 },
+  writable_schema: { column: "writable_schema", value: 0 }
+};
+function isPragmaTvfName(name) {
+  const lower = name.toLowerCase();
+  if (PRAGMA_TVF_NAMES.includes(lower)) return true;
+  if (lower.startsWith("pragma_")) {
+    return PRAGMA_TVF_NAMES.includes(lower.slice("pragma_".length));
+  }
+  return false;
+}
+function normalizePragmaKey(name) {
+  const lower = name.toLowerCase();
+  if (PRAGMA_TVF_NAMES.includes(lower)) return lower;
+  if (lower.startsWith("pragma_")) {
+    const stripped = lower.slice("pragma_".length);
+    if (PRAGMA_TVF_NAMES.includes(stripped)) return stripped;
+    return stripped;
+  }
+  return lower;
+}
+function queryPragma(name, args, env) {
+  const key = normalizePragmaKey(name);
+  switch (key) {
+    case "foreign_keys":
+      return single("foreign_keys", env.state.foreignKeysEnabled ? 1 : 0);
+    case "user_version":
+      return single("user_version", env.state.userVersion);
+    case "schema_version":
+      return single("schema_version", env.state.schemaVersion);
+    case "table_info":
+      return pragmaTableInfo(args, env, false);
+    case "table_xinfo":
+      return pragmaTableInfo(args, env, true);
+    case "index_list":
+      return pragmaIndexList(args, env);
+    case "index_info":
+      return pragmaIndexInfo(args, env, false);
+    case "index_xinfo":
+      return pragmaIndexInfo(args, env, true);
+    case "foreign_key_list":
+      return pragmaForeignKeyList(args, env);
+    case "foreign_key_check":
+      return pragmaForeignKeyCheck(args, env);
+    case "database_list":
+      return pragmaDatabaseList(env);
+    case "table_list":
+      return pragmaTableList(env);
+    case "collation_list":
+      return {
+        columns: ["seq", "name"],
+        rows: [
+          [0, "RTRIM"],
+          [1, "NOCASE"],
+          [2, "BINARY"]
+        ]
+      };
+    case "compile_options":
+      return { columns: ["compile_options"], rows: COMPILE_OPTIONS2.map((opt) => [opt]) };
+    case "function_list":
+      return pragmaFunctionList();
+    case "module_list":
+      return pragmaModuleList();
+    case "pragma_list":
+      return { columns: ["name"], rows: PRAGMA_LIST_NAMES.map((n) => [n]) };
+    case "integrity_check":
+    case "quick_check":
+      return single(key, "ok");
+    case "optimize":
+      return { columns: ["optimize"], rows: [] };
+    case "page_count":
+      return single("page_count", estimatePageCount(env));
+    default: {
+      const storage = STORAGE_DEFAULTS[key];
+      if (storage) return single(storage.column, storage.value);
+      return { columns: [], rows: [] };
+    }
+  }
+}
+function single(column, value) {
+  return { columns: [column], rows: [[value]] };
+}
+function estimatePageCount(env) {
+  const objects = env.state.tables.size + env.state.indexes.size + env.state.views.size + env.state.virtualTables.size;
+  return objects === 0 ? 0 : Math.max(1, objects);
+}
+function pragmaTableInfo(args, env, xinfo) {
+  const tableName = requireNameArg(args, "table_info");
+  const table = env.state.tables.get(tableName.toLowerCase());
+  if (!table) return { columns: xinfoColumns(xinfo), rows: [] };
+  const rows = table.columns.map((column, cid) => {
+    const pkIndex = table.columns.filter((c) => c.primaryKey).findIndex((c) => c.name === column.name);
+    const pk = column.primaryKey ? pkIndex >= 0 ? pkIndex + 1 : 1 : 0;
+    const dflt = column.defaultExpr ? defaultLiteral(column.defaultExpr) : null;
+    const base = [cid, column.name, column.typeName ?? "", column.notNull ? 1 : 0, dflt, pk];
+    if (xinfo) {
+      let hidden = 0;
+      if (column.generated && !column.generated.stored) hidden = 2;
+      if (column.generated?.stored) hidden = 3;
+      base.push(hidden);
+    }
+    return base;
+  });
+  return { columns: xinfoColumns(xinfo), rows };
+}
+function xinfoColumns(xinfo) {
+  return xinfo ? ["cid", "name", "type", "notnull", "dflt_value", "pk", "hidden"] : ["cid", "name", "type", "notnull", "dflt_value", "pk"];
+}
+function defaultLiteral(expr) {
+  if (expr.type === "literal")
+    return typeof expr.value === "string" ? `'${expr.value.replace(/'/g, "''")}'` : expr.value;
+  if (expr.type === "null") return "NULL";
+  return null;
+}
+function pragmaIndexList(args, env) {
+  const tableName = requireNameArg(args, "index_list");
+  const table = env.state.tables.get(tableName.toLowerCase());
+  if (!table) return { columns: ["seq", "name", "unique", "origin", "partial"], rows: [] };
+  const rows = [];
+  let seq = 0;
+  for (const name of table.indexes) {
+    const index = env.state.indexes.get(name.toLowerCase());
+    if (!index) continue;
+    rows.push([seq++, index.name, index.unique ? 1 : 0, indexOrigin(index), index.where ? 1 : 0]);
+  }
+  return { columns: ["seq", "name", "unique", "origin", "partial"], rows };
+}
+function indexOrigin(index) {
+  if (index.originalSql) return "c";
+  if (index.name.toLowerCase().startsWith("sqlite_autoindex_") && index.unique) return "u";
+  return "c";
+}
+function pragmaIndexInfo(args, env, xinfo) {
+  const indexName = requireNameArg(args, "index_info");
+  const index = env.state.indexes.get(indexName.toLowerCase());
+  const columns = xinfo ? ["seqno", "cid", "name", "desc", "coll", "key"] : ["seqno", "cid", "name"];
+  if (!index) return { columns, rows: [] };
+  const table = env.state.tables.get(index.tableName.toLowerCase());
+  const rows = index.columns.map((column, seqno) => {
+    const cid = table?.columns.findIndex((c) => c.name.toLowerCase() === column.name.toLowerCase()) ?? -1;
+    const base = [seqno, cid, column.name];
+    if (xinfo) {
+      base.push(column.order === "DESC" ? 1 : 0, (column.collate ?? "BINARY").toUpperCase(), 1);
+    }
+    return base;
+  });
+  if (xinfo) {
+    rows.push([index.columns.length, -1, null, 0, "BINARY", 0]);
+  }
+  return { columns, rows };
+}
+function pragmaForeignKeyList(args, env) {
+  const tableName = requireNameArg(args, "foreign_key_list");
+  const table = env.state.tables.get(tableName.toLowerCase());
+  const columns = ["id", "seq", "table", "from", "to", "on_update", "on_delete", "match"];
+  if (!table) return { columns, rows: [] };
+  const rows = [];
+  let id = 0;
+  for (const constraint of table.constraints) {
+    if (constraint.type !== "foreign_key") continue;
+    const refColumns = constraint.refColumns ?? env.state.tables.get(constraint.refTable.toLowerCase())?.columns.filter((c) => c.primaryKey).map((c) => c.name) ?? [];
+    constraint.columns.forEach((column, seq) => {
+      rows.push([
+        id,
+        seq,
+        constraint.refTable,
+        column,
+        refColumns[seq] ?? null,
+        constraint.onUpdate ?? "NO ACTION",
+        constraint.onDelete ?? "NO ACTION",
+        "NONE"
+      ]);
+    });
+    id++;
+  }
+  return { columns, rows };
+}
+function pragmaForeignKeyCheck(args, env) {
+  const columns = ["table", "rowid", "parent", "fkid"];
+  const filter = args[0] != null && args[0] !== null ? String(args[0]).toLowerCase() : null;
+  const rows = [];
+  for (const table of env.state.tables.values()) {
+    if (filter && table.name.toLowerCase() !== filter) continue;
+    let fkid = 0;
+    for (const constraint of table.constraints) {
+      if (constraint.type !== "foreign_key") continue;
+      const parent = env.state.tables.get(constraint.refTable.toLowerCase());
+      const refColumns = constraint.refColumns ?? parent?.columns.filter((c) => c.primaryKey).map((c) => c.name) ?? [];
+      for (const row of table.scan()) {
+        let allNull = true;
+        const childValues = [];
+        for (const col of constraint.columns) {
+          const value = row.values.get(col.toLowerCase()) ?? null;
+          childValues.push(value);
+          if (value !== null) allNull = false;
+        }
+        if (allNull) continue;
+        if (!parent || !parentHasMatch(parent, refColumns, childValues)) {
+          rows.push([table.name, row.rowid, constraint.refTable, fkid]);
+        }
+      }
+      fkid++;
+    }
+  }
+  return { columns, rows };
+}
+function parentHasMatch(parent, refColumns, childValues) {
+  if (refColumns.length === 0) return false;
+  for (const row of parent.scan()) {
+    let ok = true;
+    for (let i = 0; i < refColumns.length; i++) {
+      const parentVal = row.values.get(refColumns[i].toLowerCase()) ?? null;
+      if (!sqlValuesEqual(parentVal, childValues[i] ?? null)) {
+        ok = false;
+        break;
+      }
+    }
+    if (ok) return true;
+  }
+  return false;
+}
+function sqlValuesEqual(a, b) {
+  if (a === null || b === null) return a === b;
+  if (typeof a === "number" && typeof b === "number") return a === b;
+  if (typeof a === "bigint" || typeof b === "bigint") {
+    return BigInt(a) === BigInt(b);
+  }
+  if (a instanceof Uint8Array || b instanceof Uint8Array) return false;
+  return String(a) === String(b);
+}
+function pragmaDatabaseList(env) {
+  const rows = [[0, "main", ""]];
+  let seq = 2;
+  for (const [name, attached] of env.state.attached) {
+    const file = attached.filename === ":memory:" ? "" : attached.filename;
+    rows.push([seq++, name, file]);
+  }
+  return { columns: ["seq", "name", "file"], rows };
+}
+function pragmaTableList(env) {
+  const columns = ["schema", "name", "type", "ncol", "wr", "strict"];
+  const rows = [];
+  for (const table of env.state.tables.values()) {
+    rows.push(["main", table.name, "table", table.columns.length, table.withoutRowid ? 1 : 0, table.strict ? 1 : 0]);
+  }
+  for (const view of env.state.views.values()) {
+    const ncol = view.columns?.length ?? 0;
+    rows.push(["main", view.name, "view", ncol, 0, 0]);
+  }
+  for (const vt of env.state.virtualTables.values()) {
+    rows.push(["main", vt.name, "virtual", vt.columns.length, 0, 0]);
+  }
+  rows.push(["main", "sqlite_schema", "table", 5, 0, 0]);
+  rows.push(["temp", "sqlite_temp_schema", "table", 5, 0, 0]);
+  for (const [schema] of env.state.attached) {
+    rows.push([schema, "sqlite_schema", "table", 5, 0, 0]);
+  }
+  return { columns, rows };
+}
+function pragmaFunctionList() {
+  const columns = ["name", "builtin", "type", "enc", "narg", "flags"];
+  const rows = [];
+  const add = (name, type, narg, flags) => {
+    rows.push([name, 1, type, "utf8", narg, flags]);
+  };
+  for (const name of Object.keys(getScalarFunctions())) add(name, "s", -1, 2099200);
+  for (const name of Object.keys(dateTimeFunctions)) add(name, "s", -1, 2099200);
+  for (const name of Object.keys(jsonScalarFunctions)) add(name, "s", -1, 2099200);
+  for (const name of Object.keys(mathFunctions)) add(name, "s", -1, 2099200);
+  for (const name of Object.keys(ftsAuxFunctions)) add(name, "s", -1, 2099200);
+  for (const name of Object.keys(rtreeAuxFunctions)) add(name, "s", -1, 2099200);
+  for (const name of Object.keys(aggregateFunctions)) {
+    add(name, "w", name === "count" ? 0 : 1, 2097152);
+    if (name === "count") add(name, "w", 1, 2097152);
+  }
+  for (const name of Object.keys(jsonAggregateFunctions)) add(name, "w", -1, 2097152);
+  for (const name of Object.keys(windowFunctions)) add(name, "w", -1, 2097152);
+  for (const name of ["generate_series", "json_each", "json_tree"]) {
+    add(name, "s", -1, 2099200);
+  }
+  rows.sort((a, b) => String(a[0]).localeCompare(String(b[0])) || Number(a[4]) - Number(b[4]));
+  return { columns, rows };
+}
+function pragmaModuleList() {
+  const names = /* @__PURE__ */ new Set([
+    ...MEMORY_VTABLE_MODULES,
+    ...PRAGMA_TVF_NAMES.map((n) => `pragma_${n}`),
+    "generate_series",
+    "json_each",
+    "json_tree"
+  ]);
+  return {
+    columns: ["name"],
+    rows: [...names].sort((a, b) => a.localeCompare(b)).map((name) => [name])
+  };
+}
+function requireNameArg(args, pragma) {
+  if (args.length === 0 || args[0] == null) {
+    throw new SqliteError(`missing pragma argument for ${pragma}`, "misuse");
+  }
+  const value = args[0];
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "bigint") return String(value);
+  throw new SqliteError(`invalid pragma argument for ${pragma}`, "misuse");
+}
+function evalPragmaArgs(expr, env) {
+  if (expr === null) return [];
+  if (expr.type === "column" && expr.table === null) return [expr.name];
+  if (expr.type === "literal") return [expr.value];
+  return [evalExpr(expr, env.createEvalContext())];
+}
+function evalPragmaSetValue(expr, env) {
+  if (expr.type === "column" && expr.table === null) {
+    const keyword = expr.name.toLowerCase();
+    if (keyword === "on" || keyword === "true" || keyword === "yes") return 1;
+    if (keyword === "off" || keyword === "false" || keyword === "no") return 0;
+    return expr.name;
+  }
+  return evalExpr(expr, env.createEvalContext());
+}
+function coercePragmaInt(value) {
+  if (typeof value === "number") return Math.trunc(value);
+  if (typeof value === "bigint") return Number(value);
+  if (typeof value === "string") {
+    const n = Number.parseInt(value, 10);
+    return Number.isFinite(n) ? n : 0;
+  }
+  const asInt = toInteger(value);
+  return asInt === null ? 0 : typeof asInt === "bigint" ? Number(asInt) : asInt;
+}
+function coercePragmaTruthy(value) {
+  return isTruthySql(value) === true;
+}
+
+// src/functions/table-valued-registry.ts
 var registry = /* @__PURE__ */ new Map();
+function registerTableValuedFunction(name, fn) {
+  registry.set(name.toLowerCase(), fn);
+}
+function getTableValuedFunction(name) {
+  return registry.get(name.toLowerCase());
+}
+function hasRegisteredTableValuedFunction(name) {
+  return registry.has(name.toLowerCase());
+}
+
+// src/functions/pragma-tvf.ts
+function toTvfResult(alias, defaultName, columns, rows) {
+  const table = alias ?? defaultName;
+  return {
+    columns,
+    rows: rows.map((row) => ({
+      cells: columns.map((name, index) => ({
+        table,
+        name,
+        value: row[index] ?? null
+      }))
+    }))
+  };
+}
+var registered = false;
+function ensurePragmaTvfsRegistered() {
+  if (registered) return;
+  registered = true;
+  for (const baseName of PRAGMA_TVF_NAMES) {
+    const tvfName = `pragma_${baseName}`;
+    registerTableValuedFunction(tvfName, (args, alias, env) => {
+      const result = queryPragma(baseName, args, env);
+      return toTvfResult(alias, tvfName, result.columns, result.rows);
+    });
+  }
+}
+
+// src/functions/table-valued.ts
 var JSON_TVF_COLUMNS = ["key", "value", "type", "atom", "id", "parent", "fullkey", "path"];
 function jsonTvfResult(alias, defaultName, rows) {
   const table = alias ?? defaultName;
@@ -9198,7 +9777,7 @@ function jsonTvfResult(alias, defaultName, rows) {
     }))
   };
 }
-registry.set("generate_series", (args, alias) => {
+registerTableValuedFunction("generate_series", (args, alias) => {
   if (args.length < 2 || args.length > 3) {
     throw new SqliteError("wrong number of arguments to function generate_series()", "misuse");
   }
@@ -9229,13 +9808,13 @@ registry.set("generate_series", (args, alias) => {
   }
   return { columns: ["value"], rows };
 });
-registry.set("json_each", (args, alias) => {
+registerTableValuedFunction("json_each", (args, alias) => {
   if (args.length < 1 || args.length > 2) {
     throw new SqliteError("wrong number of arguments to function json_each()", "misuse");
   }
   return jsonTvfResult(alias, "json_each", jsonEachRows(args[0], args[1]));
 });
-registry.set("json_tree", (args, alias) => {
+registerTableValuedFunction("json_tree", (args, alias) => {
   if (args.length < 1 || args.length > 2) {
     throw new SqliteError("wrong number of arguments to function json_tree()", "misuse");
   }
@@ -9245,11 +9824,16 @@ function safeInt(value) {
   return value <= BigInt(Number.MAX_SAFE_INTEGER) && value >= BigInt(Number.MIN_SAFE_INTEGER) ? Number(value) : value;
 }
 function evaluateTableFunction(name, args, alias, env, scope, parent) {
-  const fn = registry.get(name.toLowerCase());
+  ensurePragmaTvfsRegistered();
+  const fn = getTableValuedFunction(name);
   if (!fn) throw new SqliteError(`no such table-valued function: ${name}`, "no_such_table");
   const values = args.map((arg) => evalExpr(arg, env.createEvalContext(scope ?? null, parent)));
   return fn(values, alias, env);
 }
+function hasTableValuedFunction(name) {
+  ensurePragmaTvfsRegistered();
+  return hasRegisteredTableValuedFunction(name);
+}
 
 // src/schema/catalog.ts
 function schemaCatalogRows(state) {
@@ -9980,10 +10564,10 @@ function executeSelect2(stmt, env, parent) {
         rows = uniqueRows([...leftRows, ...rightRows]);
         break;
       case "INTERSECT":
-        rows = uniqueRows(leftRows).filter((row) => rightRows.some((other) => rowsEqual(row, other)));
+        rows = uniqueRows(leftRows).filter((row) => rightRows.some((other) => rowsEqual2(row, other)));
         break;
       case "EXCEPT":
-        rows = uniqueRows(leftRows).filter((row) => !rightRows.some((other) => rowsEqual(row, other)));
+        rows = uniqueRows(leftRows).filter((row) => !rightRows.some((other) => rowsEqual2(row, other)));
         break;
     }
     if (stmt.orderBy.length > 0) rows.sort((a, b) => compareCompoundRows(a, b, stmt.orderBy, base.columns));
@@ -10017,7 +10601,7 @@ function executeWith(stmt, env, parent) {
         env.ctes.set(key, valuesToResult(columns, delta));
         const nextResult = executeSelect2(cte.select.compound.select, env, parent);
         const candidates = resultValues(nextResult);
-        const additions = cte.select.compound.op === "UNION ALL" ? candidates : candidates.filter((row) => !accumulated.some((existing) => rowsEqual(existing, row)));
+        const additions = cte.select.compound.op === "UNION ALL" ? candidates : candidates.filter((row) => !accumulated.some((existing) => rowsEqual2(existing, row)));
         if (additions.length === 0) break;
         accumulated = [...accumulated, ...additions];
         delta = additions;
@@ -10319,6 +10903,9 @@ function scanFrom(item, env, parent) {
   if (item.type === "table_func") {
     return evaluateTableFunction(item.name, item.args, item.alias, env).rows;
   }
+  if (item.type === "table" && isPragmaTvfName(item.name) && hasTableValuedFunction(item.name.toLowerCase())) {
+    return evaluateTableFunction(item.name, [], item.alias, env, null, parent).rows;
+  }
   const alias = item.alias ?? item.name;
   const qualified = item.schema ? `${item.schema}.${item.name}` : item.name;
   const db = env.state.databaseForSchema(item.schema, qualified);
@@ -10491,6 +11078,14 @@ function shapeOf(item, env) {
       value: null
     }));
   }
+  if (item.type === "table" && isPragmaTvfName(item.name) && hasTableValuedFunction(item.name.toLowerCase())) {
+    const columns = evaluateTableFunction(item.name, [], item.alias, env).columns;
+    return columns.map((name) => ({
+      table: item.alias ?? item.name,
+      name,
+      value: null
+    }));
+  }
   const alias = item.alias ?? item.name;
   const qualified = item.schema ? `${item.schema}.${item.name}` : item.name;
   const db = env.state.databaseForSchema(item.schema, qualified);
@@ -10560,7 +11155,7 @@ function aggregateValue(expr, rows, env, parent) {
     const ctx = env.createEvalContext(row, parent);
     if (expr.filter && isTruthySql(evalExpr(expr.filter, ctx)) !== true) continue;
     const args = expr.args === "*" ? [] : expr.args.map((arg) => evalExpr(arg, ctx));
-    if (expr.distinct && seen.some((values) => rowsEqual(values, args))) continue;
+    if (expr.distinct && seen.some((values) => rowsEqual2(values, args))) continue;
     seen.push(args);
     accumulator.step(args);
   }
@@ -10571,7 +11166,7 @@ function windowValue(expr, current, rows, env, parent, namedWindows) {
   const currentCtx = env.createEvalContext(current, parent);
   const partitionKey = spec.partitionBy.map((item) => evalExpr(item, currentCtx));
   const partition = rows.filter(
-    (row) => rowsEqual(
+    (row) => rowsEqual2(
       partitionKey,
       spec.partitionBy.map((item) => evalExpr(item, env.createEvalContext(row, parent)))
     )
@@ -10600,13 +11195,13 @@ function windowValue(expr, current, rows, env, parent, namedWindows) {
   if (name === "row_number") return index + 1;
   if (name === "rank") {
     let first = index;
-    while (first > 0 && rowsEqual(orderKeys[first], orderKeys[first - 1])) first--;
+    while (first > 0 && rowsEqual2(orderKeys[first], orderKeys[first - 1])) first--;
     return first + 1;
   }
   if (name === "dense_rank") {
-    let rank = 1;
-    for (let i = 1; i <= index; i++) if (!rowsEqual(orderKeys[i], orderKeys[i - 1])) rank++;
-    return rank;
+    let rank2 = 1;
+    for (let i = 1; i <= index; i++) if (!rowsEqual2(orderKeys[i], orderKeys[i - 1])) rank2++;
+    return rank2;
   }
   const evaluated = args.map((arg) => evalExpr(arg, currentCtx));
   if (name === "lag" || name === "lead") {
@@ -10640,7 +11235,7 @@ function windowValue(expr, current, rows, env, parent, namedWindows) {
   if (name === "cume_dist") {
     if (partition.length === 0) return null;
     let lastPeer = index;
-    while (lastPeer + 1 < partition.length && rowsEqual(orderKeys[lastPeer + 1], orderKeys[index])) {
+    while (lastPeer + 1 < partition.length && rowsEqual2(orderKeys[lastPeer + 1], orderKeys[index])) {
       lastPeer++;
     }
     return (lastPeer + 1) / partition.length;
@@ -10648,7 +11243,7 @@ function windowValue(expr, current, rows, env, parent, namedWindows) {
   if (name === "percent_rank") {
     if (partition.length <= 1) return 0;
     let first = index;
-    while (first > 0 && rowsEqual(orderKeys[first], orderKeys[first - 1])) first--;
+    while (first > 0 && rowsEqual2(orderKeys[first], orderKeys[first - 1])) first--;
     return first / (partition.length - 1);
   }
   throw new SqliteError(`no such window function: ${expr.func.name}`, "other");
@@ -10673,7 +11268,7 @@ function frameBounds(spec, index, length, ctx, defaultFrameEnd, orderKeys) {
   const isRangeLike = spec.frame.type === "RANGE" || spec.frame.type === "GROUPS";
   let peerFirst = index;
   if (isRangeLike && spec.orderBy.length > 0) {
-    while (peerFirst > 0 && rowsEqual(orderKeys[peerFirst], orderKeys[peerFirst - 1])) peerFirst--;
+    while (peerFirst > 0 && rowsEqual2(orderKeys[peerFirst], orderKeys[peerFirst - 1])) peerFirst--;
   }
   const bound = (item, isStart) => {
     switch (item.kind) {
@@ -10695,8 +11290,8 @@ function frameBounds(spec, index, length, ctx, defaultFrameEnd, orderKeys) {
 function frameRows(partition, start, end, index, orderKeys, exclude) {
   let peerFirst = index;
   let peerLast = index;
-  while (peerFirst > 0 && rowsEqual(orderKeys[peerFirst], orderKeys[peerFirst - 1])) peerFirst--;
-  while (peerLast + 1 < partition.length && rowsEqual(orderKeys[peerLast], orderKeys[peerLast + 1])) peerLast++;
+  while (peerFirst > 0 && rowsEqual2(orderKeys[peerFirst], orderKeys[peerFirst - 1])) peerFirst--;
+  while (peerLast + 1 < partition.length && rowsEqual2(orderKeys[peerLast], orderKeys[peerLast + 1])) peerLast++;
   const rows = [];
   for (let i = Math.max(0, start); i <= end && i < partition.length; i++) {
     if (exclude === "current_row" && i === index) continue;
@@ -10922,7 +11517,7 @@ function referencesTable(select, name) {
   };
   return visit(select.from) || (select.compound ? referencesTable(select.compound.select, name) : false);
 }
-function rowsEqual(left, right) {
+function rowsEqual2(left, right) {
   return left.length === right.length && left.every((value, index) => {
     const other = right[index] ?? null;
     return value === null && other === null || value !== null && other !== null && sqlValueEquals(value, other);
@@ -12347,154 +12942,24 @@ function asExplicitRowid(value) {
 // src/executor/pragma.ts
 function executePragma(name, expr, env) {
   const key = name.toLowerCase();
-  switch (key) {
-    case "foreign_keys":
-      return pragmaForeignKeys(expr, env);
-    case "table_info":
-      return pragmaTableInfo(expr, env, false);
-    case "table_xinfo":
-      return pragmaTableInfo(expr, env, true);
-    case "index_list":
-      return pragmaIndexList(expr, env);
-    case "index_info":
-      return pragmaIndexInfo(expr, env);
-    case "foreign_key_list":
-      return pragmaForeignKeyList(expr, env);
-    case "database_list":
-      return pragmaDatabaseList(env);
-    case "user_version":
-      return pragmaIntVersion("user_version", expr, env, "userVersion");
-    case "schema_version":
-      return pragmaIntVersion("schema_version", expr, env, "schemaVersion");
-    default:
-      return emptyResult(0, env.state.lastInsertRowid);
-  }
-}
-function pragmaForeignKeys(expr, env) {
-  if (expr === null) {
-    return valuesToResult(["foreign_keys"], [[env.state.foreignKeysEnabled ? 1 : 0]], 0, env.state.lastInsertRowid);
-  }
-  const value = pragmaValue(expr, env);
-  if (!env.transactions.inTransaction) env.state.foreignKeysEnabled = isTruthySql(value) === true;
-  return emptyResult(0, env.state.lastInsertRowid);
-}
-function pragmaTableInfo(expr, env, xinfo) {
-  const tableName = pragmaTableArg(expr, env);
-  const table = env.state.tables.get(tableName.toLowerCase());
-  if (!table) return emptyResult(0, env.state.lastInsertRowid);
-  const columns = xinfo ? ["cid", "name", "type", "notnull", "dflt_value", "pk", "hidden"] : ["cid", "name", "type", "notnull", "dflt_value", "pk"];
-  const rows = table.columns.map((column, cid) => {
-    const pkIndex = table.columns.filter((c) => c.primaryKey).findIndex((c) => c.name === column.name);
-    const pk = column.primaryKey ? pkIndex >= 0 ? pkIndex + 1 : 1 : 0;
-    const dflt = column.defaultExpr ? defaultLiteral(column.defaultExpr) : null;
-    const base = [cid, column.name, column.typeName ?? "", column.notNull ? 1 : 0, dflt, pk];
-    if (xinfo) {
-      let hidden = 0;
-      if (column.generated?.stored) hidden = 2;
-      else if (column.generated) hidden = 2;
-      if (column.generated && !column.generated.stored) hidden = 2;
-      if (column.generated?.stored) hidden = 3;
-      base.push(hidden);
-    }
-    return base;
-  });
-  return valuesToResult(columns, rows, 0, env.state.lastInsertRowid);
-}
-function defaultLiteral(expr) {
-  if (expr.type === "literal")
-    return typeof expr.value === "string" ? `'${expr.value.replace(/'/g, "''")}'` : expr.value;
-  if (expr.type === "null") return "NULL";
-  return null;
-}
-function pragmaIndexList(expr, env) {
-  const tableName = pragmaTableArg(expr, env);
-  const table = env.state.tables.get(tableName.toLowerCase());
-  if (!table) return emptyResult(0, env.state.lastInsertRowid);
-  const rows = [];
-  let seq = 0;
-  for (const name of table.indexes) {
-    const index = env.state.indexes.get(name.toLowerCase());
-    if (!index) continue;
-    rows.push([seq++, index.name, index.unique ? 1 : 0, "c", 0]);
-  }
-  return valuesToResult(["seq", "name", "unique", "origin", "partial"], rows, 0, env.state.lastInsertRowid);
-}
-function pragmaIndexInfo(expr, env) {
-  const indexName = pragmaTableArg(expr, env);
-  const index = env.state.indexes.get(indexName.toLowerCase());
-  if (!index) return emptyResult(0, env.state.lastInsertRowid);
-  const table = env.state.getTable(index.tableName);
-  const rows = index.columns.map((column, seqno) => {
-    const cid = table.columns.findIndex((c) => c.name.toLowerCase() === column.name.toLowerCase());
-    return [seqno, cid, column.name];
-  });
-  return valuesToResult(["seqno", "cid", "name"], rows, 0, env.state.lastInsertRowid);
-}
-function pragmaForeignKeyList(expr, env) {
-  const tableName = pragmaTableArg(expr, env);
-  const table = env.state.tables.get(tableName.toLowerCase());
-  if (!table) return emptyResult(0, env.state.lastInsertRowid);
-  const rows = [];
-  let id = 0;
-  for (const constraint of table.constraints) {
-    if (constraint.type !== "foreign_key") continue;
-    const refColumns = constraint.refColumns ?? env.state.tables.get(constraint.refTable.toLowerCase())?.columns.filter((c) => c.primaryKey).map((c) => c.name) ?? [];
-    constraint.columns.forEach((column, seq) => {
-      rows.push([
-        id,
-        seq,
-        constraint.refTable,
-        column,
-        refColumns[seq] ?? null,
-        constraint.onUpdate ?? "NO ACTION",
-        constraint.onDelete ?? "NO ACTION",
-        "NONE"
-      ]);
-    });
-    id++;
-  }
-  return valuesToResult(
-    ["id", "seq", "table", "from", "to", "on_update", "on_delete", "match"],
-    rows,
-    0,
-    env.state.lastInsertRowid
-  );
-}
-function pragmaDatabaseList(env) {
-  const rows = [[0, "main", ""]];
-  let seq = 2;
-  for (const [name, attached] of env.state.attached) {
-    const file = attached.filename === ":memory:" ? "" : attached.filename;
-    rows.push([seq++, name, file]);
+  if (key === "foreign_keys" && expr !== null) {
+    const value = evalPragmaSetValue(expr, env);
+    if (!env.transactions.inTransaction) env.state.foreignKeysEnabled = coercePragmaTruthy(value);
+    return emptyResult(0, env.state.lastInsertRowid);
   }
-  return valuesToResult(["seq", "name", "file"], rows, 0, env.state.lastInsertRowid);
-}
-function pragmaIntVersion(label, expr, env, field) {
-  if (expr === null) {
-    return valuesToResult([label], [[env.state[field]]], 0, env.state.lastInsertRowid);
+  if ((key === "user_version" || key === "schema_version") && expr !== null) {
+    const value = evalPragmaSetValue(expr, env);
+    const num2 = coercePragmaInt(value);
+    if (key === "user_version") env.state.userVersion = num2;
+    else env.state.schemaVersion = num2;
+    return emptyResult(0, env.state.lastInsertRowid);
   }
-  const value = pragmaValue(expr, env);
-  const num2 = typeof value === "number" ? Math.trunc(value) : typeof value === "bigint" ? Number(value) : typeof value === "string" ? Number.parseInt(value, 10) : 0;
-  if (field === "userVersion") env.state.userVersion = Number.isFinite(num2) ? num2 : 0;
-  else env.state.schemaVersion = Number.isFinite(num2) ? num2 : 0;
-  return emptyResult(0, env.state.lastInsertRowid);
-}
-function pragmaTableArg(expr, env) {
-  if (!expr) throw new SqliteError("missing pragma argument", "misuse");
-  if (expr.type === "column" && expr.table === null) return expr.name;
-  if (expr.type === "literal" && typeof expr.value === "string") return expr.value;
-  const value = evalExpr(expr, env.createEvalContext());
-  if (typeof value === "string") return value;
-  throw new SqliteError("invalid pragma argument", "misuse");
-}
-function pragmaValue(expr, env) {
-  if (expr.type === "column" && expr.table === null) {
-    const keyword = expr.name.toLowerCase();
-    if (keyword === "on" || keyword === "true" || keyword === "yes") return 1;
-    if (keyword === "off" || keyword === "false" || keyword === "no") return 0;
-    return expr.name;
+  const args = evalPragmaArgs(expr, env);
+  const result = queryPragma(key, args, env);
+  if (result.columns.length === 0 && result.rows.length === 0) {
+    return emptyResult(0, env.state.lastInsertRowid);
   }
-  return evalExpr(expr, env.createEvalContext());
+  return valuesToResult(result.columns, result.rows, 0, env.state.lastInsertRowid);
 }
 
 // src/executor/execute.ts
@@ -12637,50 +13102,37 @@ var Statement = class _Statement {
   }
   database;
   sql;
-  bound = [];
   namedPlan = null;
   env = null;
   statements;
   schemaVersion;
   /**
-   * Construct a {@link Statement} for {@link Database.prepare}.
+   * Construct a {@link Statement} for {@link Database.prepare} / {@link Database.exec}.
    * @internal
    */
   static create(database, sql, statements) {
     return new _Statement(database, sql, statements);
   }
-  /**
-   * Store parameters for later {@link run} / {@link all} / {@link get} / {@link result}.
-   *
-   * Supports positional `?` / `?NNN` and named `:name` / `@name` / `$name` placeholders.
-   *
-   * @param params - Values to bind, in placeholder order.
-   * @returns `this` for chaining.
-   */
-  bind(...params) {
-    this.bound = [...params];
-    return this;
-  }
   /**
    * Execute for side effects (INSERT / UPDATE / DELETE / DDL).
    *
-   * @param params - If provided, override the last {@link bind}; otherwise bound values are used.
+   * @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) {
-    const result = this.execute(params.length > 0 ? params : this.bound, { named: false });
+    const result = this.execute(params, { named: false });
     return { changes: result.changes, lastInsertRowid: result.lastInsertRowid };
   }
   /**
    * Execute and return every result row as an object keyed by column name.
    *
    * @typeParam T - Row shape. Defaults to {@link QueryRow}.
-   * @param params - If provided, override the last {@link bind}; otherwise bound values are used.
+   * @param params - Bind values for this call only.
    * @throws {SqliteError} If the database is closed, the statement is empty, or execution fails.
    */
   all(...params) {
-    return this.execute(params.length > 0 ? params : this.bound, { named: true }).rows;
+    return this.execute(params, { named: true }).rows;
   }
   /**
    * Execute and return the full {@link ResultSet}, including column names.
@@ -12688,38 +13140,41 @@ var Statement = class _Statement {
    * Use this when you need metadata for an empty result (column names with zero rows).
    * {@link all} only returns row objects.
    *
-   * @param params - If provided, override the last {@link bind}; otherwise bound values are used.
+   * @param params - Bind values for this call only.
    * @throws {SqliteError} If the database is closed, the statement is empty, or execution fails.
    */
   result(...params) {
-    return this.execute(params.length > 0 ? params : this.bound, { named: true });
+    return this.execute(params, { named: true });
   }
   /**
    * Execute and return the first row, or `undefined` if there are no rows.
    *
    * @typeParam T - Row shape. Defaults to {@link QueryRow}.
-   * @param params - If provided, override the last {@link bind}; otherwise bound values are used.
+   * @param params - Bind values for this call only.
    * @throws {SqliteError} If the database is closed, the statement is empty, or execution fails.
    */
   get(...params) {
-    return this.execute(params.length > 0 ? params : this.bound, { named: true, maxRows: 1 }).rows[0];
+    return this.execute(params, { named: true, maxRows: 1 }).rows[0];
   }
   execute(params, options) {
     this.database.assertOpen();
     this.reprepareIfSchemaChanged();
     if (this.statements.length === 0) throw new SqliteError("empty statement", "misuse");
+    this.namedPlan ??= planNamedParameters(this.sql);
+    const expected = this.namedPlan.expectedCount;
+    if (params.length > 0 && params.length !== expected) {
+      throw new SqliteError(`SQLite query expected ${expected} values, received ${params.length}`, "misuse");
+    }
     const env = this.obtainEnv(params);
     env.maxRows = options?.maxRows ?? Number.POSITIVE_INFINITY;
     env.includeNamedRows = options?.named !== false;
     env.includeValues = true;
     this.bindNamed(env, params);
     let result;
-    let lastQuery;
     for (const statement of this.statements) {
       result = executeStatement(statement, env);
-      if (result.columns.length > 0) lastQuery = result;
     }
-    return lastQuery ?? result;
+    return result;
   }
   obtainEnv(params) {
     if (this.env) {
@@ -12769,18 +13224,18 @@ function planNamedParameters(sql) {
       }
     }
   }
-  return { named };
+  return { named, expectedCount: nextSlot - 1 };
 }
 
 // src/api/database.ts
 var Database = class {
   /** @internal Engine catalog, tables, and mutation counters. */
   state = new DatabaseState();
-  /** Seed used to construct the PRNG when `options.prng` is omitted. */
+  /** Seed used to construct the PRNG. */
   seed;
   /**
    * PRNG backing `random()` / `randomblob()` and related builtins.
-   * Prefer passing `seed` or `prng` to the constructor.
+   * Prefer passing `seed` to the constructor.
    * @internal
    */
   prng;
@@ -12794,6 +13249,8 @@ var Database = class {
   transactions;
   closed = false;
   transactionSequence = 0;
+  /** Depth of active {@link transaction} callbacks (not SQL BEGIN). */
+  apiTransactionDepth = 0;
   /**
    * Create an empty in-memory database.
    *
@@ -12801,49 +13258,53 @@ var Database = class {
    */
   constructor(options = {}) {
     this.seed = options.seed ?? DEFAULT_DATABASE_SEED;
-    this.prng = options.prng ?? new Prng(this.seed);
+    this.prng = new Prng(this.seed);
     this.now = resolveClock(options.now);
     this.transactions = new TransactionManager(this.state, this.prng);
   }
   /**
    * 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).
-   * @param params - Bound parameters for `?` / `:name` placeholders.
-   * @throws {SqliteError} If the database is closed or the SQL fails.
+   * @throws {SqliteError} If the database is closed, extra arguments are passed, or the SQL fails.
    */
-  exec(sql, params = []) {
+  exec(sql) {
     this.assertOpen();
-    Statement.create(this, sql, parse(sql)).run(...params);
+    if (arguments.length > 1) {
+      throw new SqliteError("exec() does not accept parameters; use prepare() or query()", "misuse");
+    }
+    Statement.create(this, sql, parse(sql)).run();
   }
   /**
-   * Execute a query and return all rows as objects keyed by column name.
+   * 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 - SQL SELECT (or any statement that produces a result set).
+   * @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 or the SQL fails.
+   * @throws {SqliteError} If the database is closed, `sql` is not a single statement, or execution fails.
    */
   query(sql, params = []) {
     this.assertOpen();
-    return Statement.create(this, sql, parse(sql)).all(...params);
+    return this.prepareSingle(sql).all(...params);
   }
   /**
-   * Compile `sql` into a reusable {@link Statement}.
+   * Compile a single SQL statement into a reusable {@link Statement}.
    *
-   * @param sql - SQL to prepare.
-   * @throws {SqliteError} If the database is closed or `sql` cannot be parsed.
+   * @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) {
     this.assertOpen();
-    return Statement.create(this, sql, parse(sql));
+    return this.prepareSingle(sql);
   }
   /**
    * 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.
+   * 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`.
@@ -12851,27 +13312,32 @@ var Database = class {
    */
   transaction(fn) {
     this.assertOpen();
-    if (!this.transactions.inTransaction) {
-      this.transactions.begin();
+    this.apiTransactionDepth++;
+    try {
+      if (!this.transactions.inTransaction) {
+        this.transactions.begin();
+        try {
+          const value = fn();
+          this.transactions.commit();
+          return value;
+        } catch (error) {
+          this.transactions.rollback();
+          throw error;
+        }
+      }
+      const name = `__api_transaction_${++this.transactionSequence}`;
+      this.transactions.savepoint(name);
       try {
         const value = fn();
-        this.transactions.commit();
+        this.transactions.release(name);
         return value;
       } catch (error) {
-        this.transactions.rollback();
+        this.transactions.rollback(name);
+        this.transactions.release(name);
         throw error;
       }
-    }
-    const name = `__api_transaction_${++this.transactionSequence}`;
-    this.transactions.savepoint(name);
-    try {
-      const value = fn();
-      this.transactions.release(name);
-      return value;
-    } catch (error) {
-      this.transactions.rollback(name);
-      this.transactions.release(name);
-      throw error;
+    } finally {
+      this.apiTransactionDepth--;
     }
   }
   /**
@@ -12892,6 +13358,8 @@ var Database = class {
    * 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.
@@ -12910,10 +13378,14 @@ var Database = class {
   /**
    * Close the database. Further SQL throws {@link SqliteError}. Idempotent.
    *
-   * Rolls back an open transaction, if any.
+   * Rolls back an open SQL transaction, if any. Throws if called from inside
+   * a {@link transaction} callback.
    */
   close() {
     if (this.closed) return;
+    if (this.apiTransactionDepth > 0) {
+      throw new SqliteError("cannot close database inside transaction()", "misuse");
+    }
     if (this.transactions.inTransaction) this.transactions.rollback();
     this.closed = true;
   }
@@ -12943,42 +13415,30 @@ var Database = class {
   assertOpen() {
     if (this.closed) throw new SqliteError("Database is closed", "misuse");
   }
+  prepareSingle(sql) {
+    const statements = parse(sql);
+    if (statements.length === 0) {
+      throw new SqliteError("empty statement", "misuse");
+    }
+    if (statements.length > 1) {
+      throw new SqliteError("query()/prepare() accept a single statement only; use exec() for scripts", "misuse");
+    }
+    return Statement.create(this, sql, statements);
+  }
 };
+var disposeKey = Symbol.dispose;
+if (typeof disposeKey === "symbol") {
+  Object.defineProperty(Database.prototype, disposeKey, {
+    value: function() {
+      this.close();
+    },
+    writable: true,
+    configurable: true
+  });
+}
 export {
-  DEFAULT_DATABASE_SEED,
-  DEFAULT_NOW,
   Database,
-  Prng,
-  SqlJsonText,
-  SqlReal,
   SqliteError,
-  Statement,
-  affinityFromTypeName,
-  applyAffinity,
-  asSqlJsonText,
-  asSqlReal,
-  canonicalizeNumber,
-  cloneSqlValue,
-  coerceToNumber,
-  compareSql,
-  decodeDatabaseState,
-  deriveSeed,
-  encodeDatabaseState,
-  evalExpr,
-  fixedClock,
-  globMatch,
-  isSqlJsonText,
-  isSqlReal,
-  isTruthySql,
-  likeMatch,
-  parse,
-  resolveClock,
-  sqlValueEquals,
-  storageClassOf,
-  toInteger,
-  tokenize,
-  typeofSql,
-  utf8Decode,
-  utf8Encode
+  Statement
 };
 //# sourceMappingURL=index.js.map