@dolthub/doltlite 0.10.8 → 0.11.8

package/README.md

@@ -173,7 +173,7 @@ bun test      # run the test suite
 
 ## Versioning
 
-The package version tracks the DoltLite version. `@dolthub/doltlite@0.10.0` ships the DoltLite 0.10.0 amalgamation.
+The package version tracks the DoltLite version. `@dolthub/doltlite@0.11.8` ships the DoltLite 0.11.8 amalgamation.
 
 ## License
 

package/index.d.ts

@@ -85,13 +85,21 @@ export class StatementSync {
   /** Execute the statement and return change metadata. */
   run(...params: unknown[]): RunResult
   /** Return the first result row, or undefined. */
-  get(...params: unknown[]): Record<string, unknown> | undefined
+  get(...params: unknown[]): Record<string, unknown> | unknown[] | undefined
   /** Return all result rows. */
-  all(...params: unknown[]): Record<string, unknown>[]
+  all(...params: unknown[]): Array<Record<string, unknown> | unknown[]>
   /** Return an iterator over result rows. */
-  iterate(...params: unknown[]): IterableIterator<Record<string, unknown>>
+  iterate(...params: unknown[]): IterableIterator<Record<string, unknown> | unknown[]>
   /** Return column metadata for the statement. */
   columns(): ColumnInfo[]
+  /** Return result rows as arrays instead of objects. */
+  setReturnArrays(enabled: boolean): void
+  /** Return integer columns as BigInt values. */
+  setReadBigInts(enabled: boolean): void
+  /** Allow bare object keys for named parameters. */
+  setAllowBareNamedParameters(enabled: boolean): void
+  /** Ignore unknown named parameter keys. */
+  setAllowUnknownNamedParameters(enabled: boolean): void
   /** The SQL source text of the statement. */
   readonly sourceSQL: string
   /** The SQL text with bound parameters expanded. */

package/index.js

@@ -10,15 +10,21 @@ function loadAddon() {
   const arch = process.arch
   const prebuilt = path.join(__dirname, "prebuilds", `${platform}-${arch}`, "doltlite.node")
   const compiled = path.join(__dirname, "build", "Release", "doltlite.node")
+  const compiledObjTarget = path.join(__dirname, "build", "Release", "obj.target", "doltlite.node")
 
-  for (const candidate of [prebuilt, compiled]) {
+  const errors = []
+  for (const candidate of [prebuilt, compiled, compiledObjTarget]) {
+    if (!fs.existsSync(candidate)) continue
     try {
       return require(candidate)
-    } catch {}
+    } catch (err) {
+      errors.push(`${candidate}: ${err && err.message ? err.message : err}`)
+    }
   }
 
   throw new Error(
     `@dolthub/doltlite: no native binary found for ${platform}-${arch}.\n` +
+    (errors.length ? `Tried:\n${errors.join("\n")}\n` : "") +
     `Run \`npm install\` to build from source, or file an issue at ` +
     `https://github.com/dolthub/doltlite-node/issues`
   )

package/package.json

@@ -1,22 +1,27 @@
 {
   "name": "@dolthub/doltlite",
-  "version": "0.10.8",
+  "version": "0.11.8",
   "description": "Node.js bindings for DoltLite — a SQLite fork with Git-style version control",
   "license": "Apache-2.0",
   "main": "index.js",
   "types": "index.d.ts",
   "type": "commonjs",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
   "files": [
     "index.js",
     "index.d.ts",
     "src/",
     "binding.gyp",
+    "scripts/install.js",
     "scripts/download.js",
     "scripts/build-amalgamation.js",
     "prebuilds/"
   ],
   "scripts": {
-    "install": "node scripts/download.js && node-gyp rebuild",
+    "install": "node scripts/install.js",
     "build": "node-gyp rebuild",
     "build:debug": "node-gyp rebuild --debug",
     "test": "bun test test/",

package/scripts/build-amalgamation.js

@@ -1,523 +1,84 @@
 #!/usr/bin/env node
-// Builds a complete doltlite amalgamation from the autoconf source tree.
-//
-// Generates two C files:
-//
-//   amalgamation/doltlite_orig.c  — the original SQLite btree/pager/wal/backup code
-//       compiled with btree_orig_prefix.h so every exported symbol gets an orig_
-//       prefix.  This keeps the original implementation available alongside the
-//       prolly-tree replacements.  Compiled as a separate translation unit so its
-//       struct definitions (original BtShared, Pager, etc.) don't clash with the
-//       prolly versions in doltlite.c.
-//
-//   amalgamation/doltlite.c  — the base sqlite3.c amalgamation (with btree/pager/
-//       wal/btmutex/backup sections wrapped in #ifndef DOLTLITE_PROLLY), followed
-//       by the blake3, prolly-tree, and doltlite SQL-function source files.
-//
-// When both files are compiled with -DDOLTLITE_PROLLY=1, the full version-
-// control stack is active.  Without that flag doltlite.c degrades to plain SQLite
-// and doltlite_orig.c is a harmless dead-code object.
+// Prepares the DoltLite release amalgamation for the native Node addon.
 
 "use strict"
 
 const fs = require("fs")
 const path = require("path")
-
-const { version } = require("../package.json")
-
-const srcRoot    = path.join(__dirname, "../doltlite-src")
-const baseSqlite = path.join(srcRoot, "sqlite3.c")
-const srcDir     = path.join(srcRoot, "src")
-const blake3Dir  = path.join(srcRoot, "ext", "blake3")
-const outDir     = path.join(__dirname, "../amalgamation")
-const outFile    = path.join(outDir, "doltlite.c")
-const outOrig    = path.join(outDir, "doltlite_orig.c")
-const outHeader  = path.join(outDir, "doltlite.h")
-
-// Files in the sqlite3.c amalgamation whose symbols are replaced by prolly_btree.c / pager_shim.c.
-// They are wrapped in #ifndef DOLTLITE_PROLLY so the compiler only sees one definition.
-const GUARDED = ["btree.c", "pager.c", "wal.c", "btmutex.c", "backup.c"]
-
-// Source files to append to doltlite.c.
-// Each entry is either a filename relative to srcDir, or an absolute path.
-// Order matters: lower-level files before the code that calls them.
-const EXTRA = [
-  // blake3 hash library (required by prolly_hash.c, lives in ext/blake3/)
-  // blake3_dispatch.c replaced blake3_dispatch_portable.c in 0.10.6.
-  path.join(blake3Dir, "blake3.c"),
-  path.join(blake3Dir, "blake3_portable.c"),
-  path.join(blake3Dir, fs.existsSync(path.join(blake3Dir, "blake3_dispatch.c"))
-    ? "blake3_dispatch.c" : "blake3_dispatch_portable.c"),
-  // prolly tree
-  "prolly_hash.c",
-  "prolly_xxhash.c",
-  "prolly_hashset.c",
-  "prolly_node.c",
-  "prolly_cache.c",
-  // chunk store subsystems (split out of chunk_store.c in 0.10.8)
-  "chunk_file.c",
-  "chunk_refs.c",
-  "chunk_index.c",
-  "chunk_staging.c",
-  "chunk_wal.c",
-  "chunk_store.c",
-  "prolly_cursor.c",
-  "prolly_mutmap.c",
-  "prolly_chunker.c",
-  "prolly_mutate.c",
-  "prolly_diff.c",
-  "prolly_three_way_diff.c",
-  "prolly_three_way_merge.c",
-  "prolly_btree.c",
-  "pager_shim.c",
-  "sortkey.c",
-  // dolt SQL functions
-  "doltlite.c",
-  "doltlite_commit.c",
-  "doltlite_ref.c",
-  "doltlite_log.c",
-  "doltlite_status.c",
-  "doltlite_diff.c",
-  "doltlite_diff_table.c",
-  "doltlite_branch.c",
-  "doltlite_tag.c",
-  "doltlite_ancestor.c",
-  "doltlite_commit_ancestors.c",
-  "doltlite_merge.c",
-  "doltlite_schema_merge.c",
-  "doltlite_conflicts.c",
-  "doltlite_gc.c",
-  "doltlite_chunk_walk.c",
-  "doltlite_history.c",
-  "doltlite_at.c",
-  "doltlite_blame.c",
-  "doltlite_schema_diff.c",
-  "doltlite_schemas.c",
-  "doltlite_diff_stat.c",
-  "doltlite_record.c",
-  "doltlite_ignore.c",
-  "doltlite_hashof.c",
-  "doltlite_constraint_violations.c",
-  "doltlite_merge_constraints.c",
-  "doltlite_dbpage.c",
-  "doltlite_remote.c",
-  "doltlite_remote_sql.c",
-  "doltlite_http_remote.c",
-  "doltlite_remotesrv.c",
-]
-
-// Per-file symbol renames to resolve conflicts when multiple source files are
-// merged into a single translation unit.
-// Each entry: { file: basename, renames: [[oldWord, newWord], ...] }
-// Replacements are applied as whole-word substitutions (word-boundary regex).
-const FILE_PATCHES = [
-  {
-    // prolly_btree.c defines struct TableEntry, struct SchemaEntry, and
-    // tableEntryNameCmp/buildSchemaCatalogRecord — rename the duplicates that
-    // appear later in doltlite_merge.c so they don't collide.
-    file: "doltlite_merge.c",
-    renames: [
-      // Rename the local MergeFieldValue (used only by buildSchemaCatalogRecord)
-      // so it doesn't clash with doltlite_merge_constraints.c's MergeFieldValue.
-      ["mergeCatalogSerialType",  "dlMergeCatalogSerialType"],
-      ["mergeCatalogSerialPut",   "dlMergeCatalogSerialPut"],
-      ["MergeFieldValue",         "DlMergeSchemaMFV"],
-      // buildSchemaCatalogRecord is also defined in prolly_btree.c.
-      ["buildSchemaCatalogRecord","dlMergeBuildSchemaRecord"],
-      // ConflictRow is embedded in RowMergeCtx here; doltlite_conflicts.c also
-      // embeds an identically-named struct → rename the merge.c version.
-      ["ConflictRow",             "DlMergeConflictRow"],
-      // freeConflictTables has a different signature in doltlite_conflicts.c.
-      ["freeConflictTables",      "dlMergeFreeConflictTables"],
-    ],
-  },
-  {
-    // doltlite_merge_constraints.c defines its own MergeFieldValue (which has
-    // an extra `double r` field vs the one in doltlite_merge.c).
-    file: "doltlite_merge_constraints.c",
-    renames: [
-      ["mergeSerialType",         "dlConstraintMergeSerialType"],
-      ["mergeSerialPut",          "dlConstraintMergeSerialPut"],
-      ["MergeFieldValue",         "DlConstraintMFV"],
-    ],
-  },
-  {
-    // writeAll is also defined (identically) in doltlite_http_remote.c which
-    // comes earlier in the EXTRA list.
-    file: "doltlite_remotesrv.c",
-    renames: [
-      ["writeAll", "srvWriteAll"],
-    ],
-  },
-]
-
-// Per-file exact text patches (verbatim old → new, applied after renames).
-// Each entry: { file: basename, patches: [[oldText, newText], ...] }
-const FILE_TEXT_PATCHES = [
-  {
-    // os_win.c does not implement SQLITE_FCNTL_HAS_MOVED; sqlite3OsFileControl
-    // returns SQLITE_NOTFOUND ("unknown operation") for that opcode.
-    // csDetectExternalChanges previously propagated that error, so every write
-    // transaction on a file-based database failed on Windows.  Treat NOTFOUND
-    // the same way the standard pager does: assume the file has not moved.
-    file: "chunk_store.c",
-    patches: [
-      // 0.10.5 used 2-space indent; 0.10.6 uses 4-space inside the hasMovedChecked guard.
-      [
-        `    rc = sqlite3OsFileControl(cs->file.pFile, SQLITE_FCNTL_HAS_MOVED, &bMoved);\n    if( rc!=SQLITE_OK ) return rc;\n    if( bMoved ){`,
-        `    rc = sqlite3OsFileControl(cs->file.pFile, SQLITE_FCNTL_HAS_MOVED, &bMoved);\n    if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK; /* not supported by this VFS */\n    if( rc!=SQLITE_OK ) return rc;\n    if( bMoved ){`,
-      ],
-      // On Windows, csFileLock / csFileLockNB opened the database file itself
-      // and held an exclusive byte-range lock over ALL bytes.  sqlite3OsWrite
-      // then tried to write via cs->pFile (a different HANDLE to the same path).
-      // Windows exclusive byte-range locks block WriteFile from other handles —
-      // even handles in the same process — causing SQLITE_IOERR_WRITE after the
-      // winRetryIoerr retry loop.  Fix: use a separate "<path>.lock" file so
-      // the lock fd and the I/O fd never conflict.
-      [
-        `#ifdef _WIN32\n# include <io.h>\n# include <windows.h>\n  static int csFileLock(const char *path, int *pFd){\n    int fd = _open(path, _O_BINARY | _O_RDWR | _O_CREAT, 0644);\n    if( fd < 0 ) return -1;\n    {\n      HANDLE h = (HANDLE)_get_osfhandle(fd);\n      OVERLAPPED ov = {0};\n      if( !LockFileEx(h, LOCKFILE_EXCLUSIVE_LOCK, 0, MAXDWORD, MAXDWORD, &ov) ){\n        _close(fd);\n        return -1;\n      }\n    }\n    *pFd = fd;\n    return 0;\n  }\n  static void csFileUnlock(int fd){\n    if( fd >= 0 ){\n      HANDLE h = (HANDLE)_get_osfhandle(fd);\n      OVERLAPPED ov = {0};\n      UnlockFileEx(h, 0, MAXDWORD, MAXDWORD, &ov);\n      _close(fd);\n    }\n  }\n  static int csFileLockNB(const char *path, int *pFd){\n    int fd = _open(path, _O_BINARY | _O_RDWR | _O_CREAT, 0644);\n    if( fd < 0 ) return -1;\n    {\n      HANDLE h = (HANDLE)_get_osfhandle(fd);\n      OVERLAPPED ov = {0};\n      if( !LockFileEx(h, LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY,\n                       0, MAXDWORD, MAXDWORD, &ov) ){\n        _close(fd);\n        return -1;\n      }\n    }\n    *pFd = fd;\n    return 0;\n  }\n#else`,
-        `#ifdef _WIN32\n# include <io.h>\n# include <windows.h>\n  /* Use a separate "<path>.lock" file for byte-range locking so that\n  ** LockFileEx on the lock fd does not conflict with WriteFile on\n  ** cs->pFile (a different HANDLE to the same path).  On Windows,\n  ** exclusive byte-range locks block writes from other handles to the\n  ** locked region even within the same process. */\n  static int csMakeLockPath(const char *path, char **ppLock){\n    int n = (int)strlen(path);\n    char *p = (char *)malloc(n + 6);\n    if( !p ) return -1;\n    memcpy(p, path, n);\n    memcpy(p + n, ".lock", 6);\n    *ppLock = p;\n    return 0;\n  }\n  static int csFileLock(const char *path, int *pFd){\n    char *lockPath = 0;\n    int fd;\n    if( csMakeLockPath(path, &lockPath) ) return -1;\n    fd = _open(lockPath, _O_BINARY | _O_RDWR | _O_CREAT, 0644);\n    free(lockPath);\n    if( fd < 0 ) return -1;\n    {\n      HANDLE h = (HANDLE)_get_osfhandle(fd);\n      OVERLAPPED ov = {0};\n      if( !LockFileEx(h, LOCKFILE_EXCLUSIVE_LOCK, 0, MAXDWORD, MAXDWORD, &ov) ){\n        _close(fd);\n        return -1;\n      }\n    }\n    *pFd = fd;\n    return 0;\n  }\n  static void csFileUnlock(int fd){\n    if( fd >= 0 ){\n      HANDLE h = (HANDLE)_get_osfhandle(fd);\n      OVERLAPPED ov = {0};\n      UnlockFileEx(h, 0, MAXDWORD, MAXDWORD, &ov);\n      _close(fd);\n    }\n  }\n  static int csFileLockNB(const char *path, int *pFd){\n    char *lockPath = 0;\n    int fd;\n    if( csMakeLockPath(path, &lockPath) ) return -1;\n    fd = _open(lockPath, _O_BINARY | _O_RDWR | _O_CREAT, 0644);\n    free(lockPath);\n    if( fd < 0 ) return -1;\n    {\n      HANDLE h = (HANDLE)_get_osfhandle(fd);\n      OVERLAPPED ov = {0};\n      if( !LockFileEx(h, LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY,\n                       0, MAXDWORD, MAXDWORD, &ov) ){\n        _close(fd);\n        return -1;\n      }\n    }\n    *pFd = fd;\n    return 0;\n  }\n#else`,
-      ],
-    ],
-  },
-]
-
-// Build a map from basename → rename pairs for fast lookup.
-const patchMap = new Map()
-for (const { file, renames } of FILE_PATCHES) {
-  patchMap.set(file, renames)
-}
-
-// Build a map from basename → text patches for fast lookup.
-const textPatchMap = new Map()
-for (const { file, patches } of FILE_TEXT_PATCHES) {
-  textPatchMap.set(file, patches)
-}
-
-function applyRenames(src, renames) {
-  let out = src
-  for (const [from, to] of renames) {
-    // Word-boundary replacement: only replace complete identifiers.
-    const re = new RegExp(`\\b${from}\\b`, "g")
-    out = out.replace(re, to)
-  }
-  return out
-}
-
-function applyTextPatches(src, patches) {
-  let out = src
-  for (const [from, to] of patches) {
-    if (!out.includes(from)) {
-      process.stderr.write(`build-amalgamation: warning — text patch not found in source\n  expected: ${JSON.stringify(from.slice(0, 60))}\n`)
-    }
-    out = out.split(from).join(to)
-  }
-  return out
-}
-
-if (!fs.existsSync(baseSqlite)) {
-  console.error(`build-amalgamation: ${baseSqlite} not found — run download.js first`)
+const pkg = require("../package.json")
+
+const outDir    = path.join(__dirname, "../amalgamation")
+const srcRoot   = path.join(outDir, ".source")
+const srcDir    = path.join(srcRoot, "src")
+const blake3Dir = path.join(srcRoot, "ext", "blake3")
+
+const inC       = path.join(srcRoot, "sqlite3.c")
+const inH       = path.join(srcRoot, "sqlite3.h")
+const outC      = path.join(outDir, "doltlite.c")
+const outH      = path.join(outDir, "doltlite.h")
+const outOrig   = path.join(outDir, "doltlite_orig.c")
+const versionMarker = path.join(outDir, ".doltlite-source-version")
+
+if (!fs.existsSync(inC)) {
+  console.error(`build-amalgamation: ${inC} not found - run download.js first`)
   process.exit(1)
 }
-
-console.log("Building full doltlite amalgamation...")
-
-// Extract generated headers (parse.h, opcodes.h) from the sqlite3.c amalgamation.
-// These files are produced by the SQLite build system and are not shipped in the tarball.
-{
-  const base = fs.readFileSync(baseSqlite, "utf8")
-  for (const hdr of ["parse.h", "opcodes.h"]) {
-    const hdrPath = path.join(srcDir, hdr)
-    if (fs.existsSync(hdrPath)) continue
-    const beginMark = `/************** Begin file ${hdr}`
-    const endMark   = `/************** End of ${hdr}`
-    const bi = base.indexOf(beginMark)
-    const ei = base.indexOf(endMark)
-    if (bi !== -1 && ei !== -1) {
-      const startOfContent = base.indexOf("\n", bi) + 1
-      const endOfContent   = base.lastIndexOf("\n", ei) + 1
-      fs.writeFileSync(hdrPath, base.slice(startOfContent, endOfContent))
-      console.log(`Extracted ${hdr} to ${hdrPath}`)
-    } else {
-      process.stderr.write(`build-amalgamation: warning — could not find ${hdr} in sqlite3.c\n`)
-    }
-  }
-}
-
-// Patch btreeInt.h to add include guards.
-// The original file has none; when multiple _orig.c files (each of which does
-// #include "btmutex.c" / "backup.c" / etc.) are merged into a single translation
-// unit, the compiler re-includes btreeInt.h through each of them, triggering
-// struct redefinition errors.
-{
-  const btreeIntPath = path.join(srcDir, "btreeInt.h")
-  if (fs.existsSync(btreeIntPath)) {
-    const src = fs.readFileSync(btreeIntPath, "utf8")
-    if (!src.includes("#ifndef BTREEINT_H")) {
-      fs.writeFileSync(btreeIntPath,
-        "#ifndef BTREEINT_H\n#define BTREEINT_H\n" + src + "\n#endif /* BTREEINT_H */\n"
-      )
-      console.log("Patched btreeInt.h with include guards")
-    }
-  }
-}
-
-// ── doltlite_orig.c ────────────────────────────────────────────────────────
-// Compile the original SQLite btree/pager/wal/backup with orig_ prefix symbols.
-// This must be a separate TU because it defines the original BtShared / Pager
-// structs, which conflict with prolly_btree.c's replacements in doltlite.c.
-{
-  const origFiles = [
-    "btmutex_orig.c",
-    "pager_orig.c",
-    "wal_orig.c",
-    "backup_orig.c",
-    "btree_orig.c",
-    "btree_orig_api.c",
-  ]
-
-  // Variables defined in the original pager/btree code that pager_shim.c in
-  // doltlite.c also defines.  We rename them here so the linker sees two
-  // different symbols and doesn't complain about duplicate definitions.
-  // (These are test/statistics counters, only incremented under #ifdef SQLITE_TEST,
-  // so renaming them away from their original names has no runtime effect in
-  // release builds.)
-  const conflictingGlobals = [
-    "sqlite3_pager_readdb_count",
-    "sqlite3_pager_writedb_count",
-    "sqlite3_pager_writej_count",
-    "sqlite3_opentemp_count",
-    "sqlite3SharedCacheList",
-  ]
-
-  const origLines = [
-    "/* Generated by build-amalgamation.js — DO NOT EDIT */",
-    "/* Original SQLite btree/pager/wal/backup compiled with orig_ prefix symbols.",
-    "** Compiled as a separate translation unit from doltlite.c. */",
-    "",
-    "/* btree_orig_api.c needs DOLTLITE_PROLLY */",
-    "#ifndef DOLTLITE_PROLLY",
-    "#define DOLTLITE_PROLLY 1",
-    "#endif",
-    "",
-    "/* Rename globals that pager_shim.c in doltlite.c also defines, to avoid",
-    "** duplicate-symbol linker errors in release (non-SQLITE_TEST) builds. */",
-    ...conflictingGlobals.map(g => `#define ${g} dlt_orig_${g.replace(/^sqlite3_?/, "")}`),
-    "",
-  ]
-
-  for (const f of origFiles) {
-    const p = path.join(srcDir, f)
-    if (!fs.existsSync(p)) {
-      process.stderr.write(`build-amalgamation: warning — ${f} not found, skipping\n`)
-      continue
-    }
-    origLines.push(`/************** Begin doltlite_orig file ${f} **************/`)
-    origLines.push(fs.readFileSync(p, "utf8"))
-    origLines.push(`/************** End of doltlite_orig file ${f} ******************/`)
-    origLines.push("")
-  }
-
-  fs.mkdirSync(outDir, { recursive: true })
-  fs.writeFileSync(outOrig, origLines.join("\n"))
-  console.log(`doltlite_orig.c written to ${outOrig}`)
-}
-
-// ── doltlite.c ────────────────────────────────────────────────────────────
-let content = fs.readFileSync(baseSqlite, "utf8")
-
-// Make SQLITE_PRIVATE symbols non-static so doltlite_orig.c (a separate TU
-// that contains the original pager/btree/wal code) can link against them.
-// The amalgamation defines SQLITE_PRIVATE as `static`, which gives every
-// internal function internal linkage — invisible to other TUs.  Removing
-// the `static` makes them hidden-visibility globals (via -fvisibility=hidden)
-// that are linkable within the final .node binary but not exported from it.
-content = content.replace(/#\s*define\s+SQLITE_PRIVATE\s+static\b/, '# define SQLITE_PRIVATE')
-
-// Wrap each guarded section.
-// The amalgamation uses markers of the form:
-//   /************** Begin file btree.c **************/
-//   /************** End of btree.c ******************/
-for (const file of GUARDED) {
-  const escapedFile = file.replace(".", "\\.")
-  const beginRe = new RegExp(`(/\\*{6,}\\s*Begin file ${escapedFile}\\s*\\*{6,}/)`)
-  const endRe   = new RegExp(`(/\\*{6,}\\s*End of ${escapedFile}\\s*\\*{6,}/)`)
-  const bm = beginRe.exec(content)
-  const em = endRe.exec(content)
-  if (!bm || !em) {
-    process.stderr.write(`build-amalgamation: warning — markers not found for ${file}\n`)
-    continue
-  }
-  const before  = content.slice(0, bm.index)
-  const section = content.slice(bm.index, em.index + em[0].length)
-  const after   = content.slice(em.index + em[0].length)
-  content = `${before}#ifndef DOLTLITE_PROLLY\n${section}\n#endif /* !DOLTLITE_PROLLY */\n${after}`
-}
-
-// Append prolly + doltlite source files.
-const parts = [content]
-for (const file of EXTRA) {
-  const p = path.isAbsolute(file) ? file : path.join(srcDir, file)
-  const name = path.basename(p)
-  if (!fs.existsSync(p)) {
-    process.stderr.write(`build-amalgamation: warning — ${name} not found, skipping\n`)
-    continue
-  }
-  let src = fs.readFileSync(p, "utf8")
-  if (patchMap.has(name)) {
-    src = applyRenames(src, patchMap.get(name))
-  }
-  if (textPatchMap.has(name)) {
-    src = applyTextPatches(src, textPatchMap.get(name))
-  }
-  parts.push(`\n/************** Begin DOLTLITE-EXTRA file ${name} **************/\n`)
-  parts.push(src)
-  parts.push(`\n/************** End of DOLTLITE-EXTRA ${name} ******************/\n`)
-}
-
-// Prepend the DOLTLITE_VERSION define into the extra section so that
-// prolly_btree.c and doltlite.c can use it without compiler flag quoting issues.
-parts.splice(1, 0, `\n/* Injected by build-amalgamation.js */\n#ifndef DOLTLITE_VERSION\n#define DOLTLITE_VERSION "${version}"\n#endif\n`)
-
-// sqlite3PagerWalSystemErrno is defined in pager.c, which is skipped in
-// DOLTLITE_PROLLY builds.  pager_shim.c does not implement it.  Provide a
-// stub: shim-pagers have no WAL (return 0); plain-sqlite Pagers (from ATTACH)
-// dispatch to the orig_ version compiled in doltlite_orig.c.
-// strncasecmp is a POSIX extension absent from MSVC — map it to _strnicmp.
-parts.push(`
-#ifdef DOLTLITE_PROLLY
-#ifdef _WIN32
-#  ifndef strncasecmp
-#    define strncasecmp _strnicmp
-#  endif
-#endif
-extern int orig_sqlite3PagerWalSystemErrno(Pager *pPager);
-int sqlite3PagerWalSystemErrno(Pager *pPager){
-  if( !pPager ) return 0;
-  /* Shim pagers start with PAGER_SHIM_MAGIC (0x50534D31) at offset 0. */
-  if( ((const unsigned int*)pPager)[0] == 0x50534D31u ) return 0;
-  return orig_sqlite3PagerWalSystemErrno(pPager);
+if (!fs.existsSync(inH)) {
+  console.error(`build-amalgamation: ${inH} not found - run download.js first`)
+  process.exit(1)
 }
-#endif /* DOLTLITE_PROLLY */
-`)
 
+console.log("Preparing released doltlite amalgamation...")
 fs.mkdirSync(outDir, { recursive: true })
-fs.writeFileSync(outFile, parts.join(""))
-console.log(`Amalgamation written to ${outFile}`)
-
-// Generate a shim doltlite_internal.h in the output directory.
-// Since amalgamation/ is listed first in include_dirs, this takes priority
-// over the one in doltlite-src/src/.  It wraps the definitions that
-// prolly_btree.c already provides so they don't get redefined.
-const origInternal = fs.readFileSync(
-  path.join(srcDir, "doltlite_internal.h"), "utf8"
-)
-// prolly_btree.c (compiled earlier in the same TU) already defines:
-//   struct TableEntry, typedef/struct SchemaEntry, tableEntryNameCmp
-// Wrap those in #ifndef DOLTLITE_PROLLY so they're skipped in prolly mode.
-let shimInternal = origInternal
-
-// Guard `struct TableEntry { ... };`
-shimInternal = shimInternal.replace(
-  /(struct TableEntry \{[^}]*\};)/s,
-  "#ifndef DOLTLITE_PROLLY\n$1\n#endif /* !DOLTLITE_PROLLY */"
-)
-
-// Guard `typedef struct SchemaEntry SchemaEntry;`
-shimInternal = shimInternal.replace(
-  /typedef struct SchemaEntry SchemaEntry;/,
-  "#ifndef DOLTLITE_PROLLY\ntypedef struct SchemaEntry SchemaEntry;\n#endif /* !DOLTLITE_PROLLY */"
-)
+let amalgamation = fs.readFileSync(inC, "utf8")
+amalgamation += `
 
-// Guard `struct SchemaEntry { ... };` (at end of file)
-shimInternal = shimInternal.replace(
-  /(struct SchemaEntry \{[^}]*\};)/s,
-  "#ifndef DOLTLITE_PROLLY\n$1\n#endif /* !DOLTLITE_PROLLY */"
-)
-
-// Guard `tableEntryNameCmp` static inline function
-shimInternal = shimInternal.replace(
-  /(static SQLITE_INLINE int tableEntryNameCmp\([\s\S]*?\n\})/,
-  "#ifndef DOLTLITE_PROLLY\n$1\n#endif /* !DOLTLITE_PROLLY */"
-)
-
-const shimPath = path.join(outDir, "doltlite_internal.h")
-fs.writeFileSync(shimPath, shimInternal)
-
-// Copy the header alongside.
-const baseHeader = path.join(srcRoot, "sqlite3.h")
-if (fs.existsSync(baseHeader) && !fs.existsSync(outHeader)) {
-  fs.copyFileSync(baseHeader, outHeader)
+#if defined(DOLTLITE_PROLLY) && defined(SQLITE_USE_SEH) && !defined(SQLITE_OMIT_WAL)
+SQLITE_PRIVATE int sqlite3PagerWalSystemErrno(Pager *pPager){
+  (void)pPager;
+  return 0;
 }
+#endif
+`
+fs.writeFileSync(outC, amalgamation)
+fs.copyFileSync(inH, outH)
+fs.writeFileSync(versionMarker, `${pkg.version}\n`)
+
+// Kept for binding.gyp compatibility. DoltLite release amalgamations are now
+// self-contained and include the prefixed original SQLite implementation.
+fs.writeFileSync(outOrig, [
+  "/* Generated by build-amalgamation.js - intentionally empty.",
+  "** The released doltlite.c amalgamation is self-contained. */",
+  "",
+].join("\n"))
 
-console.log(`Shim doltlite_internal.h written to ${shimPath}`)
-
-// Copy all .h files from doltlite-src/src/ and doltlite-src/ext/blake3/ into
-// amalgamation/ so the compiler can find them via the existing "amalgamation"
-// include_dir without needing doltlite-src in the C include path.
-// Skip files that already have custom shims (btreeInt.h, doltlite_internal.h).
-const SKIP_HEADERS = new Set(["btreeInt.h", "doltlite_internal.h"])
+// Copy headers included by addon sources and by the BLAKE3 SIMD wrappers.
 for (const hdrDir of [srcRoot, srcDir, blake3Dir]) {
   if (!fs.existsSync(hdrDir)) continue
   for (const f of fs.readdirSync(hdrDir)) {
-    if (!f.endsWith(".h") || SKIP_HEADERS.has(f)) continue
-    const dest = path.join(outDir, f)
-    if (!fs.existsSync(dest)) {
-      fs.copyFileSync(path.join(hdrDir, f), dest)
+    if (f.endsWith(".h")) {
+      fs.copyFileSync(path.join(hdrDir, f), path.join(outDir, f))
     }
   }
 }
 
-// The _orig.c wrapper files each textually #include their base SQLite .c file
-// (e.g. btmutex_orig.c does #include "btmutex.c").  When those wrappers are
-// inlined into doltlite_orig.c the compiler resolves the include relative to
-// amalgamation/, so the base .c files must be present there too.
-for (const f of ["btmutex.c", "pager.c", "wal.c", "backup.c", "btree.c"]) {
-  const src = path.join(srcDir, f)
-  const dest = path.join(outDir, f)
-  if (fs.existsSync(src) && !fs.existsSync(dest)) {
-    fs.copyFileSync(src, dest)
-  }
-}
-
-// Generate amalgamation/btreeInt.h — adds include guards that the original lacks.
-// Without guards, each _orig.c file in doltlite_orig.c re-includes btreeInt.h via
-// sqliteInt.h, causing struct redefinition errors in a single translation unit.
-// The shim must NOT have its own #ifndef BTREEINT_H guard: we already patch the
-// original btreeInt.h to add that guard, so if the shim defined it first the
-// original's body would be skipped and struct Btree would never be declared.
-const btreeIntShim = [
-  "/* Generated by build-amalgamation.js — DO NOT EDIT */",
-  "/* Redirects to doltlite-src/src/btreeInt.h (which has its own include guard). */",
-  `#include "../doltlite-src/src/btreeInt.h"`,
-  "",
-].join("\n")
-fs.writeFileSync(path.join(outDir, "btreeInt.h"), btreeIntShim)
-console.log(`Shim btreeInt.h written to ${path.join(outDir, "btreeInt.h")}`)
-
-// Generate SIMD wrapper files for BLAKE3.
-//
-// SSE4.1, AVX2, and AVX-512 are disabled via BLAKE3_NO_* defines in binding.gyp
-// because they require per-file compiler flags that GYP can't express portably.
-// SSE2 (baseline on x86_64) and NEON (baseline on aarch64) need no special flags
-// and are compiled here as separate translation units.
 const simdWrappers = [
-  // name in amalgamation/    source file       arch guard
-  ["blake3_sse2_impl.c",  "blake3_sse2.c",  "defined(__x86_64__)||defined(_M_X64)||defined(__i386__)"],
-  ["blake3_neon_impl.c",  "blake3_neon.c",  "defined(__aarch64__)||defined(__arm__)"],
+  ["blake3_sse2_impl.c", "blake3_sse2.c", "defined(__x86_64__)||defined(_M_X64)||defined(__i386__)"],
+  ["blake3_neon_impl.c", "blake3_neon.c", "defined(__aarch64__)||defined(__arm__)"],
 ]
 
 for (const [wrapName, srcName, archGuard] of simdWrappers) {
   const srcPath = path.join(blake3Dir, srcName)
   if (!fs.existsSync(srcPath)) continue
   const relSrc = path.relative(outDir, srcPath).replace(/\\/g, "/")
-  const lines = [
-    "/* Generated by build-amalgamation.js — DO NOT EDIT */",
+  fs.writeFileSync(path.join(outDir, wrapName), [
+    "/* Generated by build-amalgamation.js - DO NOT EDIT */",
     `#if ${archGuard}`,
     `#include "${relSrc}"`,
     "#endif",
     "",
-  ]
-  fs.writeFileSync(path.join(outDir, wrapName), lines.join("\n"))
+  ].join("\n"))
   console.log(`SIMD wrapper ${wrapName} written`)
 }
+
+console.log(`Amalgamation written to ${outC}`)

package/scripts/download.js

@@ -1,13 +1,12 @@
 #!/usr/bin/env node
-// Downloads the doltlite autoconf source tarball from GitHub releases and
-// builds a complete amalgamation from it, and bundles the matching doltlite
+// Downloads the doltlite autoconf source tarball from GitHub releases,
+// prepares its released amalgamation for node-gyp, and bundles the matching doltlite
 // CLI binary for the current platform into prebuilds/${platform}-${arch}/
 // so that binPath() can return an absolute path.
 //
-// The autoconf tarball contains both sqlite3.c (the base SQLite amalgamation
-// with doltlite's storage patches) and the prolly tree + dolt SQL function
-// source files under src/.  We stitch them into a single doltlite.c that,
-// when compiled with -DDOLTLITE_PROLLY=1, has full version-control support.
+// The autoconf tarball contains a self-contained sqlite3.c with DoltLite's
+// prolly tree and SQL function sources already included. We copy it to
+// amalgamation/doltlite.c so the addon builds the exact released source.
 
 "use strict"
 
@@ -22,7 +21,22 @@ const version = pkg.version
 const amalgDir  = path.join(__dirname, "../amalgamation")
 const outC      = path.join(amalgDir, "doltlite.c")
 const outH      = path.join(amalgDir, "doltlite.h")
-const srcRoot   = path.join(__dirname, "../doltlite-src")
+const versionMarker = path.join(amalgDir, ".doltlite-source-version")
+const srcRoot   = path.join(amalgDir, ".source")
+
+function normalizeVersion(v) {
+  return String(v || "").trim().replace(/^v/, "")
+}
+
+function sourceReady() {
+  if (!fs.existsSync(outC) || !fs.existsSync(outH) || !fs.existsSync(versionMarker)) return false
+  try {
+    const marker = fs.readFileSync(versionMarker, "utf8")
+    return normalizeVersion(marker) === normalizeVersion(version)
+  } catch (_) {
+    return false
+  }
+}
 
 // Upstream dolthub/doltlite ships the CLI for these platform-arch pairs;
 // place the binary next to the .node addon so binPath() can return it.
@@ -51,7 +65,7 @@ function download(url, dest, cb) {
 }
 
 function fetchSource(cb) {
-  if (fs.existsSync(outC) && fs.existsSync(outH)) return cb()
+  if (sourceReady()) return cb()
 
   const tarballUrl = `https://github.com/dolthub/doltlite/releases/download/v${version}/doltlite-autoconf-${version}.tar.gz`
   const tarballPath = path.join(__dirname, `../doltlite-autoconf-${version}.tar.gz`)

package/scripts/install.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+// Uses a packaged native prebuild when available, otherwise prepares source
+// and builds the addon locally.
+
+"use strict"
+
+const fs = require("fs")
+const path = require("path")
+const { spawnSync } = require("child_process")
+
+const root = path.join(__dirname, "..")
+const prebuilt = path.join(root, "prebuilds", `${process.platform}-${process.arch}`, "doltlite.node")
+
+function run(command, args) {
+  const result = spawnSync(command, args, { cwd: root, stdio: "inherit", shell: process.platform === "win32" })
+  if (result.error) {
+    console.error(result.error.message)
+    process.exit(1)
+  }
+  if (result.status !== 0) process.exit(result.status || 1)
+}
+
+if (fs.existsSync(prebuilt)) {
+  console.log(`@dolthub/doltlite: using prebuilt addon ${path.relative(root, prebuilt)}`)
+  process.exit(0)
+}
+
+run(process.execPath, [path.join(__dirname, "download.js")])
+run("node-gyp", ["rebuild"])

package/src/bun_compat.cpp

@@ -10,7 +10,7 @@ extern "C" napi_value _doltlite_init(napi_env env, napi_value exports);
 // this weak definition. MSVC doesn't support weak functions; skip it there
 // since Windows builds target Node 22+ which supplies the symbol via NAPI_MODULE.
 #if !defined(_MSC_VER)
-extern "C" __attribute__((weak)) napi_value napi_register_module_v1(napi_env env, napi_value exports) {
+extern "C" __attribute__((weak, visibility("default"))) napi_value napi_register_module_v1(napi_env env, napi_value exports) {
   return _doltlite_init(env, exports);
 }
 #endif

package/src/database.cpp

@@ -4,6 +4,19 @@
 #include <vector>
 #include <string>
 
+static std::string SqliteOpenPath(const std::string& path) {
+#ifdef _WIN32
+  if (path != ":memory:" && path.rfind("file:", 0) != 0) {
+    std::string normalized = path;
+    for (char& c : normalized) {
+      if (c == '\\') c = '/';
+    }
+    return normalized;
+  }
+#endif
+  return path;
+}
+
 // ── Constructor ──────────────────────────────────────────────────────────────
 
 Database::Database(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Database>(info) {
@@ -32,13 +45,15 @@ Database::Database(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Database>(
     : (SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
   flags |= SQLITE_OPEN_URI;
 
-  int rc = sqlite3_open_v2(path.c_str(), &db_, flags, nullptr);
+  std::string openPath = SqliteOpenPath(path);
+  int rc = sqlite3_open_v2(openPath.c_str(), &db_, flags, nullptr);
   if (rc != SQLITE_OK) {
     std::string msg = db_ ? sqlite3_errmsg(db_) : "Failed to open database";
     if (db_) { sqlite3_close(db_); db_ = nullptr; }
     Napi::Error::New(env, msg).ThrowAsJavaScriptException();
     return;
   }
+  if (path != ":memory:") path_ = path;
 
   sqlite3_busy_timeout(db_, 5000);
   sqlite3_exec(db_, "PRAGMA foreign_keys = ON", nullptr, nullptr, nullptr);
@@ -65,7 +80,8 @@ Napi::Value Database::Open(const Napi::CallbackInfo& info) {
     return env.Undefined();
   }
   std::string path = info[0].As<Napi::String>().Utf8Value();
-  int rc = sqlite3_open_v2(path.c_str(), &db_,
+  std::string openPath = SqliteOpenPath(path);
+  int rc = sqlite3_open_v2(openPath.c_str(), &db_,
                            SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_URI,
                            nullptr);
   if (rc != SQLITE_OK) {
@@ -73,11 +89,13 @@ Napi::Value Database::Open(const Napi::CallbackInfo& info) {
     if (db_) { sqlite3_close(db_); db_ = nullptr; }
     Napi::Error::New(env, msg).ThrowAsJavaScriptException();
   }
+  if (rc == SQLITE_OK && path != ":memory:") path_ = path;
   return env.Undefined();
 }
 
 Napi::Value Database::Close(const Napi::CallbackInfo& info) {
   if (db_) { sqlite3_close_v2(db_); db_ = nullptr; }
+  path_.clear();
   return info.Env().Undefined();
 }
 
@@ -124,6 +142,7 @@ Napi::Value Database::IsTransactionGetter(const Napi::CallbackInfo& info) {
 Napi::Value Database::Location(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   if (!db_) return env.Null();
+  if (!path_.empty()) return Napi::String::New(env, path_);
   const char* loc = sqlite3_db_filename(db_, "main");
   if (!loc || loc[0] == '\0' || strcmp(loc, ":memory:") == 0) return env.Null();
   return Napi::String::New(env, loc);

package/src/database.h

@@ -1,6 +1,7 @@
 #pragma once
 #include <napi.h>
 #include "doltlite.h"
+#include <string>
 
 class Database : public Napi::ObjectWrap<Database> {
 public:
@@ -13,6 +14,7 @@ public:
 
 private:
   sqlite3* db_ = nullptr;
+  std::string path_;
 
   // node:sqlite-compatible methods
   Napi::Value Exec(const Napi::CallbackInfo& info);

package/src/statement.cpp

@@ -39,7 +39,8 @@ Statement::~Statement() {
 Napi::Value Statement::Run(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   if (!stmt_) { Napi::Error::New(env, "Statement is finalised").ThrowAsJavaScriptException(); return env.Undefined(); }
-  if (!BindArgs(env, stmt_, info)) return env.Undefined();
+  if (!BindArgs(env, stmt_, info, 0, allowBareNamedParameters_,
+                allowUnknownNamedParameters_)) return env.Undefined();
 
   int rc = sqlite3_step(stmt_);
   sqlite3_reset(stmt_);
@@ -60,11 +61,15 @@ Napi::Value Statement::Run(const Napi::CallbackInfo& info) {
 Napi::Value Statement::Get(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   if (!stmt_) { Napi::Error::New(env, "Statement is finalised").ThrowAsJavaScriptException(); return env.Undefined(); }
-  if (!BindArgs(env, stmt_, info)) return env.Undefined();
+  if (!BindArgs(env, stmt_, info, 0, allowBareNamedParameters_,
+                allowUnknownNamedParameters_)) return env.Undefined();
 
   int rc = sqlite3_step(stmt_);
   Napi::Value result = env.Undefined();
-  if (rc == SQLITE_ROW) result = RowToObject(env, stmt_);
+  if (rc == SQLITE_ROW) {
+    result = returnArrays_ ? (Napi::Value)RowToArray(env, stmt_, readBigInts_)
+                           : (Napi::Value)RowToObject(env, stmt_, readBigInts_);
+  }
   else if (rc != SQLITE_DONE) ThrowSQLiteError(env, db_->Handle(), "get");
   sqlite3_reset(stmt_);
   return result;
@@ -75,18 +80,42 @@ Napi::Value Statement::Get(const Napi::CallbackInfo& info) {
 Napi::Value Statement::All(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   if (!stmt_) { Napi::Error::New(env, "Statement is finalised").ThrowAsJavaScriptException(); return env.Undefined(); }
-  if (!BindArgs(env, stmt_, info)) return env.Undefined();
+  if (!BindArgs(env, stmt_, info, 0, allowBareNamedParameters_,
+                allowUnknownNamedParameters_)) return env.Undefined();
 
   auto result = Napi::Array::New(env);
   uint32_t idx = 0;
   int rc;
   while ((rc = sqlite3_step(stmt_)) == SQLITE_ROW)
-    result.Set(idx++, RowToObject(env, stmt_));
+    result.Set(idx++, returnArrays_ ? (Napi::Value)RowToArray(env, stmt_, readBigInts_)
+                                    : (Napi::Value)RowToObject(env, stmt_, readBigInts_));
   sqlite3_reset(stmt_);
   if (rc != SQLITE_DONE) ThrowSQLiteError(env, db_->Handle(), "all");
   return result;
 }
 
+// ── node:sqlite compatibility flags ──────────────────────────────────────────
+
+Napi::Value Statement::SetReturnArrays(const Napi::CallbackInfo& info) {
+  returnArrays_ = info.Length() > 0 && info[0].ToBoolean().Value();
+  return info.Env().Undefined();
+}
+
+Napi::Value Statement::SetReadBigInts(const Napi::CallbackInfo& info) {
+  readBigInts_ = info.Length() > 0 && info[0].ToBoolean().Value();
+  return info.Env().Undefined();
+}
+
+Napi::Value Statement::SetAllowBareNamedParameters(const Napi::CallbackInfo& info) {
+  allowBareNamedParameters_ = info.Length() > 0 && info[0].ToBoolean().Value();
+  return info.Env().Undefined();
+}
+
+Napi::Value Statement::SetAllowUnknownNamedParameters(const Napi::CallbackInfo& info) {
+  allowUnknownNamedParameters_ = info.Length() > 0 && info[0].ToBoolean().Value();
+  return info.Env().Undefined();
+}
+
 // ── iterate() → IterableIterator ─────────────────────────────────────────────
 // Returns a plain JS iterator object: { next() { return {value, done} } }
 // A full Symbol.iterator implementation requires a persistent Napi::Reference
@@ -174,11 +203,15 @@ Napi::Value Statement::ExpandedSQLGetter(const Napi::CallbackInfo& info) {
 
 Napi::Object Statement::Init(Napi::Env env, Napi::Object exports) {
   Napi::Function ctor = DefineClass(env, "StatementSync", {
-    InstanceMethod("run",     &Statement::Run),
-    InstanceMethod("get",     &Statement::Get),
-    InstanceMethod("all",     &Statement::All),
-    InstanceMethod("iterate", &Statement::Iterate),
-    InstanceMethod("columns", &Statement::Columns),
+    InstanceMethod("run",                             &Statement::Run),
+    InstanceMethod("get",                             &Statement::Get),
+    InstanceMethod("all",                             &Statement::All),
+    InstanceMethod("iterate",                         &Statement::Iterate),
+    InstanceMethod("columns",                         &Statement::Columns),
+    InstanceMethod("setReturnArrays",                 &Statement::SetReturnArrays),
+    InstanceMethod("setReadBigInts",                  &Statement::SetReadBigInts),
+    InstanceMethod("setAllowBareNamedParameters",     &Statement::SetAllowBareNamedParameters),
+    InstanceMethod("setAllowUnknownNamedParameters",  &Statement::SetAllowUnknownNamedParameters),
     InstanceAccessor("sourceSQL",   &Statement::SourceSQLGetter,   nullptr),
     InstanceAccessor("expandedSQL", &Statement::ExpandedSQLGetter, nullptr),
   });

package/src/statement.h

@@ -16,12 +16,20 @@ private:
   sqlite3_stmt* stmt_ = nullptr;
   Database* db_ = nullptr;
   std::string source_;
+  bool returnArrays_ = false;
+  bool readBigInts_ = false;
+  bool allowBareNamedParameters_ = true;
+  bool allowUnknownNamedParameters_ = false;
 
   Napi::Value Run(const Napi::CallbackInfo& info);
   Napi::Value Get(const Napi::CallbackInfo& info);
   Napi::Value All(const Napi::CallbackInfo& info);
   Napi::Value Iterate(const Napi::CallbackInfo& info);
   Napi::Value Columns(const Napi::CallbackInfo& info);
+  Napi::Value SetReturnArrays(const Napi::CallbackInfo& info);
+  Napi::Value SetReadBigInts(const Napi::CallbackInfo& info);
+  Napi::Value SetAllowBareNamedParameters(const Napi::CallbackInfo& info);
+  Napi::Value SetAllowUnknownNamedParameters(const Napi::CallbackInfo& info);
   Napi::Value SourceSQLGetter(const Napi::CallbackInfo& info);
   Napi::Value ExpandedSQLGetter(const Napi::CallbackInfo& info);
 

package/src/util.h

@@ -4,10 +4,14 @@
 #include <string>
 
 // Converts a SQLite column value to a Napi::Value.
-inline Napi::Value ColumnToNapi(Napi::Env env, sqlite3_stmt* stmt, int col) {
+inline Napi::Value ColumnToNapi(Napi::Env env, sqlite3_stmt* stmt, int col,
+                                bool readBigInts = false) {
   switch (sqlite3_column_type(stmt, col)) {
-    case SQLITE_INTEGER:
-      return Napi::Number::New(env, (double)sqlite3_column_int64(stmt, col));
+    case SQLITE_INTEGER: {
+      sqlite3_int64 i = sqlite3_column_int64(stmt, col);
+      if (readBigInts) return Napi::BigInt::New(env, (int64_t)i);
+      return Napi::Number::New(env, (double)i);
+    }
     case SQLITE_FLOAT:
       return Napi::Number::New(env, sqlite3_column_double(stmt, col));
     case SQLITE_TEXT: {
@@ -28,16 +32,28 @@ inline Napi::Value ColumnToNapi(Napi::Env env, sqlite3_stmt* stmt, int col) {
 }
 
 // Builds a JS object from the current row of a prepared statement.
-inline Napi::Object RowToObject(Napi::Env env, sqlite3_stmt* stmt) {
+inline Napi::Object RowToObject(Napi::Env env, sqlite3_stmt* stmt,
+                                bool readBigInts = false) {
   auto obj = Napi::Object::New(env);
   int n = sqlite3_column_count(stmt);
   for (int i = 0; i < n; i++) {
     const char* name = sqlite3_column_name(stmt, i);
-    obj.Set(name, ColumnToNapi(env, stmt, i));
+    obj.Set(name, ColumnToNapi(env, stmt, i, readBigInts));
   }
   return obj;
 }
 
+// Builds a JS array from the current row of a prepared statement.
+inline Napi::Array RowToArray(Napi::Env env, sqlite3_stmt* stmt,
+                              bool readBigInts = false) {
+  int n = sqlite3_column_count(stmt);
+  auto arr = Napi::Array::New(env, n);
+  for (int i = 0; i < n; i++) {
+    arr.Set((uint32_t)i, ColumnToNapi(env, stmt, i, readBigInts));
+  }
+  return arr;
+}
+
 // Binds a JS value to a prepared statement parameter (1-based index).
 inline bool BindNapi(Napi::Env env, sqlite3_stmt* stmt, int idx, Napi::Value val) {
   if (val.IsNull() || val.IsUndefined()) {
@@ -74,9 +90,9 @@ inline bool BindNapi(Napi::Env env, sqlite3_stmt* stmt, int idx, Napi::Value val
 // named: bind({$name: val, ...}) or bare names {name: val} if allowBare=true
 inline bool BindArgs(Napi::Env env, sqlite3_stmt* stmt,
                      const Napi::CallbackInfo& info, size_t startIdx = 0,
-                     bool allowBare = true) {
+                     bool allowBare = true, bool allowUnknown = false) {
   sqlite3_clear_bindings(stmt);
-  if (info.Length() <= (int)startIdx) return true;
+  if (info.Length() <= startIdx) return true;
 
   // Named parameters via a plain object
   if (info.Length() == startIdx + 1 && info[startIdx].IsObject()
@@ -85,15 +101,22 @@ inline bool BindArgs(Napi::Env env, sqlite3_stmt* stmt,
     auto keys = obj.GetPropertyNames();
     for (uint32_t i = 0; i < keys.Length(); i++) {
       std::string key = keys.Get(i).As<Napi::String>().Utf8Value();
-      // Try $name, :name, @name prefixes, then bare if allowBare
       int idx = 0;
-      for (const char* prefix : {"", "$", ":", "@"}) {
-        std::string k = std::string(prefix) + key;
-        idx = sqlite3_bind_parameter_index(stmt, k.c_str());
-        if (idx > 0) break;
+      if (!key.empty() && (key[0] == '$' || key[0] == ':' || key[0] == '@')) {
+        idx = sqlite3_bind_parameter_index(stmt, key.c_str());
+      } else if (allowBare) {
+        for (const char* prefix : {"$", ":", "@", ""}) {
+          std::string k = std::string(prefix) + key;
+          idx = sqlite3_bind_parameter_index(stmt, k.c_str());
+          if (idx > 0) break;
+        }
+      }
+      if (idx == 0) {
+        if (allowUnknown) continue;
+        Napi::Error::New(env, "Unknown named parameter '" + key + "'")
+            .ThrowAsJavaScriptException();
+        return false;
       }
-      if (idx == 0 && !allowBare) continue;
-      if (idx == 0) continue;
       if (!BindNapi(env, stmt, idx, obj.Get(keys.Get(i)))) return false;
     }
     return true;