crispy-recall 0.1.6 → 0.2.0

package/dist/recall.js

@@ -858,9 +858,9 @@ var require_pump = __commonJS({
   "node_modules/pump/index.js"(exports2, module2) {
     var once = require_once();
     var eos = require_end_of_stream();
-    var fs3;
+    var fs5;
     try {
-      fs3 = require("fs");
+      fs5 = require("fs");
     } catch (e2) {
     }
     var noop = function() {
@@ -872,9 +872,9 @@ var require_pump = __commonJS({
     var isFS = function(stream2) {
       if (!ancient)
         return false;
-      if (!fs3)
+      if (!fs5)
         return false;
-      return (stream2 instanceof (fs3.ReadStream || noop) || stream2 instanceof (fs3.WriteStream || noop)) && isFn(stream2.close);
+      return (stream2 instanceof (fs5.ReadStream || noop) || stream2 instanceof (fs5.WriteStream || noop)) && isFn(stream2.close);
     };
     var isRequest = function(stream2) {
       return stream2.setHeader && isFn(stream2.abort);
@@ -1098,7 +1098,7 @@ var require_pend = __commonJS({
 // node_modules/fd-slicer/index.js
 var require_fd_slicer = __commonJS({
   "node_modules/fd-slicer/index.js"(exports2) {
-    var fs3 = require("fs");
+    var fs5 = require("fs");
     var util = require("util");
     var stream2 = require("stream");
     var Readable = stream2.Readable;
@@ -1123,7 +1123,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.read = function(buffer, offset2, length, position, callback) {
       var self = this;
       self.pend.go(function(cb) {
-        fs3.read(self.fd, buffer, offset2, length, position, function(err, bytesRead, buffer2) {
+        fs5.read(self.fd, buffer, offset2, length, position, function(err, bytesRead, buffer2) {
           cb();
           callback(err, bytesRead, buffer2);
         });
@@ -1132,7 +1132,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.write = function(buffer, offset2, length, position, callback) {
       var self = this;
       self.pend.go(function(cb) {
-        fs3.write(self.fd, buffer, offset2, length, position, function(err, written, buffer2) {
+        fs5.write(self.fd, buffer, offset2, length, position, function(err, written, buffer2) {
           cb();
           callback(err, written, buffer2);
         });
@@ -1155,7 +1155,7 @@ var require_fd_slicer = __commonJS({
       if (self.refCount < 0)
         throw new Error("invalid unref");
       if (self.autoClose) {
-        fs3.close(self.fd, onCloseDone);
+        fs5.close(self.fd, onCloseDone);
       }
       function onCloseDone(err) {
         if (err) {
@@ -1194,7 +1194,7 @@ var require_fd_slicer = __commonJS({
         if (self.destroyed)
           return cb();
         var buffer = new Buffer(toRead);
-        fs3.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) {
+        fs5.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) {
           if (err) {
             self.destroy(err);
           } else if (bytesRead === 0) {
@@ -1244,7 +1244,7 @@ var require_fd_slicer = __commonJS({
       self.context.pend.go(function(cb) {
         if (self.destroyed)
           return cb();
-        fs3.write(self.context.fd, buffer, 0, buffer.length, self.pos, function(err2, bytes) {
+        fs5.write(self.context.fd, buffer, 0, buffer.length, self.pos, function(err2, bytes) {
           if (err2) {
             self.destroy();
             cb();
@@ -1673,7 +1673,7 @@ var require_buffer_crc32 = __commonJS({
 // node_modules/yauzl/index.js
 var require_yauzl = __commonJS({
   "node_modules/yauzl/index.js"(exports2) {
-    var fs3 = require("fs");
+    var fs5 = require("fs");
     var zlib = require("zlib");
     var fd_slicer = require_fd_slicer();
     var crc32 = require_buffer_crc32();
@@ -1691,7 +1691,7 @@ var require_yauzl = __commonJS({
     exports2.ZipFile = ZipFile;
     exports2.Entry = Entry;
     exports2.RandomAccessReader = RandomAccessReader;
-    function open(path3, options, callback) {
+    function open(path4, options, callback) {
       if (typeof options === "function") {
         callback = options;
         options = null;
@@ -1710,12 +1710,12 @@ var require_yauzl = __commonJS({
         options.strictFileNames = false;
       if (callback == null)
         callback = defaultCallback;
-      fs3.open(path3, "r", function(err, fd) {
+      fs5.open(path4, "r", function(err, fd) {
         if (err)
           return callback(err);
         fromFd(fd, options, function(err2, zipfile) {
           if (err2)
-            fs3.close(fd, defaultCallback);
+            fs5.close(fd, defaultCallback);
           callback(err2, zipfile);
         });
       });
@@ -1739,7 +1739,7 @@ var require_yauzl = __commonJS({
         options.strictFileNames = false;
       if (callback == null)
         callback = defaultCallback;
-      fs3.fstat(fd, function(err, stats) {
+      fs5.fstat(fd, function(err, stats) {
         if (err)
           return callback(err);
         var reader = fd_slicer.createFromFd(fd, { autoClose: true });
@@ -2375,9 +2375,9 @@ var require_yauzl = __commonJS({
 var require_extract_zip = __commonJS({
   "node_modules/extract-zip/index.js"(exports2, module2) {
     var debug = require_src()("extract-zip");
-    var { createWriteStream: createWriteStream3, promises: fs3 } = require("fs");
+    var { createWriteStream: createWriteStream3, promises: fs5 } = require("fs");
     var getStream = require_get_stream();
-    var path3 = require("path");
+    var path4 = require("path");
     var { promisify: promisify3 } = require("util");
     var stream2 = require("stream");
     var yauzl = require_yauzl();
@@ -2414,12 +2414,12 @@ var require_extract_zip = __commonJS({
               this.zipfile.readEntry();
               return;
             }
-            const destDir = path3.dirname(path3.join(this.opts.dir, entry.fileName));
+            const destDir = path4.dirname(path4.join(this.opts.dir, entry.fileName));
             try {
-              await fs3.mkdir(destDir, { recursive: true });
-              const canonicalDestDir = await fs3.realpath(destDir);
-              const relativeDestDir = path3.relative(this.opts.dir, canonicalDestDir);
-              if (relativeDestDir.split(path3.sep).includes("..")) {
+              await fs5.mkdir(destDir, { recursive: true });
+              const canonicalDestDir = await fs5.realpath(destDir);
+              const relativeDestDir = path4.relative(this.opts.dir, canonicalDestDir);
+              if (relativeDestDir.split(path4.sep).includes("..")) {
                 throw new Error(`Out of bound path "${canonicalDestDir}" found while processing file ${entry.fileName}`);
               }
               await this.extractEntry(entry);
@@ -2441,7 +2441,7 @@ var require_extract_zip = __commonJS({
         if (this.opts.onEntry) {
           this.opts.onEntry(entry, this.zipfile);
         }
-        const dest = path3.join(this.opts.dir, entry.fileName);
+        const dest = path4.join(this.opts.dir, entry.fileName);
         const mode = entry.externalFileAttributes >> 16 & 65535;
         const IFMT2 = 61440;
         const IFDIR2 = 16384;
@@ -2456,13 +2456,13 @@ var require_extract_zip = __commonJS({
           isDir = madeBy === 0 && entry.externalFileAttributes === 16;
         debug("extracting entry", { filename: entry.fileName, isDir, isSymlink: symlink });
         const procMode = this.getExtractedMode(mode, isDir) & 511;
-        const destDir = isDir ? dest : path3.dirname(dest);
+        const destDir = isDir ? dest : path4.dirname(dest);
         const mkdirOptions = { recursive: true };
         if (isDir) {
           mkdirOptions.mode = procMode;
         }
         debug("mkdir", { dir: destDir, ...mkdirOptions });
-        await fs3.mkdir(destDir, mkdirOptions);
+        await fs5.mkdir(destDir, mkdirOptions);
         if (isDir)
           return;
         debug("opening read stream", dest);
@@ -2470,7 +2470,7 @@ var require_extract_zip = __commonJS({
         if (symlink) {
           const link = await getStream(readStream);
           debug("creating symlink", link, dest);
-          await fs3.symlink(link, dest);
+          await fs5.symlink(link, dest);
         } else {
           await pipeline(readStream, createWriteStream3(dest, { mode: procMode }));
         }
@@ -2499,11 +2499,11 @@ var require_extract_zip = __commonJS({
     };
     module2.exports = async function(zipPath, opts) {
       debug("creating target directory", opts.dir);
-      if (!path3.isAbsolute(opts.dir)) {
+      if (!path4.isAbsolute(opts.dir)) {
         throw new Error("Target directory is expected to be absolute");
       }
-      await fs3.mkdir(opts.dir, { recursive: true });
-      opts.dir = await fs3.realpath(opts.dir);
+      await fs5.mkdir(opts.dir, { recursive: true });
+      opts.dir = await fs5.realpath(opts.dir);
       return new Extractor(zipPath, opts).extract();
     };
   }
@@ -2585,11 +2585,11 @@ var init_paths = __esm({
 });
 
 // src/installer/settings-merge.ts
-function writeFileAtomic(path3, contents) {
-  const tmp = `${path3}.tmp.${process.pid}`;
+function writeFileAtomic(path4, contents) {
+  const tmp = `${path4}.tmp.${process.pid}`;
   try {
     (0, import_node_fs2.writeFileSync)(tmp, contents);
-    (0, import_node_fs2.renameSync)(tmp, path3);
+    (0, import_node_fs2.renameSync)(tmp, path4);
   } catch (err) {
     try {
       if ((0, import_node_fs2.existsSync)(tmp))
@@ -2602,9 +2602,9 @@ function writeFileAtomic(path3, contents) {
 function backupStamp() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
 }
-function backupFile(path3) {
-  const dest = `${path3}.bak.${backupStamp()}`;
-  (0, import_node_fs2.copyFileSync)(path3, dest);
+function backupFile(path4) {
+  const dest = `${path4}.bak.${backupStamp()}`;
+  (0, import_node_fs2.copyFileSync)(path4, dest);
   return dest;
 }
 function detectLineEnding(raw2) {
@@ -2653,7 +2653,7 @@ function makeEntry(command) {
   return { matcher: "", hooks: [{ type: "command", command }] };
 }
 function mergeStopHook(filePath, hookScriptPath) {
-  const desiredCommand = `node ${hookScriptPath}`;
+  const desiredCommand = `"${process.execPath}" "${hookScriptPath}"`;
   const exists = (0, import_node_fs2.existsSync)(filePath);
   const raw2 = exists ? (0, import_node_fs2.readFileSync)(filePath, "utf-8") : null;
   const obj = raw2 && raw2.trim().length > 0 ? parseTolerant(raw2) : {};
@@ -3409,13 +3409,13 @@ async function retryServer() {
     serverRetryPromise = null;
   }
 }
-function httpPost(socketPath, path3, body, timeoutMs) {
+function httpPost(socketPath, path4, body, timeoutMs) {
   return new Promise((resolve, reject) => {
     const data = JSON.stringify(body);
     const req = (0, import_node_http.request)(
       {
         socketPath,
-        path: path3,
+        path: path4,
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -3749,1418 +3749,842 @@ var init_quantize = __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 v2 = 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: [v2, n2], result_null: [v2, n1], result_text: [v2, n4], result_blob: [v2, n4], result_blob64: [v2, n4], result_int: [v2, n2], result_int64: [v2, n2], result_error: [v2, 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";
+// 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, argv2) {
-      const args = [];
-      for (let i = 0; i < argc; i++) {
-        const ptr = getValue(argv2 + 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;
+    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;
     }
-    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}"`);
+    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 sep2 = 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 path4 = rest.substring(firstSlash + 1);
+      if ("localhost" == host)
+        host = "";
+      if (host) {
+        host = sep2 + sep2 + host;
+      }
+      path4 = path4.replace(/^(.+)\|/, "$1:");
+      if (sep2 == "\\") {
+        path4 = path4.replace(/\//g, "\\");
+      }
+      if (/^.+\:/.test(path4)) {
+      } else {
+        path4 = sep2 + path4;
       }
+      return host + path4;
     }
-    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, argv2) {
-          const args = parseFunctionArguments(argc, argv2);
-          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: expand2 = false } = {}) {
-        return this._query(sql, values, false, expand2);
-      }
-      get(sql, values, { expand: expand2 = false } = {}) {
-        return this._query(sql, values, true, expand2);
-      }
-      _query(sql, values, single, expand2) {
-        const stmt = this.prepare(sql);
-        try {
-          if (single) {
-            return stmt.get(values, { expand: expand2 });
-          } else {
-            return stmt.all(values, { expand: expand2 });
-          }
-        } 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 fs5 = require("fs");
+    var path4 = require("path");
+    var fileURLToPath3 = require_file_uri_to_path();
+    var join17 = path4.join;
+    var dirname5 = path4.dirname;
+    var exists = fs5.accessSync && function(path5) {
+      try {
+        fs5.accessSync(path5);
+      } catch (e2) {
+        return false;
       }
+      return true;
+    } || fs5.existsSync || path4.existsSync;
+    var defaults2 = {
+      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(db4, sql) {
-        const tempPtr = stringToHeap(sql);
-        try {
-          db4._handleError(sqlite3.prepare_v2(db4._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 = db4;
-      }
-      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: expand2 = false } = {}) {
-        return this._queryRows(values, expand2);
-      }
-      all(values, { expand: expand2 = false } = {}) {
-        return Array.from(this.iterate(values, { expand: expand2 }));
-      }
-      get(values, { expand: expand2 = false } = {}) {
-        const result = this._queryRows(values, expand2).next();
-        return result.done ? null : result.value;
+    function bindings(opts) {
+      if (typeof opts == "string") {
+        opts = { bindings: opts };
+      } else if (!opts) {
+        opts = {};
       }
-      finalize() {
-        if (this.isFinalized)
-          throw new SQLite3Error("Statement already finalized");
+      Object.keys(defaults2).map(function(i2) {
+        if (!(i2 in opts))
+          opts[i2] = defaults2[i2];
+      });
+      if (!opts.module_root) {
+        opts.module_root = exports2.getRoot(exports2.getFileName());
+      }
+      if (path4.extname(opts.bindings) != ".node") {
+        opts.bindings += ".node";
+      }
+      var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
+      var tries = [], i = 0, l2 = opts.try.length, n, b3, err;
+      for (; i < l2; i++) {
+        n = join17.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, expand2) {
-        this._assertReady();
-        this._bind(values);
-        const columns = this._getColumnNames();
-        while (this._step())
-          yield this._getRow(columns, expand2);
-      }
-      _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);
+          b3 = opts.path ? requireFunc.resolve(n) : requireFunc(n);
+          if (!opts.path) {
+            b3.path = n;
+          }
+          return b3;
+        } catch (e2) {
+          if (e2.code !== "MODULE_NOT_FOUND" && e2.code !== "QUALIFIED_PATH_RESOLUTION_FAILED" && !/not find/i.test(e2.message)) {
+            throw e2;
+          }
         }
       }
-      _getRow(columns, expand2) {
-        const row = {};
-        for (let i = 0; i < columns.length; i++) {
-          let v2;
-          const colType = sqlite3.column_type(this._ptr, i);
-          switch (colType) {
-            case SQLITE_INTEGER:
-              v2 = toNumberOrNot(sqlite3.column_int64(this._ptr, i));
-              break;
-            case SQLITE_FLOAT:
-              v2 = sqlite3.column_double(this._ptr, i);
-              break;
-            case SQLITE_TEXT:
-              v2 = sqlite3.column_text(this._ptr, i);
-              break;
-            case SQLITE_BLOB:
-              const p = sqlite3.column_blob(this._ptr, i);
-              if (p != NULL) {
-                v2 = HEAPU8.slice(p, p + sqlite3.column_bytes(this._ptr, i));
-              } else {
-                v2 = new Uint8Array();
+      err = new Error(
+        "Could not locate the bindings file. Tried:\n" + tries.map(function(a3) {
+          return opts.arrow + a3;
+        }).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(e2, st) {
+        for (var i = 0, l2 = st.length; i < l2; i++) {
+          fileName = st[i].getFileName();
+          if (fileName !== __filename) {
+            if (calling_file) {
+              if (fileName !== calling_file) {
+                return;
               }
-              break;
-            case SQLITE_NULL:
-              v2 = null;
-              break;
-          }
-          const column = columns[i];
-          if (expand2) {
-            let table = sqlite3.column_table_name(this._ptr, i);
-            table = table === "" ? "$" : table;
-            if (Object.hasOwn(row, table)) {
-              row[table][column] = v2;
             } else {
-              row[table] = { [column]: v2 };
+              return;
             }
-          } else {
-            row[column] = v2;
           }
         }
-        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);
-              }
-              _free(tempPtr2);
-            } else {
-              throw new SQLite3Error(`Unsupported type for binding: "${typeof value}"`);
-            }
-            break;
-          default:
-            throw new SQLite3Error(`Unsupported type for binding: "${typeof value}"`);
+      };
+      Error.captureStackTrace(dummy);
+      dummy.stack;
+      Error.prepareStackTrace = origPST;
+      Error.stackTraceLimit = origSTL;
+      var fileSchema = "file://";
+      if (fileName.indexOf(fileSchema) === 0) {
+        fileName = fileURLToPath3(fileName);
+      }
+      return fileName;
+    };
+    exports2.getRoot = function getRoot(file) {
+      var dir = dirname5(file), prev;
+      while (true) {
+        if (dir === ".") {
+          dir = process.cwd();
         }
-        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");
+        if (exists(join17(dir, "package.json")) || exists(join17(dir, "node_modules"))) {
+          return dir;
+        }
+        if (prev === dir) {
+          throw new Error(
+            'Could not find module root given file: "' + file + '". Do you have a `package.json` file? '
+          );
+        }
+        prev = dir;
+        dir = join17(dir, "..");
       }
     };
-    Module.Database = Database;
-    Module.SQLite3Error = SQLite3Error;
-    var path3 = 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_ = (status2, toThrow) => {
-      throw toThrow;
+  }
+});
+
+// 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 _scriptName;
-    if (typeof __filename != "undefined") {
-      _scriptName = __filename;
-    } else {
-    }
-    var scriptDirectory = "";
-    function locateFile(path4) {
-      if (Module["locateFile"]) {
-        return Module["locateFile"](path4, scriptDirectory);
-      }
-      return scriptDirectory + path4;
-    }
-    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_ = (status2, toThrow) => {
-        process.exitCode = status2;
-        throw toThrow;
-      };
-    } else {
-    }
-    var fs3;
-    var out = console.log.bind(console);
-    var err = console.error.bind(console);
-    var wasmBinary;
-    var ABORT2 = false;
-    var EXITSTATUS;
-    var isFileURI = (filename) => filename.startsWith("file://");
-    var runtimeInitialized = false;
-    function updateMemoryViews() {
-      var b3 = wasmMemory.buffer;
-      HEAP8 = new Int8Array(b3);
-      HEAP16 = new Int16Array(b3);
-      HEAPU8 = new Uint8Array(b3);
-      HEAPU16 = new Uint16Array(b3);
-      HEAP32 = new Int32Array(b3);
-      HEAPU32 = new Uint32Array(b3);
-      HEAPF32 = new Float32Array(b3);
-      HEAPF64 = new Float64Array(b3);
-      HEAP64 = new BigInt64Array(b3);
-      HEAPU64 = new BigUint64Array(b3);
-    }
-    function preRun() {
-      if (Module["preRun"]) {
-        if (typeof Module["preRun"] == "function")
-          Module["preRun"] = [Module["preRun"]];
-        while (Module["preRun"].length) {
-          addOnPreRun(Module["preRun"].shift());
-        }
-      }
-      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());
-        }
-      }
-      callRuntimeCallbacks(onPostRuns);
-    }
-    function abort(what) {
-      Module["onAbort"]?.(what);
-      what = `Aborted(${what})`;
-      err(what);
-      ABORT2 = true;
-      what += ". Build with -sASSERTIONS for more info.";
-      var e2 = new WebAssembly.RuntimeError(what);
-      throw e2;
-    }
-    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(status2) {
-        this.message = `Program terminated with exit(${status2})`;
-        this.status = status2;
-      }
+    exports2.exec = function exec(sql) {
+      this[cppdb].exec(sql);
+      return this;
     };
-    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);
-      }
+    exports2.close = function close() {
+      this[cppdb].close();
+      return this;
     };
-    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;
+    exports2.loadExtension = function loadExtension(...args) {
+      this[cppdb].loadExtension(...args);
+      return this;
     };
-    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.defaultSafeIntegers = function defaultSafeIntegers(...args) {
+      this[cppdb].defaultSafeIntegers(...args);
+      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 = (e2) => {
-      if (e2 instanceof ExitStatus || e2 == "unwind") {
-        return EXITSTATUS;
-      }
-      quit_(1, e2);
+    exports2.unsafeMode = function unsafeMode(...args) {
+      this[cppdb].unsafeMode(...args);
+      return this;
     };
-    var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
-    var _proc_exit = (code) => {
-      EXITSTATUS = code;
-      if (!keepRuntimeAlive()) {
-        Module["onExit"]?.(code);
-        ABORT2 = true;
-      }
-      quit_(code, new ExitStatus(code));
+    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 exitJS = (status2, implicit) => {
-      EXITSTATUS = status2;
-      _proc_exit(status2);
+  }
+});
+
+// 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 db4 = this[cppdb];
+      const controller = getController(db4, this);
+      const { apply } = Function.prototype;
+      const properties = {
+        default: { value: wrapTransaction(apply, fn, db4, controller.default) },
+        deferred: { value: wrapTransaction(apply, fn, db4, controller.deferred) },
+        immediate: { value: wrapTransaction(apply, fn, db4, controller.immediate) },
+        exclusive: { value: wrapTransaction(apply, fn, db4, 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 _exit = exitJS;
-    var maybeExit = () => {
-      if (!keepRuntimeAlive()) {
-        try {
-          _exit(EXITSTATUS);
-        } catch (e2) {
-          handleException(e2);
-        }
+    var getController = (db4, self) => {
+      let controller = controllers.get(db4);
+      if (!controller) {
+        const shared = {
+          commit: db4.prepare("COMMIT", self, false),
+          rollback: db4.prepare("ROLLBACK", self, false),
+          savepoint: db4.prepare("SAVEPOINT `	_bs3.	`", self, false),
+          release: db4.prepare("RELEASE `	_bs3.	`", self, false),
+          rollbackTo: db4.prepare("ROLLBACK TO `	_bs3.	`", self, false)
+        };
+        controllers.set(db4, controller = {
+          default: Object.assign({ begin: db4.prepare("BEGIN", self, false) }, shared),
+          deferred: Object.assign({ begin: db4.prepare("BEGIN DEFERRED", self, false) }, shared),
+          immediate: Object.assign({ begin: db4.prepare("BEGIN IMMEDIATE", self, false) }, shared),
+          exclusive: Object.assign({ begin: db4.prepare("BEGIN EXCLUSIVE", self, false) }, shared)
+        });
       }
+      return controller;
     };
-    var callUserCallback = (func) => {
-      if (ABORT2) {
-        return;
+    var wrapTransaction = (apply, fn, db4, { begin, commit, rollback, savepoint, release, rollbackTo }) => function sqliteTransaction() {
+      let before, after, undo;
+      if (db4.inTransaction) {
+        before = savepoint;
+        after = release;
+        undo = rollbackTo;
+      } else {
+        before = begin;
+        after = commit;
+        undo = rollback;
       }
+      before.run();
       try {
-        return func();
-      } catch (e2) {
-        handleException(e2);
-      } finally {
-        maybeExit();
+        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 (db4.inTransaction) {
+          undo.run();
+          if (undo !== rollback)
+            after.run();
+        }
+        throw ex;
       }
     };
-    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/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 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++;
-        }
-      }
-      heap[outIdx] = 0;
-      return outIdx - startIdx;
+  }
+});
+
+// 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 fs5 = require("fs");
+    var path4 = require("path");
+    var { promisify: promisify3 } = require("util");
+    var { cppdb } = require_util();
+    var fsAccess = promisify3(fs5.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(path4.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 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);
-      } else {
-        stringToUTF8(winterName, dst_name, 17);
-        stringToUTF8(summerName, std_name, 17);
-      }
+    var runBackup = (backup, handler) => {
+      let rate = 0;
+      let useDefault = true;
+      return new Promise((resolve, reject) => {
+        setImmediate(function step() {
+          try {
+            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);
+          }
+        });
+      });
     };
-    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;
-      try {
-        wasmMemory.grow(pages);
-        updateMemoryViews();
-        return 1;
-      } catch (e2) {
-      }
+  }
+});
+
+// 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 serialize2(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);
     };
-    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;
-        }
+  }
+});
+
+// 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 = {};
       }
-      return false;
+      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;
     };
-    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/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 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;
+    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 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");
+    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 = defer2(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 _nodejsCheckReservedLock(fi, outResult) {
-      try {
-        fs3.accessSync(`${_path(fi)}.lock`, fs3.constants.F_OK);
-        setValue(outResult, 1, "i32");
-      } catch {
-        setValue(outResult, 0, "i32");
+    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 _nodejsClose(fi) {
-      _nodejsUnlock(fi, SQLITE_LOCK_NONE);
-      try {
-        fs3.closeSync(_fd(fi));
-      } catch {
-        return SQLITE_IOERR_CLOSE;
+      if (!hasOwnProperty.call(def, "columns")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "columns" property`);
       }
-      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;
+      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 (dirSync) {
-        let fd = -1;
-        try {
-          fd = fs3.openSync(path3.dirname(pathStr), "r");
-          fs3.fsyncSync(fd);
-        } catch {
-          return SQLITE_IOERR_FSYNC;
-        } finally {
-          try {
-            fs3.closeSync(fd);
-          } catch {
-            return SQLITE_IOERR_FSYNC;
-          }
-        }
+      let columns = def.columns;
+      if (!Array.isArray(columns) || !(columns = [...columns]).every((x3) => typeof x3 === "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_OK;
-    }
-    function _nodejsFileSize(fi, outSize) {
-      try {
-        setValue(outSize, fs3.fstatSync(_fd(fi)).size, "i64");
-      } catch {
-        return SQLITE_IOERR_FSTAT;
+      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 _nodejsFullPathname(vfs, relPath, sizeFullPath, outFullPath) {
-      const full = path3.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);
-      }
-      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, offset2) {
-      const buf = HEAPU8.subarray(outBuffer, outBuffer + bytes);
-      let bytesRead;
-      try {
-        bytesRead = fs3.readSync(_fd(fi), buf, 0, bytes, offset2);
-      } catch {
-        return SQLITE_IOERR_READ;
+      if (!columns.length) {
+        throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with zero columns`);
       }
-      if (bytesRead == bytes) {
-        return SQLITE_OK;
-      } else if (bytesRead >= 0) {
-        if (bytesRead < bytes) {
-          try {
-            buf.fill(0, bytesRead);
-          } catch {
-            return SQLITE_IOERR_READ;
-          }
+      let parameters;
+      if (hasOwnProperty.call(def, "parameters")) {
+        parameters = def.parameters;
+        if (!Array.isArray(parameters) || !(parameters = [...parameters]).every((x3) => typeof x3 === "string")) {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "parameters" property (should be an array of strings)`);
         }
-        return SQLITE_IOERR_SHORT_READ;
+      } else {
+        parameters = inferParameters(rows);
       }
-      return SQLITE_IOERR_READ;
-    }
-    function _nodejsSync(fi, flags) {
-      try {
-        fs3.fsyncSync(_fd(fi));
-      } catch {
-        return SQLITE_IOERR_FSYNC;
+      if (parameters.length !== new Set(parameters).size) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate parameter names`);
       }
-      return SQLITE_OK;
-    }
-    function _nodejsTruncate(fi, size) {
-      try {
-        fs3.ftruncateSync(_fd(fi), _safeInt(size));
-      } catch {
-        return SQLITE_IOERR_TRUNCATE;
+      if (parameters.length > 32) {
+        throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with more than the maximum number of 32 parameters`);
       }
-      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;
+      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`);
         }
-        _setLocked(fi, false);
       }
-      return SQLITE_OK;
-    }
-    function _nodejsWrite(fi, buffer, bytes, offset2) {
-      try {
-        const bytesWritten = fs3.writeSync(_fd(fi), HEAPU8.subarray(buffer, buffer + bytes), 0, bytes, _safeInt(offset2));
-        return bytesWritten != bytes ? SQLITE_IOERR_WRITE : SQLITE_OK;
-      } catch {
-        return SQLITE_IOERR_WRITE;
-      }
-    }
-    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;
+      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)`);
+        }
+        safeIntegers = +bool;
       }
-    }
-    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;
+      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)`);
         }
       }
-      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);
-        }
-        return ret2;
-      }, array: (arr) => {
-        var ret2 = stackAlloc(arr.length);
-        writeArrayToMemory(arr, ret2);
-        return ret2;
-      } };
-      function convertReturnValue(ret2) {
-        if (returnType === "string") {
-          return UTF8ToString(ret2);
-        }
-        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((x3, i) => [x3, parameters.length + i])), moduleName),
+        parameters,
+        safeIntegers,
+        directOnly
+      ];
+    }
+    function wrapGenerator(generator, columnMap, moduleName) {
+      return function* virtualTable(...args) {
+        const output = args.map((x3) => Buffer.isBuffer(x3) ? Buffer.from(x3) : x3);
+        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 offset2 = output.length - columnCount;
+      for (let i = 0; i < columnCount; ++i) {
+        output[i + offset2] = row[i];
       }
-      return func;
-    };
-    var updateTableMap = (offset2, count) => {
-      if (functionsInTableMap) {
-        for (var i = offset2; i < offset2 + 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 = (types2) => uleb128EncodeWithLen(Array.from(types2, (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 defer2 = (x3) => () => x3;
+  }
+});
+
+// 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 Database4() {
     };
-    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()();
-        }
-      }
-    }
-    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 (ABORT2)
-          return;
-        initRuntime();
-        Module["onRuntimeInitialized"]?.();
-        postRun();
-      }
-      if (Module["setStatus"]) {
-        Module["setStatus"]("Running...");
-        setTimeout(() => {
-          setTimeout(() => Module["setStatus"](""), 1);
-          doRun();
-        }, 1);
+  }
+});
+
+// node_modules/better-sqlite3/lib/database.js
+var require_database = __commonJS({
+  "node_modules/better-sqlite3/lib/database.js"(exports2, module2) {
+    "use strict";
+    var fs5 = require("fs");
+    var path4 = require("path");
+    var util = require_util();
+    var SqliteError = require_sqlite_error();
+    var DEFAULT_ADDON;
+    function Database4(filenameGiven, options) {
+      if (new.target == null) {
+        return new Database4(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(path4.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
       } else {
-        doRun();
+        addon = nativeBinding;
+      }
+      if (!addon.isInitialized) {
+        addon.setErrorConstructor(SqliteError);
+        addon.isInitialized = true;
       }
+      if (!anonymous && !filename.startsWith("file:") && !fs5.existsSync(path4.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();
+    Database4.prototype.prepare = wrappers.prepare;
+    Database4.prototype.transaction = require_transaction();
+    Database4.prototype.pragma = require_pragma();
+    Database4.prototype.backup = require_backup();
+    Database4.prototype.serialize = require_serialize();
+    Database4.prototype.function = require_function();
+    Database4.prototype.aggregate = require_aggregate();
+    Database4.prototype.table = require_table();
+    Database4.prototype.loadExtension = wrappers.loadExtension;
+    Database4.prototype.exec = wrappers.exec;
+    Database4.prototype.close = wrappers.close;
+    Database4.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
+    Database4.prototype.unsafeMode = wrappers.unsafeMode;
+    Database4.prototype[util.inspect] = require_inspect();
+    module2.exports = Database4;
+  }
+});
+
+// node_modules/better-sqlite3/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/better-sqlite3/lib/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = require_database();
+    module2.exports.SqliteError = require_sqlite_error();
   }
 });
 
 // src/db.ts
+function isBindingLoadError(e2) {
+  if (!e2 || typeof e2 !== "object")
+    return false;
+  const err = e2;
+  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
+  );
+}
 function getDb(dbPath2) {
   if (db && currentDbPath === dbPath2)
     return db;
@@ -5168,15 +4592,16 @@ function getDb(dbPath2) {
     closeDb();
   }
   (0, import_node_fs5.mkdirSync)((0, import_node_path4.dirname)(dbPath2), { recursive: true });
-  clearStaleLock(dbPath2);
-  writeOwnerFile(dbPath2);
-  db = new import_node_sqlite3_wasm.Database(dbPath2);
+  cleanupWasmArtifacts(dbPath2);
+  const raw2 = openDatabase(dbPath2);
+  try {
+    configurePragmas(raw2, dbPath2);
+  } catch (e2) {
+    raw2.close();
+    throw e2;
+  }
+  db = createAdapter(raw2);
   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;
@@ -5184,84 +4609,114 @@ function getDb(dbPath2) {
 function closeDb() {
   if (db) {
     db.close();
-    if (currentDbPath)
-      removeOwnerFile(currentDbPath);
     db = null;
     currentDbPath = null;
   }
 }
-function ownerFilePath(dbPath2) {
-  return `${dbPath2}.owner`;
+function _resetDb() {
+  closeDb();
 }
-function processStartToken(pid) {
-  if (process.platform !== "linux")
-    return "";
+function openDatabase(dbPath2) {
+  const nativeBinding = resolveNativeBinding();
   try {
-    const stat = (0, import_node_fs5.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 (e2) {
+    if (isBindingLoadError(e2))
+      throw new BindingLoadError(dbPath2, e2);
+    throw e2;
   }
 }
-function writeOwnerFile(dbPath2) {
-  try {
-    const token = processStartToken(process.pid);
-    (0, import_node_fs5.writeFileSync)(ownerFilePath(dbPath2), `${process.pid}:${token}`, "utf-8");
-  } catch {
-  }
+function resolveNativeBinding() {
+  const sibling = (0, import_node_path4.join)(__dirname, "better_sqlite3.node");
+  if ((0, import_node_fs5.existsSync)(sibling))
+    return sibling;
+  const resolved = resolveInstalledBinding();
+  if (resolved)
+    return resolved;
+  const staged = (0, import_node_path4.join)(binDir(), "better_sqlite3.node");
+  if ((0, import_node_fs5.existsSync)(staged))
+    return staged;
+  return null;
 }
-function removeOwnerFile(dbPath2) {
+function resolveInstalledBinding() {
   try {
-    (0, import_node_fs5.unlinkSync)(ownerFilePath(dbPath2));
+    const pkgJson = (0, import_node_module.createRequire)(__filename).resolve("better-sqlite3/package.json");
+    return findNativeBinding((0, import_node_path4.dirname)(pkgJson));
   } catch {
+    return null;
   }
 }
-function isProcessAlive2(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
+function findNativeBinding(baseDir) {
+  for (const c of [
+    (0, import_node_path4.join)(baseDir, "build", "Release", "better_sqlite3.node"),
+    (0, import_node_path4.join)(baseDir, "build", "Debug", "better_sqlite3.node")
+  ]) {
+    try {
+      if ((0, import_node_fs5.statSync)(c).isFile())
+        return c;
+    } catch {
+    }
   }
-}
-function clearStaleLock(dbPath2) {
-  const lockDir = `${dbPath2}.lock`;
-  if (!(0, import_node_fs5.existsSync)(lockDir))
-    return;
-  const ownerFile = ownerFilePath(dbPath2);
-  if ((0, import_node_fs5.existsSync)(ownerFile)) {
+  const stack = [baseDir];
+  while (stack.length) {
+    const dir = stack.pop();
+    let entries;
     try {
-      const raw2 = (0, import_node_fs5.readFileSync)(ownerFile, "utf-8").trim();
-      const sep2 = raw2.indexOf(":");
-      const pidStr = sep2 === -1 ? raw2 : raw2.slice(0, sep2);
-      const storedToken = sep2 === -1 ? "" : raw2.slice(sep2 + 1);
-      const pid = parseInt(pidStr, 10);
-      if (!isNaN(pid) && isProcessAlive2(pid)) {
-        if (storedToken === "" || storedToken === processStartToken(pid)) {
-          return;
-        }
-      }
+      entries = (0, import_node_fs5.readdirSync)(dir, { withFileTypes: true });
     } catch {
+      continue;
+    }
+    for (const e2 of entries) {
+      const p = (0, import_node_path4.join)(dir, e2.name);
+      if (e2.isDirectory())
+        stack.push(p);
+      else if (e2.name.endsWith(".node"))
+        return p;
     }
   }
+  return null;
+}
+function createAdapter(raw2) {
+  return {
+    all: (sql, params) => raw2.prepare(sql).all(...params ?? []),
+    get: (sql, params) => raw2.prepare(sql).get(...params ?? []),
+    run: (sql, params) => raw2.prepare(sql).run(...params ?? []),
+    exec: (sql) => {
+      raw2.exec(sql);
+    },
+    prepare: (sql) => {
+      const st = raw2.prepare(sql);
+      return {
+        run: (p) => st.run(...p ?? []),
+        all: (p) => st.all(...p ?? []),
+        get: (p) => st.get(...p ?? [])
+      };
+    },
+    close: () => raw2.close()
+  };
+}
+function configurePragmas(raw2, dbPath2) {
+  const isMemory = dbPath2 === ":memory:" || dbPath2.includes(":memory:") || dbPath2.startsWith("file::memory:");
+  raw2.pragma("busy_timeout = 5000");
+  const mode = raw2.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\`.`
+    );
+  }
+  raw2.pragma("synchronous = NORMAL");
+  raw2.pragma("wal_autocheckpoint = 1000");
+  raw2.pragma("foreign_keys = ON");
+}
+function cleanupWasmArtifacts(dbPath2) {
   try {
-    (0, import_node_fs5.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_fs5.rmSync)(`${dbPath2}.lock`, { recursive: true, force: true });
+  } catch {
+  }
+  try {
+    if ((0, import_node_fs5.existsSync)(`${dbPath2}.owner`))
+      (0, import_node_fs5.unlinkSync)(`${dbPath2}.owner`);
+  } catch {
   }
 }
 function ensureSchema(db4) {
@@ -5279,6 +4734,12 @@ function ensureSchema(db4) {
 
     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);
   `);
   db4.exec(`
     CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
@@ -5319,9 +4780,19 @@ function ensureSchema(db4) {
       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 = () => db4.all(`PRAGMA table_info(message_vectors)`).some((c) => c.name === "embed_version");
+  if (!hasEmbedVersion()) {
+    try {
+      db4.exec(`ALTER TABLE message_vectors ADD COLUMN embed_version INTEGER NOT NULL DEFAULT 1`);
+    } catch (e2) {
+      if (!hasEmbedVersion())
+        throw e2;
+    }
+  }
   db4.exec(`
     CREATE TABLE IF NOT EXISTS ingest_watermark (
       transcript_path TEXT PRIMARY KEY,
@@ -5332,14 +4803,27 @@ function ensureSchema(db4) {
     CREATE INDEX IF NOT EXISTS idx_watermark_vendor ON ingest_watermark(vendor);
   `);
 }
-var import_node_fs5, import_node_path4, import_node_sqlite3_wasm, db, currentDbPath;
+var import_node_fs5, import_node_path4, import_node_module, import_better_sqlite3, BindingLoadError, db, currentDbPath;
 var init_db = __esm({
   "src/db.ts"() {
     "use strict";
     import_node_fs5 = require("node:fs");
     import_node_path4 = require("node:path");
+    import_node_module = require("node:module");
     init_log();
-    import_node_sqlite3_wasm = __toESM(require_node_sqlite3_wasm());
+    init_paths();
+    import_better_sqlite3 = __toESM(require_lib());
+    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";
+      }
+    };
     db = null;
     currentDbPath = null;
   }
@@ -5393,7 +4877,7 @@ function normalizeTokenSeparators(input) {
     return part.replace(/(\w)[-_](\w)/g, "$1 $2");
   }).join("");
 }
-function sanitizeFts5Query(raw2) {
+function sanitizeFts5Query(raw2, opts) {
   const trimmed = raw2.trim();
   if (!trimmed)
     return null;
@@ -5416,21 +4900,23 @@ function sanitizeFts5Query(raw2) {
   if (words.length <= 2)
     return words.map((w3) => `"${w3}"`).join(" ");
   const originalCount = words.length;
-  const dropped = [];
-  words = words.filter((w3) => {
-    const df = getTermDocFrequency(w3);
-    if (df >= IDF_PERCENTILE_THRESHOLD) {
-      dropped.push(`${w3}(${(df * 100).toFixed(0)}%)`);
-      return false;
-    }
-    return true;
-  });
-  if (dropped.length > 0) {
-    log({
-      source: "query-sanitizer",
-      level: "debug",
-      summary: `IDF filter: ${originalCount} \u2192 ${words.length} terms, dropped: ${dropped.join(", ")}`
+  if (!opts?.skipIdf) {
+    const dropped = [];
+    words = words.filter((w3) => {
+      const df = getTermDocFrequency(w3);
+      if (df >= IDF_PERCENTILE_THRESHOLD) {
+        dropped.push(`${w3}(${(df * 100).toFixed(0)}%)`);
+        return false;
+      }
+      return true;
     });
+    if (dropped.length > 0) {
+      log({
+        source: "query-sanitizer",
+        level: "debug",
+        summary: `IDF filter: ${originalCount} \u2192 ${words.length} terms, dropped: ${dropped.join(", ")}`
+      });
+    }
   }
   words = [...new Set(words.map((w3) => w3.toLowerCase()))];
   if (words.length === 0) {
@@ -5467,6 +4953,25 @@ var init_query_sanitizer = __esm({
   }
 });
 
+// src/recall/embed-config.ts
+function buildEmbedText(messageText, prevText) {
+  if (messageText.length >= ENRICH_MAX_CHARS || !prevText)
+    return messageText;
+  return prevText.slice(-ENRICH_PREV_CHARS) + ENRICH_SEP + messageText;
+}
+var DOC_PREFIX, QUERY_PREFIX, EMBED_VERSION, ENRICH_MAX_CHARS, ENRICH_PREV_CHARS, ENRICH_SEP;
+var init_embed_config = __esm({
+  "src/recall/embed-config.ts"() {
+    "use strict";
+    DOC_PREFIX = "search_document: ";
+    QUERY_PREFIX = "search_query: ";
+    EMBED_VERSION = 3;
+    ENRICH_MAX_CHARS = 200;
+    ENRICH_PREV_CHARS = 512;
+    ENRICH_SEP = "\n";
+  }
+});
+
 // src/recall/message-store.ts
 function db2() {
   return getDb(dbPath());
@@ -5482,7 +4987,7 @@ function insertMessages(messages, opts) {
     return;
   ensureDir2();
   const d3 = db2();
-  d3.exec("BEGIN");
+  d3.exec("BEGIN IMMEDIATE");
   try {
     if (opts?.replaceSessionId) {
       d3.run(
@@ -5497,20 +5002,16 @@ function insertMessages(messages, opts) {
        (message_id, session_id, message_seq, message_text, project_id, created_at, message_role)
        VALUES (?, ?, ?, ?, ?, ?, ?)`
     );
-    try {
-      for (const m2 of messages) {
-        stmt.run([
-          m2.message_id,
-          m2.session_id,
-          m2.message_seq,
-          m2.message_text,
-          m2.project_id,
-          m2.created_at,
-          m2.message_role
-        ]);
-      }
-    } finally {
-      stmt.finalize();
+    for (const m2 of messages) {
+      stmt.run([
+        m2.message_id,
+        m2.session_id,
+        m2.message_seq,
+        m2.message_text,
+        m2.project_id,
+        m2.created_at,
+        m2.message_role
+      ]);
     }
     d3.exec("COMMIT");
   } catch (e2) {
@@ -5518,9 +5019,9 @@ function insertMessages(messages, opts) {
     throw e2;
   }
 }
-function searchMessagesFts(query, limit2 = 20, projectId, sessionId, excludeSessionId) {
+function searchMessagesFts(query, limit2 = 20, projectId, sessionId, excludeSessionId, skipIdf) {
   try {
-    const sanitized = sanitizeFts5Query(query);
+    const sanitized = sanitizeFts5Query(query, { skipIdf });
     if (!sanitized)
       return [];
     const params = [sanitized];
@@ -5631,24 +5132,21 @@ function insertMessageVectors(records) {
     return;
   ensureDir2();
   const d3 = db2();
-  d3.exec("BEGIN");
+  d3.exec("BEGIN IMMEDIATE");
   try {
     const stmt = d3.prepare(
       `INSERT OR REPLACE INTO message_vectors
-       (message_id, embedding_q8, norm, quant_scale)
-       VALUES (?, ?, ?, ?)`
+       (message_id, embedding_q8, norm, quant_scale, embed_version)
+       VALUES (?, ?, ?, ?, ?)`
     );
-    try {
-      for (const r2 of records) {
-        stmt.run([
-          r2.messageId,
-          Buffer.from(r2.embeddingQ8.buffer, r2.embeddingQ8.byteOffset, r2.embeddingQ8.byteLength),
-          r2.norm,
-          r2.quantScale
-        ]);
-      }
-    } finally {
-      stmt.finalize();
+    for (const r2 of records) {
+      stmt.run([
+        r2.messageId,
+        Buffer.from(r2.embeddingQ8.buffer, r2.embeddingQ8.byteOffset, r2.embeddingQ8.byteLength),
+        r2.norm,
+        r2.quantScale,
+        EMBED_VERSION
+      ]);
     }
     d3.exec("COMMIT");
   } catch (e2) {
@@ -5656,6 +5154,23 @@ function insertMessageVectors(records) {
     throw e2;
   }
 }
+function getEmbedVersionStats() {
+  try {
+    const row = db2().get(
+      `SELECT COUNT(*) AS total,
+              COALESCE(SUM(CASE WHEN embed_version = ? THEN 1 ELSE 0 END), 0) AS current
+       FROM message_vectors`,
+      [EMBED_VERSION]
+    );
+    const total = row ? row.total : 0;
+    const current = row ? row.current ?? 0 : 0;
+    const stale = total - current;
+    const coverage = total === 0 ? 1 : current / total;
+    return { total, current, stale, coverage };
+  } catch {
+    return { total: 0, current: 0, stale: 0, coverage: 1 };
+  }
+}
 function searchMessagesSemantic(queryQ8, queryNorm, queryScale, opts) {
   try {
     const limit2 = opts?.limit ?? 20;
@@ -5673,13 +5188,16 @@ function searchMessagesSemantic(queryQ8, queryNorm, queryScale, opts) {
       filterClauses += " AND m.session_id != ?";
       params.push(opts.excludeSessionId);
     }
+    const versionClause = opts?.tolerant ? "" : " AND mv.embed_version = ?";
+    if (!opts?.tolerant)
+      params.push(EMBED_VERSION);
     const rows = db2().all(
       `SELECT mv.message_id, mv.embedding_q8, mv.norm, mv.quant_scale,
               m.session_id, m.message_seq, m.project_id, m.created_at, m.message_role,
               SUBSTR(m.message_text, 1, 401) as message_preview_raw
        FROM message_vectors mv
        JOIN messages m ON m.message_id = mv.message_id
-       WHERE 1=1${filterClauses}`,
+       WHERE 1=1${filterClauses}${versionClause}`,
       params
     );
     if (rows.length === 0)
@@ -5692,6 +5210,8 @@ function searchMessagesSemantic(queryQ8, queryNorm, queryScale, opts) {
       if (storedNorm === 0 || queryNorm === 0)
         continue;
       const storedQ8Buf = row.embedding_q8;
+      if (storedQ8Buf.byteLength !== queryQ8.byteLength)
+        continue;
       const storedQ8 = new Int8Array(
         storedQ8Buf.buffer,
         storedQ8Buf.byteOffset,
@@ -5740,9 +5260,12 @@ function getEmbeddingGapStats() {
     const row = db2().get(
       `SELECT
         COUNT(*) as total,
-        SUM(CASE WHEN NOT EXISTS (SELECT 1 FROM message_vectors mv WHERE mv.message_id = m.message_id)
-                       AND LENGTH(m.message_text) >= ${MIN_EMBED_CHARS} THEN 1 ELSE 0 END) as gap
-       FROM messages m WHERE m.message_text != ''`
+        SUM(CASE WHEN NOT EXISTS (SELECT 1 FROM message_vectors mv WHERE mv.message_id = m.message_id AND mv.embed_version = ?)
+                       AND (LENGTH(m.message_text) >= ${MIN_EMBED_CHARS}
+                            OR EXISTS (SELECT 1 FROM messages p WHERE p.session_id = m.session_id AND p.message_seq < m.message_seq))
+                       THEN 1 ELSE 0 END) as gap
+       FROM messages m WHERE m.message_text != ''`,
+      [EMBED_VERSION]
     );
     return {
       totalMessages: row ? row.total : 0,
@@ -5755,19 +5278,29 @@ function getEmbeddingGapStats() {
 function getUnembeddedMessages(limit2) {
   try {
     const rows = db2().all(
-      `SELECT m.message_id, m.session_id, m.message_text FROM messages m
+      `SELECT m.message_id, m.session_id, m.message_text,
+         (SELECT p.message_text FROM messages p
+           WHERE p.session_id = m.session_id AND p.message_seq < m.message_seq
+           ORDER BY p.message_seq DESC LIMIT 1) AS prev_text
+       FROM messages m
        WHERE m.message_text != ''
-         AND LENGTH(m.message_text) >= ${MIN_EMBED_CHARS}
-         AND NOT EXISTS (SELECT 1 FROM message_vectors mv WHERE mv.message_id = m.message_id)
+         AND (LENGTH(m.message_text) >= ${MIN_EMBED_CHARS}
+              OR EXISTS (SELECT 1 FROM messages p2 WHERE p2.session_id = m.session_id AND p2.message_seq < m.message_seq))
+         AND NOT EXISTS (SELECT 1 FROM message_vectors mv WHERE mv.message_id = m.message_id AND mv.embed_version = ?)
        ORDER BY m.created_at DESC
        LIMIT ?`,
-      [limit2]
+      [EMBED_VERSION, limit2]
     );
-    return rows.map((r2) => ({
-      message_id: r2.message_id,
-      session_id: r2.session_id,
-      message_text: r2.message_text
-    }));
+    return rows.map((r2) => {
+      const message_text = r2.message_text;
+      const prev_text = r2.prev_text ?? null;
+      return {
+        message_id: r2.message_id,
+        session_id: r2.session_id,
+        message_text,
+        embed_text: buildEmbedText(message_text, prev_text)
+      };
+    });
   } catch {
     return [];
   }
@@ -5791,6 +5324,7 @@ var init_message_store = __esm({
     init_paths();
     init_query_sanitizer();
     init_quantize();
+    init_embed_config();
     dirEnsured = false;
     MIN_EMBED_CHARS = 50;
   }
@@ -10203,12 +9737,12 @@ var init_esm4 = __esm({
       /**
        * Get the Path object referenced by the string path, resolved from this Path
        */
-      resolve(path3) {
-        if (!path3) {
+      resolve(path4) {
+        if (!path4) {
           return this;
         }
-        const rootPath = this.getRootString(path3);
-        const dir = path3.substring(rootPath.length);
+        const rootPath = this.getRootString(path4);
+        const dir = path4.substring(rootPath.length);
         const dirParts = dir.split(this.splitSep);
         const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
         return result;
@@ -10960,8 +10494,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      getRootString(path3) {
-        return import_node_path5.win32.parse(path3).root;
+      getRootString(path4) {
+        return import_node_path5.win32.parse(path4).root;
       }
       /**
        * @internal
@@ -11007,8 +10541,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      getRootString(path3) {
-        return path3.startsWith("/") ? "/" : "";
+      getRootString(path4) {
+        return path4.startsWith("/") ? "/" : "";
       }
       /**
        * @internal
@@ -11057,8 +10591,8 @@ var init_esm4 = __esm({
        *
        * @internal
        */
-      constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs3 = defaultFS } = {}) {
-        this.#fs = fsFromOption(fs3);
+      constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs5 = defaultFS } = {}) {
+        this.#fs = fsFromOption(fs5);
         if (cwd instanceof URL || cwd.startsWith("file://")) {
           cwd = (0, import_node_url.fileURLToPath)(cwd);
         }
@@ -11097,11 +10631,11 @@ var init_esm4 = __esm({
       /**
        * Get the depth of a provided path, string, or the cwd
        */
-      depth(path3 = this.cwd) {
-        if (typeof path3 === "string") {
-          path3 = this.cwd.resolve(path3);
+      depth(path4 = this.cwd) {
+        if (typeof path4 === "string") {
+          path4 = this.cwd.resolve(path4);
         }
-        return path3.depth();
+        return path4.depth();
       }
       /**
        * Return the cache of child entries.  Exposed so subclasses can create
@@ -11588,9 +11122,9 @@ var init_esm4 = __esm({
         process2();
         return results;
       }
-      chdir(path3 = this.cwd) {
+      chdir(path4 = this.cwd) {
         const oldCwd = this.cwd;
-        this.cwd = typeof path3 === "string" ? this.cwd.resolve(path3) : path3;
+        this.cwd = typeof path4 === "string" ? this.cwd.resolve(path4) : path4;
         this.cwd[setAsCwd](oldCwd);
       }
     };
@@ -11616,8 +11150,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      newRoot(fs3) {
-        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs3 });
+      newRoot(fs5) {
+        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs5 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -11645,8 +11179,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      newRoot(fs3) {
-        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs3 });
+      newRoot(fs5) {
+        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs5 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -11965,8 +11499,8 @@ var init_processor = __esm({
       }
       // match, absolute, ifdir
       entries() {
-        return [...this.store.entries()].map(([path3, n]) => [
-          path3,
+        return [...this.store.entries()].map(([path4, n]) => [
+          path4,
           !!(n & 2),
           !!(n & 1)
         ]);
@@ -12179,9 +11713,9 @@ var init_walker = __esm({
       signal;
       maxDepth;
       includeChildMatches;
-      constructor(patterns, path3, opts) {
+      constructor(patterns, path4, opts) {
         this.patterns = patterns;
-        this.path = path3;
+        this.path = path4;
         this.opts = opts;
         this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
         this.includeChildMatches = opts.includeChildMatches !== false;
@@ -12200,11 +11734,11 @@ var init_walker = __esm({
           });
         }
       }
-      #ignored(path3) {
-        return this.seen.has(path3) || !!this.#ignore?.ignored?.(path3);
+      #ignored(path4) {
+        return this.seen.has(path4) || !!this.#ignore?.ignored?.(path4);
       }
-      #childrenIgnored(path3) {
-        return !!this.#ignore?.childrenIgnored?.(path3);
+      #childrenIgnored(path4) {
+        return !!this.#ignore?.childrenIgnored?.(path4);
       }
       // backpressure mechanism
       pause() {
@@ -12419,8 +11953,8 @@ var init_walker = __esm({
     };
     GlobWalker = class extends GlobUtil {
       matches = /* @__PURE__ */ new Set();
-      constructor(patterns, path3, opts) {
-        super(patterns, path3, opts);
+      constructor(patterns, path4, opts) {
+        super(patterns, path4, opts);
       }
       matchEmit(e2) {
         this.matches.add(e2);
@@ -12457,8 +11991,8 @@ var init_walker = __esm({
     };
     GlobStream = class extends GlobUtil {
       results;
-      constructor(patterns, path3, opts) {
-        super(patterns, path3, opts);
+      constructor(patterns, path4, opts) {
+        super(patterns, path4, opts);
         this.results = new Minipass({
           signal: this.signal,
           objectMode: true
@@ -13689,6 +13223,7 @@ async function ingestSessionMessages(sessionId, transcriptPath, vendor, options)
 async function embedRowsResilient(rows) {
   const { embedBatch: embedBatch2 } = await Promise.resolve().then(() => (init_embedder(), embedder_exports));
   const { quantizeToQ8: quantizeToQ82, computeNorm: computeNorm2 } = await Promise.resolve().then(() => (init_quantize(), quantize_exports));
+  rows = rows.map((r2) => ({ messageId: r2.messageId, text: DOC_PREFIX + r2.text }));
   const toRecord = (messageId, f32) => {
     const { q8, scale } = quantizeToQ82(f32);
     return { messageId, embeddingQ8: q8, norm: computeNorm2(f32), quantScale: scale };
@@ -13723,7 +13258,7 @@ async function embedMessageBatch(messages) {
     return 0;
   const truncated = [];
   for (const m2 of messages) {
-    const text = m2.message_text.trim();
+    const text = (m2.embed_text ?? m2.message_text).trim();
     if (!text)
       continue;
     truncated.push({
@@ -13743,6 +13278,7 @@ var init_message_ingest = __esm({
     "use strict";
     init_transcript_utils();
     init_message_store();
+    init_embed_config();
     init_db();
     init_paths();
     init_url_path_resolver();
@@ -15180,11 +14716,11 @@ function downloadFile2(url, destPath) {
     (0, import_node_https.get)(url, { headers: { "User-Agent": "recall" } }, pipeTo).on("error", done);
   });
 }
-var import_node_child_process2, import_node_fs9, import_node_path9, import_node_util2, import_node_os6, import_node_https, import_extract_zip2, execFileAsync2, EXPECTED_DIMS2, OFFLOAD_TIMEOUT_MS, DEFAULT_NGL, CUDA_ASSET_NAME, CUDA_ASSET_URL, STAGE_DOWNLOAD_TIMEOUT_MS;
+var import_node_child_process3, import_node_fs9, import_node_path9, import_node_util2, import_node_os6, import_node_https, import_extract_zip2, execFileAsync2, EXPECTED_DIMS2, OFFLOAD_TIMEOUT_MS, DEFAULT_NGL, CUDA_ASSET_NAME, CUDA_ASSET_URL, STAGE_DOWNLOAD_TIMEOUT_MS;
 var init_gpu = __esm({
   "src/installer/gpu.ts"() {
     "use strict";
-    import_node_child_process2 = require("node:child_process");
+    import_node_child_process3 = require("node:child_process");
     import_node_fs9 = require("node:fs");
     import_node_path9 = require("node:path");
     import_node_util2 = require("node:util");
@@ -15195,7 +14731,7 @@ var init_gpu = __esm({
     init_paths();
     init_config();
     init_log();
-    execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
+    execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process3.execFile);
     EXPECTED_DIMS2 = 768;
     OFFLOAD_TIMEOUT_MS = 15e3;
     DEFAULT_NGL = 999;
@@ -15286,25 +14822,25 @@ function detectWsl() {
     return false;
   }
 }
-function canWrite(path3) {
+function canWrite(path4) {
   try {
-    (0, import_node_fs10.accessSync)(path3, import_node_fs10.constants.W_OK);
+    (0, import_node_fs10.accessSync)(path4, import_node_fs10.constants.W_OK);
     return true;
   } catch {
     return false;
   }
 }
 function checkPlatform(report, opts) {
-  const os2 = opts.platform ?? (0, import_node_os7.platform)();
+  const os3 = opts.platform ?? (0, import_node_os7.platform)();
   const a3 = opts.arch ?? (0, import_node_os7.arch)();
   const isWsl = detectWsl();
-  const supported = os2 === "linux" && (a3 === "x64" || a3 === "arm64") || os2 === "darwin" && (a3 === "x64" || a3 === "arm64") || os2 === "win32" && a3 === "x64";
-  report.platform = { os: os2, arch: a3, isWsl, ok: supported };
+  const supported = os3 === "linux" && (a3 === "x64" || a3 === "arm64") || os3 === "darwin" && (a3 === "x64" || a3 === "arm64") || os3 === "win32" && a3 === "x64";
+  report.platform = { os: os3, arch: a3, isWsl, ok: supported };
   if (!supported) {
     report.failures.push({
       check: "platform",
       severity: "FAIL",
-      message: `Unsupported platform ${os2}/${a3}`,
+      message: `Unsupported platform ${os3}/${a3}`,
       remediation: "recall supports Linux x64/arm64, macOS x64/arm64, Windows x64."
     });
   }
@@ -15590,10 +15126,140 @@ var init_manifest = __esm({
   }
 });
 
+// src/installer/upgrade-migrate.ts
+function openReadonly(dbFile) {
+  const staged = (0, import_node_path11.join)(binDir(), "better_sqlite3.node");
+  try {
+    return (0, import_node_fs11.existsSync)(staged) ? new import_better_sqlite32.default(dbFile, { readonly: true, fileMustExist: true, nativeBinding: staged }) : new import_better_sqlite32.default(dbFile, { readonly: true, fileMustExist: true });
+  } catch {
+    try {
+      return new import_better_sqlite32.default(dbFile, { readonly: true, fileMustExist: true });
+    } catch {
+      return null;
+    }
+  }
+}
+function classifyUpgrade() {
+  const dbFile = dbPath();
+  if (!(0, import_node_fs11.existsSync)(dbFile)) {
+    return { state: "fresh", journalMode: null, markerPresent: false, coverage: 1 };
+  }
+  const markerPresent = (0, import_node_fs11.existsSync)((0, import_node_path11.join)(binDir(), ".binding-info.json"));
+  let journalMode = null;
+  let coverage = 1;
+  const raw2 = openReadonly(dbFile);
+  if (raw2) {
+    try {
+      journalMode = String(raw2.pragma("journal_mode", { simple: true }));
+    } catch {
+      journalMode = null;
+    }
+    try {
+      const row = raw2.prepare(
+        `SELECT COUNT(*) AS total,
+                  COALESCE(SUM(CASE WHEN embed_version = ? THEN 1 ELSE 0 END), 0) AS current
+           FROM message_vectors`
+      ).get(EMBED_VERSION);
+      const total = row ? Number(row.total) : 0;
+      const current = row ? Number(row.current ?? 0) : 0;
+      coverage = total === 0 ? 1 : current / total;
+    } catch {
+      coverage = 1;
+    }
+    try {
+      raw2.close();
+    } catch {
+    }
+  }
+  const state = markerPresent && journalMode === "wal" ? "already-migrated" : "needs-migration";
+  return { state, journalMode, markerPresent, coverage };
+}
+function snapshotDb() {
+  const dbFile = dbPath();
+  if (!(0, import_node_fs11.existsSync)(dbFile))
+    return null;
+  const dest = `${dbFile}.pre-upgrade-${backupStamp()}`;
+  try {
+    (0, import_node_fs11.copyFileSync)(dbFile, dest);
+    const journal = `${dbFile}-journal`;
+    if ((0, import_node_fs11.existsSync)(journal))
+      (0, import_node_fs11.copyFileSync)(journal, `${dest}-journal`);
+    return dest;
+  } catch (e2) {
+    log({ source: "installer/upgrade", level: "warn", summary: `pre-upgrade snapshot failed: ${e2.message}` });
+    return null;
+  }
+}
+function integrityStatus() {
+  try {
+    const d3 = getDb(dbPath());
+    const row = d3.get("PRAGMA integrity_check");
+    const detail = row ? String(Object.values(row)[0] ?? "") : "unknown";
+    return { ok: detail === "ok", detail };
+  } catch (e2) {
+    return { ok: false, detail: e2.message };
+  }
+}
+function repairStemTables() {
+  try {
+    const d3 = getDb(dbPath());
+    d3.exec("DROP TABLE IF EXISTS _stem_vocab");
+    d3.exec("DROP TABLE IF EXISTS _stem");
+    _resetDb();
+    getDb(dbPath());
+    return integrityStatus().ok;
+  } catch {
+    return false;
+  }
+}
+function handleIntegrity() {
+  const st = integrityStatus();
+  if (st.ok)
+    return { status: "ok" };
+  if (/_stem/i.test(st.detail) && repairStemTables()) {
+    return { status: "repaired-stem" };
+  }
+  return { status: "unrecoverable", detail: st.detail };
+}
+function backfillAlreadyRunning() {
+  const pidFile = (0, import_node_path11.join)(runDir(), "backfill.pid");
+  if (!(0, import_node_fs11.existsSync)(pidFile))
+    return false;
+  try {
+    const pid = parseInt((0, import_node_fs11.readFileSync)(pidFile, "utf-8").trim(), 10);
+    if (Number.isNaN(pid))
+      return false;
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function migrationReportLine(coverage) {
+  if (coverage >= 1)
+    return null;
+  const pct = Math.round(coverage * 100);
+  return `Embed migration: re-embedding in background (${pct}% at v${EMBED_VERSION}) \u2014 semantic search stays available`;
+}
+var import_node_fs11, import_node_path11, import_better_sqlite32;
+var init_upgrade_migrate = __esm({
+  "src/installer/upgrade-migrate.ts"() {
+    "use strict";
+    import_node_fs11 = require("node:fs");
+    import_node_path11 = require("node:path");
+    import_better_sqlite32 = __toESM(require_lib());
+    init_db();
+    init_paths();
+    init_embed_config();
+    init_settings_merge();
+    init_log();
+  }
+});
+
 // src/installer/claudemd-nudge.ts
 function applyNudge(filePath) {
-  const exists = (0, import_node_fs11.existsSync)(filePath);
-  const raw2 = exists ? (0, import_node_fs11.readFileSync)(filePath, "utf-8") : "";
+  const exists = (0, import_node_fs12.existsSync)(filePath);
+  const raw2 = exists ? (0, import_node_fs12.readFileSync)(filePath, "utf-8") : "";
   if (RECALL_HEADING.test(raw2))
     return { changed: false };
   const ending = raw2.includes("\r\n") ? "\r\n" : "\n";
@@ -15607,9 +15273,9 @@ function applyNudge(filePath) {
   return backup ? { changed: true, backup } : { changed: true };
 }
 function removeNudge(filePath) {
-  if (!(0, import_node_fs11.existsSync)(filePath))
+  if (!(0, import_node_fs12.existsSync)(filePath))
     return { changed: false };
-  const raw2 = (0, import_node_fs11.readFileSync)(filePath, "utf-8");
+  const raw2 = (0, import_node_fs12.readFileSync)(filePath, "utf-8");
   if (!RECALL_HEADING.test(raw2))
     return { changed: false };
   const ending = raw2.includes("\r\n") ? "\r\n" : "\n";
@@ -15637,11 +15303,11 @@ function removeNudge(filePath) {
   writeFileAtomic(filePath, next);
   return { changed: true, backup };
 }
-var import_node_fs11, RECALL_BLOCK, RECALL_HEADING;
+var import_node_fs12, RECALL_BLOCK, RECALL_HEADING;
 var init_claudemd_nudge = __esm({
   "src/installer/claudemd-nudge.ts"() {
     "use strict";
-    import_node_fs11 = require("node:fs");
+    import_node_fs12 = require("node:fs");
     init_settings_merge();
     RECALL_BLOCK = [
       "",
@@ -15665,60 +15331,132 @@ function defaultDistDir() {
   const argv1 = process.argv[1];
   if (argv1) {
     try {
-      return (0, import_node_path11.dirname)((0, import_node_fs12.realpathSync)(argv1));
+      return (0, import_node_path12.dirname)((0, import_node_fs13.realpathSync)(argv1));
     } catch {
-      return (0, import_node_path11.dirname)(argv1);
+      return (0, import_node_path12.dirname)(argv1);
     }
   }
   return __dirname;
 }
 function resolveTemplatePath(explicit) {
-  if (explicit && (0, import_node_fs12.existsSync)(explicit))
+  if (explicit && (0, import_node_fs13.existsSync)(explicit))
     return explicit;
   const here = __dirname;
   const candidates = [
-    (0, import_node_path11.join)(here, "SKILL.md.template"),
+    (0, import_node_path12.join)(here, "SKILL.md.template"),
     // bundled: copied next to recall.js
-    (0, import_node_path11.join)(here, "..", "skill", "SKILL.md.template"),
+    (0, import_node_path12.join)(here, "..", "skill", "SKILL.md.template"),
     // dist/ sibling skill/
-    (0, import_node_path11.join)(here, "..", "..", "skill", "SKILL.md.template")
+    (0, import_node_path12.join)(here, "..", "..", "skill", "SKILL.md.template")
     // source: src/installer/
   ];
   for (const c of candidates)
-    if ((0, import_node_fs12.existsSync)(c))
+    if ((0, import_node_fs13.existsSync)(c))
       return c;
   return candidates[candidates.length - 1];
 }
 function recallBinCommand() {
-  return `node ${(0, import_node_path11.join)(binDir(), "recall.js")}`;
+  return `"${process.execPath}" "${(0, import_node_path12.join)(binDir(), "recall.js")}"`;
 }
 function writeSkill(targetPath, templatePath, runnable) {
-  const template = (0, import_node_fs12.readFileSync)(templatePath, "utf-8");
+  const template = (0, import_node_fs13.readFileSync)(templatePath, "utf-8");
   const body = template.replaceAll("$RECALL_BIN", runnable);
-  (0, import_node_fs12.mkdirSync)((0, import_node_path11.dirname)(targetPath), { recursive: true });
-  if ((0, import_node_fs12.existsSync)(targetPath)) {
-    if ((0, import_node_fs12.readFileSync)(targetPath, "utf-8") === body)
+  (0, import_node_fs13.mkdirSync)((0, import_node_path12.dirname)(targetPath), { recursive: true });
+  if ((0, import_node_fs13.existsSync)(targetPath)) {
+    if ((0, import_node_fs13.readFileSync)(targetPath, "utf-8") === body)
       return false;
     backupFile(targetPath);
   }
-  (0, import_node_fs12.writeFileSync)(targetPath, body);
+  (0, import_node_fs13.writeFileSync)(targetPath, body);
   return true;
 }
 function stageBundles(distDir, written) {
-  (0, import_node_fs12.mkdirSync)(binDir(), { recursive: true });
+  (0, import_node_fs13.mkdirSync)(binDir(), { recursive: true });
   for (const name of STAGED_BUNDLES) {
-    const src = (0, import_node_path11.join)(distDir, name);
-    if (!(0, import_node_fs12.existsSync)(src)) {
+    const src = (0, import_node_path12.join)(distDir, name);
+    if (!(0, import_node_fs13.existsSync)(src)) {
       log({ source: "installer/install", level: "warn", summary: `bundle ${name} not found in ${distDir} \u2014 skipping stage` });
       continue;
     }
-    const dest = (0, import_node_path11.join)(binDir(), name);
-    (0, import_node_fs12.copyFileSync)(src, dest);
+    const dest = (0, import_node_path12.join)(binDir(), name);
+    (0, import_node_fs13.copyFileSync)(src, dest);
     written.push(dest);
   }
-  const wasm = (0, import_node_path11.join)(distDir, "node-sqlite3-wasm.wasm");
-  if ((0, import_node_fs12.existsSync)(wasm))
-    (0, import_node_fs12.copyFileSync)(wasm, (0, import_node_path11.join)(binDir(), "node-sqlite3-wasm.wasm"));
+  stageNativeBinding(written);
+}
+function stageNativeBinding(written) {
+  const staleWasm = (0, import_node_path12.join)(binDir(), "node-sqlite3-wasm.wasm");
+  if ((0, import_node_fs13.existsSync)(staleWasm)) {
+    try {
+      (0, import_node_fs13.unlinkSync)(staleWasm);
+    } catch {
+    }
+  }
+  const binding = resolveInstalledBinding2();
+  if (!binding) {
+    log({
+      source: "installer/install",
+      level: "warn",
+      summary: "better_sqlite3.node not found in node_modules \u2014 the CLI/hooks will fail to load SQLite until reinstalled"
+    });
+    return;
+  }
+  const dest = (0, import_node_path12.join)(binDir(), "better_sqlite3.node");
+  (0, import_node_fs13.copyFileSync)(binding, dest);
+  written.push(dest);
+  const markerPath = (0, import_node_path12.join)(binDir(), ".binding-info.json");
+  (0, import_node_fs13.writeFileSync)(
+    markerPath,
+    JSON.stringify(
+      {
+        platform: process.platform,
+        arch: process.arch,
+        nodeModuleVersion: process.versions.modules,
+        nodePath: process.execPath
+      },
+      null,
+      2
+    )
+  );
+  written.push(markerPath);
+}
+function resolveInstalledBinding2() {
+  try {
+    const pkgJson = (0, import_node_module2.createRequire)(__filename).resolve("better-sqlite3/package.json");
+    return findDotNode((0, import_node_path12.dirname)(pkgJson));
+  } catch {
+    return null;
+  }
+}
+function findDotNode(baseDir) {
+  for (const c of [
+    (0, import_node_path12.join)(baseDir, "build", "Release", "better_sqlite3.node"),
+    (0, import_node_path12.join)(baseDir, "build", "Debug", "better_sqlite3.node")
+  ]) {
+    try {
+      if ((0, import_node_fs13.statSync)(c).isFile())
+        return c;
+    } catch {
+    }
+  }
+  const stack = [baseDir];
+  while (stack.length) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = (0, import_node_fs13.readdirSync)(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e2 of entries) {
+      const p = (0, import_node_path12.join)(dir, e2.name);
+      if (e2.isDirectory())
+        stack.push(p);
+      else if (e2.name.endsWith(".node"))
+        return p;
+    }
+  }
+  return null;
 }
 async function runInstall(opts = {}) {
   const interactive = !!process.stdout.isTTY && !opts.yes && !opts.json;
@@ -15775,21 +15513,41 @@ ${wmsg}` });
       log({ source: "installer/install", level: "error", summary: msg });
     return { aborted: true, report, selected: [...selected], gpu: { mode: "cpu", libDir: null, ngl: 0, cudaAvailable: "none" }, filesWritten: [] };
   }
+  const migration = classifyUpgrade();
   const filesWritten = [];
   let gpu = { mode: "cpu", libDir: null, ngl: 0, cudaAvailable: "none" };
   let backfillPid;
+  let snapshotPath;
+  let integrity;
+  let drainLaunched = false;
   try {
+    if (migration.state === "needs-migration") {
+      for (const p of [claudeSettingsPath(), codexHooksPath()]) {
+        const r2 = removeStopHook(p);
+        if (r2.changed)
+          filesWritten.push(p);
+      }
+      say("upgrade: quiesced stale Stop hook before migration");
+    }
     for (const d3 of [binDir(), modelsDir(), runDir(), logsDir()])
-      (0, import_node_fs12.mkdirSync)(d3, { recursive: true });
+      (0, import_node_fs13.mkdirSync)(d3, { recursive: true });
     stageBundles(opts.distDir ?? defaultDistDir(), filesWritten);
     say(`scaffolded ${recallRoot()}`);
     if (opts.offline) {
-      const haveBin = (0, import_node_fs12.existsSync)(getBinaryPath());
-      const haveModel = (0, import_node_fs12.existsSync)(getModelPath());
+      const haveBin = (0, import_node_fs13.existsSync)(getBinaryPath());
+      const haveModel = (0, import_node_fs13.existsSync)(getModelPath());
       if (!haveBin || !haveModel) {
-        const msg = `--offline but runtime not pre-staged (binary=${haveBin}, model=${haveModel}).`;
+        const msg = `--offline but runtime not pre-staged (binary=${haveBin}, model=${haveModel}). Pre-stage ~/.recall/bin + model (or drop --offline), then re-run \`recall install\`` + (migration.state === "needs-migration" ? " (which restores the recall Stop hook)." : ".");
         log({ source: "installer/install", level: "error", summary: msg });
-        return { aborted: true, report, selected: [...selected], gpu, filesWritten };
+        return {
+          aborted: true,
+          abortReason: msg,
+          report,
+          selected: [...selected],
+          gpu,
+          filesWritten,
+          migration: { state: migration.state, coverage: migration.coverage, drainLaunched: false }
+        };
       }
       say("offline: CPU runtime already staged");
     } else {
@@ -15806,11 +15564,75 @@ ${wmsg}` });
       ...opts.offline ? { offline: true } : {}
     });
     say(gpu.mode === "gpu" ? `GPU acceleration enabled (${gpu.cudaAvailable})` : `using CPU embeddings${gpu.reason ? ` (${gpu.reason})` : ""}`);
-    getDb(dbPath());
+    if (migration.state === "needs-migration") {
+      snapshotPath = snapshotDb() ?? void 0;
+      say(snapshotPath ? `pre-upgrade snapshot: ${snapshotPath}` : "pre-upgrade snapshot skipped (no DB / copy failed)");
+    }
+    try {
+      getDb(dbPath());
+    } catch (e2) {
+      const emsg = e2.message;
+      const rerun = migration.state === "needs-migration" ? " Then re-run `recall install` to finish migrating and restore the recall Stop hook." : " Then re-run `recall install`.";
+      let remediation;
+      if (isBindingLoadError(e2)) {
+        remediation = `The native SQLite binding failed to load (${emsg}). Run \`recall install\` (or \`recall doctor\`).`;
+      } else if (/database is locked|SQLITE_BUSY|busy_timeout/i.test(emsg)) {
+        remediation = `A live session is holding the database. Exit all Claude/Codex sessions.${rerun}`;
+      } else if (/expected WAL journal_mode/i.test(emsg)) {
+        remediation = `recall could not enable WAL on this filesystem (e.g. a network / virtual mount). Put ~/.recall on a local disk (or set RECALL_HOME to one).${rerun}`;
+      } else {
+        remediation = `Could not open the database (${emsg}). Run \`recall doctor --integrity\`; if unrecoverable, rebuild from JSONL with \`recall repair --full\`.${rerun}`;
+      }
+      if (interactive)
+        le(remediation, "Migration aborted");
+      else
+        log({ source: "installer/install", level: "error", summary: `migration aborted: ${remediation}` });
+      return {
+        aborted: true,
+        abortReason: remediation,
+        report,
+        selected: [...selected],
+        gpu,
+        filesWritten,
+        migration: {
+          state: migration.state,
+          coverage: migration.coverage,
+          drainLaunched: false,
+          ...snapshotPath ? { snapshotPath } : {}
+        }
+      };
+    }
     say("database initialized");
+    if (migration.state === "needs-migration") {
+      const res = handleIntegrity();
+      integrity = res.status;
+      if (res.status === "unrecoverable") {
+        const remediation = `Database integrity check failed (${res.detail ?? "unknown"}) and could not be auto-repaired. Your pre-upgrade snapshot is preserved at ${snapshotPath ?? "(snapshot unavailable)"}. Rebuild the index from JSONL with \`recall repair --full\`, then re-run \`recall install\` to restore the recall Stop hook.`;
+        if (interactive)
+          le(remediation, "Migration aborted");
+        else
+          log({ source: "installer/install", level: "error", summary: `migration aborted: ${remediation}` });
+        return {
+          aborted: true,
+          abortReason: remediation,
+          report,
+          selected: [...selected],
+          gpu,
+          filesWritten,
+          migration: {
+            state: migration.state,
+            coverage: migration.coverage,
+            drainLaunched: false,
+            integrity,
+            ...snapshotPath ? { snapshotPath } : {}
+          }
+        };
+      }
+      say(res.status === "repaired-stem" ? "upgrade: repaired corrupt _stem index" : "upgrade: integrity check passed");
+    }
     const runnable = recallBinCommand();
     const templatePath = resolveTemplatePath(opts.templatePath);
-    const hookScript = (0, import_node_path11.join)(binDir(), "stop-hook.js");
+    const hookScript = (0, import_node_path12.join)(binDir(), "stop-hook.js");
     if (selected.has("skill")) {
       if (writeSkill(claudeRecallSkillPath(), templatePath, runnable))
         filesWritten.push(claudeRecallSkillPath());
@@ -15834,7 +15656,11 @@ ${wmsg}` });
       if (r2.changed)
         filesWritten.push(codexAgentsPath());
     }
+    if (filesWritten.length !== new Set(filesWritten).size) {
+      filesWritten.splice(0, filesWritten.length, ...new Set(filesWritten));
+    }
     say(`wrote ${filesWritten.length} files`);
+    const coverage = getEmbedVersionStats().coverage;
     if (opts.noBackfill) {
       say("backfill skipped (--no-backfill)");
     } else if (opts.autoBackfill) {
@@ -15845,56 +15671,84 @@ ${wmsg}` });
       await startRecallCatchup2({ autoEmbed: true });
       await mtimeScan2();
       sp?.stop("Backfill complete");
+      drainLaunched = true;
+    } else if (backfillAlreadyRunning()) {
+      say("backfill already running in background \u2014 not relaunching");
+    } else if (migration.state === "already-migrated" && coverage >= 1 && getEmbeddingGapStats().gapCount === 0) {
+      say("already migrated (all vectors current) \u2014 no background re-embed needed");
     } else {
       backfillPid = spawnDetachedBackfill();
+      drainLaunched = backfillPid !== void 0;
       say(backfillPid ? `backfill running in background (PID ${backfillPid})` : "backfill could not be launched");
     }
   } finally {
     releaseInstallLock();
   }
+  const finalCoverage = getEmbedVersionStats().coverage;
+  const migrationInfo = {
+    state: migration.state,
+    coverage: finalCoverage,
+    drainLaunched,
+    ...snapshotPath ? { snapshotPath } : {},
+    ...integrity ? { integrity } : {}
+  };
+  const migLine = migrationReportLine(finalCoverage);
   if (interactive) {
     const lines = [
       gpu.mode === "gpu" ? "GPU acceleration: enabled" : `Embeddings: CPU${gpu.reason ? ` (${gpu.reason})` : ""}`,
       `Files written/edited: ${filesWritten.length}`,
       backfillPid ? `Backfill running in background (PID ${backfillPid}) \u2014 check with \`recall status\`.` : "Backfill: see above",
+      ...migLine ? [migLine] : [],
       'Try it \u2014 ask Claude: "what did I work on yesterday?"',
       "Commands: recall doctor \xB7 recall status \xB7 recall uninstall"
     ];
     $e(lines.join("\n"));
+  } else if (migLine) {
+    log({ source: "installer/install", level: "info", summary: migLine });
   }
-  return { report, selected: [...selected], gpu, filesWritten, ...backfillPid ? { backfillPid } : {} };
+  return {
+    report,
+    selected: [...selected],
+    gpu,
+    filesWritten,
+    migration: migrationInfo,
+    ...backfillPid ? { backfillPid } : {}
+  };
 }
 function spawnDetachedBackfill() {
-  (0, import_node_fs12.mkdirSync)(runDir(), { recursive: true });
-  (0, import_node_fs12.mkdirSync)(logsDir(), { recursive: true });
-  const recallBundle = (0, import_node_path11.join)(binDir(), "recall.js");
-  const logFd = (0, import_node_fs12.openSync)((0, import_node_path11.join)(logsDir(), "backfill.log"), "a");
-  const child = (0, import_node_child_process3.spawn)(process.execPath, [recallBundle, "backfill", "--auto-embed"], {
+  (0, import_node_fs13.mkdirSync)(runDir(), { recursive: true });
+  (0, import_node_fs13.mkdirSync)(logsDir(), { recursive: true });
+  const recallBundle = (0, import_node_path12.join)(binDir(), "recall.js");
+  const logFd = (0, import_node_fs13.openSync)((0, import_node_path12.join)(logsDir(), "backfill.log"), "a");
+  const child = (0, import_node_child_process4.spawn)(process.execPath, [recallBundle, "backfill", "--auto-embed"], {
     detached: true,
     stdio: ["ignore", logFd, logFd],
     windowsHide: true,
     env: { ...process.env }
   });
   if (child.pid !== void 0) {
-    (0, import_node_fs12.writeFileSync)((0, import_node_path11.join)(runDir(), "backfill.pid"), String(child.pid));
+    (0, import_node_fs13.writeFileSync)((0, import_node_path12.join)(runDir(), "backfill.pid"), String(child.pid));
   }
   child.unref();
   return child.pid;
 }
-var import_node_fs12, import_node_child_process3, import_node_path11, STAGED_BUNDLES;
+var import_node_fs13, import_node_child_process4, import_node_module2, import_node_path12, STAGED_BUNDLES;
 var init_install = __esm({
   "src/installer/install.ts"() {
     "use strict";
     init_dist2();
-    import_node_fs12 = require("node:fs");
-    import_node_child_process3 = require("node:child_process");
-    import_node_path11 = require("node:path");
+    import_node_fs13 = require("node:fs");
+    import_node_child_process4 = require("node:child_process");
+    import_node_module2 = require("node:module");
+    import_node_path12 = require("node:path");
     init_paths();
     init_db();
+    init_message_store();
     init_preflight();
     init_manifest();
     init_gpu();
     init_settings_merge();
+    init_upgrade_migrate();
     init_claudemd_nudge();
     init_embedder();
     init_log();
@@ -15910,9 +15764,9 @@ __export(uninstall_exports, {
 function runUninstall(opts = {}) {
   const removed = [];
   for (const skillFile of [claudeRecallSkillPath(), codexRecallSkillPath()]) {
-    const dir = (0, import_node_path12.dirname)(skillFile);
-    if ((0, import_node_fs13.existsSync)(dir)) {
-      (0, import_node_fs13.rmSync)(dir, { recursive: true, force: true });
+    const dir = (0, import_node_path13.dirname)(skillFile);
+    if ((0, import_node_fs14.existsSync)(dir)) {
+      (0, import_node_fs14.rmSync)(dir, { recursive: true, force: true });
       removed.push(dir);
     }
   }
@@ -15927,8 +15781,8 @@ function runUninstall(opts = {}) {
   let purged = false;
   if (opts.purge) {
     closeDb();
-    if ((0, import_node_fs13.existsSync)(recallRoot())) {
-      (0, import_node_fs13.rmSync)(recallRoot(), { recursive: true, force: true });
+    if ((0, import_node_fs14.existsSync)(recallRoot())) {
+      (0, import_node_fs14.rmSync)(recallRoot(), { recursive: true, force: true });
       removed.push(recallRoot());
     }
     purged = true;
@@ -15936,12 +15790,12 @@ function runUninstall(opts = {}) {
   log({ source: "installer/uninstall", level: "info", summary: `uninstall removed ${removed.length} targets (purge=${purged})` });
   return { removed, purged };
 }
-var import_node_fs13, import_node_path12;
+var import_node_fs14, import_node_path13;
 var init_uninstall = __esm({
   "src/installer/uninstall.ts"() {
     "use strict";
-    import_node_fs13 = require("node:fs");
-    import_node_path12 = require("node:path");
+    import_node_fs14 = require("node:fs");
+    import_node_path13 = require("node:path");
     init_settings_merge();
     init_claudemd_nudge();
     init_preflight();
@@ -15962,13 +15816,14 @@ function getStatus() {
   const messageCount = d3.get("SELECT COUNT(*) AS c FROM messages").c;
   const lastRow = d3.get("SELECT MAX(created_at) AS m FROM messages");
   const lastIngest = lastRow.m ? new Date(lastRow.m).toISOString() : null;
-  const dbSizeBytes = (0, import_node_fs14.existsSync)(dbPath()) ? (0, import_node_fs14.statSync)(dbPath()).size : 0;
+  const dbSizeBytes = (0, import_node_fs15.existsSync)(dbPath()) ? (0, import_node_fs15.statSync)(dbPath()).size : 0;
   const embeddingGap = getEmbeddingGapStats();
+  const embedVersions = getEmbedVersionStats();
   let backfillPid = null;
   let backfillRunning = false;
-  const pidFile = (0, import_node_path13.join)(runDir(), "backfill.pid");
-  if ((0, import_node_fs14.existsSync)(pidFile)) {
-    const pid = parseInt((0, import_node_fs14.readFileSync)(pidFile, "utf-8").trim(), 10);
+  const pidFile = (0, import_node_path14.join)(runDir(), "backfill.pid");
+  if ((0, import_node_fs15.existsSync)(pidFile)) {
+    const pid = parseInt((0, import_node_fs15.readFileSync)(pidFile, "utf-8").trim(), 10);
     if (!Number.isNaN(pid)) {
       backfillPid = pid;
       try {
@@ -15985,6 +15840,7 @@ function getStatus() {
     messageCount,
     lastIngest,
     embeddingGap,
+    embedVersions,
     backfillPid,
     backfillRunning,
     embedder: readEmbedderConfig().mode
@@ -16003,18 +15859,23 @@ function printStatus(json) {
   console.log(`Messages:      ${s.messageCount}`);
   console.log(`Last ingest:   ${s.lastIngest ?? "never"}`);
   console.log(`Embedding gap: ${s.embeddingGap.gapCount} of ${s.embeddingGap.totalMessages} unembedded`);
+  if (s.embedVersions.coverage < 1) {
+    const pct = Math.round(s.embedVersions.coverage * 100);
+    console.log(`Embed migration: ${s.embedVersions.current} of ${s.embedVersions.total} at v${EMBED_VERSION} (${pct}%)`);
+  }
   console.log(`Embedder:      ${s.embedder.toUpperCase()}`);
   console.log(`Backfill:      ${s.backfillPid === null ? "none recorded" : `PID ${s.backfillPid} (${s.backfillRunning ? "running" : "finished"})`}`);
 }
-var import_node_fs14, import_node_path13;
+var import_node_fs15, import_node_path14;
 var init_status = __esm({
   "src/installer/status.ts"() {
     "use strict";
-    import_node_fs14 = require("node:fs");
-    import_node_path13 = require("node:path");
+    import_node_fs15 = require("node:fs");
+    import_node_path14 = require("node:path");
     init_db();
     init_paths();
     init_message_store();
+    init_embed_config();
     init_config();
   }
 });
@@ -16068,7 +15929,7 @@ async function repairFull(opts = {}) {
     }
   }
   const d3 = db3();
-  d3.exec("BEGIN");
+  d3.exec("BEGIN IMMEDIATE");
   try {
     d3.exec("DELETE FROM messages;");
     d3.exec("DELETE FROM ingest_watermark;");
@@ -16107,12 +15968,125 @@ async function runDoctor(opts = {}) {
     return printIntegrity(opts.json ?? false);
   const report = await runPreflight({ ...opts.offline ? { offline: true } : {} });
   const embedder = readConfig()?.embedder ?? null;
+  const binding = checkBindingHealth();
   if (opts.json) {
-    console.log(JSON.stringify({ ...report, embedder }, null, 2));
+    console.log(JSON.stringify({ ...report, embedder, binding }, null, 2));
   } else {
     printTable(report, embedder?.mode ?? "cpu", embedder?.fallbackReason);
+    printBinding(binding);
+  }
+  const bindingFailed = binding.installed && binding.problems.length > 0;
+  return report.failures.length > 0 || bindingFailed ? 1 : 0;
+}
+function stagedBindingPath() {
+  return (0, import_node_path15.join)(binDir(), "better_sqlite3.node");
+}
+function checkBindingHealth() {
+  const problems = [];
+  const installed = (0, import_node_fs16.existsSync)((0, import_node_path15.join)(binDir(), "recall.js"));
+  if (!installed) {
+    return {
+      installed: false,
+      markerPresent: false,
+      abiOk: null,
+      pinnedNodeOk: null,
+      bindingLoads: false,
+      journalMode: null,
+      embedCoverage: null,
+      problems: ["recall is not installed \u2014 run `recall install`"]
+    };
+  }
+  const markerPath = (0, import_node_path15.join)(binDir(), ".binding-info.json");
+  const markerPresent = (0, import_node_fs16.existsSync)(markerPath);
+  let abiOk = null;
+  let pinnedNodeOk = null;
+  if (!markerPresent) {
+    problems.push("no .binding-info.json marker \u2014 pre-migration (wasm-era) install; run `recall install`");
+  } else {
+    try {
+      const marker = JSON.parse((0, import_node_fs16.readFileSync)(markerPath, "utf-8"));
+      abiOk = String(marker.nodeModuleVersion) === String(process.versions.modules);
+      if (!abiOk) {
+        problems.push(
+          `binding ABI mismatch (staged for NODE_MODULE_VERSION ${marker.nodeModuleVersion}, current ${process.versions.modules}) \u2014 run \`recall install\``
+        );
+      }
+      pinnedNodeOk = !!marker.nodePath && (0, import_node_fs16.existsSync)(marker.nodePath);
+      if (!pinnedNodeOk) {
+        problems.push(`pinned Node path missing (${marker.nodePath ?? "unset"}) \u2014 run \`recall install\``);
+      }
+    } catch {
+      problems.push("unreadable .binding-info.json marker \u2014 run `recall install`");
+    }
+  }
+  let bindingLoads = false;
+  let journalMode = null;
+  let embedCoverage = null;
+  const localBinding = stagedBindingPath();
+  const dbFile = dbPath();
+  if ((0, import_node_fs16.existsSync)(dbFile)) {
+    try {
+      const raw2 = (0, import_node_fs16.existsSync)(localBinding) ? new import_better_sqlite33.default(dbFile, { readonly: true, fileMustExist: true, nativeBinding: localBinding }) : new import_better_sqlite33.default(dbFile, { readonly: true, fileMustExist: true });
+      bindingLoads = true;
+      journalMode = String(raw2.pragma("journal_mode", { simple: true }));
+      try {
+        const row = raw2.prepare(
+          `SELECT COUNT(*) AS total,
+                    COALESCE(SUM(CASE WHEN embed_version = ? THEN 1 ELSE 0 END), 0) AS current
+             FROM message_vectors`
+        ).get(EMBED_VERSION);
+        const total = row ? Number(row.total) : 0;
+        const current = row ? Number(row.current ?? 0) : 0;
+        embedCoverage = total === 0 ? null : current / total;
+      } catch {
+        embedCoverage = null;
+      }
+      raw2.close();
+      if (journalMode !== "wal") {
+        problems.push(
+          `live DB journal_mode is '${journalMode}', not 'wal' \u2014 a native build on a non-WAL DB is drift (the WAL conversion is a separate attended step; do not restage over a delete-mode DB blindly)`
+        );
+      }
+    } catch (e2) {
+      if (isBindingLoadError(e2)) {
+        problems.push("better_sqlite3.node failed to load (ABI/dlopen) \u2014 run `recall install`");
+      } else {
+        problems.push(`could not read live DB journal_mode: ${e2.message}`);
+      }
+    }
+  } else {
+    try {
+      const raw2 = (0, import_node_fs16.existsSync)(localBinding) ? new import_better_sqlite33.default(":memory:", { nativeBinding: localBinding }) : new import_better_sqlite33.default(":memory:");
+      bindingLoads = true;
+      raw2.close();
+    } catch (e2) {
+      problems.push(
+        isBindingLoadError(e2) ? "better_sqlite3.node failed to load (ABI/dlopen) \u2014 run `recall install`" : `binding self-test failed: ${e2.message}`
+      );
+    }
+  }
+  return { installed, markerPresent, abiOk, pinnedNodeOk, bindingLoads, journalMode, embedCoverage, problems };
+}
+function printBinding(b3) {
+  const ok = (v2) => v2 ? "OK" : "FAIL";
+  console.log("\nSQLite binding (better-sqlite3, native WAL)");
+  console.log("------------------------------------------");
+  if (!b3.installed) {
+    console.log("  not installed \u2014 run `recall install`");
+    return;
+  }
+  console.log(`Binding loads:  ${ok(b3.bindingLoads)}`);
+  console.log(`ABI marker:     ${b3.markerPresent ? b3.abiOk ? "OK" : "MISMATCH" : "absent (wasm-era)"}`);
+  console.log(`Pinned Node:    ${b3.pinnedNodeOk === null ? "n/a" : ok(b3.pinnedNodeOk)}`);
+  console.log(`journal_mode:   ${b3.journalMode ?? "no DB yet"}${b3.journalMode && b3.journalMode !== "wal" ? "  [DRIFT]" : ""}`);
+  if (b3.embedCoverage !== null && b3.embedCoverage < 1) {
+    console.log(`Embed migration: re-embedding to v${EMBED_VERSION} (${Math.round(b3.embedCoverage * 100)}%) \u2014 semantic search stays available`);
+  }
+  if (b3.problems.length) {
+    console.log("  Issues:");
+    for (const p of b3.problems)
+      console.log(`   \u2716 ${p}`);
   }
-  return report.failures.length > 0 ? 1 : 0;
 }
 function printIntegrity(json) {
   const r2 = integrityCheck();
@@ -16156,12 +16130,19 @@ function printTable(report, embedderMode, fallbackReason) {
   if (!report.warnings.length && !report.failures.length)
     console.log("\nAll checks passed.");
 }
+var import_node_fs16, import_node_path15, import_better_sqlite33;
 var init_doctor = __esm({
   "src/installer/doctor.ts"() {
     "use strict";
+    import_node_fs16 = require("node:fs");
+    import_node_path15 = require("node:path");
+    import_better_sqlite33 = __toESM(require_lib());
     init_preflight();
     init_config();
     init_repair();
+    init_db();
+    init_paths();
+    init_embed_config();
   }
 });
 
@@ -16169,23 +16150,31 @@ var init_doctor = __esm({
 init_embedder();
 init_quantize();
 init_message_store();
+init_embed_config();
 init_log();
 var DEFAULT_LIMIT = 200;
 var FETCH_MULTIPLIER = 3;
 var RRF_K = 60;
-var DEFAULT_RECENCY_DECAY = 0.02;
 var SEMANTIC_DISCOVERY_BOOST = 1.05;
+function recencyMultiplier(decay, ageMs) {
+  if (!(decay && decay > 0))
+    return 1;
+  const ageDays = Math.max(0, ageMs) / 864e5;
+  return 1 / (1 + ageDays * decay);
+}
 async function dualPathSearch(query, opts) {
   const limit2 = opts?.limit ?? DEFAULT_LIMIT;
   const fetchLimit = limit2 * FETCH_MULTIPLIER;
   if (!query.trim())
-    return { results: [], scored: [], semanticAvailable: false, ftsCount: 0, semanticCount: 0 };
+    return { results: [], scored: [], semanticAvailable: false, ftsCount: 0, semanticCount: 0, embedCoverage: 1 };
+  const embedCoverage = getEmbedVersionStats().coverage;
+  const tolerant = embedCoverage < 0.95;
   let queryQ8 = null;
   let queryNorm = 0;
   let queryScale = 0;
   let semanticAvailable = true;
   try {
-    const queryF32 = await embed(query);
+    const queryF32 = await embed(QUERY_PREFIX + query);
     queryNorm = computeNorm(queryF32);
     const quantized = quantizeToQ8(queryF32);
     queryQ8 = quantized.q8;
@@ -16198,32 +16187,31 @@ async function dualPathSearch(query, opts) {
       summary: `Semantic path disabled \u2014 embed() failed: ${err instanceof Error ? err.message : String(err)}`
     });
   }
-  const ftsResults = searchMessagesFts(query, fetchLimit, opts?.projectId, opts?.sessionId, opts?.excludeSessionId);
+  const ftsResults = searchMessagesFts(query, fetchLimit, opts?.projectId, opts?.sessionId, opts?.excludeSessionId, opts?.skipIdf);
   const semanticResults = queryQ8 && queryNorm > 0 ? searchMessagesSemantic(queryQ8, queryNorm, queryScale, {
     limit: fetchLimit,
     projectId: opts?.projectId,
     sessionId: opts?.sessionId,
-    excludeSessionId: opts?.excludeSessionId
+    excludeSessionId: opts?.excludeSessionId,
+    tolerant
   }) : [];
   log({
     source: "recall:dual-path",
     level: semanticAvailable ? "info" : "warn",
     summary: `FTS5: ${ftsResults.length} results, Semantic: ${semanticResults.length} results${!semanticAvailable ? " (UNAVAILABLE \u2014 embed failed)" : ""}`
   });
-  const decay = opts?.recencyDecay ?? DEFAULT_RECENCY_DECAY;
+  const decay = opts?.recencyDecay;
   const now = Date.now();
   const rrfScores = /* @__PURE__ */ new Map();
   for (let i = 0; i < ftsResults.length; i++) {
     const r2 = ftsResults[i];
-    const ageDays = (now - r2.created_at) / 864e5;
-    const recency = 1 / (1 + ageDays * decay);
+    const recency = recencyMultiplier(decay, now - r2.created_at);
     rrfScores.set(r2.message_id, { result: r2, score: 1 / (RRF_K + i) * recency, paths: ["fts5"] });
   }
   const ftsSessionIdSet = new Set(ftsResults.map((r2) => r2.session_id));
   for (let i = 0; i < semanticResults.length; i++) {
     const r2 = semanticResults[i];
-    const ageDays = (now - r2.created_at) / 864e5;
-    const recency = 1 / (1 + ageDays * decay);
+    const recency = recencyMultiplier(decay, now - r2.created_at);
     const rrfScore = 1 / (RRF_K + i) * recency;
     const existing = rrfScores.get(r2.message_id);
     if (existing) {
@@ -16246,7 +16234,8 @@ async function dualPathSearch(query, opts) {
     // full list with RRF scores — groupBySession uses for gap detection
     semanticAvailable,
     ftsCount: ftsResults.length,
-    semanticCount: semanticResults.length
+    semanticCount: semanticResults.length,
+    embedCoverage
   };
 }
 
@@ -16307,9 +16296,451 @@ init_url_path_resolver();
 init_mtime_scan();
 init_catchup();
 init_paths();
-var import_node_fs15 = require("node:fs");
-var import_node_child_process4 = require("node:child_process");
-var import_node_path14 = require("node:path");
+
+// src/git-attribution.ts
+var fs4 = __toESM(require("node:fs"));
+var path3 = __toESM(require("node:path"));
+var os2 = __toESM(require("node:os"));
+var import_node_child_process2 = require("node:child_process");
+
+// src/adapters/claude/transcript-edits.ts
+var fs3 = __toESM(require("node:fs"));
+var readline = __toESM(require("node:readline"));
+async function extractSessionEdits(filePath, opts = {}) {
+  const sessionId = sessionIdFromPath3(filePath);
+  const edits = [];
+  let firstTs = Infinity;
+  let lastTs = -Infinity;
+  let skippedLines = 0;
+  let skippedEvents = 0;
+  const stream2 = fs3.createReadStream(filePath, { encoding: "utf8" });
+  const rl = readline.createInterface({ input: stream2, crlfDelay: Infinity });
+  const pushEdit = (fp, cnt, ts) => {
+    if (typeof fp !== "string" || typeof cnt !== "string")
+      return;
+    edits.push({ file: normalizePath2(fp, opts.repoRoot), content: cnt, ts });
+    if (ts < firstTs)
+      firstTs = ts;
+    if (ts > lastTs)
+      lastTs = ts;
+  };
+  for await (const line of rl) {
+    if (!line.trim())
+      continue;
+    let evt;
+    try {
+      evt = JSON.parse(line);
+    } catch {
+      skippedLines++;
+      continue;
+    }
+    if (!isAssistantEvent(evt))
+      continue;
+    const ts = parseTimestamp(evt);
+    if (!Number.isFinite(ts)) {
+      skippedEvents++;
+      continue;
+    }
+    for (const block of evt.message.content) {
+      if (!isToolUseBlock(block))
+        continue;
+      const input = block.input;
+      if (block.name === "Edit") {
+        pushEdit(input.file_path, input.new_string, ts);
+      } else if (block.name === "Write") {
+        pushEdit(input.file_path, input.content, ts);
+      } else if (block.name === "MultiEdit") {
+        const fp = input.file_path;
+        const edArr = input.edits;
+        if (Array.isArray(edArr)) {
+          for (const e2 of edArr) {
+            if (e2 && typeof e2 === "object") {
+              pushEdit(fp, e2.new_string, ts);
+            }
+          }
+        }
+      }
+    }
+  }
+  return { sessionId, edits, firstTs, lastTs, skippedLines, skippedEvents };
+}
+function sessionIdFromPath3(filePath) {
+  const base = filePath.replace(/^.*[\\/]/, "");
+  return base.endsWith(".jsonl") ? base.slice(0, -".jsonl".length) : base;
+}
+function isAssistantEvent(evt) {
+  if (!evt || typeof evt !== "object")
+    return false;
+  const e2 = evt;
+  if (e2.type !== "assistant")
+    return false;
+  const m2 = e2.message;
+  return !!m2 && Array.isArray(m2.content);
+}
+function isToolUseBlock(block) {
+  if (!block || typeof block !== "object")
+    return false;
+  const b3 = block;
+  if (b3.type !== "tool_use")
+    return false;
+  if (typeof b3.name !== "string")
+    return false;
+  if (b3.input && typeof b3.input !== "object")
+    return false;
+  return true;
+}
+function parseTimestamp(evt) {
+  if (typeof evt.timestamp !== "string")
+    return NaN;
+  return new Date(evt.timestamp).getTime();
+}
+function normalizePath2(p, repoRoot) {
+  if (!repoRoot)
+    return p;
+  const prefix = repoRoot.endsWith("/") ? repoRoot : repoRoot + "/";
+  if (p.startsWith(prefix))
+    return p.slice(prefix.length);
+  if (p === repoRoot)
+    return "";
+  return p;
+}
+
+// src/git-attribution.ts
+init_log();
+function parseBlameSpec(s) {
+  const lastColon = s.lastIndexOf(":");
+  if (lastColon < 0)
+    return { path: s };
+  const tail = s.slice(lastColon + 1);
+  const m2 = tail.match(/^(\d+)(?:-(\d+))?$/);
+  if (!m2)
+    return { path: s };
+  const lineStart = parseInt(m2[1], 10);
+  const lineEnd = m2[2] !== void 0 ? parseInt(m2[2], 10) : lineStart;
+  return { path: s.slice(0, lastColon), lineStart, lineEnd };
+}
+async function findSessionsForCommit(commitHash, opts) {
+  const info = getCommitInfo(opts.repoRoot, commitHash);
+  return matchCommit(info, opts, /* @__PURE__ */ new Map());
+}
+async function findSessionsForBlame(specs, opts) {
+  if (specs.length === 0)
+    return [];
+  const commitSet = /* @__PURE__ */ new Set();
+  for (const spec of specs) {
+    for (const h2 of blameCommits(opts.repoRoot, spec)) {
+      commitSet.add(h2);
+    }
+  }
+  const commitFileTriCache = /* @__PURE__ */ new Map();
+  const all = [];
+  for (const h2 of commitSet) {
+    let info;
+    try {
+      info = getCommitInfo(opts.repoRoot, h2);
+    } catch (err) {
+      log({
+        source: "git-attribution",
+        level: "warn",
+        summary: `failed to read commit ${h2}`,
+        data: { error: String(err) }
+      });
+      continue;
+    }
+    const ms = await matchCommit(info, opts, commitFileTriCache);
+    for (const m2 of ms)
+      all.push(m2);
+  }
+  all.sort((a3, b3) => Date.parse(a3.last_edit_at) - Date.parse(b3.last_edit_at));
+  if (opts.limit && opts.limit > 0 && all.length > opts.limit) {
+    return all.slice(-opts.limit);
+  }
+  return all;
+}
+function getCommitInfo(repoRoot, hash) {
+  const meta = git(repoRoot, ["show", "--pretty=format:%H%n%aI", "--name-only", hash]).trim().split("\n");
+  const fullHash = meta[0] ?? hash;
+  const commitTime = meta[1] ? Date.parse(meta[1]) : 0;
+  const files = meta.slice(2).filter((f3) => f3.length > 0);
+  const parentRaw = gitSafe(repoRoot, ["log", "-1", "--pretty=format:%aI", `${hash}^`]);
+  const parentTime = parentRaw ? Date.parse(parentRaw.trim()) : 0;
+  const diff = git(repoRoot, ["show", "-U0", hash]);
+  const added = /* @__PURE__ */ new Map();
+  const removed = /* @__PURE__ */ new Map();
+  let curFile = null;
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("diff --git")) {
+      curFile = null;
+      continue;
+    }
+    if (line.startsWith("+++ b/")) {
+      curFile = line.slice(6);
+      if (!added.has(curFile))
+        added.set(curFile, []);
+      if (!removed.has(curFile))
+        removed.set(curFile, []);
+      continue;
+    }
+    if (line.startsWith("--- ") || line.startsWith("+++ "))
+      continue;
+    if (line.startsWith("@@"))
+      continue;
+    if (!curFile)
+      continue;
+    if (line.startsWith("+"))
+      added.get(curFile).push(line.slice(1));
+    else if (line.startsWith("-"))
+      removed.get(curFile).push(line.slice(1));
+  }
+  return { hash: fullHash, commitTime, parentTime, files, addedLines: added, removedLines: removed };
+}
+function cwdToProjectSlug(cwd) {
+  return cwd.replace(/[^a-zA-Z0-9]/g, "-");
+}
+function cwdToProjectSlugNarrow(cwd) {
+  return cwd.replace(/[:\/\\]/g, "-");
+}
+function defaultSessionsDir(repoRoot) {
+  const claudeRoot = process.env["CLAUDE_CONFIG_DIR"] ?? path3.join(os2.homedir(), ".claude");
+  const broad = path3.join(claudeRoot, "projects", cwdToProjectSlug(repoRoot));
+  if (fs4.existsSync(broad))
+    return broad;
+  const narrow = path3.join(claudeRoot, "projects", cwdToProjectSlugNarrow(repoRoot));
+  if (fs4.existsSync(narrow))
+    return narrow;
+  return broad;
+}
+async function matchCommit(info, opts, commitFileTriCache) {
+  const commitFiles = new Set(info.files);
+  const windowAfterMs = opts.windowAfterMs ?? 60 * 60 * 1e3;
+  const lower = info.parentTime;
+  const upper = info.commitTime + windowAfterMs;
+  const sessionsDir = opts.sessionsDir ?? defaultSessionsDir(opts.repoRoot);
+  if (!fs4.existsSync(sessionsDir)) {
+    log({
+      source: "git-attribution",
+      level: "warn",
+      summary: `sessions dir not found: ${sessionsDir}`
+    });
+    return [];
+  }
+  const candidates = collectCandidates(sessionsDir, lower, info.commitTime);
+  const addedTriByFile = /* @__PURE__ */ new Map();
+  for (const [file, lines] of info.addedLines) {
+    addedTriByFile.set(file, triGrams(lines));
+  }
+  const matches = [];
+  for (const cand of candidates) {
+    let trace;
+    try {
+      trace = await extractSessionEdits(cand.jsonlPath, { repoRoot: opts.repoRoot });
+    } catch (err) {
+      log({
+        source: "git-attribution",
+        level: "debug",
+        summary: `extractSessionEdits failed for ${cand.jsonlPath}`,
+        data: { error: String(err) }
+      });
+      continue;
+    }
+    if (trace.skippedLines > 0 || trace.skippedEvents > 0) {
+      log({
+        source: "git-attribution",
+        level: "debug",
+        summary: `skipped content in ${cand.jsonlPath}`,
+        data: { skippedLines: trace.skippedLines, skippedEvents: trace.skippedEvents }
+      });
+    }
+    if (trace.edits.length === 0)
+      continue;
+    const inWindow = trace.edits.filter((e2) => e2.ts >= lower && e2.ts <= upper);
+    if (inWindow.length === 0)
+      continue;
+    const touchedFiles = new Set(inWindow.map((e2) => e2.file).filter((f3) => commitFiles.has(f3)));
+    if (touchedFiles.size === 0)
+      continue;
+    const sessionTriByFile = /* @__PURE__ */ new Map();
+    for (const e2 of inWindow) {
+      if (!commitFiles.has(e2.file))
+        continue;
+      let bucket = sessionTriByFile.get(e2.file);
+      if (!bucket) {
+        bucket = /* @__PURE__ */ new Set();
+        sessionTriByFile.set(e2.file, bucket);
+      }
+      for (const t of triGrams(e2.content.split("\n")))
+        bucket.add(t);
+    }
+    if (sessionTriByFile.size === 0)
+      continue;
+    let contentHits = 0;
+    for (const [file, sessTri] of sessionTriByFile) {
+      const add = addedTriByFile.get(file);
+      if (!add)
+        continue;
+      for (const t of sessTri) {
+        if (add.has(t))
+          contentHits++;
+      }
+    }
+    if (contentHits === 0)
+      continue;
+    let survivingHits = 0;
+    let totalTris = 0;
+    for (const [file, sessTri] of sessionTriByFile) {
+      const commitTri = lookupCommitFileTri(opts.repoRoot, info.hash, file, commitFileTriCache);
+      totalTris += sessTri.size;
+      for (const t of sessTri) {
+        if (commitTri.has(t))
+          survivingHits++;
+      }
+    }
+    const ratio = totalTris === 0 ? 0 : survivingHits / totalTris;
+    const lastEditTs = inWindow.reduce((m2, e2) => e2.ts > m2 ? e2.ts : m2, -Infinity);
+    matches.push({
+      session: trace.sessionId,
+      parent_session_id: cand.parentSessionId,
+      agent_type: cand.agentType,
+      commit: info.hash,
+      matched_files: [...touchedFiles],
+      content_hits: contentHits,
+      edit_count: inWindow.length,
+      last_edit_at: new Date(lastEditTs).toISOString(),
+      surviving_in_commit: ratio >= 0.5,
+      surviving_ratio: Math.round(ratio * 100) / 100
+    });
+  }
+  matches.sort((a3, b3) => Date.parse(a3.last_edit_at) - Date.parse(b3.last_edit_at));
+  return matches;
+}
+function collectCandidates(sessionsDir, lower, commitTime) {
+  const mtimeLower = lower - 6e4;
+  const mtimeUpper = commitTime + 24 * 60 * 60 * 1e3;
+  const inWindow = (p) => {
+    let stat;
+    try {
+      stat = fs4.statSync(p);
+    } catch {
+      return false;
+    }
+    if (stat.mtimeMs < mtimeLower)
+      return false;
+    if (stat.mtimeMs > mtimeUpper)
+      return false;
+    return true;
+  };
+  const out = [];
+  let entries;
+  try {
+    entries = fs4.readdirSync(sessionsDir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const ent of entries) {
+    if (ent.isFile() && ent.name.endsWith(".jsonl")) {
+      const full = path3.join(sessionsDir, ent.name);
+      if (inWindow(full)) {
+        out.push({ jsonlPath: full, parentSessionId: null, agentType: null });
+      }
+      continue;
+    }
+    if (!ent.isDirectory())
+      continue;
+    const parentDir = path3.join(sessionsDir, ent.name);
+    const subDir = path3.join(parentDir, "subagents");
+    let subEntries;
+    try {
+      subEntries = fs4.readdirSync(subDir);
+    } catch {
+      continue;
+    }
+    for (const sub of subEntries) {
+      if (!sub.endsWith(".jsonl"))
+        continue;
+      const full = path3.join(subDir, sub);
+      if (!inWindow(full))
+        continue;
+      const metaPath = path3.join(subDir, sub.slice(0, -".jsonl".length) + ".meta.json");
+      let agentType = null;
+      try {
+        const raw2 = fs4.readFileSync(metaPath, "utf8");
+        const meta = JSON.parse(raw2);
+        if (typeof meta.agentType === "string")
+          agentType = meta.agentType;
+      } catch {
+      }
+      out.push({ jsonlPath: full, parentSessionId: ent.name, agentType });
+    }
+  }
+  return out;
+}
+function lookupCommitFileTri(repoRoot, commit, file, cache) {
+  const key = `${commit}:${file}`;
+  const hit = cache.get(key);
+  if (hit)
+    return hit;
+  const raw2 = gitSafe(repoRoot, ["show", `${commit}:${file}`]);
+  const tri = raw2 ? triGrams(raw2.split("\n")) : /* @__PURE__ */ new Set();
+  cache.set(key, tri);
+  return tri;
+}
+function triGrams(lines) {
+  const nonBlank = [];
+  for (const l2 of lines) {
+    const t = normalizeWs(l2).trim();
+    if (t.length > 0)
+      nonBlank.push(t);
+  }
+  const out = /* @__PURE__ */ new Set();
+  for (let i = 0; i + 3 <= nonBlank.length; i++) {
+    out.add(nonBlank[i] + "\n" + nonBlank[i + 1] + "\n" + nonBlank[i + 2]);
+  }
+  return out;
+}
+function normalizeWs(s) {
+  return s.replace(/[ \t]+/g, " ").replace(/[ \t]+$/g, "");
+}
+function blameCommits(repoRoot, spec) {
+  const args = ["blame", "--porcelain"];
+  if (spec.lineStart !== void 0) {
+    const end = spec.lineEnd ?? spec.lineStart;
+    if (end < spec.lineStart) {
+      throw new Error(`blame range end (${end}) is before start (${spec.lineStart})`);
+    }
+    args.push("-L", `${spec.lineStart},${end}`);
+  }
+  args.push("--", spec.path);
+  const out = gitSafe(repoRoot, args);
+  const hashes = /* @__PURE__ */ new Set();
+  if (!out)
+    return hashes;
+  for (const line of out.split("\n")) {
+    const m2 = line.match(/^([0-9a-f]{40}) \d+ \d+/);
+    if (m2 && m2[1] !== "0".repeat(40))
+      hashes.add(m2[1]);
+  }
+  return hashes;
+}
+function git(repoRoot, args) {
+  return (0, import_node_child_process2.execFileSync)("git", args, {
+    cwd: repoRoot,
+    encoding: "utf8",
+    maxBuffer: 64 * 1024 * 1024,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+}
+function gitSafe(repoRoot, args) {
+  try {
+    return git(repoRoot, args);
+  } catch {
+    return null;
+  }
+}
+
+// src/cli/recall.ts
+var import_node_fs17 = require("node:fs");
+var import_node_child_process5 = require("node:child_process");
+var import_node_path16 = require("node:path");
 var UUID_PREFIX = /^[0-9a-f]{8}/i;
 var argv = process.argv.slice(2);
 function hasFlag(name) {
@@ -16329,6 +16760,8 @@ function flagInt(name, fallback) {
   return Number.isNaN(n) ? fallback : n;
 }
 var raw = hasFlag("--raw");
+var rawMessages = hasFlag("--raw-messages");
+var noIdf = hasFlag("--no-idf");
 var showHelp = hasFlag("--help") || hasFlag("-h");
 var showVersion = hasFlag("--version") || hasFlag("-v");
 var listMode = hasFlag("--list");
@@ -16340,6 +16773,8 @@ var projectFlag = flagValue("--project");
 var allProjects = hasFlag("--all");
 var reverse = hasFlag("--reverse");
 var recent = hasFlag("--recent");
+var commitFlag = flagValue("--commit");
+var blameMode = hasFlag("--blame");
 var ExitSignal = class extends Error {
   constructor(code) {
     super(`exit:${code}`);
@@ -16351,9 +16786,11 @@ function exit(code) {
   throw new ExitSignal(code);
 }
 var effectiveProject = allProjects ? void 0 : normalizePath(projectFlag ?? process.cwd());
-var FLAG_WITH_VALUE = /* @__PURE__ */ new Set(["--limit", "--offset", "--since", "--until", "--project", "--vendor"]);
+var FLAG_WITH_VALUE = /* @__PURE__ */ new Set(["--limit", "--offset", "--since", "--until", "--project", "--vendor", "--commit"]);
 var FLAG_BOOLEAN = /* @__PURE__ */ new Set([
   "--raw",
+  "--raw-messages",
+  "--no-idf",
   "--help",
   "-h",
   "--version",
@@ -16362,6 +16799,7 @@ var FLAG_BOOLEAN = /* @__PURE__ */ new Set([
   "--all",
   "--reverse",
   "--recent",
+  "--blame",
   "--no-catchup",
   "--auto-embed",
   "--detach",
@@ -16392,7 +16830,7 @@ for (let i = 0; i < argv.length; i++) {
 function getVersion() {
   try {
     const pkg = JSON.parse(
-      (0, import_node_fs15.readFileSync)((0, import_node_path14.join)(__dirname, "..", "package.json"), "utf8")
+      (0, import_node_fs17.readFileSync)((0, import_node_path16.join)(__dirname, "..", "package.json"), "utf8")
     );
     return pkg.version ?? "unknown";
   } catch {
@@ -16408,6 +16846,9 @@ USAGE
   recall <session-id>                Read messages from a session
   recall <session-id> <message-id>   Read centered on matched message
   recall --list                      List recent sessions
+  recall --commit <hash>             Sessions that produced a commit
+  recall --blame <path>[:<line>[-<line>]]...  Sessions responsible for a file
+                                     or a specific line/range (via git blame)
   recall backfill [flags]            Catch up FTS5 + embeddings against transcript files
 
 ARGUMENTS
@@ -16425,7 +16866,15 @@ FLAGS
   --recent         Strongly boost recent sessions in search ranking
   --reverse        Read session messages newest-first (default: oldest-first)
   --raw            Output raw JSON instead of formatted tables
+  --raw-messages   Output the FULL pre-shaping per-message ranked list as JSON
+                   (bypasses score-gap cutoff, session-dedup, and pagination);
+                   for per-turn retrieval scoring. Honors --limit as the top-k.
+  --no-idf         Bypass the FTS5 IDF high-frequency-term filter (keeps
+                   common-but-meaningful terms like when/before/after)
   --list           List sessions mode
+  --commit HASH    Sessions that produced the given commit (git attribution)
+  --blame SPEC...  Sessions responsible for a file or line range at HEAD; takes
+                   one or more <path>[:<line>[-<line>]] specs (via git blame)
   --no-catchup     Skip the per-invocation mtime catch-up scan (T1)
   --help, -h       Show this help
   --version, -v    Print the recall version
@@ -16450,6 +16899,18 @@ EXAMPLES
   recall a1b2c3d4 e5f6a7b8
   recall a1b2c3d4 --reverse
   recall --list --since 2026-04-10 --until 2026-04-10
+  recall --commit 25dd0f8
+  recall --blame src/paths.ts:82-84
+  recall --blame src/foo.ts:42 src/bar.ts:10-20 --limit 20
+
+COMMIT ATTRIBUTION (--commit / --blame)
+  Returns the session(s) whose Edit/Write/MultiEdit tool calls structurally
+  match each commit's diff. Sessions are listed chronologically (oldest first).
+  The most recent is usually the load-bearing edit for current code; earlier
+  sessions show evolution and may reveal originating intent or rejected
+  approaches. --blame runs git blame to find the commits responsible for the
+  current file (or line range) at HEAD, then attributes each. --limit (with
+  --blame) caps the number of returned matches.
 `.trim());
 }
 function initDb() {
@@ -16667,7 +17128,9 @@ async function runSearch(query) {
   const r2 = await dualPathSearch(query, {
     limit: ceiling,
     projectId: effectiveProject,
+    ...noIdf ? { skipIdf: true } : {},
     ...recent ? { recencyDecay: 0.1 } : {}
+    // default is off; --recent opts into absolute age decay
   });
   let { scored } = r2;
   if (since) {
@@ -16694,6 +17157,28 @@ async function runSearch(query) {
       exit(1);
     }
   }
+  if (rawMessages) {
+    const top = scored.slice(0, ceiling);
+    console.log(JSON.stringify({
+      query,
+      no_idf: noIdf,
+      semantic_available: r2.semanticAvailable,
+      semantic_count: r2.semanticCount,
+      fts_count: r2.ftsCount,
+      embed_coverage: r2.embedCoverage,
+      total: top.length,
+      messages: top.map((x3, i) => ({
+        rank: i + 1,
+        session_id: x3.result.session_id,
+        message_id: x3.result.message_id,
+        message_seq: x3.result.message_seq,
+        score: x3.score,
+        snippet: (x3.result.match_snippet || x3.result.message_preview || "").slice(0, 200).replace(/\n/g, " "),
+        tag: x3.paths.includes("fts5") && x3.paths.includes("semantic") ? "FTS5+SEMANTIC" : x3.paths.includes("semantic") ? "SEMANTIC-ONLY" : "FTS5-ONLY"
+      }))
+    }, null, 2));
+    return;
+  }
   let cutoffIdx = scored.length;
   if (scored.length > 10) {
     let maxDrop = 0;
@@ -16771,6 +17256,7 @@ async function runSearch(query) {
       fts_count: r2.ftsCount,
       semantic_count: r2.semanticCount,
       semantic_available: r2.semanticAvailable,
+      embed_coverage: r2.embedCoverage,
       unique_sessions: totalSessions,
       showing_offset: pageStart,
       showing_count: page.length,
@@ -16780,7 +17266,8 @@ async function runSearch(query) {
   } else {
     console.log(`Query: "${query}"`);
     console.log(`Results: ${trimmed.length} messages, ${totalSessions} unique sessions (showing ${pageStart + 1}-${pageEnd})`);
-    console.log(`Paths: FTS5=${r2.ftsCount}  Semantic=${r2.semanticCount} (${r2.semanticAvailable ? "active" : "UNAVAILABLE"})`);
+    const migrating = r2.embedCoverage < 0.95 ? `  (migrating: ${Math.round(r2.embedCoverage * 100)}% re-embedded)` : "";
+    console.log(`Paths: FTS5=${r2.ftsCount}  Semantic=${r2.semanticCount} (${r2.semanticAvailable ? "active" : "UNAVAILABLE"})${migrating}`);
     if (cutoffIdx < scored.length) {
       console.log(`Cutoff: position ${cutoffIdx} of ${scored.length} (score gap detected)`);
     }
@@ -16805,6 +17292,102 @@ async function runSearch(query) {
     }
   }
 }
+function blamePositionals() {
+  const idx = argv.indexOf("--blame");
+  if (idx < 0)
+    return [];
+  const out = [];
+  for (let i = idx + 1; i < argv.length; i++) {
+    const a3 = argv[i];
+    if (a3.startsWith("--"))
+      break;
+    out.push(a3);
+  }
+  return out;
+}
+function printCommitAttribution(query, matches) {
+  const note = "Sessions are listed chronologically (oldest first). The most recent is usually the load-bearing one for current code; earlier sessions show evolution and may reveal originating intent or rejected approaches.";
+  if (raw) {
+    console.log(JSON.stringify({
+      query,
+      note,
+      count: matches.length,
+      matches
+    }, null, 2));
+    return;
+  }
+  console.log(`Query: ${query}`);
+  console.log(`Matches: ${matches.length}`);
+  console.log(`Note: ${note}`);
+  console.log("---");
+  if (matches.length === 0) {
+    console.log("No sessions matched.");
+    return;
+  }
+  const sessLabels = matches.map(
+    (m2) => m2.parent_session_id ? `${m2.session} \u21B3` : m2.session
+  );
+  const sessW = Math.max("Session".length, ...sessLabels.map((s) => s.length));
+  const commitW = 12;
+  const hitsW = 6;
+  const survW = 5;
+  const ratioW = 6;
+  const dateW = 19;
+  const GAP = "  ";
+  const header = "Session".padEnd(sessW) + GAP + "Commit".padEnd(commitW) + GAP + "Hits".padStart(hitsW) + GAP + "Surv?".padEnd(survW) + GAP + "Ratio".padStart(ratioW) + GAP + "Last edit".padEnd(dateW) + GAP + "Files";
+  console.log(header);
+  console.log("-".repeat(header.length));
+  matches.forEach((m2, i) => {
+    const date = m2.last_edit_at.slice(0, 19).replace("T", " ");
+    console.log(
+      sessLabels[i].padEnd(sessW) + GAP + m2.commit.slice(0, 10).padEnd(commitW) + GAP + String(m2.content_hits).padStart(hitsW) + GAP + (m2.surviving_in_commit ? "yes" : "no").padEnd(survW) + GAP + String(m2.surviving_ratio).padStart(ratioW) + GAP + date.padEnd(dateW) + GAP + m2.matched_files.join(", ")
+    );
+    if (m2.parent_session_id) {
+      console.log(
+        " ".repeat(2) + `(subagent of ${m2.parent_session_id.slice(0, 8)}${m2.agent_type ? `, type=${m2.agent_type}` : ""})`
+      );
+    }
+  });
+}
+async function runCommitAttribution() {
+  const repoRoot = projectFlag ?? process.cwd();
+  if (hasFlag("--commit")) {
+    if (commitFlag === void 0 || commitFlag.startsWith("--")) {
+      console.error("--commit requires a commit hash. Use --help for usage.");
+      exit(1);
+    }
+    let matches2;
+    try {
+      matches2 = await findSessionsForCommit(commitFlag, { repoRoot });
+    } catch (err) {
+      console.error(`recall --commit: git failed for "${commitFlag}" in ${repoRoot}: ${gitErrLine(err)}`);
+      exit(1);
+    }
+    printCommitAttribution(`--commit ${commitFlag}`, matches2);
+    return;
+  }
+  const rawSpecs = blamePositionals();
+  if (rawSpecs.length === 0) {
+    console.error("--blame requires at least one path or path:line[-line] spec. Use --help for usage.");
+    exit(1);
+  }
+  const specs = rawSpecs.map(parseBlameSpec);
+  const matchLimit = limit > 0 ? limit : void 0;
+  let matches;
+  try {
+    matches = await findSessionsForBlame(specs, { repoRoot, ...matchLimit !== void 0 ? { limit: matchLimit } : {} });
+  } catch (err) {
+    console.error(`recall --blame: ${gitErrLine(err)}`);
+    exit(1);
+  }
+  printCommitAttribution(`--blame ${rawSpecs.join(" ")}`, matches);
+}
+function gitErrLine(err) {
+  const stderr = err.stderr;
+  if (typeof stderr === "string" && stderr.trim())
+    return stderr.trim().split("\n")[0];
+  return err instanceof Error ? err.message.split("\n")[0] : String(err);
+}
 function parseVendors() {
   const v2 = flagValue("--vendor");
   if (!v2)
@@ -16823,22 +17406,22 @@ async function runBackfill() {
   clearCancelFlag();
   const detach = hasFlag("--detach");
   if (detach) {
-    (0, import_node_fs15.mkdirSync)(logsDir(), { recursive: true });
-    (0, import_node_fs15.mkdirSync)(runDir(), { recursive: true });
-    const logPath = (0, import_node_path14.join)(logsDir(), "backfill.log");
-    const logFd = (0, import_node_fs15.openSync)(logPath, "a");
+    (0, import_node_fs17.mkdirSync)(logsDir(), { recursive: true });
+    (0, import_node_fs17.mkdirSync)(runDir(), { recursive: true });
+    const logPath = (0, import_node_path16.join)(logsDir(), "backfill.log");
+    const logFd = (0, import_node_fs17.openSync)(logPath, "a");
     const args = [process.argv[1], "backfill", "--auto-embed"];
     const vendors2 = parseVendors();
     if (vendors2) {
       args.push("--vendor", vendors2[0]);
     }
-    const child = (0, import_node_child_process4.spawn)(process.execPath, args, {
+    const child = (0, import_node_child_process5.spawn)(process.execPath, args, {
       detached: true,
       stdio: ["ignore", logFd, logFd],
       windowsHide: true
     });
     if (child.pid !== void 0) {
-      (0, import_node_fs15.writeFileSync)((0, import_node_path14.join)(runDir(), "backfill.pid"), String(child.pid));
+      (0, import_node_fs17.writeFileSync)((0, import_node_path16.join)(runDir(), "backfill.pid"), String(child.pid));
     }
     child.unref();
     process.stderr.write(`[recall] backfill detached (pid=${child.pid}, log=${logPath})
@@ -16940,6 +17523,10 @@ async function main() {
     printHelp();
     exit(0);
   }
+  if (hasFlag("--commit") || blameMode) {
+    await runCommitAttribution();
+    exit(0);
+  }
   if (positional[0] === "backfill") {
     await runBackfill();
     exit(0);