sqlite3-compat 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tom Ryan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,63 @@
+# sqlite3-compat
+
+The [`sqlite3`](https://github.com/TryGhost/node-sqlite3) (node-sqlite3) callback API on Node's built-in [`node:sqlite`](https://nodejs.org/api/sqlite.html). No native addon, no `node-pre-gyp` download, no rebuild after a Node or Electron upgrade: the same `Database`, `Statement` and `Backup` classes, the same `serialize()`/`parallelize()` scheduling, `trace`/`profile` events, `cached.Database`, `verbose()` stack traces, error `code`/`errno` values and constants.
+
+```sh
+npm install sqlite3-compat
+```
+
+```js
+const sqlite3 = require('sqlite3-compat').verbose();
+const db = new sqlite3.Database(':memory:');
+
+db.serialize(() => {
+  db.run('CREATE TABLE lorem (info TEXT)');
+  const stmt = db.prepare('INSERT INTO lorem VALUES (?)');
+  for (let i = 0; i < 10; i++) stmt.run('Ipsum ' + i);
+  stmt.finalize();
+  db.each('SELECT rowid AS id, info FROM lorem', (err, row) => console.log(row.id + ': ' + row.info));
+});
+db.close();
+```
+
+Requires Node.js 24.16 or later (Node 26 recommended). Deno and Bun do not provide `node:sqlite` with this surface.
+
+## Drop-in use
+
+- **Direct**: `import sqlite3 from 'sqlite3-compat'` or `require('sqlite3-compat')`.
+- **Alias** for libraries that `require('sqlite3')` internally (Sequelize, TypeORM, Knex, the `sqlite` wrapper, session stores, Node-RED nodes):
+
+```sh
+npm install sqlite3@npm:sqlite3-compat
+```
+
+Libraries that declare a peer range on `sqlite3` (TypeORM expects `^5.0.3`) see this package's own version through the alias; add an `overrides` entry or install with `--legacy-peer-deps` in that case (see [examples/alias.md](examples/alias.md)).
+
+Verified with Sequelize 6.37, TypeORM 0.3.30, Knex 3.1 and `sqlite` 5.1 (see [docs/compatibility.md](docs/compatibility.md)). Electron 41 and later ship Node 24.18+, so Electron apps get the same API with no `electron-rebuild` step.
+
+## How compatible
+
+node-sqlite3's own test suite runs unchanged in this repository's CI. On Node 24 and 26, **166 of its 171 tests** pass (node-sqlite3 6.0.1 itself passes 171 in the same environment). The five that do not need `sqlite3_update_hook` (`change` events, 3 tests), incremental backup steps (`step(pages)` copies everything, 1 test) and a backup from a file into an open connection (1 test); none of these has a `node:sqlite` primitive.
+
+## What is different
+
+- Statements execute synchronously on the main thread (that is how `node:sqlite` works) and callbacks are delivered afterwards, in order. node-sqlite3 runs statements on libuv's thread pool. Short statements are faster here (no thread hop); a statement that runs for seconds blocks the event loop for that long.
+- `serialize()`/`parallelize()` keep their API and ordering guarantees, but work is always executed in call order, never concurrently.
+- `db.on('change', …)` never fires: `node:sqlite` has no update hook.
+- `db.interrupt()` stops an `each()` between rows with `SQLITE_INTERRUPT`; it cannot stop a single long-running `get()`, `all()` or `run()`.
+- `Backup#step(pages)` copies all remaining pages in one step (`step(0)` still reports `pageCount`/`remaining` without copying); `db.backup(file, source, dest, false)` (file into the open connection) is unavailable.
+- A backup into a locked destination reports `SQLITE_BUSY` (the underlying `node:sqlite` error carries no code).
+- `OPEN_SHAREDCACHE` is applied by adding `cache=shared` to the (URI) filename; `OPEN_FULLMUTEX`, `OPEN_PRIVATECACHE` and `OPEN_URI` are accepted (URI filenames always work).
+- Integers beyond 2^53 come back as lossy JavaScript numbers, like node-sqlite3.
+
+## Performance
+
+In-memory database, Node 24.21, one run each (`bench/perf.mjs` in the research notes): 200k `stmt.run()` inserts in one transaction 231 ms (node-sqlite3 2,063 ms); 20k sequential awaited `db.get()` 584 ms (542 ms); 20k `db.get()` issued at once 187 ms (434 ms); `all()` of 200k rows 154 ms (258 ms); `each()` over 100k rows 85 ms (82 ms); 20k `stmt.get()` on a reused statement 364 ms (228 ms); 20k `db.run()` updates 139 ms (469 ms). Statement-heavy workloads gain the most; single-row cursor reads on a reused statement are slower because each `get()` keeps a real cursor open.
+
+## API
+
+Everything in node-sqlite3's [API reference](https://github.com/TryGhost/node-sqlite3/wiki/API) except the differences above: `new Database(filename[, mode][, callback])`, `close`, `run`, `get`, `all`, `each`, `map`, `exec`, `prepare`, `serialize`, `parallelize`, `configure('busyTimeout' | 'limit' | 'trace' | 'profile')`, `loadExtension`, `wait`, `interrupt`, `backup`, the `open`/`close`/`error`/`trace`/`profile` events; `Statement` `bind`, `reset`, `finalize`, `run`, `get`, `all`, `each`, `map` with `this.lastID`/`this.changes`; `Backup` `step`, `finish`, `idle`, `completed`, `failed`, `remaining`, `pageCount`, `retryErrors`; `sqlite3.cached.Database`, `sqlite3.verbose()`, the `OPEN_*`, result-code and `LIMIT_*` constants, `VERSION`, `VERSION_NUMBER` and `SOURCE_ID`. Errors carry `code` (`'SQLITE_ERROR'`) and `errno`, and read `SQLITE_ERROR: no such table: foo` like node-sqlite3's.
+
+## License
+
+MIT. The parity suite under `test/parity/node-sqlite3` is node-sqlite3's test suite, BSD-3-Clause, Mapbox and Ghost Foundation; it is not part of the npm package.

package/dist/index.cjs

@@ -0,0 +1,725 @@
+'use strict';
+// The node-sqlite3 (`sqlite3`) callback API implemented on node:sqlite. No native addon, no prebuilt binaries.
+const {DatabaseSync, backup: nativeBackup} = require('node:sqlite');
+const {EventEmitter} = require('node:events');
+const {AsyncResource} = require('node:async_hooks');
+const fs = require('node:fs');
+const path = require('node:path');
+const util = require('node:util');
+
+const constants = {
+  OPEN_READONLY: 1, OPEN_READWRITE: 2, OPEN_CREATE: 4, OPEN_URI: 0x40, OPEN_SHAREDCACHE: 0x20000, OPEN_PRIVATECACHE: 0x40000, OPEN_FULLMUTEX: 0x10000,
+  OK: 0, ERROR: 1, INTERNAL: 2, PERM: 3, ABORT: 4, BUSY: 5, LOCKED: 6, NOMEM: 7, READONLY: 8, INTERRUPT: 9, IOERR: 10, CORRUPT: 11, NOTFOUND: 12,
+  FULL: 13, CANTOPEN: 14, PROTOCOL: 15, EMPTY: 16, SCHEMA: 17, TOOBIG: 18, CONSTRAINT: 19, MISMATCH: 20, MISUSE: 21, NOLFS: 22, AUTH: 23,
+  FORMAT: 24, RANGE: 25, NOTADB: 26,
+  LIMIT_LENGTH: 0, LIMIT_SQL_LENGTH: 1, LIMIT_COLUMN: 2, LIMIT_EXPR_DEPTH: 3, LIMIT_COMPOUND_SELECT: 4, LIMIT_VDBE_OP: 5, LIMIT_FUNCTION_ARG: 6,
+  LIMIT_ATTACHED: 7, LIMIT_LIKE_PATTERN_LENGTH: 8, LIMIT_VARIABLE_NUMBER: 9, LIMIT_TRIGGER_DEPTH: 10, LIMIT_WORKER_THREADS: 11,
+};
+const codeNames = ['SQLITE_OK', 'SQLITE_ERROR', 'SQLITE_INTERNAL', 'SQLITE_PERM', 'SQLITE_ABORT', 'SQLITE_BUSY', 'SQLITE_LOCKED', 'SQLITE_NOMEM',
+  'SQLITE_READONLY', 'SQLITE_INTERRUPT', 'SQLITE_IOERR', 'SQLITE_CORRUPT', 'SQLITE_NOTFOUND', 'SQLITE_FULL', 'SQLITE_CANTOPEN', 'SQLITE_PROTOCOL',
+  'SQLITE_EMPTY', 'SQLITE_SCHEMA', 'SQLITE_TOOBIG', 'SQLITE_CONSTRAINT', 'SQLITE_MISMATCH', 'SQLITE_MISUSE', 'SQLITE_NOLFS', 'SQLITE_AUTH',
+  'SQLITE_FORMAT', 'SQLITE_RANGE', 'SQLITE_NOTADB'];
+const limitNames = ['length', 'sqlLength', 'column', 'exprDepth', 'compoundSelect', 'vdbeOp', 'functionArg', 'attach', 'likePatternLength', 'variableNumber', 'triggerDepth'];
+
+const versionInfo = (() => {
+  const probe = new DatabaseSync(':memory:');
+  const row = probe.prepare('SELECT sqlite_version() AS v, sqlite_source_id() AS s').get();
+  probe.close();
+  const [major, minor, patch] = row.v.split('.').map(Number);
+  return {VERSION: row.v, SOURCE_ID: row.s, VERSION_NUMBER: major * 1000000 + minor * 1000 + (patch || 0)};
+})();
+
+function sqliteError(code, message) {
+  const name = codeNames[code] || 'SQLITE_ERROR';
+  const error = new Error(`${name}: ${message}`);
+  error.errno = code;
+  error.code = name;
+  return error;
+}
+function convertError(error) {
+  if (error && error.errno !== undefined && error.code && String(error.code).startsWith('SQLITE_')) return error;
+  if (error && typeof error.errcode === 'number') return sqliteError(error.errcode & 0xff, error.message || error.errstr);
+  if (error && error.code === 'ERR_SQLITE_ERROR') return sqliteError(constants.ERROR, error.message);
+  if (error && (error.code === 'ERR_INVALID_ARG_TYPE' || error.code === 'ERR_INVALID_STATE' || error.code === 'ERR_OUT_OF_RANGE' || error.code === 'ERR_INVALID_ARG_VALUE')) {
+    if (/not open|closed|finalized/i.test(error.message)) return sqliteError(constants.MISUSE, error.message);
+    return sqliteError(constants.RANGE, 'column index out of range');
+  }
+  return error;
+}
+const closedError = () => sqliteError(constants.MISUSE, 'Database handle is closed');
+const isFunction = value => typeof value === 'function';
+
+// --- binding -----------------------------------------------------------------------------------
+function convertValue(value) {
+  if (value === null || value === undefined) return null;
+  switch (typeof value) {
+    case 'number': return Number.isInteger(value) && Math.abs(value) < 2 ** 63 ? BigInt(value) : value;
+    case 'string': return value;
+    case 'bigint': return value >= -(2n ** 63n) && value < 2n ** 63n ? value : Number(value);
+    case 'boolean': return value ? 1n : 0n;
+    case 'object': break;
+    default: return {unsupported: true};
+  }
+  if (Buffer.isBuffer(value)) return value;
+  if (value instanceof Uint8Array) return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+  if (value instanceof ArrayBuffer) return Buffer.from(value);
+  if (value instanceof Date) return convertValue(value.valueOf());
+  if (value instanceof RegExp) return String(value);
+  try { return String(value); } catch { return null; }
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== 'object' || Array.isArray(value) || Buffer.isBuffer(value) || value instanceof Uint8Array || value instanceof ArrayBuffer || value instanceof Date || value instanceof RegExp) return false;
+  return true;
+}
+const isNameChar = c => /[A-Za-z0-9_$]/.test(c);
+// Ordered 1-based parameter slots of a statement: prefixed name for named parameters, null for anonymous ones.
+function scanParameters(sql) {
+  const slots = [];
+  const named = new Map();
+  let i = 0;
+  const n = sql.length;
+  while (i < n) {
+    const c = sql[i];
+    if (c === '-' && sql[i + 1] === '-') { const e = sql.indexOf('\n', i); i = e === -1 ? n : e + 1; continue; }
+    if (c === '/' && sql[i + 1] === '*') { const e = sql.indexOf('*/', i + 2); i = e === -1 ? n : e + 2; continue; }
+    if (c === "'" || c === '"' || c === '`') { let j = i + 1; while (j < n) { if (sql[j] === c) { if (sql[j + 1] === c) { j += 2; continue; } break; } j++; } i = j + 1; continue; }
+    if (c === '[') { const e = sql.indexOf(']', i); i = e === -1 ? n : e + 1; continue; }
+    if ((c === 'x' || c === 'X') && sql[i + 1] === "'") { const e = sql.indexOf("'", i + 2); i = e === -1 ? n : e + 1; continue; }
+    if (c === '?') {
+      let j = i + 1; while (j < n && sql[j] >= '0' && sql[j] <= '9') j++;
+      const index = j > i + 1 ? Number(sql.slice(i + 1, j)) : slots.length + 1;
+      while (slots.length < index) slots.push(undefined);
+      if (slots[index - 1] === undefined) slots[index - 1] = null;
+      i = j; continue;
+    }
+    if ((c === ':' || c === '@' || c === '$') && i + 1 < n && isNameChar(sql[i + 1])) {
+      let j = i + 1; while (j < n && (isNameChar(sql[j]) || (c === '$' && sql[j] === ':'))) j++;
+      const name = sql.slice(i, j);
+      if (!named.has(name)) { named.set(name, slots.length + 1); slots.push(name); }
+      i = j; continue;
+    }
+    i++;
+  }
+  return slots;
+}
+function positional(values, slots) {
+  const converted = values.map(convertValue);
+  if (!slots || !slots.some(slot => typeof slot === 'string')) return converted;
+  const named = {};
+  const anonymous = [];
+  for (let k = 0; k < slots.length; k++) {
+    const value = k < converted.length ? converted[k] : null;
+    if (typeof slots[k] === 'string') named[slots[k]] = value; else anonymous.push(value);
+  }
+  return [named, ...anonymous];
+}
+// Returns the argument list for StatementSync methods: [named?, ...anonymous].
+function normalizeParams(args, slots) {
+  const values = args.filter(value => value !== undefined);
+  if (values.length === 0) return [];
+  if (values.length === 1 && Array.isArray(values[0])) return positional(values[0], slots);
+  if (values.length === 1 && isPlainObject(values[0])) {
+    const source = values[0];
+    const keys = Object.keys(source);
+    if (keys.length > 0 && keys.every(key => /^[1-9][0-9]*$/.test(key))) {
+      const out = [];
+      for (const key of keys) out[Number(key) - 1] = source[key];
+      for (let k = 0; k < out.length; k++) if (out[k] === undefined) out[k] = null;
+      return positional(out, slots);
+    }
+    const named = {};
+    for (const key of keys) named[key] = convertValue(source[key]);
+    return [named];
+  }
+  return positional(values, slots);
+}
+function convertRow(row) {
+  if (row === undefined || row === null) return row;
+  const out = {};
+  for (const key of Object.keys(row)) {
+    let value = row[key];
+    if (typeof value === 'bigint') value = Number(value);
+    else if (value instanceof Uint8Array && !Buffer.isBuffer(value)) value = Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+    out[key] = value;
+  }
+  return out;
+}
+
+// --- scheduling ------------------------------------------------------------------------------
+function invoke(resource, callback, thisArg, args) {
+  if (resource) return resource.runInAsyncScope(callback, thisArg, ...args);
+  return callback.apply(thisArg, args);
+}
+
+function Database(filename, mode, callback) {
+  if (!new.target) throw new TypeError("Class constructors cannot be invoked without 'new'");
+  EventEmitter.call(this);
+  if (typeof filename !== 'string') throw new TypeError('Filename is required');
+  if (isFunction(mode)) { callback = mode; mode = undefined; }
+  if (mode === undefined) mode = constants.OPEN_READWRITE | constants.OPEN_CREATE | constants.OPEN_FULLMUTEX;
+  if (typeof mode !== 'number') throw new TypeError('Mode must be a number');
+  this.filename = filename;
+  this.mode = mode;
+  this.open = false;
+  Object.defineProperties(this, {
+    _native: {value: null, writable: true},
+    _queue: {value: [], writable: true},
+    _head: {value: 0, writable: true},
+    _draining: {value: false, writable: true},
+    _closing: {value: false, writable: true},
+    _closed: {value: false, writable: true},
+    _statements: {value: new Set(), writable: true},
+    _backups: {value: new Set(), writable: true},
+    _serialized: {value: false, writable: true},
+    _flags: {value: {trace: false, profile: false, change: false}, writable: true},
+    _interrupted: {value: false, writable: true},
+    _executing: {value: false, writable: true},
+  });
+  const resource = new AsyncResource('sqlite3.Database.open');
+  this._enqueue(() => {
+    try {
+      this._native = openNative(filename, mode);
+    } catch (error) {
+      const converted = convertError(error);
+      this._closed = true;
+      if (callback) invoke(resource, callback, this, [converted]);
+      else this.emit('error', converted);
+      return;
+    }
+    this.open = true;
+    this._executing = false;
+    if (callback) invoke(resource, callback, this, [null]);
+    this.emit('open');
+  });
+}
+util.inherits(Database, EventEmitter);
+
+function openNative(filename, mode) {
+  const readOnly = (mode & constants.OPEN_READONLY) !== 0 && (mode & constants.OPEN_READWRITE) === 0;
+  const isUri = filename.startsWith('file:');
+  const anonymous = filename === '' || filename === ':memory:';
+  if (!anonymous && !isUri && !(mode & constants.OPEN_CREATE) && !fs.existsSync(filename)) throw sqliteError(constants.CANTOPEN, 'unable to open database file');
+  if (!anonymous && !isUri && (mode & constants.OPEN_CREATE) && !fs.existsSync(path.dirname(path.resolve(filename)))) throw sqliteError(constants.CANTOPEN, 'unable to open database file');
+  let target = filename;
+  if (!anonymous && (mode & constants.OPEN_SHAREDCACHE) && !/[?&]cache=/.test(filename)) {
+    const uri = isUri ? filename : `file:${encodeURI(path.resolve(filename))}`;
+    target = uri + (uri.includes('?') ? '&' : '?') + 'cache=shared';
+  }
+  try {
+    return new DatabaseSync(target, {readOnly, allowExtension: true});
+  } catch (error) {
+    throw convertError(error);
+  }
+}
+
+const proto = Database.prototype;
+
+proto._enqueue = function (task) {
+  this._queue.push(task);
+  if (!this._draining) {
+    this._draining = true;
+    setImmediate(() => this._drain());
+  }
+};
+proto._next = function () {
+  if (this._head >= this._queue.length) return undefined;
+  const task = this._queue[this._head];
+  this._queue[this._head++] = undefined;
+  if (this._head === this._queue.length) { this._queue.length = 0; this._head = 0; }
+  else if (this._head > 4096 && this._head * 2 > this._queue.length) { this._queue = this._queue.slice(this._head); this._head = 0; }
+  return task;
+};
+proto._drain = function () {
+  let budget = 10000;
+  let task;
+  while (budget-- > 0 && (task = this._next()) !== undefined) {
+    this._executing = true;
+    try { task(); } catch (error) {
+      this._executing = false;
+      if (this._head < this._queue.length) setImmediate(() => this._drain()); else this._draining = false;
+      throw error;
+    }
+    this._executing = false;
+  }
+  if (this._head < this._queue.length) setImmediate(() => this._drain());
+  else this._draining = false;
+};
+proto._fail = function (error, callback, resource) {
+  if (callback) invoke(resource, callback, this, [error]);
+  else this.emit('error', error);
+};
+
+proto.serialize = function (callback) {
+  const previous = this._serialized;
+  this._serialized = true;
+  if (isFunction(callback)) { try { callback.call(this); } finally { this._serialized = previous; } }
+  return this;
+};
+proto.parallelize = function (callback) {
+  const previous = this._serialized;
+  this._serialized = false;
+  if (isFunction(callback)) { try { callback.call(this); } finally { this._serialized = previous; } }
+  return this;
+};
+
+proto.wait = function (callback) {
+  const resource = new AsyncResource('sqlite3.Database.wait');
+  this._enqueue(() => { if (callback) invoke(resource, callback, this, [null]); });
+  return this;
+};
+
+proto.close = function (callback) {
+  const resource = new AsyncResource('sqlite3.Database.close');
+  if (this.open && !this._executing && this._head >= this._queue.length) this._closing = true;
+  this._enqueue(() => {
+    this._closing = true;
+    if (this._closed || !this._native) {
+      this._closing = false;
+      return this._fail(sqliteError(constants.MISUSE, 'Database is closed'), callback, resource);
+    }
+    if (this._backups.size > 0) {
+      this._closing = false;
+      return this._fail(sqliteError(constants.BUSY, 'unable to close due to unfinalised statements or unfinished backups'), callback, resource);
+    }
+    if (this._statements.size > 0) {
+      this._closing = false;
+      return this._fail(sqliteError(constants.BUSY, 'unable to close due to unfinalised statements'), callback, resource);
+    }
+    try { this._native.close(); } catch (error) { this._closing = false; return this._fail(convertError(error), callback, resource); }
+    this._closed = true;
+    this._closing = false;
+    this.open = false;
+    this._executing = false;
+    if (callback) invoke(resource, callback, this, [null]);
+    this.emit('close');
+  });
+  return this;
+};
+
+proto.exec = function (sql, callback) {
+  const resource = new AsyncResource('sqlite3.Database.exec');
+  this._enqueue(() => {
+    if (this._closed || !this._native) return this._fail(closedError(), callback, resource);
+    try { this._native.exec(sql); } catch (error) { return this._fail(convertError(error), callback, resource); }
+    this._executing = false;
+    if (callback) invoke(resource, callback, this, [null]);
+  });
+  return this;
+};
+
+proto.configure = function (option, value, extra) {
+  switch (option) {
+    case 'trace': case 'profile': case 'change': this._flags[option] = Boolean(value); return;
+    case 'busyTimeout':
+      this._enqueue(() => { if (this._native && !this._closed) this._native.exec(`PRAGMA busy_timeout = ${Number(value) | 0}`); });
+      return;
+    case 'limit': {
+      const name = limitNames[value];
+      this._enqueue(() => { if (this._native && !this._closed && name) this._native.limits[name] = extra; });
+      return;
+    }
+    default: throw new Error(`Unknown option: ${option}`);
+  }
+};
+
+proto.loadExtension = function (filename, callback) {
+  const resource = new AsyncResource('sqlite3.Database.loadExtension');
+  this._enqueue(() => {
+    if (this._closed || !this._native) return this._fail(closedError(), callback, resource);
+    try { this._native.enableLoadExtension(true); this._native.loadExtension(filename); } catch (error) { return this._fail(convertError(error), callback, resource); }
+    finally { try { this._native.enableLoadExtension(false); } catch {} }
+    if (callback) invoke(resource, callback, this, [null]);
+  });
+  return this;
+};
+
+proto.interrupt = function () {
+  if (this._closing) throw new Error('Database is closing');
+  if (!this.open || this._closed) throw new Error('Database is not open');
+  this._interrupted = true;
+};
+
+const supportedEvents = ['trace', 'profile', 'change'];
+proto.addListener = proto.on = function (type) {
+  const value = EventEmitter.prototype.addListener.apply(this, arguments);
+  if (supportedEvents.includes(type)) this.configure(type, true);
+  return value;
+};
+proto.removeListener = function (type) {
+  const value = EventEmitter.prototype.removeListener.apply(this, arguments);
+  if (supportedEvents.includes(type) && this.listenerCount(type) === 0) this.configure(type, false);
+  return value;
+};
+proto.removeAllListeners = function (type) {
+  const value = EventEmitter.prototype.removeAllListeners.apply(this, arguments);
+  if (supportedEvents.includes(type)) this.configure(type, false);
+  else if (type === undefined) for (const name of supportedEvents) this.configure(name, false);
+  return value;
+};
+
+// --- statements ---------------------------------------------------------------------------------
+function Statement(db, sql, callback, resource) {
+  if (!new.target) throw new TypeError("Class constructors cannot be invoked without 'new'");
+  EventEmitter.call(this);
+  this.sql = sql;
+  this.lastID = 0;
+  this.changes = 0;
+  Object.defineProperties(this, {
+    _db: {value: db},
+    _native: {value: null, writable: true},
+    _params: {value: [], writable: true},
+    _cursor: {value: null, writable: true},
+    _exhausted: {value: false, writable: true},
+    _finalized: {value: false, writable: true},
+    _failed: {value: false, writable: true},
+    _resource: {value: resource || null, writable: true},
+    _slots: {value: null, writable: true},
+  });
+  resource = resource || new AsyncResource('sqlite3.Statement.prepare');
+  db._enqueue(() => {
+    if (db._closed || !db._native) { this._failed = true; return this._error(closedError(), callback, resource, db); }
+    if (typeof sql !== 'string') { this._failed = true; return this._error(sqliteError(constants.MISUSE, 'SQL query expected'), callback, resource); }
+    try {
+      this._native = db._native.prepare(sql);
+      this._native.setReadBigInts(true);
+      this._slots = scanParameters(sql);
+    } catch (error) {
+      this._failed = true;
+      return this._error(convertError(error), callback, resource);
+    }
+    db._statements.add(this);
+    db._executing = false;
+    if (callback) invoke(resource, callback, this, [null]);
+  });
+}
+util.inherits(Statement, EventEmitter);
+const sproto = Statement.prototype;
+
+sproto._error = function (error, callback, resource, emitter) {
+  if (callback) return invoke(resource, callback, this, [error]);
+  const target = emitter || this;
+  if (target.listenerCount('error') > 0) target.emit('error', error);
+};
+function splitCallback(args) {
+  let callback;
+  if (args.length && isFunction(args[args.length - 1])) callback = args.pop();
+  return callback;
+}
+sproto._schedule = function (name, args, work) {
+  const callback = splitCallback(args);
+  const resource = this._resource || new AsyncResource(`sqlite3.Statement.${name}`);
+  const db = this._db;
+  db._enqueue(() => {
+    if (this._failed) return;
+    if (this._finalized) return this._error(sqliteError(constants.MISUSE, 'Statement is already finalized'), callback, resource);
+    if (db._closed || !db._native) return this._error(closedError(), callback, resource);
+    let result;
+    try {
+      if (args.length) { this._params = normalizeParams(args, this._slots); this._resetCursor(); }
+      result = work(callback, resource);
+    } catch (error) {
+      db._executing = false;
+      return this._error(convertError(error), callback, resource);
+    }
+    db._executing = false;
+    if (result !== undefined && callback) invoke(resource, callback, this, result);
+  });
+  return this;
+};
+sproto._resetCursor = function () {
+  if (this._cursor) { try { this._cursor.return(); } catch {} }
+  this._cursor = null;
+  this._exhausted = false;
+};
+sproto._trace = function () {
+  return this._db._flags.profile ? process.hrtime.bigint() : null;
+};
+// Emits trace/profile once the parameters are bound, so the expanded SQL carries the bound values.
+sproto._profile = function (started) {
+  const db = this._db;
+  if (db._flags.trace) db.emit('trace', this._native.expandedSQL);
+  if (started !== null) db.emit('profile', this._native.expandedSQL, Number(process.hrtime.bigint() - started) / 1e6);
+};
+sproto._checkInterrupt = function () {
+  if (this._db._interrupted) { this._db._interrupted = false; throw sqliteError(constants.INTERRUPT, 'interrupted'); }
+};
+
+sproto.bind = function () {
+  const args = Array.prototype.slice.call(arguments);
+  return this._schedule('bind', args, () => { if (!args.length) { this._params = []; this._resetCursor(); } return [null]; });
+};
+sproto.reset = function (callback) {
+  return this._schedule('reset', callback ? [callback] : [], () => { this._resetCursor(); return [null]; });
+};
+sproto.finalize = function (callback) {
+  const resource = this._resource || new AsyncResource('sqlite3.Statement.finalize');
+  const db = this._db;
+  db._enqueue(() => {
+    if (!this._finalized && !this._failed) {
+      this._resetCursor();
+      this._finalized = true;
+      db._statements.delete(this);
+      if (this._native && typeof this._native.close === 'function') { try { this._native.close(); } catch {} }
+    }
+    if (callback) invoke(resource, callback, this, [null]);
+  });
+  return db;
+};
+sproto.run = function () {
+  const args = Array.prototype.slice.call(arguments);
+  return this._schedule('run', args, () => {
+    this._resetCursor();
+    const started = this._trace();
+    const info = this._native.run(...this._params);
+    this._profile(started);
+    this.lastID = Number(info.lastInsertRowid);
+    this.changes = Number(info.changes);
+    return [null];
+  });
+};
+sproto.get = function () {
+  const args = Array.prototype.slice.call(arguments);
+  return this._schedule('get', args, () => {
+    if (this._exhausted) return [null, undefined];
+    if (!this._cursor) {
+      const started = this._trace();
+      this._cursor = this._native.iterate(...this._params);
+      this._profile(started);
+    }
+    const next = this._cursor.next();
+    if (next.done) { this._exhausted = true; this._cursor = null; return [null, undefined]; }
+    return [null, convertRow(next.value)];
+  });
+};
+sproto.all = function () {
+  const args = Array.prototype.slice.call(arguments);
+  return this._schedule('all', args, () => {
+    this._resetCursor();
+    const started = this._trace();
+    const rows = this._native.all(...this._params);
+    this._profile(started);
+    this._exhausted = true;
+    for (let k = 0; k < rows.length; k++) rows[k] = convertRow(rows[k]);
+    return [null, rows];
+  });
+};
+sproto.each = function () {
+  const args = Array.prototype.slice.call(arguments);
+  let complete;
+  let rowCallback;
+  if (args.length && isFunction(args[args.length - 1])) {
+    const last = args.pop();
+    if (args.length && isFunction(args[args.length - 1])) { complete = last; rowCallback = args.pop(); } else rowCallback = last;
+  }
+  const finalCallback = complete || rowCallback;
+  if (finalCallback) args.push(finalCallback);
+  return this._schedule('each', args, (callback, resource) => {
+    this._resetCursor();
+    const started = this._trace();
+    const iterator = this._native.iterate(...this._params);
+    this._profile(started);
+    let count = 0;
+    try {
+      for (const row of iterator) {
+        count++;
+        if (rowCallback) invoke(resource, rowCallback, this, [null, convertRow(row)]);
+        this._checkInterrupt();
+      }
+    } catch (error) {
+      try { iterator.return(); } catch {}
+      const converted = convertError(error);
+      this._exhausted = true;
+      if (complete) invoke(resource, complete, this, [converted, count]);
+      else if (rowCallback) invoke(resource, rowCallback, this, [converted]);
+      return undefined;
+    }
+    this._exhausted = true;
+    this._db._executing = false;
+    if (complete) invoke(resource, complete, this, [null, count]);
+    return undefined;
+  });
+};
+sproto.map = function () {
+  const params = Array.prototype.slice.call(arguments);
+  const callback = params.pop();
+  params.push(function (error, rows) {
+    if (error) return callback(error);
+    const result = {};
+    if (rows.length) {
+      const keys = Object.keys(rows[0]);
+      const key = keys[0];
+      if (keys.length > 2) for (const row of rows) result[row[key]] = row;
+      else { const value = keys[1]; for (const row of rows) result[row[key]] = row[value]; }
+    }
+    callback(error, result);
+  });
+  return this.all.apply(this, params);
+};
+
+// --- Database helpers built on Statement -------------------------------------------------------
+function normalizeMethod(name, fn) {
+  return function (sql) {
+    let errBack;
+    const args = Array.prototype.slice.call(arguments, 1);
+    if (isFunction(args[args.length - 1])) {
+      const callback = args[args.length - 1];
+      errBack = function (error) { if (error) callback(error); };
+    }
+    const resource = new AsyncResource(`sqlite3.Database.${name}`);
+    const statement = new Statement(this, sql, errBack, resource);
+    return fn.call(this, statement, args);
+  };
+}
+proto.prepare = normalizeMethod('prepare', function (statement, params) { return params.length ? statement.bind.apply(statement, params) : statement; });
+proto.run = normalizeMethod('run', function (statement, params) { statement.run.apply(statement, params).finalize(); return this; });
+proto.get = normalizeMethod('get', function (statement, params) { statement.get.apply(statement, params).finalize(); return this; });
+proto.all = normalizeMethod('all', function (statement, params) { statement.all.apply(statement, params).finalize(); return this; });
+proto.each = normalizeMethod('each', function (statement, params) { statement.each.apply(statement, params).finalize(); return this; });
+proto.map = normalizeMethod('map', function (statement, params) { statement.map.apply(statement, params).finalize(); return this; });
+
+// --- backup --------------------------------------------------------------------------------------
+function Backup(db, filename, sourceName, destName, filenameIsDest, callback) {
+  if (!new.target) throw new TypeError("Class constructors cannot be invoked without 'new'");
+  EventEmitter.call(this);
+  this.idle = true;
+  this.completed = false;
+  this.failed = false;
+  this.remaining = -1;
+  this.pageCount = -1;
+  this.retryErrors = [];
+  Object.defineProperties(this, {
+    _db: {value: db}, _filename: {value: filename}, _destName: {value: destName}, _sourceName: {value: sourceName},
+    _filenameIsDest: {value: filenameIsDest}, _finished: {value: false, writable: true}, _active: {value: false, writable: true},
+  });
+  const resource = new AsyncResource('sqlite3.Backup.initialize');
+  db._enqueue(() => {
+    if (db._closed || !db._native) return this._fail(closedError(), callback, resource);
+    if (!filenameIsDest) return this._fail(sqliteError(constants.MISUSE, 'backup from a file into an open connection is not available on node:sqlite'), callback, resource);
+    db._backups.add(this);
+    this._active = true;
+    db._executing = false;
+    if (callback) invoke(resource, callback, this, [null]);
+  });
+}
+util.inherits(Backup, EventEmitter);
+Backup.prototype._fail = function (error, callback, resource) {
+  if (callback) return invoke(resource, callback, this, [error]);
+  if (this.listenerCount('error') > 0) this.emit('error', error);
+};
+Backup.prototype._releaseHandle = function () {
+  this._active = false;
+  this._db._backups.delete(this);
+};
+// Mirrors node-sqlite3: a step whose status is not OK releases the SQLite backup handle unless the status is listed in retryErrors.
+Backup.prototype._afterStep = function (status) {
+  if (status !== constants.OK && this.retryErrors.length > 0 && !this.retryErrors.includes(status)) this._releaseHandle();
+  if (status === 101) this.completed = true;
+  else if (!this._active) this.failed = true;
+};
+Backup.prototype.step = function (pages, callback) {
+  const db = this._db;
+  const resource = new AsyncResource('sqlite3.Backup.step');
+  this.idle = false;
+  db._enqueue(() => {
+    if (this._finished) { this.idle = true; return this._fail(sqliteError(constants.MISUSE, 'Backup is already finished'), callback, resource); }
+    if (db._closed || !db._native) { this.idle = true; return this._fail(closedError(), callback, resource); }
+    const source = this._sourceName === 'main' ? 'main' : this._sourceName;
+    let pageCount;
+    try { pageCount = Number(db._native.prepare(`PRAGMA "${source.replace(/"/g, '""')}".page_count`).get().page_count); } catch (error) { this.idle = true; return this._fail(convertError(error), callback, resource); }
+    if (this.pageCount < 0) { this.pageCount = pageCount; this.remaining = pageCount; }
+    if (!this._active) { this.idle = true; this.failed = true; return this._fail(sqliteError(constants.MISUSE, 'Backup is already finished'), callback, resource); }
+    if (pages === 0) { this.idle = true; if (callback) invoke(resource, callback, this, [null, false]); return; }
+    let pending;
+    try { pending = nativeBackup(db._native, this._filename, {source, target: this._destName}); } catch (error) { this.idle = true; return this._fail(convertError(error), callback, resource); }
+    // Node 26.8 settles the backup promise only when another task wakes the event loop; keep it awake until then.
+    const keepAlive = setInterval(() => {}, 10);
+    pending.finally(() => clearInterval(keepAlive));
+    pending.then(() => {
+      this.remaining = 0;
+      this._afterStep(101);
+      this.idle = true;
+      if (callback) invoke(resource, callback, this, [null, true]);
+    }, error => {
+      const converted = error && error.errcode === 0 ? sqliteError(constants.BUSY, 'database is locked') : convertError(error);
+      this._afterStep(converted.errno);
+      this.idle = true;
+      if (callback) invoke(resource, callback, this, [converted]);
+      else if (this.listenerCount('error') > 0) this.emit('error', converted);
+    });
+  });
+  return this;
+};
+Backup.prototype.finish = function (callback) {
+  const db = this._db;
+  const resource = new AsyncResource('sqlite3.Backup.finish');
+  db._enqueue(() => {
+    if (!this._finished) {
+      if (!this.completed && !this.failed) this.failed = true;
+      this._finished = true;
+      this._releaseHandle();
+    }
+    db._executing = false;
+    if (callback) invoke(resource, callback, this, [null]);
+  });
+  return this;
+};
+proto.backup = function () {
+  let backup;
+  if (arguments.length <= 2) backup = new Backup(this, arguments[0], 'main', 'main', true, arguments[1]);
+  else backup = new Backup(this, arguments[0], arguments[1], arguments[2], arguments[3], arguments[4]);
+  backup.retryErrors = [constants.BUSY, constants.LOCKED];
+  return backup;
+};
+
+// --- module surface ------------------------------------------------------------------------------
+const sqlite3 = {...constants, ...versionInfo, Database, Statement, Backup};
+sqlite3.cached = {
+  Database: function (file, a, b) {
+    if (file === '' || file === ':memory:') return new Database(file, a, b);
+    let db;
+    file = path.resolve(file);
+    if (!sqlite3.cached.objects[file]) db = sqlite3.cached.objects[file] = new Database(file, a, b);
+    else {
+      db = sqlite3.cached.objects[file];
+      const callback = typeof a === 'number' ? b : a;
+      if (isFunction(callback)) {
+        const cb = () => callback.call(db, null);
+        if (db.open) process.nextTick(cb); else db.once('open', cb);
+      }
+    }
+    return db;
+  },
+  objects: {},
+};
+let isVerbose = false;
+function extendTrace(object, property, pos) {
+  const old = object[property];
+  object[property] = function () {
+    const error = new Error();
+    const name = `${object.constructor.name}#${property}(${Array.prototype.slice.call(arguments).map(el => util.inspect(el, false, 0)).join(', ')})`;
+    if (pos === undefined) pos = -1;
+    if (pos < 0) pos += arguments.length;
+    const cb = arguments[pos];
+    if (isFunction(cb)) {
+      arguments[pos] = function replacement() {
+        const err = arguments[0];
+        if (err && err.stack && !err.__augmented) {
+          err.stack = filterStack(err).join('\n') + '\n--> in ' + name + '\n' + filterStack(error).slice(1).join('\n');
+          err.__augmented = true;
+        }
+        return cb.apply(this, arguments);
+      };
+    }
+    return old.apply(this, arguments);
+  };
+}
+function filterStack(error) { return error.stack.split('\n').filter(line => !line.includes(__filename)); }
+sqlite3.verbose = function () {
+  if (!isVerbose) {
+    for (const name of ['prepare', 'get', 'run', 'all', 'each', 'map', 'close', 'exec']) extendTrace(Database.prototype, name);
+    for (const name of ['bind', 'get', 'run', 'all', 'each', 'map', 'reset', 'finalize']) extendTrace(Statement.prototype, name);
+    isVerbose = true;
+  }
+  return sqlite3;
+};
+module.exports = sqlite3;

package/dist/index.d.cts

@@ -0,0 +1,170 @@
+/// <reference types="node" />
+import type {EventEmitter} from 'node:events';
+
+declare namespace sqlite3 {
+  const OPEN_READONLY: number;
+  const OPEN_READWRITE: number;
+  const OPEN_CREATE: number;
+  const OPEN_FULLMUTEX: number;
+  const OPEN_SHAREDCACHE: number;
+  const OPEN_PRIVATECACHE: number;
+  const OPEN_URI: number;
+  const VERSION: string;
+  const SOURCE_ID: string;
+  const VERSION_NUMBER: number;
+  const OK: number;
+  const ERROR: number;
+  const INTERNAL: number;
+  const PERM: number;
+  const ABORT: number;
+  const BUSY: number;
+  const LOCKED: number;
+  const NOMEM: number;
+  const READONLY: number;
+  const INTERRUPT: number;
+  const IOERR: number;
+  const CORRUPT: number;
+  const NOTFOUND: number;
+  const FULL: number;
+  const CANTOPEN: number;
+  const PROTOCOL: number;
+  const EMPTY: number;
+  const SCHEMA: number;
+  const TOOBIG: number;
+  const CONSTRAINT: number;
+  const MISMATCH: number;
+  const MISUSE: number;
+  const NOLFS: number;
+  const AUTH: number;
+  const FORMAT: number;
+  const RANGE: number;
+  const NOTADB: number;
+  const LIMIT_LENGTH: number;
+  const LIMIT_SQL_LENGTH: number;
+  const LIMIT_COLUMN: number;
+  const LIMIT_EXPR_DEPTH: number;
+  const LIMIT_COMPOUND_SELECT: number;
+  const LIMIT_VDBE_OP: number;
+  const LIMIT_FUNCTION_ARG: number;
+  const LIMIT_ATTACHED: number;
+  const LIMIT_LIKE_PATTERN_LENGTH: number;
+  const LIMIT_VARIABLE_NUMBER: number;
+  const LIMIT_TRIGGER_DEPTH: number;
+  const LIMIT_WORKER_THREADS: number;
+
+  /** Errors carry the SQLite result code as `errno` and its name (`SQLITE_ERROR`, `SQLITE_BUSY`, …) as `code`. */
+  interface SqliteError extends Error {
+    errno: number;
+    code: string;
+  }
+
+  interface RunResult extends Statement {
+    lastID: number;
+    changes: number;
+  }
+
+  class Statement extends EventEmitter {
+    readonly sql: string;
+    lastID: number;
+    changes: number;
+    bind(callback?: (err: Error | null) => void): this;
+    bind(...params: any[]): this;
+    reset(callback?: (err: null) => void): this;
+    finalize(callback?: (err: Error | null) => void): Database;
+    run(callback?: (this: RunResult, err: Error | null) => void): this;
+    run(params: any, callback?: (this: RunResult, err: Error | null) => void): this;
+    run(...params: any[]): this;
+    get<T = any>(callback?: (this: Statement, err: Error | null, row?: T) => void): this;
+    get<T = any>(params: any, callback?: (this: Statement, err: Error | null, row?: T) => void): this;
+    get(...params: any[]): this;
+    all<T = any>(callback?: (this: Statement, err: Error | null, rows: T[]) => void): this;
+    all<T = any>(params: any, callback?: (this: Statement, err: Error | null, rows: T[]) => void): this;
+    all(...params: any[]): this;
+    each<T = any>(callback?: (this: Statement, err: Error | null, row: T) => void, complete?: (err: Error | null, count: number) => void): this;
+    each<T = any>(params: any, callback?: (this: Statement, err: Error | null, row: T) => void, complete?: (err: Error | null, count: number) => void): this;
+    each(...params: any[]): this;
+    map<T = any>(callback: (err: Error | null, result: Record<string, T>) => void): this;
+    map<T = any>(params: any, callback: (err: Error | null, result: Record<string, T>) => void): this;
+    map(...params: any[]): this;
+  }
+
+  class Backup extends EventEmitter {
+    readonly idle: boolean;
+    readonly completed: boolean;
+    readonly failed: boolean;
+    readonly remaining: number;
+    readonly pageCount: number;
+    retryErrors: number[];
+    step(pages: number, callback?: (this: Backup, err: Error | null, completed?: boolean) => void): this;
+    finish(callback?: (this: Backup, err: Error | null) => void): this;
+  }
+
+  class Database extends EventEmitter {
+    constructor(filename: string, callback?: (this: Database, err: Error | null) => void);
+    constructor(filename: string, mode?: number, callback?: (this: Database, err: Error | null) => void);
+    readonly filename: string;
+    readonly mode: number;
+    readonly open: boolean;
+    close(callback?: (this: Database, err: Error | null) => void): this;
+    run(sql: string, callback?: (this: RunResult, err: Error | null) => void): this;
+    run(sql: string, params: any, callback?: (this: RunResult, err: Error | null) => void): this;
+    run(sql: string, ...params: any[]): this;
+    get<T = any>(sql: string, callback?: (this: Statement, err: Error | null, row?: T) => void): this;
+    get<T = any>(sql: string, params: any, callback?: (this: Statement, err: Error | null, row?: T) => void): this;
+    get(sql: string, ...params: any[]): this;
+    all<T = any>(sql: string, callback?: (this: Statement, err: Error | null, rows: T[]) => void): this;
+    all<T = any>(sql: string, params: any, callback?: (this: Statement, err: Error | null, rows: T[]) => void): this;
+    all(sql: string, ...params: any[]): this;
+    each<T = any>(sql: string, callback?: (this: Statement, err: Error | null, row: T) => void, complete?: (err: Error | null, count: number) => void): this;
+    each<T = any>(sql: string, params: any, callback?: (this: Statement, err: Error | null, row: T) => void, complete?: (err: Error | null, count: number) => void): this;
+    each(sql: string, ...params: any[]): this;
+    map<T = any>(sql: string, callback: (err: Error | null, result: Record<string, T>) => void): this;
+    map<T = any>(sql: string, params: any, callback: (err: Error | null, result: Record<string, T>) => void): this;
+    map(sql: string, ...params: any[]): this;
+    exec(sql: string, callback?: (this: Database, err: Error | null) => void): this;
+    prepare(sql: string, callback?: (this: Statement, err: Error | null) => void): Statement;
+    prepare(sql: string, params: any, callback?: (this: Statement, err: Error | null) => void): Statement;
+    prepare(sql: string, ...params: any[]): Statement;
+    serialize(callback?: () => void): this;
+    parallelize(callback?: () => void): this;
+    on(event: 'trace', listener: (sql: string) => void): this;
+    on(event: 'profile', listener: (sql: string, time: number) => void): this;
+    on(event: 'change', listener: (type: string, database: string, table: string, rowid: number) => void): this;
+    on(event: 'error', listener: (err: Error) => void): this;
+    on(event: 'open' | 'close', listener: () => void): this;
+    on(event: string, listener: (...args: any[]) => void): this;
+    configure(option: 'busyTimeout', value: number): void;
+    configure(option: 'limit', id: number, value: number): void;
+    configure(option: 'trace' | 'profile' | 'change', enabled: boolean): void;
+    loadExtension(filename: string, callback?: (this: Database, err: Error | null) => void): this;
+    wait(callback?: (param: null) => void): this;
+    interrupt(): void;
+    backup(filename: string, callback?: (this: Backup, err: Error | null) => void): Backup;
+    backup(filename: string, sourceName: string, destName: string, filenameIsDest: boolean, callback?: (this: Backup, err: Error | null) => void): Backup;
+  }
+
+  const cached: {
+    Database(filename: string, callback?: (this: Database, err: Error | null) => void): Database;
+    Database(filename: string, mode?: number, callback?: (this: Database, err: Error | null) => void): Database;
+    objects: Record<string, Database>;
+  };
+
+  function verbose(): sqlite3;
+
+  interface sqlite3 {
+    OPEN_READONLY: number; OPEN_READWRITE: number; OPEN_CREATE: number; OPEN_FULLMUTEX: number; OPEN_SHAREDCACHE: number; OPEN_PRIVATECACHE: number; OPEN_URI: number;
+    VERSION: string; SOURCE_ID: string; VERSION_NUMBER: number;
+    OK: number; ERROR: number; INTERNAL: number; PERM: number; ABORT: number; BUSY: number; LOCKED: number; NOMEM: number; READONLY: number; INTERRUPT: number;
+    IOERR: number; CORRUPT: number; NOTFOUND: number; FULL: number; CANTOPEN: number; PROTOCOL: number; EMPTY: number; SCHEMA: number; TOOBIG: number;
+    CONSTRAINT: number; MISMATCH: number; MISUSE: number; NOLFS: number; AUTH: number; FORMAT: number; RANGE: number; NOTADB: number;
+    LIMIT_LENGTH: number; LIMIT_SQL_LENGTH: number; LIMIT_COLUMN: number; LIMIT_EXPR_DEPTH: number; LIMIT_COMPOUND_SELECT: number; LIMIT_VDBE_OP: number;
+    LIMIT_FUNCTION_ARG: number; LIMIT_ATTACHED: number; LIMIT_LIKE_PATTERN_LENGTH: number; LIMIT_VARIABLE_NUMBER: number; LIMIT_TRIGGER_DEPTH: number; LIMIT_WORKER_THREADS: number;
+    cached: typeof cached;
+    Statement: typeof Statement;
+    Database: typeof Database;
+    Backup: typeof Backup;
+    verbose(): sqlite3;
+  }
+}
+
+export = sqlite3;

package/dist/index.d.mts

@@ -0,0 +1,169 @@
+/// <reference types="node" />
+import type {EventEmitter} from 'node:events';
+
+export const OPEN_READONLY: number;
+export const OPEN_READWRITE: number;
+export const OPEN_CREATE: number;
+export const OPEN_FULLMUTEX: number;
+export const OPEN_SHAREDCACHE: number;
+export const OPEN_PRIVATECACHE: number;
+export const OPEN_URI: number;
+export const VERSION: string;
+export const SOURCE_ID: string;
+export const VERSION_NUMBER: number;
+export const OK: number;
+export const ERROR: number;
+export const INTERNAL: number;
+export const PERM: number;
+export const ABORT: number;
+export const BUSY: number;
+export const LOCKED: number;
+export const NOMEM: number;
+export const READONLY: number;
+export const INTERRUPT: number;
+export const IOERR: number;
+export const CORRUPT: number;
+export const NOTFOUND: number;
+export const FULL: number;
+export const CANTOPEN: number;
+export const PROTOCOL: number;
+export const EMPTY: number;
+export const SCHEMA: number;
+export const TOOBIG: number;
+export const CONSTRAINT: number;
+export const MISMATCH: number;
+export const MISUSE: number;
+export const NOLFS: number;
+export const AUTH: number;
+export const FORMAT: number;
+export const RANGE: number;
+export const NOTADB: number;
+export const LIMIT_LENGTH: number;
+export const LIMIT_SQL_LENGTH: number;
+export const LIMIT_COLUMN: number;
+export const LIMIT_EXPR_DEPTH: number;
+export const LIMIT_COMPOUND_SELECT: number;
+export const LIMIT_VDBE_OP: number;
+export const LIMIT_FUNCTION_ARG: number;
+export const LIMIT_ATTACHED: number;
+export const LIMIT_LIKE_PATTERN_LENGTH: number;
+export const LIMIT_VARIABLE_NUMBER: number;
+export const LIMIT_TRIGGER_DEPTH: number;
+export const LIMIT_WORKER_THREADS: number;
+
+/** Errors carry the SQLite result code as `errno` and its name (`SQLITE_ERROR`, `SQLITE_BUSY`, …) as `code`. */
+export interface SqliteError extends Error {
+  errno: number;
+  code: string;
+}
+
+export interface RunResult extends Statement {
+  lastID: number;
+  changes: number;
+}
+
+export class Statement extends EventEmitter {
+  readonly sql: string;
+  lastID: number;
+  changes: number;
+  bind(callback?: (err: Error | null) => void): this;
+  bind(...params: any[]): this;
+  reset(callback?: (err: null) => void): this;
+  finalize(callback?: (err: Error | null) => void): Database;
+  run(callback?: (this: RunResult, err: Error | null) => void): this;
+  run(params: any, callback?: (this: RunResult, err: Error | null) => void): this;
+  run(...params: any[]): this;
+  get<T = any>(callback?: (this: Statement, err: Error | null, row?: T) => void): this;
+  get<T = any>(params: any, callback?: (this: Statement, err: Error | null, row?: T) => void): this;
+  get(...params: any[]): this;
+  all<T = any>(callback?: (this: Statement, err: Error | null, rows: T[]) => void): this;
+  all<T = any>(params: any, callback?: (this: Statement, err: Error | null, rows: T[]) => void): this;
+  all(...params: any[]): this;
+  each<T = any>(callback?: (this: Statement, err: Error | null, row: T) => void, complete?: (err: Error | null, count: number) => void): this;
+  each<T = any>(params: any, callback?: (this: Statement, err: Error | null, row: T) => void, complete?: (err: Error | null, count: number) => void): this;
+  each(...params: any[]): this;
+  map<T = any>(callback: (err: Error | null, result: Record<string, T>) => void): this;
+  map<T = any>(params: any, callback: (err: Error | null, result: Record<string, T>) => void): this;
+  map(...params: any[]): this;
+}
+
+export class Backup extends EventEmitter {
+  readonly idle: boolean;
+  readonly completed: boolean;
+  readonly failed: boolean;
+  readonly remaining: number;
+  readonly pageCount: number;
+  retryErrors: number[];
+  step(pages: number, callback?: (this: Backup, err: Error | null, completed?: boolean) => void): this;
+  finish(callback?: (this: Backup, err: Error | null) => void): this;
+}
+
+export class Database extends EventEmitter {
+  constructor(filename: string, callback?: (this: Database, err: Error | null) => void);
+  constructor(filename: string, mode?: number, callback?: (this: Database, err: Error | null) => void);
+  readonly filename: string;
+  readonly mode: number;
+  readonly open: boolean;
+  close(callback?: (this: Database, err: Error | null) => void): this;
+  run(sql: string, callback?: (this: RunResult, err: Error | null) => void): this;
+  run(sql: string, params: any, callback?: (this: RunResult, err: Error | null) => void): this;
+  run(sql: string, ...params: any[]): this;
+  get<T = any>(sql: string, callback?: (this: Statement, err: Error | null, row?: T) => void): this;
+  get<T = any>(sql: string, params: any, callback?: (this: Statement, err: Error | null, row?: T) => void): this;
+  get(sql: string, ...params: any[]): this;
+  all<T = any>(sql: string, callback?: (this: Statement, err: Error | null, rows: T[]) => void): this;
+  all<T = any>(sql: string, params: any, callback?: (this: Statement, err: Error | null, rows: T[]) => void): this;
+  all(sql: string, ...params: any[]): this;
+  each<T = any>(sql: string, callback?: (this: Statement, err: Error | null, row: T) => void, complete?: (err: Error | null, count: number) => void): this;
+  each<T = any>(sql: string, params: any, callback?: (this: Statement, err: Error | null, row: T) => void, complete?: (err: Error | null, count: number) => void): this;
+  each(sql: string, ...params: any[]): this;
+  map<T = any>(sql: string, callback: (err: Error | null, result: Record<string, T>) => void): this;
+  map<T = any>(sql: string, params: any, callback: (err: Error | null, result: Record<string, T>) => void): this;
+  map(sql: string, ...params: any[]): this;
+  exec(sql: string, callback?: (this: Database, err: Error | null) => void): this;
+  prepare(sql: string, callback?: (this: Statement, err: Error | null) => void): Statement;
+  prepare(sql: string, params: any, callback?: (this: Statement, err: Error | null) => void): Statement;
+  prepare(sql: string, ...params: any[]): Statement;
+  serialize(callback?: () => void): this;
+  parallelize(callback?: () => void): this;
+  on(event: 'trace', listener: (sql: string) => void): this;
+  on(event: 'profile', listener: (sql: string, time: number) => void): this;
+  on(event: 'change', listener: (type: string, database: string, table: string, rowid: number) => void): this;
+  on(event: 'error', listener: (err: Error) => void): this;
+  on(event: 'open' | 'close', listener: () => void): this;
+  on(event: string, listener: (...args: any[]) => void): this;
+  configure(option: 'busyTimeout', value: number): void;
+  configure(option: 'limit', id: number, value: number): void;
+  configure(option: 'trace' | 'profile' | 'change', enabled: boolean): void;
+  loadExtension(filename: string, callback?: (this: Database, err: Error | null) => void): this;
+  wait(callback?: (param: null) => void): this;
+  interrupt(): void;
+  backup(filename: string, callback?: (this: Backup, err: Error | null) => void): Backup;
+  backup(filename: string, sourceName: string, destName: string, filenameIsDest: boolean, callback?: (this: Backup, err: Error | null) => void): Backup;
+}
+
+export const cached: {
+  Database(filename: string, callback?: (this: Database, err: Error | null) => void): Database;
+  Database(filename: string, mode?: number, callback?: (this: Database, err: Error | null) => void): Database;
+  objects: Record<string, Database>;
+};
+
+export function verbose(): sqlite3;
+
+export interface sqlite3 {
+  OPEN_READONLY: number; OPEN_READWRITE: number; OPEN_CREATE: number; OPEN_FULLMUTEX: number; OPEN_SHAREDCACHE: number; OPEN_PRIVATECACHE: number; OPEN_URI: number;
+  VERSION: string; SOURCE_ID: string; VERSION_NUMBER: number;
+  OK: number; ERROR: number; INTERNAL: number; PERM: number; ABORT: number; BUSY: number; LOCKED: number; NOMEM: number; READONLY: number; INTERRUPT: number;
+  IOERR: number; CORRUPT: number; NOTFOUND: number; FULL: number; CANTOPEN: number; PROTOCOL: number; EMPTY: number; SCHEMA: number; TOOBIG: number;
+  CONSTRAINT: number; MISMATCH: number; MISUSE: number; NOLFS: number; AUTH: number; FORMAT: number; RANGE: number; NOTADB: number;
+  LIMIT_LENGTH: number; LIMIT_SQL_LENGTH: number; LIMIT_COLUMN: number; LIMIT_EXPR_DEPTH: number; LIMIT_COMPOUND_SELECT: number; LIMIT_VDBE_OP: number;
+  LIMIT_FUNCTION_ARG: number; LIMIT_ATTACHED: number; LIMIT_LIKE_PATTERN_LENGTH: number; LIMIT_VARIABLE_NUMBER: number; LIMIT_TRIGGER_DEPTH: number; LIMIT_WORKER_THREADS: number;
+  cached: typeof cached;
+  Statement: typeof Statement;
+  Database: typeof Database;
+  Backup: typeof Backup;
+  verbose(): sqlite3;
+}
+
+declare const sqlite3: sqlite3;
+export default sqlite3;

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import sqlite3 from './index.cjs';
+export const {OPEN_READONLY, OPEN_READWRITE, OPEN_CREATE, OPEN_URI, OPEN_SHAREDCACHE, OPEN_PRIVATECACHE, OPEN_FULLMUTEX, OK, ERROR, INTERNAL, PERM, ABORT, BUSY, LOCKED, NOMEM, READONLY, INTERRUPT, IOERR, CORRUPT, NOTFOUND, FULL, CANTOPEN, PROTOCOL, EMPTY, SCHEMA, TOOBIG, CONSTRAINT, MISMATCH, MISUSE, NOLFS, AUTH, FORMAT, RANGE, NOTADB, LIMIT_LENGTH, LIMIT_SQL_LENGTH, LIMIT_COLUMN, LIMIT_EXPR_DEPTH, LIMIT_COMPOUND_SELECT, LIMIT_VDBE_OP, LIMIT_FUNCTION_ARG, LIMIT_ATTACHED, LIMIT_LIKE_PATTERN_LENGTH, LIMIT_VARIABLE_NUMBER, LIMIT_TRIGGER_DEPTH, LIMIT_WORKER_THREADS, VERSION, SOURCE_ID, VERSION_NUMBER, Database, Statement, Backup, cached, verbose} = sqlite3;
+export default sqlite3;

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "sqlite3-compat",
+  "version": "0.1.0",
+  "description": "The node-sqlite3 (sqlite3) callback API on Node's built-in node:sqlite. No native addon, no prebuilt binaries: same Database, Statement, Backup, serialize/parallelize, events and error codes.",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24.16"
+  },
+  "license": "MIT",
+  "author": "Tom Ryan",
+  "keywords": [
+    "sqlite",
+    "sqlite3",
+    "node-sqlite3",
+    "node:sqlite",
+    "database",
+    "compat",
+    "no-native",
+    "prebuild",
+    "sequelize",
+    "typeorm",
+    "knex"
+  ],
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "test": "node --test test/api.test.mjs",
+    "test:parity": "node scripts/parity.mjs",
+    "test:types": "tsc -p test/tsconfig.json",
+    "test:pack": "node scripts/test-pack.mjs",
+    "verify": "npm run build && npm test && npm run test:parity && npm run test:types && npm run test:pack",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run verify"
+  },
+  "devDependencies": {
+    "@types/node": "24.10.1",
+    "mocha": "12.0.0",
+    "typescript": "5.9.3"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Atomics-hub/sqlite3-compat.git"
+  },
+  "homepage": "https://github.com/Atomics-hub/sqlite3-compat#readme",
+  "bugs": {
+    "url": "https://github.com/Atomics-hub/sqlite3-compat/issues"
+  }
+}