@dolthub/doltlite 0.10.6 → 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/binding.gyp

@@ -6,9 +6,6 @@
         "amalgamation/doltlite_orig.c",
         "amalgamation/doltlite.c",
         "amalgamation/blake3_sse2_impl.c",
-        "amalgamation/blake3_sse41_impl.c",
-        "amalgamation/blake3_avx2_impl.c",
-        "amalgamation/blake3_avx512_impl.c",
         "amalgamation/blake3_neon_impl.c",
         "src/addon.cpp",
         "src/bun_compat.cpp",
@@ -26,7 +23,10 @@
         "SQLITE_ENABLE_JSON1",
         "SQLITE_ENABLE_RTREE",
         "SQLITE_ENABLE_COLUMN_METADATA",
-        "DOLTLITE_PROLLY=1"
+        "DOLTLITE_PROLLY=1",
+        "BLAKE3_NO_SSE41=1",
+        "BLAKE3_NO_AVX2=1",
+        "BLAKE3_NO_AVX512=1"
       ],
       "cflags": ["-std=c11", "-fvisibility=hidden"],
       "cflags_cc": ["-std=c++17", "-fvisibility=hidden"],

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,21 +1,27 @@
 {
   "name": "@dolthub/doltlite",
-  "version": "0.10.6",
+  "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

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+// Prepares the DoltLite release amalgamation for the native Node addon.
+
+"use strict"
+
+const fs = require("fs")
+const path = require("path")
+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)
+}
+if (!fs.existsSync(inH)) {
+  console.error(`build-amalgamation: ${inH} not found - run download.js first`)
+  process.exit(1)
+}
+
+console.log("Preparing released doltlite amalgamation...")
+fs.mkdirSync(outDir, { recursive: true })
+let amalgamation = fs.readFileSync(inC, "utf8")
+amalgamation += `
+
+#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"))
+
+// 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")) {
+      fs.copyFileSync(path.join(hdrDir, f), path.join(outDir, f))
+    }
+  }
+}
+
+const simdWrappers = [
+  ["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, "/")
+  fs.writeFileSync(path.join(outDir, wrapName), [
+    "/* Generated by build-amalgamation.js - DO NOT EDIT */",
+    `#if ${archGuard}`,
+    `#include "${relSrc}"`,
+    "#endif",
+    "",
+  ].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;