crispy-recall 0.1.0

package/dist/stop-hook.js

@@ -0,0 +1,2785 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/log.ts
+function log(entry) {
+  if (LEVEL_ORDER[entry.level] < _threshold)
+    return;
+  const line = `[${entry.level}] ${entry.source}: ${entry.summary}`;
+  if (entry.data !== void 0) {
+    try {
+      process.stderr.write(`${line} ${JSON.stringify(entry.data)}
+`);
+    } catch {
+      process.stderr.write(`${line}
+`);
+    }
+  } else {
+    process.stderr.write(`${line}
+`);
+  }
+}
+var LEVEL_ORDER, _rawEnvLevel, _thresholdLevel, _threshold;
+var init_log = __esm({
+  "src/log.ts"() {
+    "use strict";
+    LEVEL_ORDER = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3
+    };
+    _rawEnvLevel = process.env["RECALL_LOG_LEVEL"]?.toLowerCase();
+    _thresholdLevel = _rawEnvLevel === "debug" || _rawEnvLevel === "info" || _rawEnvLevel === "warn" || _rawEnvLevel === "error" ? _rawEnvLevel : "info";
+    _threshold = LEVEL_ORDER[_thresholdLevel];
+  }
+});
+
+// node_modules/node-sqlite3-wasm/dist/node-sqlite3-wasm.js
+var require_node_sqlite3_wasm = __commonJS({
+  "node_modules/node-sqlite3-wasm/dist/node-sqlite3-wasm.js"(exports2, module2) {
+    var Module = typeof Module != "undefined" ? Module : {};
+    var ENVIRONMENT_IS_NODE = true;
+    var INT32_MIN = -2147483648;
+    var INT32_MAX = 2147483647;
+    var NULL = 0;
+    var SQLITE_OK = 0;
+    var SQLITE_ROW = 100;
+    var SQLITE_DONE = 101;
+    var SQLITE_INTEGER = 1;
+    var SQLITE_FLOAT = 2;
+    var SQLITE_TEXT = 3;
+    var SQLITE_BLOB = 4;
+    var SQLITE_NULL = 5;
+    var SQLITE_UTF8 = 1;
+    var SQLITE_TRANSIENT = -1;
+    var SQLITE_DETERMINISTIC = 2048;
+    var temp;
+    var sqlite3 = {};
+    Module.onRuntimeInitialized = () => {
+      temp = stackAlloc(4);
+      const v = null;
+      const n = "number";
+      const s = "string";
+      const n1 = [n];
+      const n2 = [n, ...n1];
+      const n3 = [n, ...n2];
+      const n4 = [n, ...n3];
+      const n5 = [n, ...n4];
+      const signatures = { open_v2: [n, [s, n, n, s]], exec: [n, n5], errmsg: [s, n1], prepare_v2: [n, n5], close_v2: [n, n1], finalize: [n, n1], reset: [n, n1], clear_bindings: [n, n1], bind_int: [n, n3], bind_int64: [n, n3], bind_double: [n, n3], bind_text: [n, n5], bind_blob: [n, n5], bind_blob64: [n, n5], bind_null: [n, n2], bind_parameter_index: [n, [n, s]], step: [n, n1], column_int64: [n, n2], column_double: [n, n2], column_text: [s, n2], column_blob: [n, n2], column_type: [n, n2], column_name: [s, n2], column_count: [n, n1], column_bytes: [n, n2], last_insert_rowid: [n, n1], changes: [n, n1], create_function_v2: [n, [n, s, n, n, n, n, n, n, n]], value_type: [n, n1], value_text: [s, n1], value_blob: [n, n1], value_int64: [n, n1], value_double: [n, n1], value_bytes: [n, n1], result_double: [v, n2], result_null: [v, n1], result_text: [v, n4], result_blob: [v, n4], result_blob64: [v, n4], result_int: [v, n2], result_int64: [v, n2], result_error: [v, n3], column_table_name: [s, n2], get_autocommit: [n, n1] };
+      for (const [name, sig] of Object.entries(signatures)) {
+        sqlite3[name] = cwrap(`sqlite3_${name}`, sig[0], sig[1]);
+      }
+    };
+    var SQLite3Error = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "SQLite3Error";
+      }
+    };
+    function arrayToHeap(array) {
+      const ptr = _malloc(array.byteLength);
+      HEAPU8.set(array, ptr);
+      return ptr;
+    }
+    function stringToHeap(str) {
+      const size = lengthBytesUTF8(str) + 1;
+      const ptr = _malloc(size);
+      stringToUTF8(str, ptr, size);
+      return ptr;
+    }
+    function toNumberOrNot(bigInt) {
+      if (bigInt >= Number.MIN_SAFE_INTEGER && bigInt <= Number.MAX_SAFE_INTEGER) {
+        return Number(bigInt);
+      }
+      return bigInt;
+    }
+    function parseFunctionArguments(argc, argv) {
+      const args = [];
+      for (let i = 0; i < argc; i++) {
+        const ptr = getValue(argv + 4 * i, "i32");
+        const type = sqlite3.value_type(ptr);
+        let arg;
+        switch (type) {
+          case SQLITE_INTEGER:
+            arg = toNumberOrNot(sqlite3.value_int64(ptr));
+            break;
+          case SQLITE_FLOAT:
+            arg = sqlite3.value_double(ptr);
+            break;
+          case SQLITE_TEXT:
+            arg = sqlite3.value_text(ptr);
+            break;
+          case SQLITE_BLOB:
+            const p = sqlite3.value_blob(ptr);
+            if (p != NULL) {
+              arg = HEAPU8.slice(p, p + sqlite3.value_bytes(ptr));
+            } else {
+              arg = new Uint8Array();
+            }
+            break;
+          case SQLITE_NULL:
+            arg = null;
+            break;
+        }
+        args.push(arg);
+      }
+      return args;
+    }
+    function setFunctionResult(cx, result) {
+      switch (typeof result) {
+        case "boolean":
+          sqlite3.result_int(cx, result ? 1 : 0);
+          break;
+        case "number":
+          if (Number.isSafeInteger(result)) {
+            if (result >= INT32_MIN && result <= INT32_MAX) {
+              sqlite3.result_int(cx, result);
+            } else {
+              sqlite3.result_int64(cx, BigInt(result));
+            }
+          } else {
+            sqlite3.result_double(cx, result);
+          }
+          break;
+        case "bigint":
+          sqlite3.result_int64(cx, result);
+          break;
+        case "string":
+          const tempPtr = stringToHeap(result);
+          sqlite3.result_text(cx, tempPtr, -1, SQLITE_TRANSIENT);
+          _free(tempPtr);
+          break;
+        case "object":
+          if (result === null) {
+            sqlite3.result_null(cx);
+          } else if (result instanceof Uint8Array) {
+            const tempPtr2 = arrayToHeap(result);
+            if (result.byteLength <= INT32_MAX) {
+              sqlite3.result_blob(cx, tempPtr2, result.byteLength, SQLITE_TRANSIENT);
+            } else {
+              sqlite3.result_blob64(cx, tempPtr2, BigInt(result.byteLength), SQLITE_TRANSIENT);
+            }
+            _free(tempPtr2);
+          } else {
+            throw new SQLite3Error(`Unsupported type for function result: "${typeof result}"`);
+          }
+          break;
+        default:
+          throw new SQLite3Error(`Unsupported type for function result: "${typeof result}"`);
+      }
+    }
+    var Database = class {
+      constructor(filename, { fileMustExist = false, readOnly = false } = {}) {
+        let flags;
+        if (readOnly) {
+          flags = SQLITE_OPEN_READONLY;
+        } else {
+          flags = SQLITE_OPEN_READWRITE;
+          if (!fileMustExist)
+            flags |= SQLITE_OPEN_CREATE;
+        }
+        const rc = sqlite3.open_v2(filename, temp, flags, NULL);
+        this._ptr = getValue(temp, "i32");
+        if (rc !== SQLITE_OK) {
+          if (this._ptr !== NULL)
+            sqlite3.close_v2(this._ptr);
+          throw new SQLite3Error(`Could not open the database "${filename}"`);
+        }
+        this._functions = /* @__PURE__ */ new Map();
+      }
+      get isOpen() {
+        return this._ptr !== null;
+      }
+      get inTransaction() {
+        this._assertOpen();
+        return sqlite3.get_autocommit(this._ptr) === 0;
+      }
+      close() {
+        this._assertOpen();
+        for (const func of this._functions.values())
+          removeFunction(func);
+        this._functions.clear();
+        this._handleError(sqlite3.close_v2(this._ptr));
+        this._ptr = null;
+      }
+      function(name, func, { deterministic = false } = {}) {
+        this._assertOpen();
+        function wrappedFunc(cx, argc, argv) {
+          const args = parseFunctionArguments(argc, argv);
+          let result;
+          try {
+            result = func.apply(null, args);
+          } catch (err2) {
+            const tempPtr = stringToHeap(err2.toString());
+            sqlite3.result_error(cx, tempPtr, -1);
+            _free(tempPtr);
+            return;
+          }
+          setFunctionResult(cx, result);
+        }
+        if (this._functions.has(name)) {
+          removeFunction(this._functions.get(name));
+          this._functions.delete(name);
+        }
+        const funcPtr = addFunction(wrappedFunc, "viii");
+        this._functions.set(name, funcPtr);
+        let eTextRep = SQLITE_UTF8;
+        if (deterministic)
+          eTextRep |= SQLITE_DETERMINISTIC;
+        this._handleError(sqlite3.create_function_v2(this._ptr, name, func.length, eTextRep, NULL, funcPtr, NULL, NULL, NULL));
+        return this;
+      }
+      exec(sql) {
+        this._assertOpen();
+        const tempPtr = stringToHeap(sql);
+        try {
+          this._handleError(sqlite3.exec(this._ptr, tempPtr, NULL, NULL, NULL));
+        } finally {
+          _free(tempPtr);
+        }
+      }
+      prepare(sql) {
+        this._assertOpen();
+        return new Statement(this, sql);
+      }
+      run(sql, values) {
+        const stmt = this.prepare(sql);
+        try {
+          return stmt.run(values);
+        } finally {
+          stmt.finalize();
+        }
+      }
+      all(sql, values, { expand = false } = {}) {
+        return this._query(sql, values, false, expand);
+      }
+      get(sql, values, { expand = false } = {}) {
+        return this._query(sql, values, true, expand);
+      }
+      _query(sql, values, single, expand) {
+        const stmt = this.prepare(sql);
+        try {
+          if (single) {
+            return stmt.get(values, { expand });
+          } else {
+            return stmt.all(values, { expand });
+          }
+        } finally {
+          stmt.finalize();
+        }
+      }
+      _assertOpen() {
+        if (!this.isOpen)
+          throw new SQLite3Error("Database already closed");
+      }
+      _handleError(returnCode) {
+        if (returnCode !== SQLITE_OK)
+          throw new SQLite3Error(sqlite3.errmsg(this._ptr));
+      }
+    };
+    var Statement = class {
+      constructor(db3, sql) {
+        const tempPtr = stringToHeap(sql);
+        try {
+          db3._handleError(sqlite3.prepare_v2(db3._ptr, tempPtr, -1, temp, NULL));
+        } finally {
+          _free(tempPtr);
+        }
+        this._ptr = getValue(temp, "i32");
+        if (this._ptr === NULL)
+          throw new SQLite3Error("Nothing to prepare");
+        this._db = db3;
+      }
+      get database() {
+        return this._db;
+      }
+      get isFinalized() {
+        return this._ptr === null;
+      }
+      run(values) {
+        this._assertReady();
+        this._bind(values);
+        this._step();
+        return { changes: sqlite3.changes(this._db._ptr), lastInsertRowid: toNumberOrNot(sqlite3.last_insert_rowid(this._db._ptr)) };
+      }
+      iterate(values, { expand = false } = {}) {
+        return this._queryRows(values, expand);
+      }
+      all(values, { expand = false } = {}) {
+        return Array.from(this.iterate(values, { expand }));
+      }
+      get(values, { expand = false } = {}) {
+        const result = this._queryRows(values, expand).next();
+        return result.done ? null : result.value;
+      }
+      finalize() {
+        if (this.isFinalized)
+          throw new SQLite3Error("Statement already finalized");
+        try {
+          this._db._handleError(sqlite3.finalize(this._ptr));
+        } finally {
+          this._ptr = null;
+        }
+      }
+      _reset() {
+        return sqlite3.clear_bindings(this._ptr) === SQLITE_OK && sqlite3.reset(this._ptr) === SQLITE_OK;
+      }
+      *_queryRows(values, expand) {
+        this._assertReady();
+        this._bind(values);
+        const columns = this._getColumnNames();
+        while (this._step())
+          yield this._getRow(columns, expand);
+      }
+      _bind(values) {
+        if (!this._reset()) {
+          throw new SQLite3Error("Could not reset statement prior to binding new values");
+        }
+        if (Array.isArray(values)) {
+          this._bindArray(values);
+        } else if (values != null && typeof values === "object") {
+          this._bindObject(values);
+        } else if (typeof values !== "undefined") {
+          this._bindValue(values, 1);
+        }
+      }
+      _step() {
+        const ret = sqlite3.step(this._ptr);
+        switch (ret) {
+          case SQLITE_ROW:
+            return true;
+          case SQLITE_DONE:
+            return false;
+          default:
+            this._db._handleError(ret);
+        }
+      }
+      _getRow(columns, expand) {
+        const row = {};
+        for (let i = 0; i < columns.length; i++) {
+          let v;
+          const colType = sqlite3.column_type(this._ptr, i);
+          switch (colType) {
+            case SQLITE_INTEGER:
+              v = toNumberOrNot(sqlite3.column_int64(this._ptr, i));
+              break;
+            case SQLITE_FLOAT:
+              v = sqlite3.column_double(this._ptr, i);
+              break;
+            case SQLITE_TEXT:
+              v = sqlite3.column_text(this._ptr, i);
+              break;
+            case SQLITE_BLOB:
+              const p = sqlite3.column_blob(this._ptr, i);
+              if (p != NULL) {
+                v = HEAPU8.slice(p, p + sqlite3.column_bytes(this._ptr, i));
+              } else {
+                v = new Uint8Array();
+              }
+              break;
+            case SQLITE_NULL:
+              v = null;
+              break;
+          }
+          const column = columns[i];
+          if (expand) {
+            let table = sqlite3.column_table_name(this._ptr, i);
+            table = table === "" ? "$" : table;
+            if (Object.hasOwn(row, table)) {
+              row[table][column] = v;
+            } else {
+              row[table] = { [column]: v };
+            }
+          } else {
+            row[column] = v;
+          }
+        }
+        return 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}"`);
+        }
+        if (ret !== SQLITE_OK)
+          this._db._handleError(ret);
+      }
+      _assertReady() {
+        if (this.isFinalized)
+          throw new SQLite3Error("Statement already finalized");
+        if (!this._db.isOpen)
+          throw new SQLite3Error("Database is closed");
+      }
+    };
+    Module.Database = Database;
+    Module.SQLite3Error = SQLite3Error;
+    var path2 = require("node:path");
+    var crypto = require("node:crypto");
+    var SQLITE_CANTOPEN = 14;
+    var SQLITE_IOERR_READ = 266;
+    var SQLITE_IOERR_SHORT_READ = 522;
+    var SQLITE_IOERR_FSYNC = 1034;
+    var SQLITE_IOERR_WRITE = 778;
+    var SQLITE_IOERR_DELETE = 2570;
+    var SQLITE_IOERR_CLOSE = 4106;
+    var SQLITE_IOERR_TRUNCATE = 1546;
+    var SQLITE_IOERR_FSTAT = 1802;
+    var SQLITE_IOERR_LOCK = 3850;
+    var SQLITE_IOERR_UNLOCK = 2058;
+    var SQLITE_OPEN_READONLY = 1;
+    var SQLITE_OPEN_READWRITE = 2;
+    var SQLITE_OPEN_CREATE = 4;
+    var SQLITE_OPEN_EXCLUSIVE = 16;
+    var SQLITE_ACCESS_READWRITE = 1;
+    var SQLITE_ACCESS_READ = 2;
+    var SQLITE_LOCK_NONE = 0;
+    var SQLITE_BUSY = 5;
+    function _fd(fileInfo) {
+      return getValue(fileInfo + 4, "i32");
+    }
+    function _isLocked(fileInfo) {
+      return getValue(fileInfo + 8, "i32") != 0;
+    }
+    function _setLocked(fileInfo, locked) {
+      setValue(fileInfo + 8, locked ? 1 : 0, "i32");
+    }
+    function _path(fileInfo) {
+      return UTF8ToString(getValue(fileInfo + 12, "i32"));
+    }
+    function _safeInt(bigInt) {
+      if (bigInt < Number.MIN_SAFE_INTEGER || bigInt > Number.MAX_SAFE_INTEGER)
+        throw 0;
+      return Number(bigInt);
+    }
+    var arguments_ = [];
+    var thisProgram = "./this.program";
+    var quit_ = (status, toThrow) => {
+      throw toThrow;
+    };
+    var _scriptName;
+    if (typeof __filename != "undefined") {
+      _scriptName = __filename;
+    } else {
+    }
+    var scriptDirectory = "";
+    function locateFile(path3) {
+      if (Module["locateFile"]) {
+        return Module["locateFile"](path3, scriptDirectory);
+      }
+      return scriptDirectory + path3;
+    }
+    var readAsync;
+    var readBinary;
+    if (ENVIRONMENT_IS_NODE) {
+      fs3 = require("node:fs");
+      scriptDirectory = __dirname + "/";
+      readBinary = (filename) => {
+        filename = isFileURI(filename) ? new URL(filename) : filename;
+        var ret = fs3.readFileSync(filename);
+        return ret;
+      };
+      readAsync = async (filename, binary = true) => {
+        filename = isFileURI(filename) ? new URL(filename) : filename;
+        var ret = fs3.readFileSync(filename, binary ? void 0 : "utf8");
+        return ret;
+      };
+      if (process.argv.length > 1) {
+        thisProgram = process.argv[1].replace(/\\/g, "/");
+      }
+      arguments_ = process.argv.slice(2);
+      if (typeof module2 != "undefined") {
+        module2["exports"] = Module;
+      }
+      quit_ = (status, toThrow) => {
+        process.exitCode = status;
+        throw toThrow;
+      };
+    } else {
+    }
+    var fs3;
+    var out = console.log.bind(console);
+    var err = console.error.bind(console);
+    var wasmBinary;
+    var ABORT = false;
+    var EXITSTATUS;
+    var isFileURI = (filename) => filename.startsWith("file://");
+    var runtimeInitialized = false;
+    function updateMemoryViews() {
+      var b = wasmMemory.buffer;
+      HEAP8 = new Int8Array(b);
+      HEAP16 = new Int16Array(b);
+      HEAPU8 = new Uint8Array(b);
+      HEAPU16 = new Uint16Array(b);
+      HEAP32 = new Int32Array(b);
+      HEAPU32 = new Uint32Array(b);
+      HEAPF32 = new Float32Array(b);
+      HEAPF64 = new Float64Array(b);
+      HEAP64 = new BigInt64Array(b);
+      HEAPU64 = new BigUint64Array(b);
+    }
+    function preRun() {
+      if (Module["preRun"]) {
+        if (typeof Module["preRun"] == "function")
+          Module["preRun"] = [Module["preRun"]];
+        while (Module["preRun"].length) {
+          addOnPreRun(Module["preRun"].shift());
+        }
+      }
+      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);
+      ABORT = true;
+      what += ". Build with -sASSERTIONS for more info.";
+      var e = new WebAssembly.RuntimeError(what);
+      throw e;
+    }
+    var wasmBinaryFile;
+    function findWasmBinary() {
+      return locateFile("node-sqlite3-wasm.wasm");
+    }
+    function getBinarySync(file) {
+      if (file == wasmBinaryFile && wasmBinary) {
+        return new Uint8Array(wasmBinary);
+      }
+      if (readBinary) {
+        return readBinary(file);
+      }
+      throw 'sync fetching of the wasm failed: you can preload it to Module["wasmBinary"] manually, or emcc.py will do that for you when generating HTML (but not JS)';
+    }
+    function instantiateSync(file, info) {
+      var module3;
+      var binary = getBinarySync(file);
+      module3 = new WebAssembly.Module(binary);
+      var instance = new WebAssembly.Instance(module3, info);
+      return [instance, module3];
+    }
+    function getWasmImports() {
+      var imports = { a: wasmImports };
+      return imports;
+    }
+    function createWasm() {
+      function receiveInstance(instance, module3) {
+        wasmExports = instance.exports;
+        assignWasmExports(wasmExports);
+        updateMemoryViews();
+        return wasmExports;
+      }
+      var info = getWasmImports();
+      if (Module["instantiateWasm"]) {
+        return new Promise((resolve, reject) => {
+          Module["instantiateWasm"](info, (inst, mod) => {
+            resolve(receiveInstance(inst, mod));
+          });
+        });
+      }
+      wasmBinaryFile ??= findWasmBinary();
+      var result = instantiateSync(wasmBinaryFile, info);
+      return receiveInstance(result[0]);
+    }
+    var ExitStatus = class {
+      name = "ExitStatus";
+      constructor(status) {
+        this.message = `Program terminated with exit(${status})`;
+        this.status = status;
+      }
+    };
+    var HEAP16;
+    var HEAP32;
+    var HEAP64;
+    var HEAP8;
+    var HEAPF32;
+    var HEAPF64;
+    var HEAPU16;
+    var HEAPU32;
+    var HEAPU64;
+    var HEAPU8;
+    var callRuntimeCallbacks = (callbacks) => {
+      while (callbacks.length > 0) {
+        callbacks.shift()(Module);
+      }
+    };
+    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;
+    };
+    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;
+    };
+    var INT53_MAX = 9007199254740992;
+    var INT53_MIN = -9007199254740992;
+    var bigintToI53Checked = (num) => num < INT53_MIN || num > INT53_MAX ? NaN : Number(num);
+    function __localtime_js(time, tmPtr) {
+      time = bigintToI53Checked(time);
+      var date = new Date(time * 1e3);
+      HEAP32[tmPtr >> 2] = date.getSeconds();
+      HEAP32[tmPtr + 4 >> 2] = date.getMinutes();
+      HEAP32[tmPtr + 8 >> 2] = date.getHours();
+      HEAP32[tmPtr + 12 >> 2] = date.getDate();
+      HEAP32[tmPtr + 16 >> 2] = date.getMonth();
+      HEAP32[tmPtr + 20 >> 2] = date.getFullYear() - 1900;
+      HEAP32[tmPtr + 24 >> 2] = date.getDay();
+      var yday = ydayFromDate(date) | 0;
+      HEAP32[tmPtr + 28 >> 2] = yday;
+      HEAP32[tmPtr + 36 >> 2] = -(date.getTimezoneOffset() * 60);
+      var start = new Date(date.getFullYear(), 0, 1);
+      var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset();
+      var winterOffset = start.getTimezoneOffset();
+      var dst = (summerOffset != winterOffset && date.getTimezoneOffset() == Math.min(winterOffset, summerOffset)) | 0;
+      HEAP32[tmPtr + 32 >> 2] = dst;
+    }
+    var timers = {};
+    var handleException = (e) => {
+      if (e instanceof ExitStatus || e == "unwind") {
+        return EXITSTATUS;
+      }
+      quit_(1, e);
+    };
+    var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
+    var _proc_exit = (code) => {
+      EXITSTATUS = code;
+      if (!keepRuntimeAlive()) {
+        Module["onExit"]?.(code);
+        ABORT = true;
+      }
+      quit_(code, new ExitStatus(code));
+    };
+    var exitJS = (status, implicit) => {
+      EXITSTATUS = status;
+      _proc_exit(status);
+    };
+    var _exit = exitJS;
+    var maybeExit = () => {
+      if (!keepRuntimeAlive()) {
+        try {
+          _exit(EXITSTATUS);
+        } catch (e) {
+          handleException(e);
+        }
+      }
+    };
+    var callUserCallback = (func) => {
+      if (ABORT) {
+        return;
+      }
+      try {
+        return func();
+      } catch (e) {
+        handleException(e);
+      } finally {
+        maybeExit();
+      }
+    };
+    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;
+    };
+    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;
+    };
+    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 _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 (e) {
+      }
+    };
+    var _emscripten_resize_heap = (requestedSize) => {
+      var oldSize = HEAPU8.length;
+      requestedSize >>>= 0;
+      var maxHeapSize = getHeapMax();
+      if (requestedSize > maxHeapSize) {
+        return false;
+      }
+      for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+        var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
+        overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+        var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536));
+        var replacement = growMemory(newSize);
+        if (replacement) {
+          return true;
+        }
+      }
+      return false;
+    };
+    var UTF8Decoder = globalThis.TextDecoder && new TextDecoder();
+    var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => {
+      var maxIdx = idx + maxBytesToRead;
+      if (ignoreNul)
+        return maxIdx;
+      while (heapOrArray[idx] && !(idx >= maxIdx))
+        ++idx;
+      return idx;
+    };
+    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 UTF8ToString = (ptr, maxBytesToRead, ignoreNul) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead, ignoreNul) : "";
+    function _nodejsAccess(vfs, filePath, flags, outResult) {
+      let aflags = fs3.constants.F_OK;
+      if (flags == SQLITE_ACCESS_READWRITE)
+        aflags = fs3.constants.R_OK | fs3.constants.W_OK;
+      if (flags == SQLITE_ACCESS_READ)
+        aflags = fs3.constants.R_OK;
+      try {
+        fs3.accessSync(UTF8ToString(filePath), aflags);
+        setValue(outResult, 1, "i32");
+      } catch {
+        setValue(outResult, 0, "i32");
+      }
+      return SQLITE_OK;
+    }
+    function _nodejsCheckReservedLock(fi, outResult) {
+      try {
+        fs3.accessSync(`${_path(fi)}.lock`, fs3.constants.F_OK);
+        setValue(outResult, 1, "i32");
+      } catch {
+        setValue(outResult, 0, "i32");
+      }
+      return SQLITE_OK;
+    }
+    function _nodejsClose(fi) {
+      _nodejsUnlock(fi, SQLITE_LOCK_NONE);
+      try {
+        fs3.closeSync(_fd(fi));
+      } catch {
+        return SQLITE_IOERR_CLOSE;
+      }
+      return SQLITE_OK;
+    }
+    function _nodejsDelete(vfs, filePath, dirSync) {
+      const pathStr = UTF8ToString(filePath);
+      try {
+        fs3.unlinkSync(pathStr);
+      } catch (err2) {
+        if (err2.code != "ENOENT")
+          return SQLITE_IOERR_DELETE;
+      }
+      if (dirSync) {
+        let fd = -1;
+        try {
+          fd = fs3.openSync(path2.dirname(pathStr), "r");
+          fs3.fsyncSync(fd);
+        } catch {
+          return SQLITE_IOERR_FSYNC;
+        } finally {
+          try {
+            fs3.closeSync(fd);
+          } catch {
+            return SQLITE_IOERR_FSYNC;
+          }
+        }
+      }
+      return SQLITE_OK;
+    }
+    function _nodejsFileSize(fi, outSize) {
+      try {
+        setValue(outSize, fs3.fstatSync(_fd(fi)).size, "i64");
+      } catch {
+        return SQLITE_IOERR_FSTAT;
+      }
+      return SQLITE_OK;
+    }
+    function _nodejsFullPathname(vfs, relPath, sizeFullPath, outFullPath) {
+      const full = path2.resolve(UTF8ToString(relPath));
+      stringToUTF8(full, outFullPath, sizeFullPath);
+      return full.length < sizeFullPath ? SQLITE_OK : SQLITE_CANTOPEN;
+    }
+    function _nodejsLock(fi, level) {
+      if (!_isLocked(fi)) {
+        try {
+          fs3.mkdirSync(`${_path(fi)}.lock`);
+        } catch (err2) {
+          return err2.code == "EEXIST" ? SQLITE_BUSY : SQLITE_IOERR_LOCK;
+        }
+        _setLocked(fi, true);
+      }
+      return SQLITE_OK;
+    }
+    function _nodejsRandomness(vfs, bytes, outBuffer) {
+      const buf = HEAPU8.subarray(outBuffer, outBuffer + bytes);
+      crypto.randomFillSync(buf);
+      return bytes;
+    }
+    function _nodejsRead(fi, outBuffer, bytes, offset) {
+      const buf = HEAPU8.subarray(outBuffer, outBuffer + bytes);
+      let bytesRead;
+      try {
+        bytesRead = fs3.readSync(_fd(fi), buf, 0, bytes, offset);
+      } catch {
+        return SQLITE_IOERR_READ;
+      }
+      if (bytesRead == bytes) {
+        return SQLITE_OK;
+      } else if (bytesRead >= 0) {
+        if (bytesRead < bytes) {
+          try {
+            buf.fill(0, bytesRead);
+          } catch {
+            return SQLITE_IOERR_READ;
+          }
+        }
+        return SQLITE_IOERR_SHORT_READ;
+      }
+      return SQLITE_IOERR_READ;
+    }
+    function _nodejsSync(fi, flags) {
+      try {
+        fs3.fsyncSync(_fd(fi));
+      } catch {
+        return SQLITE_IOERR_FSYNC;
+      }
+      return SQLITE_OK;
+    }
+    function _nodejsTruncate(fi, size) {
+      try {
+        fs3.ftruncateSync(_fd(fi), _safeInt(size));
+      } catch {
+        return SQLITE_IOERR_TRUNCATE;
+      }
+      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;
+        }
+        _setLocked(fi, false);
+      }
+      return SQLITE_OK;
+    }
+    function _nodejsWrite(fi, buffer, bytes, offset) {
+      try {
+        const bytesWritten = fs3.writeSync(_fd(fi), HEAPU8.subarray(buffer, buffer + bytes), 0, bytes, _safeInt(offset));
+        return bytesWritten != bytes ? SQLITE_IOERR_WRITE : SQLITE_OK;
+      } catch {
+        return SQLITE_IOERR_WRITE;
+      }
+    }
+    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;
+      }
+    }
+    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;
+        }
+      }
+      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]);
+          } else {
+            cArgs[i] = args[i];
+          }
+        }
+      }
+      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);
+      }
+      return func;
+    };
+    var updateTableMap = (offset, count) => {
+      if (functionsInTableMap) {
+        for (var i = offset; i < offset + count; i++) {
+          var item = getWasmTableEntry(i);
+          if (item) {
+            functionsInTableMap.set(item, i);
+          }
+        }
+      }
+    };
+    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();
+      }
+      return wasmTable["grow"](1);
+    };
+    var setWasmTableEntry = (idx, func) => {
+      wasmTable.set(idx, func);
+      wasmTableMirror[idx] = wasmTable.get(idx);
+    };
+    var uleb128EncodeWithLen = (arr) => {
+      const n = arr.length;
+      return [n % 128 | 128, n >> 7, ...arr];
+    };
+    var wasmTypeCodes = { i: 127, p: 127, j: 126, f: 125, d: 124, e: 111 };
+    var generateTypePack = (types) => uleb128EncodeWithLen(Array.from(types, (type) => {
+      var code = wasmTypeCodes[type];
+      return code;
+    }));
+    var convertJsFunctionToWasm = (func, sig) => {
+      var bytes = Uint8Array.of(0, 97, 115, 109, 1, 0, 0, 0, 1, ...uleb128EncodeWithLen([1, 96, ...generateTypePack(sig.slice(1)), ...generateTypePack(sig[0] === "v" ? "" : sig[0])]), 2, 7, 1, 1, 101, 1, 102, 0, 0, 7, 5, 1, 1, 102, 0, 0);
+      var module3 = new WebAssembly.Module(bytes);
+      var instance = new WebAssembly.Instance(module3, { e: { f: func } });
+      var wrappedFunc = instance.exports["f"];
+      return wrappedFunc;
+    };
+    var addFunction = (func, sig) => {
+      var rtn = getFunctionAddress(func);
+      if (rtn) {
+        return rtn;
+      }
+      var ret = getEmptyTableSlot();
+      try {
+        setWasmTableEntry(ret, func);
+      } catch (err2) {
+        if (!(err2 instanceof TypeError)) {
+          throw err2;
+        }
+        var wrapped = convertJsFunctionToWasm(func, sig);
+        setWasmTableEntry(ret, wrapped);
+      }
+      functionsInTableMap.set(func, ret);
+      return ret;
+    };
+    var removeFunction = (index) => {
+      functionsInTableMap.delete(getWasmTableEntry(index));
+      setWasmTableEntry(index, null);
+      freeTableIndexes.push(index);
+    };
+    {
+      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 (ABORT)
+          return;
+        initRuntime();
+        Module["onRuntimeInitialized"]?.();
+        postRun();
+      }
+      if (Module["setStatus"]) {
+        Module["setStatus"]("Running...");
+        setTimeout(() => {
+          setTimeout(() => Module["setStatus"](""), 1);
+          doRun();
+        }, 1);
+      } else {
+        doRun();
+      }
+    }
+    var wasmExports;
+    wasmExports = createWasm();
+    run();
+  }
+});
+
+// src/paths.ts
+function recallRoot() {
+  if (rootOverride)
+    return rootOverride;
+  const envRoot = process.env["RECALL_HOME"];
+  if (envRoot && envRoot.length > 0)
+    return envRoot;
+  return (0, import_node_path2.join)((0, import_node_os.homedir)(), ".recall");
+}
+function dbPath() {
+  return (0, import_node_path2.join)(recallRoot(), "recall.db");
+}
+function binDir() {
+  return (0, import_node_path2.join)(recallRoot(), "bin");
+}
+function logsDir() {
+  return (0, import_node_path2.join)(recallRoot(), "logs");
+}
+function ensureDir() {
+  (0, import_node_fs2.mkdirSync)(recallRoot(), { recursive: true });
+}
+var import_node_fs2, import_node_os, import_node_path2, rootOverride;
+var init_paths = __esm({
+  "src/paths.ts"() {
+    "use strict";
+    import_node_fs2 = require("node:fs");
+    import_node_os = require("node:os");
+    import_node_path2 = require("node:path");
+    rootOverride = null;
+  }
+});
+
+// src/recall/quantize.ts
+var init_quantize = __esm({
+  "src/recall/quantize.ts"() {
+    "use strict";
+  }
+});
+
+// src/hooks/stop-hook.ts
+var stop_hook_exports = {};
+__export(stop_hook_exports, {
+  vendorForTranscript: () => vendorForTranscript
+});
+module.exports = __toCommonJS(stop_hook_exports);
+
+// src/recall/transcript-utils.ts
+function stripToolContent(entries) {
+  const out = [];
+  for (const entry of entries) {
+    if (entry.type !== "user" && entry.type !== "assistant")
+      continue;
+    const msg = entry.message;
+    if (!msg)
+      continue;
+    if (typeof msg.content === "string") {
+      if (msg.content.trim())
+        out.push(entry);
+      continue;
+    }
+    if (!Array.isArray(msg.content)) {
+      out.push(entry);
+      continue;
+    }
+    const textBlocks = msg.content.filter(
+      (b) => b.type === "text" && b.text?.trim()
+    );
+    if (textBlocks.length === 0)
+      continue;
+    out.push({ ...entry, message: { ...msg, content: textBlocks } });
+  }
+  return out;
+}
+
+// src/db.ts
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+init_log();
+var import_node_sqlite3_wasm = __toESM(require_node_sqlite3_wasm());
+var db = null;
+var currentDbPath = null;
+function getDb(dbPath2) {
+  if (db && currentDbPath === dbPath2)
+    return db;
+  if (db) {
+    closeDb();
+  }
+  (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(dbPath2), { recursive: true });
+  clearStaleLock(dbPath2);
+  writeOwnerFile(dbPath2);
+  db = new import_node_sqlite3_wasm.Database(dbPath2);
+  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;
+}
+function closeDb() {
+  if (db) {
+    db.close();
+    if (currentDbPath)
+      removeOwnerFile(currentDbPath);
+    db = null;
+    currentDbPath = null;
+  }
+}
+function ownerFilePath(dbPath2) {
+  return `${dbPath2}.owner`;
+}
+function processStartToken(pid) {
+  if (process.platform !== "linux")
+    return "";
+  try {
+    const stat = (0, import_node_fs.readFileSync)(`/proc/${pid}/stat`, "utf-8");
+    const close = stat.lastIndexOf(")");
+    if (close === -1)
+      return "";
+    const rest = stat.slice(close + 2).trim().split(/\s+/);
+    const starttime = rest[19];
+    return starttime ?? "";
+  } catch {
+    return "";
+  }
+}
+function writeOwnerFile(dbPath2) {
+  try {
+    const token = processStartToken(process.pid);
+    (0, import_node_fs.writeFileSync)(ownerFilePath(dbPath2), `${process.pid}:${token}`, "utf-8");
+  } catch {
+  }
+}
+function removeOwnerFile(dbPath2) {
+  try {
+    (0, import_node_fs.unlinkSync)(ownerFilePath(dbPath2));
+  } catch {
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function clearStaleLock(dbPath2) {
+  const lockDir = `${dbPath2}.lock`;
+  if (!(0, import_node_fs.existsSync)(lockDir))
+    return;
+  const ownerFile = ownerFilePath(dbPath2);
+  if ((0, import_node_fs.existsSync)(ownerFile)) {
+    try {
+      const raw = (0, import_node_fs.readFileSync)(ownerFile, "utf-8").trim();
+      const sep = raw.indexOf(":");
+      const pidStr = sep === -1 ? raw : raw.slice(0, sep);
+      const storedToken = sep === -1 ? "" : raw.slice(sep + 1);
+      const pid = parseInt(pidStr, 10);
+      if (!isNaN(pid) && isProcessAlive(pid)) {
+        if (storedToken === "" || storedToken === processStartToken(pid)) {
+          return;
+        }
+      }
+    } catch {
+    }
+  }
+  try {
+    (0, import_node_fs.rmSync)(lockDir, { recursive: true, force: true });
+    log({
+      source: "db",
+      level: "warn",
+      summary: `DB: removed stale lock directory (${lockDir}) \u2014 owning process is dead`
+    });
+  } catch (err) {
+    log({
+      source: "db",
+      level: "error",
+      summary: `DB: failed to remove stale lock directory: ${err}`
+    });
+  }
+}
+function ensureSchema(db3) {
+  db3.exec(`
+    CREATE TABLE IF NOT EXISTS messages (
+      message_id    TEXT PRIMARY KEY,
+      session_id    TEXT NOT NULL,
+      message_seq   INTEGER NOT NULL,
+      message_text  TEXT NOT NULL,
+      project_id    TEXT,
+      created_at    INTEGER NOT NULL,
+      message_role  TEXT,
+      UNIQUE(session_id, message_id)
+    );
+
+    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);
+  `);
+  db3.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
+      message_text,
+      content=messages,
+      content_rowid=rowid,
+      tokenize='porter unicode61'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS messages_fts_ai AFTER INSERT ON messages BEGIN
+      INSERT INTO messages_fts(rowid, message_text) VALUES (new.rowid, new.message_text);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS messages_fts_ad AFTER DELETE ON messages BEGIN
+      INSERT INTO messages_fts(messages_fts, rowid, message_text)
+      VALUES ('delete', old.rowid, old.message_text);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS messages_fts_au AFTER UPDATE ON messages BEGIN
+      INSERT INTO messages_fts(messages_fts, rowid, message_text)
+      VALUES ('delete', old.rowid, old.message_text);
+      INSERT INTO messages_fts(rowid, message_text) VALUES (new.rowid, new.message_text);
+    END;
+  `);
+  db3.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts_vocab
+      USING fts5vocab(messages_fts, 'row');
+  `);
+  db3.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS _stem USING fts5(
+      t, tokenize='porter unicode61'
+    );
+    CREATE VIRTUAL TABLE IF NOT EXISTS _stem_vocab
+      USING fts5vocab(_stem, 'row');
+  `);
+  db3.exec(`
+    CREATE TABLE IF NOT EXISTS message_vectors (
+      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
+    );
+  `);
+  db3.exec(`
+    CREATE TABLE IF NOT EXISTS ingest_watermark (
+      transcript_path TEXT PRIMARY KEY,
+      last_mtime      INTEGER NOT NULL,
+      last_size       INTEGER NOT NULL,
+      vendor          TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_watermark_vendor ON ingest_watermark(vendor);
+  `);
+}
+
+// src/recall/message-store.ts
+init_paths();
+
+// src/recall/query-sanitizer.ts
+init_paths();
+init_log();
+
+// src/recall/message-store.ts
+init_quantize();
+var dirEnsured = false;
+function db2() {
+  return getDb(dbPath());
+}
+function ensureDir2() {
+  if (!dirEnsured) {
+    ensureDir();
+    dirEnsured = true;
+  }
+}
+function insertMessages(messages, opts) {
+  if (messages.length === 0 && !opts?.replaceSessionId)
+    return;
+  ensureDir2();
+  const d = db2();
+  d.exec("BEGIN");
+  try {
+    if (opts?.replaceSessionId) {
+      d.run(
+        `DELETE FROM message_vectors WHERE message_id IN
+         (SELECT message_id FROM messages WHERE session_id = ?)`,
+        [opts.replaceSessionId]
+      );
+      d.run("DELETE FROM messages WHERE session_id = ?", [opts.replaceSessionId]);
+    }
+    const stmt = d.prepare(
+      `INSERT OR IGNORE INTO messages
+       (message_id, session_id, message_seq, message_text, project_id, created_at, message_role)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`
+    );
+    try {
+      for (const m of messages) {
+        stmt.run([
+          m.message_id,
+          m.session_id,
+          m.message_seq,
+          m.message_text,
+          m.project_id,
+          m.created_at,
+          m.message_role
+        ]);
+      }
+    } finally {
+      stmt.finalize();
+    }
+    d.exec("COMMIT");
+  } catch (e) {
+    d.exec("ROLLBACK");
+    throw e;
+  }
+}
+
+// src/recall/message-ingest.ts
+init_paths();
+
+// src/url-path-resolver.ts
+function normalizePath(p) {
+  let normalized = p.startsWith("\\\\?\\") ? p.slice(4) : p;
+  normalized = normalized.replace(/\\/g, "/");
+  normalized = normalized.replace(/^([A-Za-z]):/, (_, d) => d.toLowerCase() + ":");
+  if (normalized.length > 1 && normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+
+// src/adapters/claude/jsonl-reader.ts
+var fs = __toESM(require("fs"));
+init_log();
+var READ_BUFFER_SIZE = 64 * 1024;
+var TURN_CONTENT_CAP = 8 * 1024;
+function parseJsonlFile(filepath) {
+  try {
+    const content = fs.readFileSync(filepath, "utf-8");
+    const lines = content.split("\n");
+    const entries = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        continue;
+      }
+      try {
+        const entry = JSON.parse(trimmed);
+        entries.push(entry);
+      } catch (err) {
+        log({ level: "warn", source: "claude:jsonl-reader", summary: `Skipping unparseable line: ${err.message}` });
+        continue;
+      }
+    }
+    return entries;
+  } catch (error) {
+    log({ level: "error", source: "jsonl-reader", summary: `Failed to read JSONL file ${filepath}: ${error instanceof Error ? error.message : String(error)}`, data: { filepath, error: String(error) } });
+    return [];
+  }
+}
+
+// src/adapters/claude/claude-entry-adapter.ts
+function isSystemContextContent(message) {
+  if (!message || message.role !== "user")
+    return false;
+  const content = message.content;
+  let text;
+  if (typeof content === "string") {
+    text = content;
+  } else if (Array.isArray(content)) {
+    const firstText = content.find(
+      (b) => typeof b === "object" && b !== null && b.type === "text"
+    );
+    if (firstText && "text" in firstText) {
+      text = firstText.text;
+    }
+  }
+  if (!text)
+    return false;
+  if (text.startsWith("<system-reminder>"))
+    return true;
+  if (text.startsWith("<environment_context>"))
+    return true;
+  if (text.startsWith("<INSTRUCTIONS>"))
+    return true;
+  if (text.startsWith("# AGENTS.md instructions for"))
+    return true;
+  if (text.startsWith("<context>"))
+    return true;
+  if (text.startsWith("<task-notification>"))
+    return true;
+  if (text.startsWith("<command-name>"))
+    return true;
+  if (text.startsWith("<local-command-stdout>"))
+    return true;
+  if (text.startsWith("<local-command-caveat>"))
+    return true;
+  return false;
+}
+function sanitizeContentBlocks(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return content;
+  return content.map((block) => {
+    if (typeof block !== "object" || block === null)
+      return block;
+    const b = block;
+    if (b.type === "tool_use" && typeof b.name !== "string") {
+      return { ...b, name: "<unknown>" };
+    }
+    return block;
+  });
+}
+function sanitizeMessage(message) {
+  if (!message)
+    return message;
+  if (Array.isArray(message.content)) {
+    return { ...message, content: sanitizeContentBlocks(message.content) };
+  }
+  return message;
+}
+function adaptClaudeEntry(raw) {
+  if (raw.type === "queue-operation")
+    return null;
+  if (typeof raw.type !== "string")
+    return null;
+  if (raw.type === "progress") {
+    const data = raw.data;
+    const innerMessage = data?.message;
+    const actualMessage = innerMessage?.message;
+    if (actualMessage?.content) {
+      const {
+        type: _type,
+        uuid: _uuid,
+        parentUuid: _parentUuid,
+        sessionId: _sessionId,
+        timestamp: _timestamp,
+        parentToolUseID: _parentToolUseID,
+        parent_tool_use_id: _parent_tool_use_id,
+        ...progressOverflow
+      } = raw;
+      return {
+        type: innerMessage?.type ?? "assistant",
+        uuid: raw.uuid,
+        parentUuid: raw.parentUuid,
+        sessionId: raw.sessionId,
+        timestamp: raw.timestamp,
+        message: sanitizeMessage(actualMessage),
+        agentId: data?.agentId,
+        parentToolUseID: raw.parentToolUseID ?? raw.parent_tool_use_id,
+        vendor: "claude",
+        ...Object.keys(progressOverflow).length > 0 && { metadata: progressOverflow }
+      };
+    }
+    return null;
+  }
+  const {
+    type,
+    uuid,
+    parentUuid,
+    sessionId,
+    session_id,
+    // SDK snake_case variant
+    timestamp,
+    isSidechain,
+    isMeta,
+    agentId,
+    cwd,
+    message,
+    toolUseResult,
+    tool_use_result,
+    // SDK snake_case variant
+    summary,
+    leafUuid,
+    customTitle,
+    sourceToolAssistantUUID,
+    // Claude's casing → our camelCase
+    parent_tool_use_id,
+    // SDK snake_case
+    parentToolUseID,
+    // JSONL camelCase
+    ...overflow
+  } = raw;
+  const mergedMetadata = {
+    ...overflow
+  };
+  let sanitizedMessage = sanitizeMessage(message);
+  if (!sanitizedMessage && typeof mergedMetadata.content === "string") {
+    sanitizedMessage = { role: "assistant", content: mergedMetadata.content };
+    delete mergedMetadata.content;
+  }
+  const detectedMeta = isMeta || type === "user" && isSystemContextContent(sanitizedMessage) || void 0;
+  return {
+    type,
+    uuid,
+    parentUuid,
+    // Prefer camelCase, fall back to snake_case (SDK format)
+    sessionId: sessionId ?? session_id,
+    timestamp,
+    vendor: "claude",
+    // Message content (sanitized — coerces malformed blocks to safe defaults)
+    message: sanitizedMessage,
+    // Sub-agent
+    isSidechain,
+    agentId,
+    parentToolUseID: parentToolUseID ?? parent_tool_use_id,
+    // Working directory
+    cwd,
+    // Structured tool result (prefer camelCase, fall back to SDK snake_case)
+    toolUseResult: toolUseResult ?? tool_use_result,
+    // Session display
+    isMeta: detectedMeta,
+    customTitle,
+    // Summary entries
+    summary,
+    leafUuid,
+    // Tool result linking
+    sourceToolAssistantUuid: sourceToolAssistantUUID,
+    // Vendor-specific overflow
+    ...Object.keys(mergedMetadata).length > 0 && { metadata: mergedMetadata }
+  };
+}
+function adaptClaudeEntries(rawEntries) {
+  return rawEntries.map(adaptClaudeEntry).filter((entry) => entry !== null);
+}
+
+// src/adapters/codex/codex-jsonl-reader.ts
+var fs2 = __toESM(require("fs"));
+init_log();
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+var CODEX_SESSIONS_DIR = path.join(os.homedir(), ".codex", "sessions");
+function parseCodexJsonlFile(filepath) {
+  try {
+    const content = fs2.readFileSync(filepath, "utf-8");
+    const lines = content.split("\n");
+    const records = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed)
+        continue;
+      try {
+        const record = JSON.parse(trimmed);
+        records.push(record);
+      } catch (err) {
+        log({ level: "warn", source: "codex-jsonl-reader", summary: `Skipping unparseable line: ${err.message}` });
+      }
+    }
+    return records;
+  } catch (error) {
+    log({ level: "error", source: "codex-jsonl-reader", summary: `Failed to read ${filepath}: ${error instanceof Error ? error.message : String(error)}`, data: { filepath, error: String(error) } });
+    return [];
+  }
+}
+var READ_BUFFER_SIZE2 = 64 * 1024;
+var TURN_CONTENT_CAP2 = 8 * 1024;
+
+// src/adapters/codex/codex-jsonl-adapter.ts
+function adaptCodexJsonlRecords(records, sessionId) {
+  const outputIndex = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    if (record.type !== "response_item")
+      continue;
+    const subtype = record.payload.type;
+    if (subtype === "function_call_output" || subtype === "custom_tool_call_output") {
+      const callId = record.payload.call_id;
+      if (callId)
+        outputIndex.set(callId, record);
+    }
+  }
+  const entries = [];
+  let currentCwd;
+  let currentModel;
+  let entryCounter = 0;
+  for (const record of records) {
+    switch (record.type) {
+      case "session_meta": {
+        currentCwd = record.payload.cwd;
+        break;
+      }
+      case "turn_context": {
+        const payload = record.payload;
+        if (payload.cwd)
+          currentCwd = payload.cwd;
+        if (payload.model)
+          currentModel = payload.model;
+        break;
+      }
+      case "event_msg":
+        break;
+      case "response_item": {
+        const emitted = emitResponseItem(
+          record,
+          sessionId,
+          outputIndex,
+          currentCwd,
+          currentModel,
+          entryCounter
+        );
+        for (const entry of emitted) {
+          entries.push(entry);
+        }
+        entryCounter += emitted.length;
+        break;
+      }
+    }
+  }
+  return entries;
+}
+function emitResponseItem(record, sessionId, outputIndex, cwd, model, counter) {
+  const payload = record.payload;
+  const subtype = payload.type;
+  const timestamp = record.timestamp;
+  const base = {
+    sessionId,
+    vendor: "codex",
+    timestamp,
+    cwd
+  };
+  switch (subtype) {
+    case "message":
+      return emitMessage(payload, base, model, counter);
+    case "reasoning":
+      return emitReasoning(payload, base, counter);
+    case "function_call":
+      return emitFunctionCall(payload, base, outputIndex, counter);
+    case "custom_tool_call":
+      return emitCustomToolCall(payload, base, outputIndex, counter);
+    case "web_search_call":
+      return emitWebSearchCall(payload, base, counter);
+    case "function_call_output":
+    case "custom_tool_call_output":
+      return emitOrphanedOutput(payload, subtype, base, outputIndex, counter);
+    case "ghost_snapshot":
+    case "compaction":
+    case "other":
+      return [];
+    default:
+      return [];
+  }
+}
+function emitMessage(payload, base, model, counter) {
+  const role = payload.role;
+  const contentItems = payload.content;
+  const phase = payload.phase;
+  if (role === "developer")
+    return [];
+  if (role === "user") {
+    return [
+      {
+        type: "user",
+        uuid: generateId(base.sessionId, counter),
+        ...base,
+        message: {
+          role: "user",
+          content: adaptContentItems(contentItems)
+        }
+      }
+    ];
+  }
+  if (role === "assistant") {
+    return [
+      {
+        type: "assistant",
+        uuid: generateId(base.sessionId, counter),
+        ...base,
+        message: {
+          role: "assistant",
+          content: adaptContentItems(contentItems),
+          model
+        },
+        metadata: phase ? { phase } : void 0
+      }
+    ];
+  }
+  return [];
+}
+function emitReasoning(payload, base, counter) {
+  const summaryItems = payload.summary;
+  const thinkingBlocks = [];
+  if (Array.isArray(summaryItems)) {
+    for (const item of summaryItems) {
+      if (item.type === "summary_text" && item.text) {
+        thinkingBlocks.push({
+          type: "thinking",
+          thinking: item.text,
+          isSummary: true
+        });
+      }
+    }
+  }
+  if (thinkingBlocks.length === 0)
+    return [];
+  return [
+    {
+      type: "assistant",
+      uuid: generateId(base.sessionId, counter),
+      ...base,
+      message: {
+        role: "assistant",
+        content: thinkingBlocks
+      }
+    }
+  ];
+}
+function emitFunctionCall(payload, base, outputIndex, _counter) {
+  const callId = payload.call_id;
+  const name = payload.name;
+  const rawArgs = payload.arguments;
+  let args = {};
+  if (typeof rawArgs === "string") {
+    try {
+      args = JSON.parse(rawArgs);
+    } catch {
+      args = { raw: rawArgs };
+    }
+  } else if (typeof rawArgs === "object" && rawArgs !== null) {
+    args = rawArgs;
+  }
+  const { toolName, toolInput, metadata } = mapFunctionCall(name, args);
+  const toolUse = {
+    type: "tool_use",
+    id: callId,
+    name: toolName,
+    input: toolInput
+  };
+  const assistantEntry = {
+    type: "assistant",
+    uuid: callId,
+    ...base,
+    message: {
+      role: "assistant",
+      content: [toolUse]
+    },
+    metadata
+  };
+  const entries = [assistantEntry];
+  const outputRecord = outputIndex.get(callId);
+  if (outputRecord) {
+    const outputPayload = outputRecord.payload;
+    const rawOutput = outputPayload.output;
+    const { exitCode, body } = parseExecOutputHeader(rawOutput);
+    const isError = exitCode !== 0;
+    const toolResult = {
+      type: "tool_result",
+      tool_use_id: callId,
+      content: body,
+      is_error: isError
+    };
+    const resultEntry = {
+      type: "result",
+      uuid: `${callId}-result`,
+      parentUuid: callId,
+      sessionId: base.sessionId,
+      vendor: base.vendor,
+      timestamp: outputRecord.timestamp,
+      cwd: base.cwd,
+      message: {
+        role: "tool",
+        content: [toolResult]
+      },
+      toolUseResult: {
+        output: body,
+        exitCode
+      }
+    };
+    entries.push(resultEntry);
+    outputIndex.delete(callId);
+  }
+  return entries;
+}
+function emitCustomToolCall(payload, base, outputIndex, _counter) {
+  const callId = payload.call_id;
+  const name = payload.name;
+  const input = payload.input;
+  if (name === "apply_patch") {
+    return emitApplyPatch(callId, input, base, outputIndex);
+  }
+  const toolUse = {
+    type: "tool_use",
+    id: callId,
+    name,
+    input: { raw: input }
+  };
+  const assistantEntry = {
+    type: "assistant",
+    uuid: callId,
+    ...base,
+    message: {
+      role: "assistant",
+      content: [toolUse]
+    }
+  };
+  const entries = [assistantEntry];
+  const outputRecord = outputIndex.get(callId);
+  if (outputRecord) {
+    entries.push(
+      buildCustomToolResult(callId, callId, outputRecord, base)
+    );
+    outputIndex.delete(callId);
+  }
+  return entries;
+}
+function emitApplyPatch(callId, input, base, outputIndex) {
+  const changes = parseCodexPatch(input);
+  if (changes.length === 0) {
+    const toolUse = {
+      type: "tool_use",
+      id: callId,
+      name: "Edit",
+      input: { patch: input }
+    };
+    const entries2 = [
+      {
+        type: "assistant",
+        uuid: callId,
+        ...base,
+        message: { role: "assistant", content: [toolUse] }
+      }
+    ];
+    const outputRecord2 = outputIndex.get(callId);
+    if (outputRecord2) {
+      entries2.push(buildCustomToolResult(callId, callId, outputRecord2, base));
+      outputIndex.delete(callId);
+    }
+    return entries2;
+  }
+  const entries = [];
+  for (let i = 0; i < changes.length; i++) {
+    const change = changes[i];
+    const entryId = i === 0 ? callId : `${callId}-file-${i}`;
+    let toolName;
+    let toolInput;
+    let metadata;
+    switch (change.kind) {
+      case "add":
+        toolName = "Write";
+        toolInput = { file_path: change.path, content: change.newString };
+        break;
+      case "delete":
+        toolName = "Edit";
+        toolInput = { file_path: change.path };
+        metadata = { isDelete: true };
+        break;
+      case "update":
+      default:
+        toolName = "Edit";
+        toolInput = {
+          file_path: change.path,
+          old_string: change.oldString,
+          new_string: change.newString
+        };
+        break;
+    }
+    const toolUse = {
+      type: "tool_use",
+      id: entryId,
+      name: toolName,
+      input: toolInput
+    };
+    entries.push({
+      type: "assistant",
+      uuid: entryId,
+      ...base,
+      message: { role: "assistant", content: [toolUse] },
+      metadata
+    });
+  }
+  const outputRecord = outputIndex.get(callId);
+  if (outputRecord) {
+    const lastEntry = entries[entries.length - 1];
+    entries.push(
+      buildCustomToolResult(lastEntry.uuid ?? callId, callId, outputRecord, base)
+    );
+    outputIndex.delete(callId);
+  }
+  return entries;
+}
+function buildCustomToolResult(parentUuid, callId, outputRecord, base) {
+  const rawOutput = outputRecord.payload.output;
+  let content;
+  let isError = false;
+  try {
+    const parsed = JSON.parse(rawOutput);
+    content = parsed.output ?? rawOutput;
+    if (parsed.success === false || parsed.error) {
+      isError = true;
+    }
+  } catch {
+    content = rawOutput;
+  }
+  const toolResult = {
+    type: "tool_result",
+    tool_use_id: callId,
+    content,
+    is_error: isError
+  };
+  return {
+    type: "result",
+    uuid: `${parentUuid}-result`,
+    parentUuid,
+    sessionId: base.sessionId,
+    vendor: base.vendor,
+    timestamp: outputRecord.timestamp,
+    cwd: base.cwd,
+    message: {
+      role: "tool",
+      content: [toolResult]
+    }
+  };
+}
+function emitWebSearchCall(payload, base, counter) {
+  const action = payload.action;
+  const query = action?.query;
+  const status = payload.status;
+  const id = generateId(base.sessionId, counter);
+  const toolUse = {
+    type: "tool_use",
+    id,
+    name: "WebSearch",
+    input: { query: query ?? "" }
+  };
+  const entries = [
+    {
+      type: "assistant",
+      uuid: id,
+      ...base,
+      message: {
+        role: "assistant",
+        content: [toolUse]
+      },
+      metadata: { action }
+    }
+  ];
+  if (status === "completed") {
+    const toolResult = {
+      type: "tool_result",
+      tool_use_id: id,
+      content: "",
+      is_error: false
+    };
+    entries.push({
+      type: "result",
+      uuid: `${id}-result`,
+      parentUuid: id,
+      ...base,
+      message: {
+        role: "tool",
+        content: [toolResult]
+      }
+    });
+  }
+  return entries;
+}
+function emitOrphanedOutput(payload, subtype, base, outputIndex, _counter) {
+  const callId = payload.call_id;
+  if (!callId)
+    return [];
+  if (!outputIndex.has(callId))
+    return [];
+  const rawOutput = payload.output;
+  let content;
+  let isError = false;
+  if (subtype === "function_call_output") {
+    const parsed = parseExecOutputHeader(rawOutput);
+    content = parsed.body;
+    isError = parsed.exitCode !== 0;
+  } else {
+    content = rawOutput;
+  }
+  const toolResult = {
+    type: "tool_result",
+    tool_use_id: callId,
+    content,
+    is_error: isError
+  };
+  outputIndex.delete(callId);
+  return [
+    {
+      type: "result",
+      uuid: `${callId}-result`,
+      parentUuid: callId,
+      ...base,
+      message: {
+        role: "tool",
+        content: [toolResult]
+      }
+    }
+  ];
+}
+function adaptContentItems(items) {
+  if (!Array.isArray(items))
+    return [];
+  const blocks = [];
+  for (const item of items) {
+    switch (item.type) {
+      case "input_text":
+      case "output_text":
+        if (item.text) {
+          blocks.push({ type: "text", text: item.text });
+        }
+        break;
+      case "input_image":
+        if (item.image_url) {
+          const dataUriMatch = item.image_url.match(
+            /^data:(image\/[^;]+);base64,(.+)$/s
+          );
+          if (dataUriMatch) {
+            blocks.push({
+              type: "image",
+              source: {
+                type: "base64",
+                media_type: dataUriMatch[1],
+                data: dataUriMatch[2]
+              }
+            });
+          } else {
+            blocks.push({
+              type: "image",
+              source: {
+                type: "base64",
+                data: item.image_url
+              }
+            });
+          }
+        }
+        break;
+    }
+  }
+  return blocks;
+}
+function mapFunctionCall(name, args) {
+  switch (name) {
+    case "exec_command":
+      return {
+        toolName: "Bash",
+        toolInput: { command: args.cmd ?? "" }
+      };
+    case "shell_command":
+      return {
+        toolName: "Bash",
+        toolInput: { command: args.command ?? "" }
+      };
+    case "view_image":
+      return {
+        toolName: "Read",
+        toolInput: { file_path: args.path ?? "" },
+        metadata: { isImageView: true }
+      };
+    case "update_plan": {
+      const plan = args.plan ?? [];
+      return {
+        toolName: "TodoWrite",
+        toolInput: {
+          todos: plan.map((item) => ({
+            content: item.step,
+            status: item.status,
+            activeForm: item.step
+          }))
+        }
+      };
+    }
+    case "write_stdin":
+      return {
+        toolName: "Bash",
+        toolInput: {
+          command: `(write_stdin to session ${args.session_id ?? "unknown"})`
+        }
+      };
+    default:
+      return { toolName: name, toolInput: args };
+  }
+}
+function parseExecOutputHeader(output) {
+  if (!output)
+    return { exitCode: 0, body: "" };
+  const currentMatch = output.match(/Process exited with code (\d+)/);
+  if (currentMatch) {
+    const exitCode = parseInt(currentMatch[1], 10);
+    const outputIdx = output.indexOf("Output:\n");
+    const body = outputIdx >= 0 ? output.slice(outputIdx + "Output:\n".length) : "";
+    return { exitCode, body };
+  }
+  const legacyMatch = output.match(/Exit code: (\d+)/);
+  if (legacyMatch) {
+    const exitCode = parseInt(legacyMatch[1], 10);
+    const outputIdx = output.indexOf("Output:\n");
+    const body = outputIdx >= 0 ? output.slice(outputIdx + "Output:\n".length) : "";
+    return { exitCode, body };
+  }
+  return { exitCode: 0, body: output };
+}
+function parseCodexPatch(input) {
+  if (!input)
+    return [];
+  const lines = input.split("\n");
+  const changes = [];
+  let currentPath;
+  let currentKind;
+  let oldLines = [];
+  let newLines = [];
+  function flushCurrent() {
+    if (currentPath && currentKind) {
+      changes.push({
+        path: currentPath,
+        kind: currentKind,
+        oldString: oldLines.join("\n"),
+        newString: newLines.join("\n")
+      });
+    }
+    currentPath = void 0;
+    currentKind = void 0;
+    oldLines = [];
+    newLines = [];
+  }
+  for (const line of lines) {
+    const updateMatch = line.match(/^\*\*\* Update File:\s*(.+)$/);
+    if (updateMatch) {
+      flushCurrent();
+      currentPath = updateMatch[1].trim();
+      currentKind = "update";
+      continue;
+    }
+    const addMatch = line.match(/^\*\*\* Add File:\s*(.+)$/);
+    if (addMatch) {
+      flushCurrent();
+      currentPath = addMatch[1].trim();
+      currentKind = "add";
+      continue;
+    }
+    const deleteMatch = line.match(/^\*\*\* Delete File:\s*(.+)$/);
+    if (deleteMatch) {
+      flushCurrent();
+      currentPath = deleteMatch[1].trim();
+      currentKind = "delete";
+      continue;
+    }
+    if (line.startsWith("*** Begin Patch") || line.startsWith("*** End Patch")) {
+      continue;
+    }
+    if (line.startsWith("@@")) {
+      continue;
+    }
+    if (!currentPath)
+      continue;
+    if (line.startsWith("-")) {
+      oldLines.push(line.slice(1));
+    } else if (line.startsWith("+")) {
+      newLines.push(line.slice(1));
+    } else if (line.startsWith(" ")) {
+      oldLines.push(line.slice(1));
+      newLines.push(line.slice(1));
+    }
+  }
+  flushCurrent();
+  return changes;
+}
+function generateId(sessionId, counter) {
+  return `codex-jsonl-${sessionId.slice(0, 8)}-${counter}`;
+}
+
+// src/recall/message-ingest.ts
+function extractEntryText(entry) {
+  const msg = entry.message;
+  if (!msg)
+    return "";
+  if (typeof msg.content === "string")
+    return msg.content.trim();
+  if (Array.isArray(msg.content)) {
+    return msg.content.filter((b) => b.type === "text").map((b) => b.text?.trim()).filter(Boolean).join("\n\n");
+  }
+  return "";
+}
+async function ingestSessionMessages(sessionId, transcriptPath, vendor, options) {
+  const rawProjectId = options?.projectId ?? null;
+  const projectId = rawProjectId ? normalizePath(rawProjectId) : null;
+  let rawEntries;
+  try {
+    if (vendor === "claude") {
+      const raw = parseJsonlFile(transcriptPath);
+      rawEntries = adaptClaudeEntries(raw);
+    } else {
+      const envelopes = parseCodexJsonlFile(transcriptPath);
+      rawEntries = adaptCodexJsonlRecords(envelopes, sessionId);
+    }
+  } catch (err) {
+    return {
+      sessionId,
+      chunksCreated: 0,
+      skipped: false,
+      error: `Failed to load session: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  if (rawEntries.length === 0) {
+    return { sessionId, chunksCreated: 0, skipped: true };
+  }
+  const filtered = stripToolContent(rawEntries);
+  const topLevel = filtered.filter((e) => !e.parentToolUseID);
+  const records = [];
+  for (let i = 0; i < topLevel.length; i++) {
+    const entry = topLevel[i];
+    if (!entry.uuid)
+      continue;
+    const text = extractEntryText(entry);
+    if (!text)
+      continue;
+    const createdAt = entry.timestamp ? new Date(entry.timestamp).getTime() : Date.now();
+    records.push({
+      message_id: entry.uuid,
+      session_id: sessionId,
+      message_seq: i,
+      message_text: text,
+      project_id: projectId,
+      created_at: createdAt,
+      message_role: entry.message?.role ?? entry.type ?? null
+    });
+  }
+  if (records.length === 0) {
+    return { sessionId, chunksCreated: 0, skipped: true };
+  }
+  try {
+    insertMessages(records, options?.force ? { replaceSessionId: sessionId } : void 0);
+  } catch (err) {
+    return {
+      sessionId,
+      chunksCreated: 0,
+      skipped: false,
+      error: `DB insert failed: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  return {
+    sessionId,
+    chunksCreated: records.length,
+    skipped: false
+  };
+}
+
+// src/hooks/stop-hook.ts
+init_paths();
+var import_fs = require("fs");
+var import_child_process = require("child_process");
+var import_path = require("path");
+function vendorForTranscript(transcriptPath) {
+  const p = transcriptPath.replace(/\\/g, "/");
+  return p.includes("/.codex/") ? "codex" : "claude";
+}
+function logStopHook(line) {
+  try {
+    (0, import_fs.mkdirSync)(logsDir(), { recursive: true });
+    (0, import_fs.appendFileSync)((0, import_path.join)(logsDir(), "stop-hook.log"), line);
+  } catch {
+  }
+}
+async function runStopHook() {
+  let data = "";
+  for await (const chunk of process.stdin)
+    data += chunk;
+  let payload;
+  try {
+    payload = JSON.parse(data);
+  } catch {
+    process.exit(0);
+  }
+  if (!payload?.session_id || !payload?.transcript_path)
+    process.exit(0);
+  if (payload.stop_hook_active)
+    process.exit(0);
+  try {
+    getDb(dbPath()).exec("PRAGMA busy_timeout = 500;");
+    const vendor = vendorForTranscript(payload.transcript_path);
+    const result = await ingestSessionMessages(
+      payload.session_id,
+      payload.transcript_path,
+      vendor,
+      { projectId: payload.cwd ?? void 0 }
+    );
+    if (result?.error) {
+      logStopHook(
+        `${(/* @__PURE__ */ new Date()).toISOString()} ingest-failed sid=${payload.session_id} err=${result.error}
+`
+      );
+    }
+  } catch (e) {
+    logStopHook(
+      `${(/* @__PURE__ */ new Date()).toISOString()} ingest-failed sid=${payload.session_id} err=${e.message}
+`
+    );
+  }
+  (0, import_child_process.spawn)(
+    process.execPath,
+    [(0, import_path.join)(binDir(), "embed-pending.js"), payload.session_id],
+    {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true
+    }
+  ).unref();
+  process.exit(0);
+}
+if (typeof require !== "undefined" && typeof module !== "undefined" && require.main === module) {
+  void runStopHook();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  vendorForTranscript
+});