crispy-recall 0.1.6 → 0.2.0

package/dist/stop-hook.js

@@ -68,1446 +68,858 @@ var init_log = __esm({
   }
 });
 
-// node_modules/node-sqlite3-wasm/dist/node-sqlite3-wasm.js
-var require_node_sqlite3_wasm = __commonJS({
-  "node_modules/node-sqlite3-wasm/dist/node-sqlite3-wasm.js"(exports2, module2) {
-    var Module = typeof Module != "undefined" ? Module : {};
-    var ENVIRONMENT_IS_NODE = true;
-    var INT32_MIN = -2147483648;
-    var INT32_MAX = 2147483647;
-    var NULL = 0;
-    var SQLITE_OK = 0;
-    var SQLITE_ROW = 100;
-    var SQLITE_DONE = 101;
-    var SQLITE_INTEGER = 1;
-    var SQLITE_FLOAT = 2;
-    var SQLITE_TEXT = 3;
-    var SQLITE_BLOB = 4;
-    var SQLITE_NULL = 5;
-    var SQLITE_UTF8 = 1;
-    var SQLITE_TRANSIENT = -1;
-    var SQLITE_DETERMINISTIC = 2048;
-    var temp;
-    var sqlite3 = {};
-    Module.onRuntimeInitialized = () => {
-      temp = stackAlloc(4);
-      const v = null;
-      const n = "number";
-      const s = "string";
-      const n1 = [n];
-      const n2 = [n, ...n1];
-      const n3 = [n, ...n2];
-      const n4 = [n, ...n3];
-      const n5 = [n, ...n4];
-      const signatures = { open_v2: [n, [s, n, n, s]], exec: [n, n5], errmsg: [s, n1], prepare_v2: [n, n5], close_v2: [n, n1], finalize: [n, n1], reset: [n, n1], clear_bindings: [n, n1], bind_int: [n, n3], bind_int64: [n, n3], bind_double: [n, n3], bind_text: [n, n5], bind_blob: [n, n5], bind_blob64: [n, n5], bind_null: [n, n2], bind_parameter_index: [n, [n, s]], step: [n, n1], column_int64: [n, n2], column_double: [n, n2], column_text: [s, n2], column_blob: [n, n2], column_type: [n, n2], column_name: [s, n2], column_count: [n, n1], column_bytes: [n, n2], last_insert_rowid: [n, n1], changes: [n, n1], create_function_v2: [n, [n, s, n, n, n, n, n, n, n]], value_type: [n, n1], value_text: [s, n1], value_blob: [n, n1], value_int64: [n, n1], value_double: [n, n1], value_bytes: [n, n1], result_double: [v, n2], result_null: [v, n1], result_text: [v, n4], result_blob: [v, n4], result_blob64: [v, n4], result_int: [v, n2], result_int64: [v, n2], result_error: [v, n3], column_table_name: [s, n2], get_autocommit: [n, n1] };
-      for (const [name, sig] of Object.entries(signatures)) {
-        sqlite3[name] = cwrap(`sqlite3_${name}`, sig[0], sig[1]);
-      }
-    };
-    var SQLite3Error = class extends Error {
-      constructor(message) {
-        super(message);
-        this.name = "SQLite3Error";
+// src/paths.ts
+function recallRoot() {
+  if (rootOverride)
+    return rootOverride;
+  const envRoot = process.env["RECALL_HOME"];
+  if (envRoot && envRoot.length > 0)
+    return envRoot;
+  return (0, import_node_path.join)((0, import_node_os.homedir)(), ".recall");
+}
+function dbPath() {
+  return (0, import_node_path.join)(recallRoot(), "recall.db");
+}
+function binDir() {
+  return (0, import_node_path.join)(recallRoot(), "bin");
+}
+function logsDir() {
+  return (0, import_node_path.join)(recallRoot(), "logs");
+}
+function ensureDir() {
+  (0, import_node_fs.mkdirSync)(recallRoot(), { recursive: true });
+}
+var import_node_fs, import_node_os, import_node_path, rootOverride;
+var init_paths = __esm({
+  "src/paths.ts"() {
+    "use strict";
+    import_node_fs = require("node:fs");
+    import_node_os = require("node:os");
+    import_node_path = require("node:path");
+    rootOverride = null;
+  }
+});
+
+// node_modules/better-sqlite3/lib/util.js
+var require_util = __commonJS({
+  "node_modules/better-sqlite3/lib/util.js"(exports2) {
+    "use strict";
+    exports2.getBooleanOption = (options, key) => {
+      let value = false;
+      if (key in options && typeof (value = options[key]) !== "boolean") {
+        throw new TypeError(`Expected the "${key}" option to be a boolean`);
       }
+      return value;
     };
-    function arrayToHeap(array) {
-      const ptr = _malloc(array.byteLength);
-      HEAPU8.set(array, ptr);
-      return ptr;
-    }
-    function stringToHeap(str) {
-      const size = lengthBytesUTF8(str) + 1;
-      const ptr = _malloc(size);
-      stringToUTF8(str, ptr, size);
-      return ptr;
-    }
-    function toNumberOrNot(bigInt) {
-      if (bigInt >= Number.MIN_SAFE_INTEGER && bigInt <= Number.MAX_SAFE_INTEGER) {
-        return Number(bigInt);
-      }
-      return bigInt;
-    }
-    function parseFunctionArguments(argc, argv) {
-      const args = [];
-      for (let i = 0; i < argc; i++) {
-        const ptr = getValue(argv + 4 * i, "i32");
-        const type = sqlite3.value_type(ptr);
-        let arg;
-        switch (type) {
-          case SQLITE_INTEGER:
-            arg = toNumberOrNot(sqlite3.value_int64(ptr));
-            break;
-          case SQLITE_FLOAT:
-            arg = sqlite3.value_double(ptr);
-            break;
-          case SQLITE_TEXT:
-            arg = sqlite3.value_text(ptr);
-            break;
-          case SQLITE_BLOB:
-            const p = sqlite3.value_blob(ptr);
-            if (p != NULL) {
-              arg = HEAPU8.slice(p, p + sqlite3.value_bytes(ptr));
-            } else {
-              arg = new Uint8Array();
-            }
-            break;
-          case SQLITE_NULL:
-            arg = null;
-            break;
-        }
-        args.push(arg);
-      }
-      return args;
-    }
-    function setFunctionResult(cx, result) {
-      switch (typeof result) {
-        case "boolean":
-          sqlite3.result_int(cx, result ? 1 : 0);
-          break;
-        case "number":
-          if (Number.isSafeInteger(result)) {
-            if (result >= INT32_MIN && result <= INT32_MAX) {
-              sqlite3.result_int(cx, result);
-            } else {
-              sqlite3.result_int64(cx, BigInt(result));
-            }
-          } else {
-            sqlite3.result_double(cx, result);
-          }
-          break;
-        case "bigint":
-          sqlite3.result_int64(cx, result);
-          break;
-        case "string":
-          const tempPtr = stringToHeap(result);
-          sqlite3.result_text(cx, tempPtr, -1, SQLITE_TRANSIENT);
-          _free(tempPtr);
-          break;
-        case "object":
-          if (result === null) {
-            sqlite3.result_null(cx);
-          } else if (result instanceof Uint8Array) {
-            const tempPtr2 = arrayToHeap(result);
-            if (result.byteLength <= INT32_MAX) {
-              sqlite3.result_blob(cx, tempPtr2, result.byteLength, SQLITE_TRANSIENT);
-            } else {
-              sqlite3.result_blob64(cx, tempPtr2, BigInt(result.byteLength), SQLITE_TRANSIENT);
-            }
-            _free(tempPtr2);
-          } else {
-            throw new SQLite3Error(`Unsupported type for function result: "${typeof result}"`);
-          }
-          break;
-        default:
-          throw new SQLite3Error(`Unsupported type for function result: "${typeof result}"`);
+    exports2.cppdb = Symbol();
+    exports2.inspect = Symbol.for("nodejs.util.inspect.custom");
+  }
+});
+
+// node_modules/better-sqlite3/lib/sqlite-error.js
+var require_sqlite_error = __commonJS({
+  "node_modules/better-sqlite3/lib/sqlite-error.js"(exports2, module2) {
+    "use strict";
+    var descriptor = { value: "SqliteError", writable: true, enumerable: false, configurable: true };
+    function SqliteError(message, code) {
+      if (new.target !== SqliteError) {
+        return new SqliteError(message, code);
+      }
+      if (typeof code !== "string") {
+        throw new TypeError("Expected second argument to be a string");
+      }
+      Error.call(this, message);
+      descriptor.value = "" + message;
+      Object.defineProperty(this, "message", descriptor);
+      Error.captureStackTrace(this, SqliteError);
+      this.code = code;
+    }
+    Object.setPrototypeOf(SqliteError, Error);
+    Object.setPrototypeOf(SqliteError.prototype, Error.prototype);
+    Object.defineProperty(SqliteError.prototype, "name", descriptor);
+    module2.exports = SqliteError;
+  }
+});
+
+// node_modules/file-uri-to-path/index.js
+var require_file_uri_to_path = __commonJS({
+  "node_modules/file-uri-to-path/index.js"(exports2, module2) {
+    var sep = require("path").sep || "/";
+    module2.exports = fileUriToPath;
+    function fileUriToPath(uri) {
+      if ("string" != typeof uri || uri.length <= 7 || "file://" != uri.substring(0, 7)) {
+        throw new TypeError("must pass in a file:// URI to convert to a file path");
+      }
+      var rest = decodeURI(uri.substring(7));
+      var firstSlash = rest.indexOf("/");
+      var host = rest.substring(0, firstSlash);
+      var path2 = rest.substring(firstSlash + 1);
+      if ("localhost" == host)
+        host = "";
+      if (host) {
+        host = sep + sep + host;
+      }
+      path2 = path2.replace(/^(.+)\|/, "$1:");
+      if (sep == "\\") {
+        path2 = path2.replace(/\//g, "\\");
+      }
+      if (/^.+\:/.test(path2)) {
+      } else {
+        path2 = sep + path2;
       }
+      return host + path2;
     }
-    var Database = class {
-      constructor(filename, { fileMustExist = false, readOnly = false } = {}) {
-        let flags;
-        if (readOnly) {
-          flags = SQLITE_OPEN_READONLY;
-        } else {
-          flags = SQLITE_OPEN_READWRITE;
-          if (!fileMustExist)
-            flags |= SQLITE_OPEN_CREATE;
-        }
-        const rc = sqlite3.open_v2(filename, temp, flags, NULL);
-        this._ptr = getValue(temp, "i32");
-        if (rc !== SQLITE_OK) {
-          if (this._ptr !== NULL)
-            sqlite3.close_v2(this._ptr);
-          throw new SQLite3Error(`Could not open the database "${filename}"`);
-        }
-        this._functions = /* @__PURE__ */ new Map();
-      }
-      get isOpen() {
-        return this._ptr !== null;
-      }
-      get inTransaction() {
-        this._assertOpen();
-        return sqlite3.get_autocommit(this._ptr) === 0;
-      }
-      close() {
-        this._assertOpen();
-        for (const func of this._functions.values())
-          removeFunction(func);
-        this._functions.clear();
-        this._handleError(sqlite3.close_v2(this._ptr));
-        this._ptr = null;
-      }
-      function(name, func, { deterministic = false } = {}) {
-        this._assertOpen();
-        function wrappedFunc(cx, argc, argv) {
-          const args = parseFunctionArguments(argc, argv);
-          let result;
-          try {
-            result = func.apply(null, args);
-          } catch (err2) {
-            const tempPtr = stringToHeap(err2.toString());
-            sqlite3.result_error(cx, tempPtr, -1);
-            _free(tempPtr);
-            return;
-          }
-          setFunctionResult(cx, result);
-        }
-        if (this._functions.has(name)) {
-          removeFunction(this._functions.get(name));
-          this._functions.delete(name);
-        }
-        const funcPtr = addFunction(wrappedFunc, "viii");
-        this._functions.set(name, funcPtr);
-        let eTextRep = SQLITE_UTF8;
-        if (deterministic)
-          eTextRep |= SQLITE_DETERMINISTIC;
-        this._handleError(sqlite3.create_function_v2(this._ptr, name, func.length, eTextRep, NULL, funcPtr, NULL, NULL, NULL));
-        return this;
-      }
-      exec(sql) {
-        this._assertOpen();
-        const tempPtr = stringToHeap(sql);
-        try {
-          this._handleError(sqlite3.exec(this._ptr, tempPtr, NULL, NULL, NULL));
-        } finally {
-          _free(tempPtr);
-        }
-      }
-      prepare(sql) {
-        this._assertOpen();
-        return new Statement(this, sql);
-      }
-      run(sql, values) {
-        const stmt = this.prepare(sql);
-        try {
-          return stmt.run(values);
-        } finally {
-          stmt.finalize();
-        }
-      }
-      all(sql, values, { expand = false } = {}) {
-        return this._query(sql, values, false, expand);
-      }
-      get(sql, values, { expand = false } = {}) {
-        return this._query(sql, values, true, expand);
-      }
-      _query(sql, values, single, expand) {
-        const stmt = this.prepare(sql);
-        try {
-          if (single) {
-            return stmt.get(values, { expand });
-          } else {
-            return stmt.all(values, { expand });
-          }
-        } finally {
-          stmt.finalize();
-        }
-      }
-      _assertOpen() {
-        if (!this.isOpen)
-          throw new SQLite3Error("Database already closed");
-      }
-      _handleError(returnCode) {
-        if (returnCode !== SQLITE_OK)
-          throw new SQLite3Error(sqlite3.errmsg(this._ptr));
+  }
+});
+
+// node_modules/bindings/bindings.js
+var require_bindings = __commonJS({
+  "node_modules/bindings/bindings.js"(exports2, module2) {
+    var fs3 = require("fs");
+    var path2 = require("path");
+    var fileURLToPath = require_file_uri_to_path();
+    var join5 = path2.join;
+    var dirname2 = path2.dirname;
+    var exists = fs3.accessSync && function(path3) {
+      try {
+        fs3.accessSync(path3);
+      } catch (e) {
+        return false;
       }
+      return true;
+    } || fs3.existsSync || path2.existsSync;
+    var defaults = {
+      arrow: process.env.NODE_BINDINGS_ARROW || " \u2192 ",
+      compiled: process.env.NODE_BINDINGS_COMPILED_DIR || "compiled",
+      platform: process.platform,
+      arch: process.arch,
+      nodePreGyp: "node-v" + process.versions.modules + "-" + process.platform + "-" + process.arch,
+      version: process.versions.node,
+      bindings: "bindings.node",
+      try: [
+        // node-gyp's linked version in the "build" dir
+        ["module_root", "build", "bindings"],
+        // node-waf and gyp_addon (a.k.a node-gyp)
+        ["module_root", "build", "Debug", "bindings"],
+        ["module_root", "build", "Release", "bindings"],
+        // Debug files, for development (legacy behavior, remove for node v0.9)
+        ["module_root", "out", "Debug", "bindings"],
+        ["module_root", "Debug", "bindings"],
+        // Release files, but manually compiled (legacy behavior, remove for node v0.9)
+        ["module_root", "out", "Release", "bindings"],
+        ["module_root", "Release", "bindings"],
+        // Legacy from node-waf, node <= 0.4.x
+        ["module_root", "build", "default", "bindings"],
+        // Production "Release" buildtype binary (meh...)
+        ["module_root", "compiled", "version", "platform", "arch", "bindings"],
+        // node-qbs builds
+        ["module_root", "addon-build", "release", "install-root", "bindings"],
+        ["module_root", "addon-build", "debug", "install-root", "bindings"],
+        ["module_root", "addon-build", "default", "install-root", "bindings"],
+        // node-pre-gyp path ./lib/binding/{node_abi}-{platform}-{arch}
+        ["module_root", "lib", "binding", "nodePreGyp", "bindings"]
+      ]
     };
-    var Statement = class {
-      constructor(db3, sql) {
-        const tempPtr = stringToHeap(sql);
-        try {
-          db3._handleError(sqlite3.prepare_v2(db3._ptr, tempPtr, -1, temp, NULL));
-        } finally {
-          _free(tempPtr);
-        }
-        this._ptr = getValue(temp, "i32");
-        if (this._ptr === NULL)
-          throw new SQLite3Error("Nothing to prepare");
-        this._db = db3;
-      }
-      get database() {
-        return this._db;
-      }
-      get isFinalized() {
-        return this._ptr === null;
-      }
-      run(values) {
-        this._assertReady();
-        this._bind(values);
-        this._step();
-        return { changes: sqlite3.changes(this._db._ptr), lastInsertRowid: toNumberOrNot(sqlite3.last_insert_rowid(this._db._ptr)) };
-      }
-      iterate(values, { expand = false } = {}) {
-        return this._queryRows(values, expand);
-      }
-      all(values, { expand = false } = {}) {
-        return Array.from(this.iterate(values, { expand }));
-      }
-      get(values, { expand = false } = {}) {
-        const result = this._queryRows(values, expand).next();
-        return result.done ? null : result.value;
-      }
-      finalize() {
-        if (this.isFinalized)
-          throw new SQLite3Error("Statement already finalized");
+    function bindings(opts) {
+      if (typeof opts == "string") {
+        opts = { bindings: opts };
+      } else if (!opts) {
+        opts = {};
+      }
+      Object.keys(defaults).map(function(i2) {
+        if (!(i2 in opts))
+          opts[i2] = defaults[i2];
+      });
+      if (!opts.module_root) {
+        opts.module_root = exports2.getRoot(exports2.getFileName());
+      }
+      if (path2.extname(opts.bindings) != ".node") {
+        opts.bindings += ".node";
+      }
+      var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
+      var tries = [], i = 0, l = opts.try.length, n, b, err;
+      for (; i < l; i++) {
+        n = join5.apply(
+          null,
+          opts.try[i].map(function(p) {
+            return opts[p] || p;
+          })
+        );
+        tries.push(n);
         try {
-          this._db._handleError(sqlite3.finalize(this._ptr));
-        } finally {
-          this._ptr = null;
-        }
-      }
-      _reset() {
-        return sqlite3.clear_bindings(this._ptr) === SQLITE_OK && sqlite3.reset(this._ptr) === SQLITE_OK;
-      }
-      *_queryRows(values, expand) {
-        this._assertReady();
-        this._bind(values);
-        const columns = this._getColumnNames();
-        while (this._step())
-          yield this._getRow(columns, expand);
-      }
-      _bind(values) {
-        if (!this._reset()) {
-          throw new SQLite3Error("Could not reset statement prior to binding new values");
-        }
-        if (Array.isArray(values)) {
-          this._bindArray(values);
-        } else if (values != null && typeof values === "object") {
-          this._bindObject(values);
-        } else if (typeof values !== "undefined") {
-          this._bindValue(values, 1);
-        }
-      }
-      _step() {
-        const ret = sqlite3.step(this._ptr);
-        switch (ret) {
-          case SQLITE_ROW:
-            return true;
-          case SQLITE_DONE:
-            return false;
-          default:
-            this._db._handleError(ret);
-        }
-      }
-      _getRow(columns, expand) {
-        const row = {};
-        for (let i = 0; i < columns.length; i++) {
-          let v;
-          const colType = sqlite3.column_type(this._ptr, i);
-          switch (colType) {
-            case SQLITE_INTEGER:
-              v = toNumberOrNot(sqlite3.column_int64(this._ptr, i));
-              break;
-            case SQLITE_FLOAT:
-              v = sqlite3.column_double(this._ptr, i);
-              break;
-            case SQLITE_TEXT:
-              v = sqlite3.column_text(this._ptr, i);
-              break;
-            case SQLITE_BLOB:
-              const p = sqlite3.column_blob(this._ptr, i);
-              if (p != NULL) {
-                v = HEAPU8.slice(p, p + sqlite3.column_bytes(this._ptr, i));
-              } else {
-                v = new Uint8Array();
-              }
-              break;
-            case SQLITE_NULL:
-              v = null;
-              break;
+          b = opts.path ? requireFunc.resolve(n) : requireFunc(n);
+          if (!opts.path) {
+            b.path = n;
           }
-          const column = columns[i];
-          if (expand) {
-            let table = sqlite3.column_table_name(this._ptr, i);
-            table = table === "" ? "$" : table;
-            if (Object.hasOwn(row, table)) {
-              row[table][column] = v;
-            } else {
-              row[table] = { [column]: v };
-            }
-          } else {
-            row[column] = v;
+          return b;
+        } catch (e) {
+          if (e.code !== "MODULE_NOT_FOUND" && e.code !== "QUALIFIED_PATH_RESOLUTION_FAILED" && !/not find/i.test(e.message)) {
+            throw e;
           }
         }
-        return row;
       }
-      _getColumnNames() {
-        const names = [];
-        const columns = sqlite3.column_count(this._ptr);
-        for (let i = 0; i < columns; i++)
-          names.push(sqlite3.column_name(this._ptr, i));
-        return names;
-      }
-      _bindArray(values) {
-        for (let i = 0; i < values.length; i++)
-          this._bindValue(values[i], i + 1);
-      }
-      _bindObject(values) {
-        for (const [param, value] of Object.entries(values)) {
-          const i = sqlite3.bind_parameter_index(this._ptr, param);
-          if (i === 0)
-            throw new SQLite3Error(`Unknown binding parameter: "${param}"`);
-          this._bindValue(value, i);
-        }
-      }
-      _bindValue(value, position) {
-        let ret;
-        switch (typeof value) {
-          case "string":
-            const tempPtr = stringToHeap(value);
-            ret = sqlite3.bind_text(this._ptr, position, tempPtr, -1, SQLITE_TRANSIENT);
-            _free(tempPtr);
-            break;
-          case "number":
-            if (Number.isSafeInteger(value)) {
-              if (value >= INT32_MIN && value <= INT32_MAX) {
-                ret = sqlite3.bind_int(this._ptr, position, value);
-              } else {
-                ret = sqlite3.bind_int64(this._ptr, position, BigInt(value));
-              }
-            } else {
-              ret = sqlite3.bind_double(this._ptr, position, value);
-            }
-            break;
-          case "bigint":
-            ret = sqlite3.bind_int64(this._ptr, position, value);
-            break;
-          case "boolean":
-            ret = sqlite3.bind_int(this._ptr, position, value ? 1 : 0);
-            break;
-          case "object":
-            if (value === null) {
-              ret = sqlite3.bind_null(this._ptr, position);
-            } else if (value instanceof Uint8Array) {
-              const tempPtr2 = arrayToHeap(value);
-              if (value.byteLength <= INT32_MAX) {
-                ret = sqlite3.bind_blob(this._ptr, position, tempPtr2, value.byteLength, SQLITE_TRANSIENT);
-              } else {
-                ret = sqlite3.bind_blob64(this._ptr, position, tempPtr2, BigInt(value.byteLength), SQLITE_TRANSIENT);
+      err = new Error(
+        "Could not locate the bindings file. Tried:\n" + tries.map(function(a) {
+          return opts.arrow + a;
+        }).join("\n")
+      );
+      err.tries = tries;
+      throw err;
+    }
+    module2.exports = exports2 = bindings;
+    exports2.getFileName = function getFileName(calling_file) {
+      var origPST = Error.prepareStackTrace, origSTL = Error.stackTraceLimit, dummy = {}, fileName;
+      Error.stackTraceLimit = 10;
+      Error.prepareStackTrace = function(e, st) {
+        for (var i = 0, l = st.length; i < l; i++) {
+          fileName = st[i].getFileName();
+          if (fileName !== __filename) {
+            if (calling_file) {
+              if (fileName !== calling_file) {
+                return;
               }
-              _free(tempPtr2);
             } else {
-              throw new SQLite3Error(`Unsupported type for binding: "${typeof value}"`);
+              return;
             }
-            break;
-          default:
-            throw new SQLite3Error(`Unsupported type for binding: "${typeof value}"`);
+          }
         }
-        if (ret !== SQLITE_OK)
-          this._db._handleError(ret);
-      }
-      _assertReady() {
-        if (this.isFinalized)
-          throw new SQLite3Error("Statement already finalized");
-        if (!this._db.isOpen)
-          throw new SQLite3Error("Database is closed");
-      }
-    };
-    Module.Database = Database;
-    Module.SQLite3Error = SQLite3Error;
-    var path2 = require("node:path");
-    var crypto = require("node:crypto");
-    var SQLITE_CANTOPEN = 14;
-    var SQLITE_IOERR_READ = 266;
-    var SQLITE_IOERR_SHORT_READ = 522;
-    var SQLITE_IOERR_FSYNC = 1034;
-    var SQLITE_IOERR_WRITE = 778;
-    var SQLITE_IOERR_DELETE = 2570;
-    var SQLITE_IOERR_CLOSE = 4106;
-    var SQLITE_IOERR_TRUNCATE = 1546;
-    var SQLITE_IOERR_FSTAT = 1802;
-    var SQLITE_IOERR_LOCK = 3850;
-    var SQLITE_IOERR_UNLOCK = 2058;
-    var SQLITE_OPEN_READONLY = 1;
-    var SQLITE_OPEN_READWRITE = 2;
-    var SQLITE_OPEN_CREATE = 4;
-    var SQLITE_OPEN_EXCLUSIVE = 16;
-    var SQLITE_ACCESS_READWRITE = 1;
-    var SQLITE_ACCESS_READ = 2;
-    var SQLITE_LOCK_NONE = 0;
-    var SQLITE_BUSY = 5;
-    function _fd(fileInfo) {
-      return getValue(fileInfo + 4, "i32");
-    }
-    function _isLocked(fileInfo) {
-      return getValue(fileInfo + 8, "i32") != 0;
-    }
-    function _setLocked(fileInfo, locked) {
-      setValue(fileInfo + 8, locked ? 1 : 0, "i32");
-    }
-    function _path(fileInfo) {
-      return UTF8ToString(getValue(fileInfo + 12, "i32"));
-    }
-    function _safeInt(bigInt) {
-      if (bigInt < Number.MIN_SAFE_INTEGER || bigInt > Number.MAX_SAFE_INTEGER)
-        throw 0;
-      return Number(bigInt);
-    }
-    var arguments_ = [];
-    var thisProgram = "./this.program";
-    var quit_ = (status, toThrow) => {
-      throw toThrow;
-    };
-    var _scriptName;
-    if (typeof __filename != "undefined") {
-      _scriptName = __filename;
-    } else {
-    }
-    var scriptDirectory = "";
-    function locateFile(path3) {
-      if (Module["locateFile"]) {
-        return Module["locateFile"](path3, scriptDirectory);
-      }
-      return scriptDirectory + path3;
-    }
-    var readAsync;
-    var readBinary;
-    if (ENVIRONMENT_IS_NODE) {
-      fs3 = require("node:fs");
-      scriptDirectory = __dirname + "/";
-      readBinary = (filename) => {
-        filename = isFileURI(filename) ? new URL(filename) : filename;
-        var ret = fs3.readFileSync(filename);
-        return ret;
-      };
-      readAsync = async (filename, binary = true) => {
-        filename = isFileURI(filename) ? new URL(filename) : filename;
-        var ret = fs3.readFileSync(filename, binary ? void 0 : "utf8");
-        return ret;
-      };
-      if (process.argv.length > 1) {
-        thisProgram = process.argv[1].replace(/\\/g, "/");
-      }
-      arguments_ = process.argv.slice(2);
-      if (typeof module2 != "undefined") {
-        module2["exports"] = Module;
-      }
-      quit_ = (status, toThrow) => {
-        process.exitCode = status;
-        throw toThrow;
       };
-    } else {
-    }
-    var fs3;
-    var out = console.log.bind(console);
-    var err = console.error.bind(console);
-    var wasmBinary;
-    var ABORT = false;
-    var EXITSTATUS;
-    var isFileURI = (filename) => filename.startsWith("file://");
-    var runtimeInitialized = false;
-    function updateMemoryViews() {
-      var b = wasmMemory.buffer;
-      HEAP8 = new Int8Array(b);
-      HEAP16 = new Int16Array(b);
-      HEAPU8 = new Uint8Array(b);
-      HEAPU16 = new Uint16Array(b);
-      HEAP32 = new Int32Array(b);
-      HEAPU32 = new Uint32Array(b);
-      HEAPF32 = new Float32Array(b);
-      HEAPF64 = new Float64Array(b);
-      HEAP64 = new BigInt64Array(b);
-      HEAPU64 = new BigUint64Array(b);
-    }
-    function preRun() {
-      if (Module["preRun"]) {
-        if (typeof Module["preRun"] == "function")
-          Module["preRun"] = [Module["preRun"]];
-        while (Module["preRun"].length) {
-          addOnPreRun(Module["preRun"].shift());
+      Error.captureStackTrace(dummy);
+      dummy.stack;
+      Error.prepareStackTrace = origPST;
+      Error.stackTraceLimit = origSTL;
+      var fileSchema = "file://";
+      if (fileName.indexOf(fileSchema) === 0) {
+        fileName = fileURLToPath(fileName);
+      }
+      return fileName;
+    };
+    exports2.getRoot = function getRoot(file) {
+      var dir = dirname2(file), prev;
+      while (true) {
+        if (dir === ".") {
+          dir = process.cwd();
         }
-      }
-      callRuntimeCallbacks(onPreRuns);
-    }
-    function initRuntime() {
-      runtimeInitialized = true;
-      wasmExports["z"]();
-    }
-    function postRun() {
-      if (Module["postRun"]) {
-        if (typeof Module["postRun"] == "function")
-          Module["postRun"] = [Module["postRun"]];
-        while (Module["postRun"].length) {
-          addOnPostRun(Module["postRun"].shift());
+        if (exists(join5(dir, "package.json")) || exists(join5(dir, "node_modules"))) {
+          return dir;
         }
-      }
-      callRuntimeCallbacks(onPostRuns);
-    }
-    function abort(what) {
-      Module["onAbort"]?.(what);
-      what = `Aborted(${what})`;
-      err(what);
-      ABORT = true;
-      what += ". Build with -sASSERTIONS for more info.";
-      var e = new WebAssembly.RuntimeError(what);
-      throw e;
-    }
-    var wasmBinaryFile;
-    function findWasmBinary() {
-      return locateFile("node-sqlite3-wasm.wasm");
-    }
-    function getBinarySync(file) {
-      if (file == wasmBinaryFile && wasmBinary) {
-        return new Uint8Array(wasmBinary);
-      }
-      if (readBinary) {
-        return readBinary(file);
-      }
-      throw 'sync fetching of the wasm failed: you can preload it to Module["wasmBinary"] manually, or emcc.py will do that for you when generating HTML (but not JS)';
-    }
-    function instantiateSync(file, info) {
-      var module3;
-      var binary = getBinarySync(file);
-      module3 = new WebAssembly.Module(binary);
-      var instance = new WebAssembly.Instance(module3, info);
-      return [instance, module3];
-    }
-    function getWasmImports() {
-      var imports = { a: wasmImports };
-      return imports;
-    }
-    function createWasm() {
-      function receiveInstance(instance, module3) {
-        wasmExports = instance.exports;
-        assignWasmExports(wasmExports);
-        updateMemoryViews();
-        return wasmExports;
-      }
-      var info = getWasmImports();
-      if (Module["instantiateWasm"]) {
-        return new Promise((resolve, reject) => {
-          Module["instantiateWasm"](info, (inst, mod) => {
-            resolve(receiveInstance(inst, mod));
-          });
-        });
-      }
-      wasmBinaryFile ??= findWasmBinary();
-      var result = instantiateSync(wasmBinaryFile, info);
-      return receiveInstance(result[0]);
-    }
-    var ExitStatus = class {
-      name = "ExitStatus";
-      constructor(status) {
-        this.message = `Program terminated with exit(${status})`;
-        this.status = status;
-      }
-    };
-    var HEAP16;
-    var HEAP32;
-    var HEAP64;
-    var HEAP8;
-    var HEAPF32;
-    var HEAPF64;
-    var HEAPU16;
-    var HEAPU32;
-    var HEAPU64;
-    var HEAPU8;
-    var callRuntimeCallbacks = (callbacks) => {
-      while (callbacks.length > 0) {
-        callbacks.shift()(Module);
+        if (prev === dir) {
+          throw new Error(
+            'Could not find module root given file: "' + file + '". Do you have a `package.json` file? '
+          );
+        }
+        prev = dir;
+        dir = join5(dir, "..");
       }
     };
-    var onPostRuns = [];
-    var addOnPostRun = (cb) => onPostRuns.push(cb);
-    var onPreRuns = [];
-    var addOnPreRun = (cb) => onPreRuns.push(cb);
-    function getValue(ptr, type = "i8") {
-      if (type.endsWith("*"))
-        type = "*";
-      switch (type) {
-        case "i1":
-          return HEAP8[ptr];
-        case "i8":
-          return HEAP8[ptr];
-        case "i16":
-          return HEAP16[ptr >> 1];
-        case "i32":
-          return HEAP32[ptr >> 2];
-        case "i64":
-          return HEAP64[ptr >> 3];
-        case "float":
-          return HEAPF32[ptr >> 2];
-        case "double":
-          return HEAPF64[ptr >> 3];
-        case "*":
-          return HEAPU32[ptr >> 2];
-        default:
-          abort(`invalid type for getValue: ${type}`);
-      }
-    }
-    var noExitRuntime = true;
-    function setValue(ptr, value, type = "i8") {
-      if (type.endsWith("*"))
-        type = "*";
-      switch (type) {
-        case "i1":
-          HEAP8[ptr] = value;
-          break;
-        case "i8":
-          HEAP8[ptr] = value;
-          break;
-        case "i16":
-          HEAP16[ptr >> 1] = value;
-          break;
-        case "i32":
-          HEAP32[ptr >> 2] = value;
-          break;
-        case "i64":
-          HEAP64[ptr >> 3] = BigInt(value);
-          break;
-        case "float":
-          HEAPF32[ptr >> 2] = value;
-          break;
-        case "double":
-          HEAPF64[ptr >> 3] = value;
-          break;
-        case "*":
-          HEAPU32[ptr >> 2] = value;
-          break;
-        default:
-          abort(`invalid type for setValue: ${type}`);
-      }
-    }
-    var stackRestore = (val) => __emscripten_stack_restore(val);
-    var stackSave = () => _emscripten_stack_get_current();
-    var __abort_js = () => abort("");
-    var runtimeKeepaliveCounter = 0;
-    var __emscripten_runtime_keepalive_clear = () => {
-      noExitRuntime = false;
-      runtimeKeepaliveCounter = 0;
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/wrappers.js
+var require_wrappers = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/wrappers.js"(exports2) {
+    "use strict";
+    var { cppdb } = require_util();
+    exports2.prepare = function prepare(sql) {
+      return this[cppdb].prepare(sql, this, false);
     };
-    var isLeapYear = (year) => year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
-    var MONTH_DAYS_LEAP_CUMULATIVE = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335];
-    var MONTH_DAYS_REGULAR_CUMULATIVE = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
-    var ydayFromDate = (date) => {
-      var leap = isLeapYear(date.getFullYear());
-      var monthDaysCumulative = leap ? MONTH_DAYS_LEAP_CUMULATIVE : MONTH_DAYS_REGULAR_CUMULATIVE;
-      var yday = monthDaysCumulative[date.getMonth()] + date.getDate() - 1;
-      return yday;
+    exports2.exec = function exec(sql) {
+      this[cppdb].exec(sql);
+      return this;
     };
-    var INT53_MAX = 9007199254740992;
-    var INT53_MIN = -9007199254740992;
-    var bigintToI53Checked = (num) => num < INT53_MIN || num > INT53_MAX ? NaN : Number(num);
-    function __localtime_js(time, tmPtr) {
-      time = bigintToI53Checked(time);
-      var date = new Date(time * 1e3);
-      HEAP32[tmPtr >> 2] = date.getSeconds();
-      HEAP32[tmPtr + 4 >> 2] = date.getMinutes();
-      HEAP32[tmPtr + 8 >> 2] = date.getHours();
-      HEAP32[tmPtr + 12 >> 2] = date.getDate();
-      HEAP32[tmPtr + 16 >> 2] = date.getMonth();
-      HEAP32[tmPtr + 20 >> 2] = date.getFullYear() - 1900;
-      HEAP32[tmPtr + 24 >> 2] = date.getDay();
-      var yday = ydayFromDate(date) | 0;
-      HEAP32[tmPtr + 28 >> 2] = yday;
-      HEAP32[tmPtr + 36 >> 2] = -(date.getTimezoneOffset() * 60);
-      var start = new Date(date.getFullYear(), 0, 1);
-      var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset();
-      var winterOffset = start.getTimezoneOffset();
-      var dst = (summerOffset != winterOffset && date.getTimezoneOffset() == Math.min(winterOffset, summerOffset)) | 0;
-      HEAP32[tmPtr + 32 >> 2] = dst;
-    }
-    var timers = {};
-    var handleException = (e) => {
-      if (e instanceof ExitStatus || e == "unwind") {
-        return EXITSTATUS;
-      }
-      quit_(1, e);
+    exports2.close = function close() {
+      this[cppdb].close();
+      return this;
     };
-    var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
-    var _proc_exit = (code) => {
-      EXITSTATUS = code;
-      if (!keepRuntimeAlive()) {
-        Module["onExit"]?.(code);
-        ABORT = true;
-      }
-      quit_(code, new ExitStatus(code));
+    exports2.loadExtension = function loadExtension(...args) {
+      this[cppdb].loadExtension(...args);
+      return this;
     };
-    var exitJS = (status, implicit) => {
-      EXITSTATUS = status;
-      _proc_exit(status);
+    exports2.defaultSafeIntegers = function defaultSafeIntegers(...args) {
+      this[cppdb].defaultSafeIntegers(...args);
+      return this;
     };
-    var _exit = exitJS;
-    var maybeExit = () => {
-      if (!keepRuntimeAlive()) {
-        try {
-          _exit(EXITSTATUS);
-        } catch (e) {
-          handleException(e);
-        }
-      }
+    exports2.unsafeMode = function unsafeMode(...args) {
+      this[cppdb].unsafeMode(...args);
+      return this;
     };
-    var callUserCallback = (func) => {
-      if (ABORT) {
-        return;
-      }
-      try {
-        return func();
-      } catch (e) {
-        handleException(e);
-      } finally {
-        maybeExit();
+    exports2.getters = {
+      name: {
+        get: function name() {
+          return this[cppdb].name;
+        },
+        enumerable: true
+      },
+      open: {
+        get: function open() {
+          return this[cppdb].open;
+        },
+        enumerable: true
+      },
+      inTransaction: {
+        get: function inTransaction() {
+          return this[cppdb].inTransaction;
+        },
+        enumerable: true
+      },
+      readonly: {
+        get: function readonly() {
+          return this[cppdb].readonly;
+        },
+        enumerable: true
+      },
+      memory: {
+        get: function memory() {
+          return this[cppdb].memory;
+        },
+        enumerable: true
       }
     };
-    var _emscripten_get_now = () => performance.now();
-    var __setitimer_js = (which, timeout_ms) => {
-      if (timers[which]) {
-        clearTimeout(timers[which].id);
-        delete timers[which];
-      }
-      if (!timeout_ms)
-        return 0;
-      var id = setTimeout(() => {
-        delete timers[which];
-        callUserCallback(() => __emscripten_timeout(which, _emscripten_get_now()));
-      }, timeout_ms);
-      timers[which] = { id, timeout_ms };
-      return 0;
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/transaction.js
+var require_transaction = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/transaction.js"(exports2, module2) {
+    "use strict";
+    var { cppdb } = require_util();
+    var controllers = /* @__PURE__ */ new WeakMap();
+    module2.exports = function transaction(fn) {
+      if (typeof fn !== "function")
+        throw new TypeError("Expected first argument to be a function");
+      const db3 = this[cppdb];
+      const controller = getController(db3, this);
+      const { apply } = Function.prototype;
+      const properties = {
+        default: { value: wrapTransaction(apply, fn, db3, controller.default) },
+        deferred: { value: wrapTransaction(apply, fn, db3, controller.deferred) },
+        immediate: { value: wrapTransaction(apply, fn, db3, controller.immediate) },
+        exclusive: { value: wrapTransaction(apply, fn, db3, controller.exclusive) },
+        database: { value: this, enumerable: true }
+      };
+      Object.defineProperties(properties.default.value, properties);
+      Object.defineProperties(properties.deferred.value, properties);
+      Object.defineProperties(properties.immediate.value, properties);
+      Object.defineProperties(properties.exclusive.value, properties);
+      return properties.default.value;
     };
-    var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
-      if (!(maxBytesToWrite > 0))
-        return 0;
-      var startIdx = outIdx;
-      var endIdx = outIdx + maxBytesToWrite - 1;
-      for (var i = 0; i < str.length; ++i) {
-        var u = str.codePointAt(i);
-        if (u <= 127) {
-          if (outIdx >= endIdx)
-            break;
-          heap[outIdx++] = u;
-        } else if (u <= 2047) {
-          if (outIdx + 1 >= endIdx)
-            break;
-          heap[outIdx++] = 192 | u >> 6;
-          heap[outIdx++] = 128 | u & 63;
-        } else if (u <= 65535) {
-          if (outIdx + 2 >= endIdx)
-            break;
-          heap[outIdx++] = 224 | u >> 12;
-          heap[outIdx++] = 128 | u >> 6 & 63;
-          heap[outIdx++] = 128 | u & 63;
-        } else {
-          if (outIdx + 3 >= endIdx)
-            break;
-          heap[outIdx++] = 240 | u >> 18;
-          heap[outIdx++] = 128 | u >> 12 & 63;
-          heap[outIdx++] = 128 | u >> 6 & 63;
-          heap[outIdx++] = 128 | u & 63;
-          i++;
-        }
+    var getController = (db3, self) => {
+      let controller = controllers.get(db3);
+      if (!controller) {
+        const shared = {
+          commit: db3.prepare("COMMIT", self, false),
+          rollback: db3.prepare("ROLLBACK", self, false),
+          savepoint: db3.prepare("SAVEPOINT `	_bs3.	`", self, false),
+          release: db3.prepare("RELEASE `	_bs3.	`", self, false),
+          rollbackTo: db3.prepare("ROLLBACK TO `	_bs3.	`", self, false)
+        };
+        controllers.set(db3, controller = {
+          default: Object.assign({ begin: db3.prepare("BEGIN", self, false) }, shared),
+          deferred: Object.assign({ begin: db3.prepare("BEGIN DEFERRED", self, false) }, shared),
+          immediate: Object.assign({ begin: db3.prepare("BEGIN IMMEDIATE", self, false) }, shared),
+          exclusive: Object.assign({ begin: db3.prepare("BEGIN EXCLUSIVE", self, false) }, shared)
+        });
       }
-      heap[outIdx] = 0;
-      return outIdx - startIdx;
+      return controller;
     };
-    var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
-    var __tzset_js = (timezone, daylight, std_name, dst_name) => {
-      var currentYear = (/* @__PURE__ */ new Date()).getFullYear();
-      var winter = new Date(currentYear, 0, 1);
-      var summer = new Date(currentYear, 6, 1);
-      var winterOffset = winter.getTimezoneOffset();
-      var summerOffset = summer.getTimezoneOffset();
-      var stdTimezoneOffset = Math.max(winterOffset, summerOffset);
-      HEAPU32[timezone >> 2] = stdTimezoneOffset * 60;
-      HEAP32[daylight >> 2] = Number(winterOffset != summerOffset);
-      var extractZone = (timezoneOffset) => {
-        var sign = timezoneOffset >= 0 ? "-" : "+";
-        var absOffset = Math.abs(timezoneOffset);
-        var hours = String(Math.floor(absOffset / 60)).padStart(2, "0");
-        var minutes = String(absOffset % 60).padStart(2, "0");
-        return `UTC${sign}${hours}${minutes}`;
-      };
-      var winterName = extractZone(winterOffset);
-      var summerName = extractZone(summerOffset);
-      if (summerOffset < winterOffset) {
-        stringToUTF8(winterName, std_name, 17);
-        stringToUTF8(summerName, dst_name, 17);
+    var wrapTransaction = (apply, fn, db3, { begin, commit, rollback, savepoint, release, rollbackTo }) => function sqliteTransaction() {
+      let before, after, undo;
+      if (db3.inTransaction) {
+        before = savepoint;
+        after = release;
+        undo = rollbackTo;
       } else {
-        stringToUTF8(winterName, dst_name, 17);
-        stringToUTF8(summerName, std_name, 17);
+        before = begin;
+        after = commit;
+        undo = rollback;
       }
-    };
-    var _emscripten_date_now = () => Date.now();
-    var getHeapMax = () => 2147483648;
-    var alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment;
-    var growMemory = (size) => {
-      var oldHeapSize = wasmMemory.buffer.byteLength;
-      var pages = (size - oldHeapSize + 65535) / 65536 | 0;
+      before.run();
       try {
-        wasmMemory.grow(pages);
-        updateMemoryViews();
-        return 1;
-      } catch (e) {
-      }
-    };
-    var _emscripten_resize_heap = (requestedSize) => {
-      var oldSize = HEAPU8.length;
-      requestedSize >>>= 0;
-      var maxHeapSize = getHeapMax();
-      if (requestedSize > maxHeapSize) {
-        return false;
-      }
-      for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
-        var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
-        overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
-        var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536));
-        var replacement = growMemory(newSize);
-        if (replacement) {
-          return true;
+        const result = apply.call(fn, this, arguments);
+        if (result && typeof result.then === "function") {
+          throw new TypeError("Transaction function cannot return a promise");
+        }
+        after.run();
+        return result;
+      } catch (ex) {
+        if (db3.inTransaction) {
+          undo.run();
+          if (undo !== rollback)
+            after.run();
         }
+        throw ex;
       }
-      return false;
     };
-    var UTF8Decoder = globalThis.TextDecoder && new TextDecoder();
-    var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => {
-      var maxIdx = idx + maxBytesToRead;
-      if (ignoreNul)
-        return maxIdx;
-      while (heapOrArray[idx] && !(idx >= maxIdx))
-        ++idx;
-      return idx;
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/pragma.js
+var require_pragma = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/pragma.js"(exports2, module2) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module2.exports = function pragma(source, options) {
+      if (options == null)
+        options = {};
+      if (typeof source !== "string")
+        throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object")
+        throw new TypeError("Expected second argument to be an options object");
+      const simple = getBooleanOption(options, "simple");
+      const stmt = this[cppdb].prepare(`PRAGMA ${source}`, this, true);
+      return simple ? stmt.pluck().get() : stmt.all();
     };
-    var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => {
-      var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead, ignoreNul);
-      if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
-        return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
-      }
-      var str = "";
-      while (idx < endPtr) {
-        var u0 = heapOrArray[idx++];
-        if (!(u0 & 128)) {
-          str += String.fromCharCode(u0);
-          continue;
-        }
-        var u1 = heapOrArray[idx++] & 63;
-        if ((u0 & 224) == 192) {
-          str += String.fromCharCode((u0 & 31) << 6 | u1);
-          continue;
-        }
-        var u2 = heapOrArray[idx++] & 63;
-        if ((u0 & 240) == 224) {
-          u0 = (u0 & 15) << 12 | u1 << 6 | u2;
-        } else {
-          u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63;
-        }
-        if (u0 < 65536) {
-          str += String.fromCharCode(u0);
-        } else {
-          var ch = u0 - 65536;
-          str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
-        }
-      }
-      return str;
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/backup.js
+var require_backup = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/backup.js"(exports2, module2) {
+    "use strict";
+    var fs3 = require("fs");
+    var path2 = require("path");
+    var { promisify } = require("util");
+    var { cppdb } = require_util();
+    var fsAccess = promisify(fs3.access);
+    module2.exports = async function backup(filename, options) {
+      if (options == null)
+        options = {};
+      if (typeof filename !== "string")
+        throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object")
+        throw new TypeError("Expected second argument to be an options object");
+      filename = filename.trim();
+      const attachedName = "attached" in options ? options.attached : "main";
+      const handler = "progress" in options ? options.progress : null;
+      if (!filename)
+        throw new TypeError("Backup filename cannot be an empty string");
+      if (filename === ":memory:")
+        throw new TypeError('Invalid backup filename ":memory:"');
+      if (typeof attachedName !== "string")
+        throw new TypeError('Expected the "attached" option to be a string');
+      if (!attachedName)
+        throw new TypeError('The "attached" option cannot be an empty string');
+      if (handler != null && typeof handler !== "function")
+        throw new TypeError('Expected the "progress" option to be a function');
+      await fsAccess(path2.dirname(filename)).catch(() => {
+        throw new TypeError("Cannot save backup because the directory does not exist");
+      });
+      const isNewFile = await fsAccess(filename).then(() => false, () => true);
+      return runBackup(this[cppdb].backup(this, attachedName, filename, isNewFile), handler || null);
     };
-    var UTF8ToString = (ptr, maxBytesToRead, ignoreNul) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead, ignoreNul) : "";
-    function _nodejsAccess(vfs, filePath, flags, outResult) {
-      let aflags = fs3.constants.F_OK;
-      if (flags == SQLITE_ACCESS_READWRITE)
-        aflags = fs3.constants.R_OK | fs3.constants.W_OK;
-      if (flags == SQLITE_ACCESS_READ)
-        aflags = fs3.constants.R_OK;
-      try {
-        fs3.accessSync(UTF8ToString(filePath), aflags);
-        setValue(outResult, 1, "i32");
-      } catch {
-        setValue(outResult, 0, "i32");
-      }
-      return SQLITE_OK;
-    }
-    function _nodejsCheckReservedLock(fi, outResult) {
-      try {
-        fs3.accessSync(`${_path(fi)}.lock`, fs3.constants.F_OK);
-        setValue(outResult, 1, "i32");
-      } catch {
-        setValue(outResult, 0, "i32");
-      }
-      return SQLITE_OK;
-    }
-    function _nodejsClose(fi) {
-      _nodejsUnlock(fi, SQLITE_LOCK_NONE);
-      try {
-        fs3.closeSync(_fd(fi));
-      } catch {
-        return SQLITE_IOERR_CLOSE;
-      }
-      return SQLITE_OK;
-    }
-    function _nodejsDelete(vfs, filePath, dirSync) {
-      const pathStr = UTF8ToString(filePath);
-      try {
-        fs3.unlinkSync(pathStr);
-      } catch (err2) {
-        if (err2.code != "ENOENT")
-          return SQLITE_IOERR_DELETE;
-      }
-      if (dirSync) {
-        let fd = -1;
-        try {
-          fd = fs3.openSync(path2.dirname(pathStr), "r");
-          fs3.fsyncSync(fd);
-        } catch {
-          return SQLITE_IOERR_FSYNC;
-        } finally {
+    var runBackup = (backup, handler) => {
+      let rate = 0;
+      let useDefault = true;
+      return new Promise((resolve, reject) => {
+        setImmediate(function step() {
           try {
-            fs3.closeSync(fd);
-          } catch {
-            return SQLITE_IOERR_FSYNC;
+            const progress = backup.transfer(rate);
+            if (!progress.remainingPages) {
+              backup.close();
+              resolve(progress);
+              return;
+            }
+            if (useDefault) {
+              useDefault = false;
+              rate = 100;
+            }
+            if (handler) {
+              const ret = handler(progress);
+              if (ret !== void 0) {
+                if (typeof ret === "number" && ret === ret)
+                  rate = Math.max(0, Math.min(2147483647, Math.round(ret)));
+                else
+                  throw new TypeError("Expected progress callback to return a number or undefined");
+              }
+            }
+            setImmediate(step);
+          } catch (err) {
+            backup.close();
+            reject(err);
           }
-        }
+        });
+      });
+    };
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/serialize.js
+var require_serialize = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/serialize.js"(exports2, module2) {
+    "use strict";
+    var { cppdb } = require_util();
+    module2.exports = function serialize(options) {
+      if (options == null)
+        options = {};
+      if (typeof options !== "object")
+        throw new TypeError("Expected first argument to be an options object");
+      const attachedName = "attached" in options ? options.attached : "main";
+      if (typeof attachedName !== "string")
+        throw new TypeError('Expected the "attached" option to be a string');
+      if (!attachedName)
+        throw new TypeError('The "attached" option cannot be an empty string');
+      return this[cppdb].serialize(attachedName);
+    };
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/function.js
+var require_function = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/function.js"(exports2, module2) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module2.exports = function defineFunction(name, options, fn) {
+      if (options == null)
+        options = {};
+      if (typeof options === "function") {
+        fn = options;
+        options = {};
+      }
+      if (typeof name !== "string")
+        throw new TypeError("Expected first argument to be a string");
+      if (typeof fn !== "function")
+        throw new TypeError("Expected last argument to be a function");
+      if (typeof options !== "object")
+        throw new TypeError("Expected second argument to be an options object");
+      if (!name)
+        throw new TypeError("User-defined function name cannot be an empty string");
+      const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
+      const deterministic = getBooleanOption(options, "deterministic");
+      const directOnly = getBooleanOption(options, "directOnly");
+      const varargs = getBooleanOption(options, "varargs");
+      let argCount = -1;
+      if (!varargs) {
+        argCount = fn.length;
+        if (!Number.isInteger(argCount) || argCount < 0)
+          throw new TypeError("Expected function.length to be a positive integer");
+        if (argCount > 100)
+          throw new RangeError("User-defined functions cannot have more than 100 arguments");
+      }
+      this[cppdb].function(fn, name, argCount, safeIntegers, deterministic, directOnly);
+      return this;
+    };
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/aggregate.js
+var require_aggregate = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/aggregate.js"(exports2, module2) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module2.exports = function defineAggregate(name, options) {
+      if (typeof name !== "string")
+        throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object" || options === null)
+        throw new TypeError("Expected second argument to be an options object");
+      if (!name)
+        throw new TypeError("User-defined function name cannot be an empty string");
+      const start = "start" in options ? options.start : null;
+      const step = getFunctionOption(options, "step", true);
+      const inverse = getFunctionOption(options, "inverse", false);
+      const result = getFunctionOption(options, "result", false);
+      const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
+      const deterministic = getBooleanOption(options, "deterministic");
+      const directOnly = getBooleanOption(options, "directOnly");
+      const varargs = getBooleanOption(options, "varargs");
+      let argCount = -1;
+      if (!varargs) {
+        argCount = Math.max(getLength(step), inverse ? getLength(inverse) : 0);
+        if (argCount > 0)
+          argCount -= 1;
+        if (argCount > 100)
+          throw new RangeError("User-defined functions cannot have more than 100 arguments");
+      }
+      this[cppdb].aggregate(start, step, inverse, result, name, argCount, safeIntegers, deterministic, directOnly);
+      return this;
+    };
+    var getFunctionOption = (options, key, required) => {
+      const value = key in options ? options[key] : null;
+      if (typeof value === "function")
+        return value;
+      if (value != null)
+        throw new TypeError(`Expected the "${key}" option to be a function`);
+      if (required)
+        throw new TypeError(`Missing required option "${key}"`);
+      return null;
+    };
+    var getLength = ({ length }) => {
+      if (Number.isInteger(length) && length >= 0)
+        return length;
+      throw new TypeError("Expected function.length to be a positive integer");
+    };
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/table.js
+var require_table = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/table.js"(exports2, module2) {
+    "use strict";
+    var { cppdb } = require_util();
+    module2.exports = function defineTable(name, factory) {
+      if (typeof name !== "string")
+        throw new TypeError("Expected first argument to be a string");
+      if (!name)
+        throw new TypeError("Virtual table module name cannot be an empty string");
+      let eponymous = false;
+      if (typeof factory === "object" && factory !== null) {
+        eponymous = true;
+        factory = defer(parseTableDefinition(factory, "used", name));
+      } else {
+        if (typeof factory !== "function")
+          throw new TypeError("Expected second argument to be a function or a table definition object");
+        factory = wrapFactory(factory);
       }
-      return SQLITE_OK;
+      this[cppdb].table(factory, name, eponymous);
+      return this;
+    };
+    function wrapFactory(factory) {
+      return function virtualTableFactory(moduleName, databaseName, tableName, ...args) {
+        const thisObject = {
+          module: moduleName,
+          database: databaseName,
+          table: tableName
+        };
+        const def = apply.call(factory, thisObject, args);
+        if (typeof def !== "object" || def === null) {
+          throw new TypeError(`Virtual table module "${moduleName}" did not return a table definition object`);
+        }
+        return parseTableDefinition(def, "returned", moduleName);
+      };
     }
-    function _nodejsFileSize(fi, outSize) {
-      try {
-        setValue(outSize, fs3.fstatSync(_fd(fi)).size, "i64");
-      } catch {
-        return SQLITE_IOERR_FSTAT;
+    function parseTableDefinition(def, verb, moduleName) {
+      if (!hasOwnProperty.call(def, "rows")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "rows" property`);
       }
-      return SQLITE_OK;
-    }
-    function _nodejsFullPathname(vfs, relPath, sizeFullPath, outFullPath) {
-      const full = path2.resolve(UTF8ToString(relPath));
-      stringToUTF8(full, outFullPath, sizeFullPath);
-      return full.length < sizeFullPath ? SQLITE_OK : SQLITE_CANTOPEN;
-    }
-    function _nodejsLock(fi, level) {
-      if (!_isLocked(fi)) {
-        try {
-          fs3.mkdirSync(`${_path(fi)}.lock`);
-        } catch (err2) {
-          return err2.code == "EEXIST" ? SQLITE_BUSY : SQLITE_IOERR_LOCK;
-        }
-        _setLocked(fi, true);
+      if (!hasOwnProperty.call(def, "columns")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "columns" property`);
       }
-      return SQLITE_OK;
-    }
-    function _nodejsRandomness(vfs, bytes, outBuffer) {
-      const buf = HEAPU8.subarray(outBuffer, outBuffer + bytes);
-      crypto.randomFillSync(buf);
-      return bytes;
-    }
-    function _nodejsRead(fi, outBuffer, bytes, offset) {
-      const buf = HEAPU8.subarray(outBuffer, outBuffer + bytes);
-      let bytesRead;
-      try {
-        bytesRead = fs3.readSync(_fd(fi), buf, 0, bytes, offset);
-      } catch {
-        return SQLITE_IOERR_READ;
+      const rows = def.rows;
+      if (typeof rows !== "function" || Object.getPrototypeOf(rows) !== GeneratorFunctionPrototype) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "rows" property (should be a generator function)`);
       }
-      if (bytesRead == bytes) {
-        return SQLITE_OK;
-      } else if (bytesRead >= 0) {
-        if (bytesRead < bytes) {
-          try {
-            buf.fill(0, bytesRead);
-          } catch {
-            return SQLITE_IOERR_READ;
-          }
-        }
-        return SQLITE_IOERR_SHORT_READ;
+      let columns = def.columns;
+      if (!Array.isArray(columns) || !(columns = [...columns]).every((x) => typeof x === "string")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "columns" property (should be an array of strings)`);
       }
-      return SQLITE_IOERR_READ;
-    }
-    function _nodejsSync(fi, flags) {
-      try {
-        fs3.fsyncSync(_fd(fi));
-      } catch {
-        return SQLITE_IOERR_FSYNC;
+      if (columns.length !== new Set(columns).size) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate column names`);
       }
-      return SQLITE_OK;
-    }
-    function _nodejsTruncate(fi, size) {
-      try {
-        fs3.ftruncateSync(_fd(fi), _safeInt(size));
-      } catch {
-        return SQLITE_IOERR_TRUNCATE;
+      if (!columns.length) {
+        throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with zero columns`);
       }
-      return SQLITE_OK;
-    }
-    function _nodejsUnlock(fi, level) {
-      if (level == SQLITE_LOCK_NONE && _isLocked(fi)) {
-        try {
-          fs3.rmdirSync(`${_path(fi)}.lock`);
-        } catch (err2) {
-          if (err2.code != "ENOENT")
-            return SQLITE_IOERR_UNLOCK;
+      let parameters;
+      if (hasOwnProperty.call(def, "parameters")) {
+        parameters = def.parameters;
+        if (!Array.isArray(parameters) || !(parameters = [...parameters]).every((x) => typeof x === "string")) {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "parameters" property (should be an array of strings)`);
         }
-        _setLocked(fi, false);
+      } else {
+        parameters = inferParameters(rows);
       }
-      return SQLITE_OK;
-    }
-    function _nodejsWrite(fi, buffer, bytes, offset) {
-      try {
-        const bytesWritten = fs3.writeSync(_fd(fi), HEAPU8.subarray(buffer, buffer + bytes), 0, bytes, _safeInt(offset));
-        return bytesWritten != bytes ? SQLITE_IOERR_WRITE : SQLITE_OK;
-      } catch {
-        return SQLITE_IOERR_WRITE;
+      if (parameters.length !== new Set(parameters).size) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate parameter names`);
       }
-    }
-    function _nodejs_max_path_length() {
-      return process.platform == "win32" ? 260 : 4096;
-    }
-    function _nodejs_open(filePath, flags, mode) {
-      let oflags = 0;
-      if (flags & SQLITE_OPEN_EXCLUSIVE)
-        oflags |= fs3.constants.O_EXCL;
-      if (flags & SQLITE_OPEN_CREATE)
-        oflags |= fs3.constants.O_CREAT;
-      if (flags & SQLITE_OPEN_READONLY)
-        oflags |= fs3.constants.O_RDONLY;
-      if (flags & SQLITE_OPEN_READWRITE)
-        oflags |= fs3.constants.O_RDWR;
-      try {
-        return fs3.openSync(UTF8ToString(filePath), oflags, mode);
-      } catch {
-        return -1;
+      if (parameters.length > 32) {
+        throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with more than the maximum number of 32 parameters`);
       }
-    }
-    var getCFunc = (ident) => {
-      var func = Module["_" + ident];
-      return func;
-    };
-    var writeArrayToMemory = (array, buffer) => {
-      HEAP8.set(array, buffer);
-    };
-    var lengthBytesUTF8 = (str) => {
-      var len = 0;
-      for (var i = 0; i < str.length; ++i) {
-        var c = str.charCodeAt(i);
-        if (c <= 127) {
-          len++;
-        } else if (c <= 2047) {
-          len += 2;
-        } else if (c >= 55296 && c <= 57343) {
-          len += 4;
-          ++i;
-        } else {
-          len += 3;
+      for (const parameter of parameters) {
+        if (columns.includes(parameter)) {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with column "${parameter}" which was ambiguously defined as both a column and parameter`);
         }
       }
-      return len;
-    };
-    var stackAlloc = (sz) => __emscripten_stack_alloc(sz);
-    var stringToUTF8OnStack = (str) => {
-      var size = lengthBytesUTF8(str) + 1;
-      var ret = stackAlloc(size);
-      stringToUTF8(str, ret, size);
-      return ret;
-    };
-    var ccall = (ident, returnType, argTypes, args, opts) => {
-      var toC = { string: (str) => {
-        var ret2 = 0;
-        if (str !== null && str !== void 0 && str !== 0) {
-          ret2 = stringToUTF8OnStack(str);
+      let safeIntegers = 2;
+      if (hasOwnProperty.call(def, "safeIntegers")) {
+        const bool = def.safeIntegers;
+        if (typeof bool !== "boolean") {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "safeIntegers" property (should be a boolean)`);
         }
-        return ret2;
-      }, array: (arr) => {
-        var ret2 = stackAlloc(arr.length);
-        writeArrayToMemory(arr, ret2);
-        return ret2;
-      } };
-      function convertReturnValue(ret2) {
-        if (returnType === "string") {
-          return UTF8ToString(ret2);
+        safeIntegers = +bool;
+      }
+      let directOnly = false;
+      if (hasOwnProperty.call(def, "directOnly")) {
+        directOnly = def.directOnly;
+        if (typeof directOnly !== "boolean") {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "directOnly" property (should be a boolean)`);
         }
-        if (returnType === "boolean")
-          return Boolean(ret2);
-        return ret2;
       }
-      var func = getCFunc(ident);
-      var cArgs = [];
-      var stack = 0;
-      if (args) {
-        for (var i = 0; i < args.length; i++) {
-          var converter = toC[argTypes[i]];
-          if (converter) {
-            if (stack === 0)
-              stack = stackSave();
-            cArgs[i] = converter(args[i]);
+      const columnDefinitions = [
+        ...parameters.map(identifier).map((str) => `${str} HIDDEN`),
+        ...columns.map(identifier)
+      ];
+      return [
+        `CREATE TABLE x(${columnDefinitions.join(", ")});`,
+        wrapGenerator(rows, new Map(columns.map((x, i) => [x, parameters.length + i])), moduleName),
+        parameters,
+        safeIntegers,
+        directOnly
+      ];
+    }
+    function wrapGenerator(generator, columnMap, moduleName) {
+      return function* virtualTable(...args) {
+        const output = args.map((x) => Buffer.isBuffer(x) ? Buffer.from(x) : x);
+        for (let i = 0; i < columnMap.size; ++i) {
+          output.push(null);
+        }
+        for (const row of generator(...args)) {
+          if (Array.isArray(row)) {
+            extractRowArray(row, output, columnMap.size, moduleName);
+            yield output;
+          } else if (typeof row === "object" && row !== null) {
+            extractRowObject(row, output, columnMap, moduleName);
+            yield output;
           } else {
-            cArgs[i] = args[i];
+            throw new TypeError(`Virtual table module "${moduleName}" yielded something that isn't a valid row object`);
           }
         }
+      };
+    }
+    function extractRowArray(row, output, columnCount, moduleName) {
+      if (row.length !== columnCount) {
+        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an incorrect number of columns`);
       }
-      var ret = func(...cArgs);
-      function onDone(ret2) {
-        if (stack !== 0)
-          stackRestore(stack);
-        return convertReturnValue(ret2);
-      }
-      ret = onDone(ret);
-      return ret;
-    };
-    var cwrap = (ident, returnType, argTypes, opts) => {
-      var numericArgs = !argTypes || argTypes.every((type) => type === "number" || type === "boolean");
-      var numericRet = returnType !== "string";
-      if (numericRet && numericArgs && !opts) {
-        return getCFunc(ident);
-      }
-      return (...args) => ccall(ident, returnType, argTypes, args, opts);
-    };
-    var wasmTableMirror = [];
-    var getWasmTableEntry = (funcPtr) => {
-      var func = wasmTableMirror[funcPtr];
-      if (!func) {
-        wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
+      const offset = output.length - columnCount;
+      for (let i = 0; i < columnCount; ++i) {
+        output[i + offset] = row[i];
       }
-      return func;
-    };
-    var updateTableMap = (offset, count) => {
-      if (functionsInTableMap) {
-        for (var i = offset; i < offset + count; i++) {
-          var item = getWasmTableEntry(i);
-          if (item) {
-            functionsInTableMap.set(item, i);
-          }
+    }
+    function extractRowObject(row, output, columnMap, moduleName) {
+      let count = 0;
+      for (const key of Object.keys(row)) {
+        const index = columnMap.get(key);
+        if (index === void 0) {
+          throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an undeclared column "${key}"`);
         }
+        output[index] = row[key];
+        count += 1;
       }
-    };
-    var functionsInTableMap;
-    var getFunctionAddress = (func) => {
-      if (!functionsInTableMap) {
-        functionsInTableMap = /* @__PURE__ */ new WeakMap();
-        updateTableMap(0, wasmTable.length);
-      }
-      return functionsInTableMap.get(func) || 0;
-    };
-    var freeTableIndexes = [];
-    var getEmptyTableSlot = () => {
-      if (freeTableIndexes.length) {
-        return freeTableIndexes.pop();
+      if (count !== columnMap.size) {
+        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with missing columns`);
       }
-      return wasmTable["grow"](1);
-    };
-    var setWasmTableEntry = (idx, func) => {
-      wasmTable.set(idx, func);
-      wasmTableMirror[idx] = wasmTable.get(idx);
-    };
-    var uleb128EncodeWithLen = (arr) => {
-      const n = arr.length;
-      return [n % 128 | 128, n >> 7, ...arr];
-    };
-    var wasmTypeCodes = { i: 127, p: 127, j: 126, f: 125, d: 124, e: 111 };
-    var generateTypePack = (types) => uleb128EncodeWithLen(Array.from(types, (type) => {
-      var code = wasmTypeCodes[type];
-      return code;
-    }));
-    var convertJsFunctionToWasm = (func, sig) => {
-      var bytes = Uint8Array.of(0, 97, 115, 109, 1, 0, 0, 0, 1, ...uleb128EncodeWithLen([1, 96, ...generateTypePack(sig.slice(1)), ...generateTypePack(sig[0] === "v" ? "" : sig[0])]), 2, 7, 1, 1, 101, 1, 102, 0, 0, 7, 5, 1, 1, 102, 0, 0);
-      var module3 = new WebAssembly.Module(bytes);
-      var instance = new WebAssembly.Instance(module3, { e: { f: func } });
-      var wrappedFunc = instance.exports["f"];
-      return wrappedFunc;
-    };
-    var addFunction = (func, sig) => {
-      var rtn = getFunctionAddress(func);
-      if (rtn) {
-        return rtn;
+    }
+    function inferParameters({ length }) {
+      if (!Number.isInteger(length) || length < 0) {
+        throw new TypeError("Expected function.length to be a positive integer");
       }
-      var ret = getEmptyTableSlot();
-      try {
-        setWasmTableEntry(ret, func);
-      } catch (err2) {
-        if (!(err2 instanceof TypeError)) {
-          throw err2;
-        }
-        var wrapped = convertJsFunctionToWasm(func, sig);
-        setWasmTableEntry(ret, wrapped);
+      const params = [];
+      for (let i = 0; i < length; ++i) {
+        params.push(`$${i + 1}`);
       }
-      functionsInTableMap.set(func, ret);
-      return ret;
+      return params;
+    }
+    var { hasOwnProperty } = Object.prototype;
+    var { apply } = Function.prototype;
+    var GeneratorFunctionPrototype = Object.getPrototypeOf(function* () {
+    });
+    var identifier = (str) => `"${str.replace(/"/g, '""')}"`;
+    var defer = (x) => () => x;
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/inspect.js
+var require_inspect = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/inspect.js"(exports2, module2) {
+    "use strict";
+    var DatabaseInspection = function Database2() {
     };
-    var removeFunction = (index) => {
-      functionsInTableMap.delete(getWasmTableEntry(index));
-      setWasmTableEntry(index, null);
-      freeTableIndexes.push(index);
+    module2.exports = function inspect(depth, opts) {
+      return Object.assign(new DatabaseInspection(), this);
     };
-    {
-      if (Module["noExitRuntime"])
-        noExitRuntime = Module["noExitRuntime"];
-      if (Module["print"])
-        out = Module["print"];
-      if (Module["printErr"])
-        err = Module["printErr"];
-      if (Module["wasmBinary"])
-        wasmBinary = Module["wasmBinary"];
-      if (Module["arguments"])
-        arguments_ = Module["arguments"];
-      if (Module["thisProgram"])
-        thisProgram = Module["thisProgram"];
-      if (Module["preInit"]) {
-        if (typeof Module["preInit"] == "function")
-          Module["preInit"] = [Module["preInit"]];
-        while (Module["preInit"].length > 0) {
-          Module["preInit"].shift()();
-        }
+  }
+});
+
+// node_modules/better-sqlite3/lib/database.js
+var require_database = __commonJS({
+  "node_modules/better-sqlite3/lib/database.js"(exports2, module2) {
+    "use strict";
+    var fs3 = require("fs");
+    var path2 = require("path");
+    var util = require_util();
+    var SqliteError = require_sqlite_error();
+    var DEFAULT_ADDON;
+    function Database2(filenameGiven, options) {
+      if (new.target == null) {
+        return new Database2(filenameGiven, options);
+      }
+      let buffer;
+      if (Buffer.isBuffer(filenameGiven)) {
+        buffer = filenameGiven;
+        filenameGiven = ":memory:";
+      }
+      if (filenameGiven == null)
+        filenameGiven = "";
+      if (options == null)
+        options = {};
+      if (typeof filenameGiven !== "string")
+        throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object")
+        throw new TypeError("Expected second argument to be an options object");
+      if ("readOnly" in options)
+        throw new TypeError('Misspelled option "readOnly" should be "readonly"');
+      if ("memory" in options)
+        throw new TypeError('Option "memory" was removed in v7.0.0 (use ":memory:" filename instead)');
+      const filename = filenameGiven.trim();
+      const anonymous = filename === "" || filename === ":memory:";
+      const readonly = util.getBooleanOption(options, "readonly");
+      const fileMustExist = util.getBooleanOption(options, "fileMustExist");
+      const timeout = "timeout" in options ? options.timeout : 5e3;
+      const verbose = "verbose" in options ? options.verbose : null;
+      const nativeBinding = "nativeBinding" in options ? options.nativeBinding : null;
+      if (readonly && anonymous && !buffer)
+        throw new TypeError("In-memory/temporary databases cannot be readonly");
+      if (!Number.isInteger(timeout) || timeout < 0)
+        throw new TypeError('Expected the "timeout" option to be a positive integer');
+      if (timeout > 2147483647)
+        throw new RangeError('Option "timeout" cannot be greater than 2147483647');
+      if (verbose != null && typeof verbose !== "function")
+        throw new TypeError('Expected the "verbose" option to be a function');
+      if (nativeBinding != null && typeof nativeBinding !== "string" && typeof nativeBinding !== "object")
+        throw new TypeError('Expected the "nativeBinding" option to be a string or addon object');
+      let addon;
+      if (nativeBinding == null) {
+        addon = DEFAULT_ADDON || (DEFAULT_ADDON = require_bindings()("better_sqlite3.node"));
+      } else if (typeof nativeBinding === "string") {
+        const requireFunc = typeof __non_webpack_require__ === "function" ? __non_webpack_require__ : require;
+        addon = requireFunc(path2.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
+      } else {
+        addon = nativeBinding;
       }
-    }
-    Module["cwrap"] = cwrap;
-    Module["addFunction"] = addFunction;
-    Module["removeFunction"] = removeFunction;
-    var _sqlite3_finalize;
-    var _sqlite3_reset;
-    var _sqlite3_clear_bindings;
-    var _sqlite3_value_blob;
-    var _sqlite3_value_text;
-    var _sqlite3_value_bytes;
-    var _sqlite3_value_double;
-    var _sqlite3_value_int64;
-    var _sqlite3_value_type;
-    var _sqlite3_result_blob;
-    var _sqlite3_result_blob64;
-    var _sqlite3_result_double;
-    var _sqlite3_result_error;
-    var _sqlite3_result_int;
-    var _sqlite3_result_int64;
-    var _sqlite3_result_null;
-    var _sqlite3_result_text;
-    var _sqlite3_step;
-    var _sqlite3_column_count;
-    var _sqlite3_column_blob;
-    var _sqlite3_column_bytes;
-    var _sqlite3_column_double;
-    var _sqlite3_column_int64;
-    var _sqlite3_column_text;
-    var _sqlite3_column_type;
-    var _sqlite3_column_name;
-    var _sqlite3_column_table_name;
-    var _sqlite3_bind_blob;
-    var _sqlite3_bind_blob64;
-    var _sqlite3_bind_double;
-    var _sqlite3_bind_int;
-    var _sqlite3_bind_int64;
-    var _sqlite3_bind_null;
-    var _sqlite3_bind_text;
-    var _sqlite3_bind_parameter_index;
-    var _sqlite3_exec;
-    var _sqlite3_prepare_v2;
-    var _sqlite3_errmsg;
-    var _sqlite3_last_insert_rowid;
-    var _sqlite3_changes;
-    var _sqlite3_close_v2;
-    var _sqlite3_create_function_v2;
-    var _sqlite3_open_v2;
-    var _sqlite3_get_autocommit;
-    var _malloc;
-    var _free;
-    var __emscripten_timeout;
-    var __emscripten_stack_restore;
-    var __emscripten_stack_alloc;
-    var _emscripten_stack_get_current;
-    var memory;
-    var __indirect_function_table;
-    var wasmMemory;
-    var wasmTable;
-    function assignWasmExports(wasmExports2) {
-      _sqlite3_finalize = Module["_sqlite3_finalize"] = wasmExports2["A"];
-      _sqlite3_reset = Module["_sqlite3_reset"] = wasmExports2["B"];
-      _sqlite3_clear_bindings = Module["_sqlite3_clear_bindings"] = wasmExports2["C"];
-      _sqlite3_value_blob = Module["_sqlite3_value_blob"] = wasmExports2["D"];
-      _sqlite3_value_text = Module["_sqlite3_value_text"] = wasmExports2["E"];
-      _sqlite3_value_bytes = Module["_sqlite3_value_bytes"] = wasmExports2["F"];
-      _sqlite3_value_double = Module["_sqlite3_value_double"] = wasmExports2["G"];
-      _sqlite3_value_int64 = Module["_sqlite3_value_int64"] = wasmExports2["H"];
-      _sqlite3_value_type = Module["_sqlite3_value_type"] = wasmExports2["I"];
-      _sqlite3_result_blob = Module["_sqlite3_result_blob"] = wasmExports2["J"];
-      _sqlite3_result_blob64 = Module["_sqlite3_result_blob64"] = wasmExports2["K"];
-      _sqlite3_result_double = Module["_sqlite3_result_double"] = wasmExports2["L"];
-      _sqlite3_result_error = Module["_sqlite3_result_error"] = wasmExports2["M"];
-      _sqlite3_result_int = Module["_sqlite3_result_int"] = wasmExports2["N"];
-      _sqlite3_result_int64 = Module["_sqlite3_result_int64"] = wasmExports2["O"];
-      _sqlite3_result_null = Module["_sqlite3_result_null"] = wasmExports2["P"];
-      _sqlite3_result_text = Module["_sqlite3_result_text"] = wasmExports2["Q"];
-      _sqlite3_step = Module["_sqlite3_step"] = wasmExports2["R"];
-      _sqlite3_column_count = Module["_sqlite3_column_count"] = wasmExports2["S"];
-      _sqlite3_column_blob = Module["_sqlite3_column_blob"] = wasmExports2["T"];
-      _sqlite3_column_bytes = Module["_sqlite3_column_bytes"] = wasmExports2["U"];
-      _sqlite3_column_double = Module["_sqlite3_column_double"] = wasmExports2["V"];
-      _sqlite3_column_int64 = Module["_sqlite3_column_int64"] = wasmExports2["W"];
-      _sqlite3_column_text = Module["_sqlite3_column_text"] = wasmExports2["X"];
-      _sqlite3_column_type = Module["_sqlite3_column_type"] = wasmExports2["Y"];
-      _sqlite3_column_name = Module["_sqlite3_column_name"] = wasmExports2["Z"];
-      _sqlite3_column_table_name = Module["_sqlite3_column_table_name"] = wasmExports2["_"];
-      _sqlite3_bind_blob = Module["_sqlite3_bind_blob"] = wasmExports2["$"];
-      _sqlite3_bind_blob64 = Module["_sqlite3_bind_blob64"] = wasmExports2["aa"];
-      _sqlite3_bind_double = Module["_sqlite3_bind_double"] = wasmExports2["ba"];
-      _sqlite3_bind_int = Module["_sqlite3_bind_int"] = wasmExports2["ca"];
-      _sqlite3_bind_int64 = Module["_sqlite3_bind_int64"] = wasmExports2["da"];
-      _sqlite3_bind_null = Module["_sqlite3_bind_null"] = wasmExports2["ea"];
-      _sqlite3_bind_text = Module["_sqlite3_bind_text"] = wasmExports2["fa"];
-      _sqlite3_bind_parameter_index = Module["_sqlite3_bind_parameter_index"] = wasmExports2["ga"];
-      _sqlite3_exec = Module["_sqlite3_exec"] = wasmExports2["ha"];
-      _sqlite3_prepare_v2 = Module["_sqlite3_prepare_v2"] = wasmExports2["ia"];
-      _sqlite3_errmsg = Module["_sqlite3_errmsg"] = wasmExports2["ja"];
-      _sqlite3_last_insert_rowid = Module["_sqlite3_last_insert_rowid"] = wasmExports2["ka"];
-      _sqlite3_changes = Module["_sqlite3_changes"] = wasmExports2["la"];
-      _sqlite3_close_v2 = Module["_sqlite3_close_v2"] = wasmExports2["ma"];
-      _sqlite3_create_function_v2 = Module["_sqlite3_create_function_v2"] = wasmExports2["na"];
-      _sqlite3_open_v2 = Module["_sqlite3_open_v2"] = wasmExports2["oa"];
-      _sqlite3_get_autocommit = Module["_sqlite3_get_autocommit"] = wasmExports2["pa"];
-      _malloc = Module["_malloc"] = wasmExports2["qa"];
-      _free = Module["_free"] = wasmExports2["ra"];
-      __emscripten_timeout = wasmExports2["ta"];
-      __emscripten_stack_restore = wasmExports2["ua"];
-      __emscripten_stack_alloc = wasmExports2["va"];
-      _emscripten_stack_get_current = wasmExports2["wa"];
-      memory = wasmMemory = wasmExports2["y"];
-      __indirect_function_table = wasmTable = wasmExports2["sa"];
-    }
-    var wasmImports = { n: __abort_js, l: __emscripten_runtime_keepalive_clear, o: __localtime_js, i: __setitimer_js, p: __tzset_js, q: _emscripten_date_now, a: _emscripten_get_now, j: _emscripten_resize_heap, w: _nodejsAccess, s: _nodejsCheckReservedLock, f: _nodejsClose, x: _nodejsDelete, v: _nodejsFileSize, m: _nodejsFullPathname, u: _nodejsLock, h: _nodejsRandomness, e: _nodejsRead, b: _nodejsSync, c: _nodejsTruncate, t: _nodejsUnlock, d: _nodejsWrite, g: _nodejs_max_path_length, r: _nodejs_open, k: _proc_exit };
-    function run() {
-      preRun();
-      function doRun() {
-        Module["calledRun"] = true;
-        if (ABORT)
-          return;
-        initRuntime();
-        Module["onRuntimeInitialized"]?.();
-        postRun();
+      if (!addon.isInitialized) {
+        addon.setErrorConstructor(SqliteError);
+        addon.isInitialized = true;
       }
-      if (Module["setStatus"]) {
-        Module["setStatus"]("Running...");
-        setTimeout(() => {
-          setTimeout(() => Module["setStatus"](""), 1);
-          doRun();
-        }, 1);
-      } else {
-        doRun();
+      if (!anonymous && !filename.startsWith("file:") && !fs3.existsSync(path2.dirname(filename))) {
+        throw new TypeError("Cannot open database because the directory does not exist");
       }
+      Object.defineProperties(this, {
+        [util.cppdb]: { value: new addon.Database(filename, filenameGiven, anonymous, readonly, fileMustExist, timeout, verbose || null, buffer || null) },
+        ...wrappers.getters
+      });
     }
-    var wasmExports;
-    wasmExports = createWasm();
-    run();
+    var wrappers = require_wrappers();
+    Database2.prototype.prepare = wrappers.prepare;
+    Database2.prototype.transaction = require_transaction();
+    Database2.prototype.pragma = require_pragma();
+    Database2.prototype.backup = require_backup();
+    Database2.prototype.serialize = require_serialize();
+    Database2.prototype.function = require_function();
+    Database2.prototype.aggregate = require_aggregate();
+    Database2.prototype.table = require_table();
+    Database2.prototype.loadExtension = wrappers.loadExtension;
+    Database2.prototype.exec = wrappers.exec;
+    Database2.prototype.close = wrappers.close;
+    Database2.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
+    Database2.prototype.unsafeMode = wrappers.unsafeMode;
+    Database2.prototype[util.inspect] = require_inspect();
+    module2.exports = Database2;
   }
 });
 
-// src/paths.ts
-function recallRoot() {
-  if (rootOverride)
-    return rootOverride;
-  const envRoot = process.env["RECALL_HOME"];
-  if (envRoot && envRoot.length > 0)
-    return envRoot;
-  return (0, import_node_path2.join)((0, import_node_os.homedir)(), ".recall");
-}
-function dbPath() {
-  return (0, import_node_path2.join)(recallRoot(), "recall.db");
-}
-function binDir() {
-  return (0, import_node_path2.join)(recallRoot(), "bin");
-}
-function logsDir() {
-  return (0, import_node_path2.join)(recallRoot(), "logs");
-}
-function ensureDir() {
-  (0, import_node_fs2.mkdirSync)(recallRoot(), { recursive: true });
-}
-var import_node_fs2, import_node_os, import_node_path2, rootOverride;
-var init_paths = __esm({
-  "src/paths.ts"() {
+// node_modules/better-sqlite3/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/better-sqlite3/lib/index.js"(exports2, module2) {
     "use strict";
-    import_node_fs2 = require("node:fs");
-    import_node_os = require("node:os");
-    import_node_path2 = require("node:path");
-    rootOverride = null;
+    module2.exports = require_database();
+    module2.exports.SqliteError = require_sqlite_error();
   }
 });
 
@@ -1554,10 +966,35 @@ function stripToolContent(entries) {
 }
 
 // src/db.ts
-var import_node_fs = require("node:fs");
-var import_node_path = require("node:path");
+var import_node_fs2 = require("node:fs");
+var import_node_path2 = require("node:path");
+var import_node_module = require("node:module");
 init_log();
-var import_node_sqlite3_wasm = __toESM(require_node_sqlite3_wasm());
+init_paths();
+var import_better_sqlite3 = __toESM(require_lib());
+var BindingLoadError = class extends Error {
+  constructor(dbPath2, cause) {
+    super(
+      `recall: failed to load the better-sqlite3 native binding while opening ${dbPath2}: ${cause.message}
+The binding is ABI-locked to the Node it was built for \u2014 run \`recall doctor\` (usually fixed by re-running \`recall install\`).`
+    );
+    this.dbPath = dbPath2;
+    this.cause = cause;
+    this.name = "BindingLoadError";
+  }
+};
+function isBindingLoadError(e) {
+  if (!e || typeof e !== "object")
+    return false;
+  const err = e;
+  const code = typeof err.code === "string" ? err.code : "";
+  if (code === "ERR_DLOPEN_FAILED" || code === "MODULE_NOT_FOUND")
+    return true;
+  const msg = typeof err.message === "string" ? err.message : "";
+  return /NODE_MODULE_VERSION|different Node\.?js version|dlopen|invalid ELF|not a valid Win32 application|better_sqlite3\.node|Could not locate the bindings|was compiled against/i.test(
+    msg
+  );
+}
 var db = null;
 var currentDbPath = null;
 function getDb(dbPath2) {
@@ -1566,16 +1003,17 @@ function getDb(dbPath2) {
   if (db) {
     closeDb();
   }
-  (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(dbPath2), { recursive: true });
-  clearStaleLock(dbPath2);
-  writeOwnerFile(dbPath2);
-  db = new import_node_sqlite3_wasm.Database(dbPath2);
+  (0, import_node_fs2.mkdirSync)((0, import_node_path2.dirname)(dbPath2), { recursive: true });
+  cleanupWasmArtifacts(dbPath2);
+  const raw = openDatabase(dbPath2);
+  try {
+    configurePragmas(raw, dbPath2);
+  } catch (e) {
+    raw.close();
+    throw e;
+  }
+  db = createAdapter(raw);
   currentDbPath = dbPath2;
-  db.exec("PRAGMA busy_timeout = 5000");
-  db.exec("PRAGMA journal_mode = WAL");
-  db.exec("PRAGMA synchronous = NORMAL");
-  db.exec("PRAGMA wal_autocheckpoint = 1000");
-  db.exec("PRAGMA foreign_keys = ON");
   ensureSchema(db);
   log({ source: "db", level: "info", summary: `DB: initialized at ${dbPath2}` });
   return db;
@@ -1583,84 +1021,111 @@ function getDb(dbPath2) {
 function closeDb() {
   if (db) {
     db.close();
-    if (currentDbPath)
-      removeOwnerFile(currentDbPath);
     db = null;
     currentDbPath = null;
   }
 }
-function ownerFilePath(dbPath2) {
-  return `${dbPath2}.owner`;
-}
-function processStartToken(pid) {
-  if (process.platform !== "linux")
-    return "";
+function openDatabase(dbPath2) {
+  const nativeBinding = resolveNativeBinding();
   try {
-    const stat = (0, import_node_fs.readFileSync)(`/proc/${pid}/stat`, "utf-8");
-    const close = stat.lastIndexOf(")");
-    if (close === -1)
-      return "";
-    const rest = stat.slice(close + 2).trim().split(/\s+/);
-    const starttime = rest[19];
-    return starttime ?? "";
-  } catch {
-    return "";
+    return nativeBinding ? new import_better_sqlite3.default(dbPath2, { nativeBinding }) : new import_better_sqlite3.default(dbPath2);
+  } catch (e) {
+    if (isBindingLoadError(e))
+      throw new BindingLoadError(dbPath2, e);
+    throw e;
   }
 }
-function writeOwnerFile(dbPath2) {
-  try {
-    const token = processStartToken(process.pid);
-    (0, import_node_fs.writeFileSync)(ownerFilePath(dbPath2), `${process.pid}:${token}`, "utf-8");
-  } catch {
-  }
+function resolveNativeBinding() {
+  const sibling = (0, import_node_path2.join)(__dirname, "better_sqlite3.node");
+  if ((0, import_node_fs2.existsSync)(sibling))
+    return sibling;
+  const resolved = resolveInstalledBinding();
+  if (resolved)
+    return resolved;
+  const staged = (0, import_node_path2.join)(binDir(), "better_sqlite3.node");
+  if ((0, import_node_fs2.existsSync)(staged))
+    return staged;
+  return null;
 }
-function removeOwnerFile(dbPath2) {
+function resolveInstalledBinding() {
   try {
-    (0, import_node_fs.unlinkSync)(ownerFilePath(dbPath2));
+    const pkgJson = (0, import_node_module.createRequire)(__filename).resolve("better-sqlite3/package.json");
+    return findNativeBinding((0, import_node_path2.dirname)(pkgJson));
   } catch {
+    return null;
   }
 }
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
+function findNativeBinding(baseDir) {
+  for (const c of [
+    (0, import_node_path2.join)(baseDir, "build", "Release", "better_sqlite3.node"),
+    (0, import_node_path2.join)(baseDir, "build", "Debug", "better_sqlite3.node")
+  ]) {
+    try {
+      if ((0, import_node_fs2.statSync)(c).isFile())
+        return c;
+    } catch {
+    }
   }
-}
-function clearStaleLock(dbPath2) {
-  const lockDir = `${dbPath2}.lock`;
-  if (!(0, import_node_fs.existsSync)(lockDir))
-    return;
-  const ownerFile = ownerFilePath(dbPath2);
-  if ((0, import_node_fs.existsSync)(ownerFile)) {
+  const stack = [baseDir];
+  while (stack.length) {
+    const dir = stack.pop();
+    let entries;
     try {
-      const raw = (0, import_node_fs.readFileSync)(ownerFile, "utf-8").trim();
-      const sep = raw.indexOf(":");
-      const pidStr = sep === -1 ? raw : raw.slice(0, sep);
-      const storedToken = sep === -1 ? "" : raw.slice(sep + 1);
-      const pid = parseInt(pidStr, 10);
-      if (!isNaN(pid) && isProcessAlive(pid)) {
-        if (storedToken === "" || storedToken === processStartToken(pid)) {
-          return;
-        }
-      }
+      entries = (0, import_node_fs2.readdirSync)(dir, { withFileTypes: true });
     } catch {
+      continue;
+    }
+    for (const e of entries) {
+      const p = (0, import_node_path2.join)(dir, e.name);
+      if (e.isDirectory())
+        stack.push(p);
+      else if (e.name.endsWith(".node"))
+        return p;
     }
   }
+  return null;
+}
+function createAdapter(raw) {
+  return {
+    all: (sql, params) => raw.prepare(sql).all(...params ?? []),
+    get: (sql, params) => raw.prepare(sql).get(...params ?? []),
+    run: (sql, params) => raw.prepare(sql).run(...params ?? []),
+    exec: (sql) => {
+      raw.exec(sql);
+    },
+    prepare: (sql) => {
+      const st = raw.prepare(sql);
+      return {
+        run: (p) => st.run(...p ?? []),
+        all: (p) => st.all(...p ?? []),
+        get: (p) => st.get(...p ?? [])
+      };
+    },
+    close: () => raw.close()
+  };
+}
+function configurePragmas(raw, dbPath2) {
+  const isMemory = dbPath2 === ":memory:" || dbPath2.includes(":memory:") || dbPath2.startsWith("file::memory:");
+  raw.pragma("busy_timeout = 5000");
+  const mode = raw.pragma("journal_mode = WAL", { simple: true });
+  if (!isMemory && mode !== "wal") {
+    throw new Error(
+      `recall: expected WAL journal_mode, got '${String(mode)}' \u2014 refusing to run on a non-WAL DB (${dbPath2}). A native build on a delete-mode DB is drift; run \`recall doctor\`.`
+    );
+  }
+  raw.pragma("synchronous = NORMAL");
+  raw.pragma("wal_autocheckpoint = 1000");
+  raw.pragma("foreign_keys = ON");
+}
+function cleanupWasmArtifacts(dbPath2) {
   try {
-    (0, import_node_fs.rmSync)(lockDir, { recursive: true, force: true });
-    log({
-      source: "db",
-      level: "warn",
-      summary: `DB: removed stale lock directory (${lockDir}) \u2014 owning process is dead`
-    });
-  } catch (err) {
-    log({
-      source: "db",
-      level: "error",
-      summary: `DB: failed to remove stale lock directory: ${err}`
-    });
+    (0, import_node_fs2.rmSync)(`${dbPath2}.lock`, { recursive: true, force: true });
+  } catch {
+  }
+  try {
+    if ((0, import_node_fs2.existsSync)(`${dbPath2}.owner`))
+      (0, import_node_fs2.unlinkSync)(`${dbPath2}.owner`);
+  } catch {
   }
 }
 function ensureSchema(db3) {
@@ -1678,6 +1143,12 @@ function ensureSchema(db3) {
 
     CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id, created_at);
     CREATE INDEX IF NOT EXISTS idx_messages_project ON messages(project_id);
+    -- getUnembeddedMessages() orders the whole table by created_at DESC (LIMIT N).
+    -- Without a standalone created_at index SQLite full-scans messages and builds
+    -- a TEMP B-TREE to sort on every call \u2014 a ~4s/batch cost that dominates the
+    -- embed drain and every Stop-hook catch-up. This index serves the ORDER BY so
+    -- the planner walks it and early-terminates at LIMIT instead.
+    CREATE INDEX IF NOT EXISTS idx_messages_created_at ON messages(created_at);
   `);
   db3.exec(`
     CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
@@ -1718,9 +1189,19 @@ function ensureSchema(db3) {
       message_id    TEXT PRIMARY KEY REFERENCES messages(message_id) ON DELETE CASCADE,
       embedding_q8  BLOB NOT NULL,
       norm          REAL NOT NULL,
-      quant_scale   REAL NOT NULL
+      quant_scale   REAL NOT NULL,
+      embed_version INTEGER NOT NULL DEFAULT 1
     );
   `);
+  const hasEmbedVersion = () => db3.all(`PRAGMA table_info(message_vectors)`).some((c) => c.name === "embed_version");
+  if (!hasEmbedVersion()) {
+    try {
+      db3.exec(`ALTER TABLE message_vectors ADD COLUMN embed_version INTEGER NOT NULL DEFAULT 1`);
+    } catch (e) {
+      if (!hasEmbedVersion())
+        throw e;
+    }
+  }
   db3.exec(`
     CREATE TABLE IF NOT EXISTS ingest_watermark (
       transcript_path TEXT PRIMARY KEY,
@@ -1756,7 +1237,7 @@ function insertMessages(messages, opts) {
     return;
   ensureDir2();
   const d = db2();
-  d.exec("BEGIN");
+  d.exec("BEGIN IMMEDIATE");
   try {
     if (opts?.replaceSessionId) {
       d.run(
@@ -1771,20 +1252,16 @@ function insertMessages(messages, opts) {
        (message_id, session_id, message_seq, message_text, project_id, created_at, message_role)
        VALUES (?, ?, ?, ?, ?, ?, ?)`
     );
-    try {
-      for (const m of messages) {
-        stmt.run([
-          m.message_id,
-          m.session_id,
-          m.message_seq,
-          m.message_text,
-          m.project_id,
-          m.created_at,
-          m.message_role
-        ]);
-      }
-    } finally {
-      stmt.finalize();
+    for (const m of messages) {
+      stmt.run([
+        m.message_id,
+        m.session_id,
+        m.message_seq,
+        m.message_text,
+        m.project_id,
+        m.created_at,
+        m.message_role
+      ]);
     }
     d.exec("COMMIT");
   } catch (e) {
@@ -2765,7 +2242,7 @@ async function runStopHook() {
   if (payload.stop_hook_active)
     process.exit(0);
   try {
-    getDb(dbPath()).exec("PRAGMA busy_timeout = 500;");
+    getDb(dbPath()).exec("PRAGMA busy_timeout = 5000;");
     const vendor = vendorForTranscript(payload.transcript_path);
     const result = await ingestSessionMessages(
       payload.session_id,