@polka-codes/runner 0.9.89 → 0.9.90

package/dist/index.js

@@ -37641,769 +37641,2288 @@ var require_mimeScore = __commonJS((exports, module) => {
   };
 });
 
-// ../../node_modules/better-sqlite3/lib/util.js
-var require_util3 = __commonJS((exports) => {
-  exports.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;
-  };
-  exports.cppdb = Symbol();
-  exports.inspect = Symbol.for("nodejs.util.inspect.custom");
-});
-
-// ../../node_modules/better-sqlite3/lib/sqlite-error.js
-var require_sqlite_error = __commonJS((exports, module) => {
-  var descriptor = { value: "SqliteError", writable: true, enumerable: false, configurable: true };
-  function SqliteError(message, code) {
-    if (new.target !== SqliteError) {
-      return new SqliteError(message, code);
-    }
-    if (typeof code !== "string") {
-      throw new TypeError("Expected second argument to be a string");
-    }
-    Error.call(this, message);
-    descriptor.value = "" + message;
-    Object.defineProperty(this, "message", descriptor);
-    Error.captureStackTrace(this, SqliteError);
-    this.code = code;
-  }
-  Object.setPrototypeOf(SqliteError, Error);
-  Object.setPrototypeOf(SqliteError.prototype, Error.prototype);
-  Object.defineProperty(SqliteError.prototype, "name", descriptor);
-  module.exports = SqliteError;
-});
-
-// ../../node_modules/file-uri-to-path/index.js
-var require_file_uri_to_path = __commonJS((exports, module) => {
-  var sep = __require("path").sep || "/";
-  module.exports = fileUriToPath;
-  function fileUriToPath(uri) {
-    if (typeof uri != "string" || uri.length <= 7 || uri.substring(0, 7) != "file://") {
-      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 path = rest.substring(firstSlash + 1);
-    if (host == "localhost")
-      host = "";
-    if (host) {
-      host = sep + sep + host;
-    }
-    path = path.replace(/^(.+)\|/, "$1:");
-    if (sep == "\\") {
-      path = path.replace(/\//g, "\\");
-    }
-    if (/^.+\:/.test(path)) {} else {
-      path = sep + path;
-    }
-    return host + path;
-  }
-});
-
-// ../../node_modules/bindings/bindings.js
-var require_bindings = __commonJS((exports, module) => {
-  var __filename = "/Users/xiliangchen/projects/polka-codes/node_modules/bindings/bindings.js";
-  var fs4 = __require("fs");
-  var path = __require("path");
-  var fileURLToPath = require_file_uri_to_path();
-  var join3 = path.join;
-  var dirname2 = path.dirname;
-  var exists = fs4.accessSync && function(path2) {
-    try {
-      fs4.accessSync(path2);
-    } catch (e2) {
-      return false;
-    }
-    return true;
-  } || fs4.existsSync || path.existsSync;
-  var defaults = {
-    arrow: process.env.NODE_BINDINGS_ARROW || " → ",
-    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: [
-      ["module_root", "build", "bindings"],
-      ["module_root", "build", "Debug", "bindings"],
-      ["module_root", "build", "Release", "bindings"],
-      ["module_root", "out", "Debug", "bindings"],
-      ["module_root", "Debug", "bindings"],
-      ["module_root", "out", "Release", "bindings"],
-      ["module_root", "Release", "bindings"],
-      ["module_root", "build", "default", "bindings"],
-      ["module_root", "compiled", "version", "platform", "arch", "bindings"],
-      ["module_root", "addon-build", "release", "install-root", "bindings"],
-      ["module_root", "addon-build", "debug", "install-root", "bindings"],
-      ["module_root", "addon-build", "default", "install-root", "bindings"],
-      ["module_root", "lib", "binding", "nodePreGyp", "bindings"]
-    ]
-  };
-  function bindings(opts) {
-    if (typeof opts == "string") {
-      opts = { bindings: opts };
-    } else if (!opts) {
-      opts = {};
-    }
-    Object.keys(defaults).map(function(i3) {
-      if (!(i3 in opts))
-        opts[i3] = defaults[i3];
-    });
-    if (!opts.module_root) {
-      opts.module_root = exports.getRoot(exports.getFileName());
-    }
-    if (path.extname(opts.bindings) != ".node") {
-      opts.bindings += ".node";
-    }
-    var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
-    var tries = [], i2 = 0, l = opts.try.length, n, b, err;
-    for (;i2 < l; i2++) {
-      n = join3.apply(null, opts.try[i2].map(function(p) {
-        return opts[p] || p;
-      }));
-      tries.push(n);
-      try {
-        b = opts.path ? requireFunc.resolve(n) : requireFunc(n);
-        if (!opts.path) {
-          b.path = n;
+// ../../node_modules/sql.js/dist/sql-wasm.js
+var require_sql_wasm = __commonJS((exports, module) => {
+  var __dirname = "/Users/xiliangchen/projects/polka-codes/node_modules/sql.js/dist";
+  var initSqlJsPromise = undefined;
+  var initSqlJs = function(moduleConfig) {
+    if (initSqlJsPromise) {
+      return initSqlJsPromise;
+    }
+    initSqlJsPromise = new Promise(function(resolveModule, reject) {
+      var Module = typeof moduleConfig !== "undefined" ? moduleConfig : {};
+      var originalOnAbortFunction = Module["onAbort"];
+      Module["onAbort"] = function(errorThatCausedAbort) {
+        reject(new Error(errorThatCausedAbort));
+        if (originalOnAbortFunction) {
+          originalOnAbortFunction(errorThatCausedAbort);
         }
-        return b;
-      } catch (e2) {
-        if (e2.code !== "MODULE_NOT_FOUND" && e2.code !== "QUALIFIED_PATH_RESOLUTION_FAILED" && !/not find/i.test(e2.message)) {
-          throw e2;
+      };
+      Module["postRun"] = Module["postRun"] || [];
+      Module["postRun"].push(function() {
+        resolveModule(Module);
+      });
+      module = undefined;
+      var f3;
+      f3 ||= typeof Module != "undefined" ? Module : {};
+      var aa = typeof window == "object", ba = typeof WorkerGlobalScope != "undefined", ca = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string" && process.type != "renderer";
+      f3.onRuntimeInitialized = function() {
+        function a(g, l) {
+          switch (typeof l) {
+            case "boolean":
+              dc(g, l ? 1 : 0);
+              break;
+            case "number":
+              ec(g, l);
+              break;
+            case "string":
+              fc(g, l, -1, -1);
+              break;
+            case "object":
+              if (l === null)
+                lb(g);
+              else if (l.length != null) {
+                var n = da(l, ea);
+                gc(g, n, l.length, -1);
+                fa(n);
+              } else
+                va(g, "Wrong API use : tried to return a value of an unknown type (" + l + ").", -1);
+              break;
+            default:
+              lb(g);
+          }
         }
-      }
-    }
-    err = new Error(`Could not locate the bindings file. Tried:
-` + tries.map(function(a) {
-      return opts.arrow + a;
-    }).join(`
-`));
-    err.tries = tries;
-    throw err;
-  }
-  module.exports = exports = bindings;
-  exports.getFileName = function getFileName(calling_file) {
-    var { prepareStackTrace: origPST, stackTraceLimit: origSTL } = Error, dummy = {}, fileName;
-    Error.stackTraceLimit = 10;
-    Error.prepareStackTrace = function(e2, st) {
-      for (var i2 = 0, l = st.length;i2 < l; i2++) {
-        fileName = st[i2].getFileName();
-        if (fileName !== __filename) {
-          if (calling_file) {
-            if (fileName !== calling_file) {
+        function b(g, l) {
+          for (var n = [], r2 = 0;r2 < g; r2 += 1) {
+            var t2 = m2(l + 4 * r2, "i32"), y = hc(t2);
+            if (y === 1 || y === 2)
+              t2 = ic(t2);
+            else if (y === 3)
+              t2 = jc(t2);
+            else if (y === 4) {
+              y = t2;
+              t2 = kc(y);
+              y = lc(y);
+              for (var L = new Uint8Array(t2), J = 0;J < t2; J += 1)
+                L[J] = p[y + J];
+              t2 = L;
+            } else
+              t2 = null;
+            n.push(t2);
+          }
+          return n;
+        }
+        function c(g, l) {
+          this.Qa = g;
+          this.db = l;
+          this.Oa = 1;
+          this.lb = [];
+        }
+        function d(g, l) {
+          this.db = l;
+          l = ha(g) + 1;
+          this.eb = ia(l);
+          if (this.eb === null)
+            throw Error("Unable to allocate memory for the SQL string");
+          u(g, x2, this.eb, l);
+          this.kb = this.eb;
+          this.Za = this.pb = null;
+        }
+        function e2(g) {
+          this.filename = "dbfile_" + (4294967295 * Math.random() >>> 0);
+          if (g != null) {
+            var l = this.filename, n = "/", r2 = l;
+            n && (n = typeof n == "string" ? n : ja(n), r2 = l ? ka(n + "/" + l) : n);
+            l = la(true, true);
+            r2 = ma(r2, l);
+            if (g) {
+              if (typeof g == "string") {
+                n = Array(g.length);
+                for (var t2 = 0, y = g.length;t2 < y; ++t2)
+                  n[t2] = g.charCodeAt(t2);
+                g = n;
+              }
+              na(r2, l | 146);
+              n = oa(r2, 577);
+              pa(n, g, 0, g.length, 0);
+              qa(n);
+              na(r2, l);
+            }
+          }
+          this.handleError(q(this.filename, h2));
+          this.db = m2(h2, "i32");
+          ob(this.db);
+          this.fb = {};
+          this.Sa = {};
+        }
+        var h2 = z2(4), k = f3.cwrap, q = k("sqlite3_open", "number", ["string", "number"]), w = k("sqlite3_close_v2", "number", ["number"]), v = k("sqlite3_exec", "number", ["number", "string", "number", "number", "number"]), C = k("sqlite3_changes", "number", ["number"]), G = k("sqlite3_prepare_v2", "number", ["number", "string", "number", "number", "number"]), pb = k("sqlite3_sql", "string", ["number"]), nc = k("sqlite3_normalized_sql", "string", ["number"]), qb = k("sqlite3_prepare_v2", "number", ["number", "number", "number", "number", "number"]), oc = k("sqlite3_bind_text", "number", ["number", "number", "number", "number", "number"]), rb = k("sqlite3_bind_blob", "number", ["number", "number", "number", "number", "number"]), pc = k("sqlite3_bind_double", "number", ["number", "number", "number"]), qc = k("sqlite3_bind_int", "number", ["number", "number", "number"]), rc = k("sqlite3_bind_parameter_index", "number", ["number", "string"]), sc = k("sqlite3_step", "number", ["number"]), tc = k("sqlite3_errmsg", "string", ["number"]), uc = k("sqlite3_column_count", "number", ["number"]), vc = k("sqlite3_data_count", "number", ["number"]), wc = k("sqlite3_column_double", "number", ["number", "number"]), sb = k("sqlite3_column_text", "string", ["number", "number"]), xc = k("sqlite3_column_blob", "number", ["number", "number"]), yc = k("sqlite3_column_bytes", "number", [
+          "number",
+          "number"
+        ]), zc = k("sqlite3_column_type", "number", ["number", "number"]), Ac = k("sqlite3_column_name", "string", ["number", "number"]), Bc = k("sqlite3_reset", "number", ["number"]), Cc = k("sqlite3_clear_bindings", "number", ["number"]), Dc = k("sqlite3_finalize", "number", ["number"]), tb = k("sqlite3_create_function_v2", "number", "number string number number number number number number number".split(" ")), hc = k("sqlite3_value_type", "number", ["number"]), kc = k("sqlite3_value_bytes", "number", ["number"]), jc = k("sqlite3_value_text", "string", ["number"]), lc = k("sqlite3_value_blob", "number", ["number"]), ic = k("sqlite3_value_double", "number", ["number"]), ec = k("sqlite3_result_double", "", ["number", "number"]), lb = k("sqlite3_result_null", "", ["number"]), fc = k("sqlite3_result_text", "", ["number", "string", "number", "number"]), gc = k("sqlite3_result_blob", "", ["number", "number", "number", "number"]), dc = k("sqlite3_result_int", "", ["number", "number"]), va = k("sqlite3_result_error", "", ["number", "string", "number"]), ub = k("sqlite3_aggregate_context", "number", ["number", "number"]), ob = k("RegisterExtensionFunctions", "number", ["number"]), vb = k("sqlite3_update_hook", "number", ["number", "number", "number"]);
+        c.prototype.bind = function(g) {
+          if (!this.Qa)
+            throw "Statement closed";
+          this.reset();
+          return Array.isArray(g) ? this.Cb(g) : g != null && typeof g === "object" ? this.Db(g) : true;
+        };
+        c.prototype.step = function() {
+          if (!this.Qa)
+            throw "Statement closed";
+          this.Oa = 1;
+          var g = sc(this.Qa);
+          switch (g) {
+            case 100:
+              return true;
+            case 101:
+              return false;
+            default:
+              throw this.db.handleError(g);
+          }
+        };
+        c.prototype.wb = function(g) {
+          g == null && (g = this.Oa, this.Oa += 1);
+          return wc(this.Qa, g);
+        };
+        c.prototype.Gb = function(g) {
+          g == null && (g = this.Oa, this.Oa += 1);
+          g = sb(this.Qa, g);
+          if (typeof BigInt !== "function")
+            throw Error("BigInt is not supported");
+          return BigInt(g);
+        };
+        c.prototype.Hb = function(g) {
+          g == null && (g = this.Oa, this.Oa += 1);
+          return sb(this.Qa, g);
+        };
+        c.prototype.getBlob = function(g) {
+          g == null && (g = this.Oa, this.Oa += 1);
+          var l = yc(this.Qa, g);
+          g = xc(this.Qa, g);
+          for (var n = new Uint8Array(l), r2 = 0;r2 < l; r2 += 1)
+            n[r2] = p[g + r2];
+          return n;
+        };
+        c.prototype.get = function(g, l) {
+          l = l || {};
+          g != null && this.bind(g) && this.step();
+          g = [];
+          for (var n = vc(this.Qa), r2 = 0;r2 < n; r2 += 1)
+            switch (zc(this.Qa, r2)) {
+              case 1:
+                var t2 = l.useBigInt ? this.Gb(r2) : this.wb(r2);
+                g.push(t2);
+                break;
+              case 2:
+                g.push(this.wb(r2));
+                break;
+              case 3:
+                g.push(this.Hb(r2));
+                break;
+              case 4:
+                g.push(this.getBlob(r2));
+                break;
+              default:
+                g.push(null);
+            }
+          return g;
+        };
+        c.prototype.getColumnNames = function() {
+          for (var g = [], l = uc(this.Qa), n = 0;n < l; n += 1)
+            g.push(Ac(this.Qa, n));
+          return g;
+        };
+        c.prototype.getAsObject = function(g, l) {
+          g = this.get(g, l);
+          l = this.getColumnNames();
+          for (var n = {}, r2 = 0;r2 < l.length; r2 += 1)
+            n[l[r2]] = g[r2];
+          return n;
+        };
+        c.prototype.getSQL = function() {
+          return pb(this.Qa);
+        };
+        c.prototype.getNormalizedSQL = function() {
+          return nc(this.Qa);
+        };
+        c.prototype.run = function(g) {
+          g != null && this.bind(g);
+          this.step();
+          return this.reset();
+        };
+        c.prototype.sb = function(g, l) {
+          l == null && (l = this.Oa, this.Oa += 1);
+          g = ra(g);
+          var n = da(g, ea);
+          this.lb.push(n);
+          this.db.handleError(oc(this.Qa, l, n, g.length - 1, 0));
+        };
+        c.prototype.Bb = function(g, l) {
+          l == null && (l = this.Oa, this.Oa += 1);
+          var n = da(g, ea);
+          this.lb.push(n);
+          this.db.handleError(rb(this.Qa, l, n, g.length, 0));
+        };
+        c.prototype.rb = function(g, l) {
+          l == null && (l = this.Oa, this.Oa += 1);
+          this.db.handleError((g === (g | 0) ? qc : pc)(this.Qa, l, g));
+        };
+        c.prototype.Eb = function(g) {
+          g == null && (g = this.Oa, this.Oa += 1);
+          rb(this.Qa, g, 0, 0, 0);
+        };
+        c.prototype.tb = function(g, l) {
+          l == null && (l = this.Oa, this.Oa += 1);
+          switch (typeof g) {
+            case "string":
+              this.sb(g, l);
+              return;
+            case "number":
+              this.rb(g, l);
+              return;
+            case "bigint":
+              this.sb(g.toString(), l);
+              return;
+            case "boolean":
+              this.rb(g + 0, l);
               return;
+            case "object":
+              if (g === null) {
+                this.Eb(l);
+                return;
+              }
+              if (g.length != null) {
+                this.Bb(g, l);
+                return;
+              }
+          }
+          throw "Wrong API use : tried to bind a value of an unknown type (" + g + ").";
+        };
+        c.prototype.Db = function(g) {
+          var l = this;
+          Object.keys(g).forEach(function(n) {
+            var r2 = rc(l.Qa, n);
+            r2 !== 0 && l.tb(g[n], r2);
+          });
+          return true;
+        };
+        c.prototype.Cb = function(g) {
+          for (var l = 0;l < g.length; l += 1)
+            this.tb(g[l], l + 1);
+          return true;
+        };
+        c.prototype.reset = function() {
+          this.freemem();
+          return Cc(this.Qa) === 0 && Bc(this.Qa) === 0;
+        };
+        c.prototype.freemem = function() {
+          for (var g;(g = this.lb.pop()) !== undefined; )
+            fa(g);
+        };
+        c.prototype.free = function() {
+          this.freemem();
+          var g = Dc(this.Qa) === 0;
+          delete this.db.fb[this.Qa];
+          this.Qa = 0;
+          return g;
+        };
+        d.prototype.next = function() {
+          if (this.eb === null)
+            return { done: true };
+          this.Za !== null && (this.Za.free(), this.Za = null);
+          if (!this.db.db)
+            throw this.mb(), Error("Database closed");
+          var g = sa(), l = z2(4);
+          ta(h2);
+          ta(l);
+          try {
+            this.db.handleError(qb(this.db.db, this.kb, -1, h2, l));
+            this.kb = m2(l, "i32");
+            var n = m2(h2, "i32");
+            if (n === 0)
+              return this.mb(), { done: true };
+            this.Za = new c(n, this.db);
+            this.db.fb[n] = this.Za;
+            return { value: this.Za, done: false };
+          } catch (r2) {
+            throw this.pb = ua(this.kb), this.mb(), r2;
+          } finally {
+            wa(g);
+          }
+        };
+        d.prototype.mb = function() {
+          fa(this.eb);
+          this.eb = null;
+        };
+        d.prototype.getRemainingSQL = function() {
+          return this.pb !== null ? this.pb : ua(this.kb);
+        };
+        typeof Symbol === "function" && typeof Symbol.iterator === "symbol" && (d.prototype[Symbol.iterator] = function() {
+          return this;
+        });
+        e2.prototype.run = function(g, l) {
+          if (!this.db)
+            throw "Database closed";
+          if (l) {
+            g = this.prepare(g, l);
+            try {
+              g.step();
+            } finally {
+              g.free();
             }
-          } else {
-            return;
+          } else
+            this.handleError(v(this.db, g, 0, 0, h2));
+          return this;
+        };
+        e2.prototype.exec = function(g, l, n) {
+          if (!this.db)
+            throw "Database closed";
+          var r2 = sa(), t2 = null;
+          try {
+            var y = xa(g), L = z2(4);
+            for (g = [];m2(y, "i8") !== 0; ) {
+              ta(h2);
+              ta(L);
+              this.handleError(qb(this.db, y, -1, h2, L));
+              var J = m2(h2, "i32");
+              y = m2(L, "i32");
+              if (J !== 0) {
+                var I = null;
+                t2 = new c(J, this);
+                for (l != null && t2.bind(l);t2.step(); )
+                  I === null && (I = { columns: t2.getColumnNames(), values: [] }, g.push(I)), I.values.push(t2.get(null, n));
+                t2.free();
+              }
+            }
+            return g;
+          } catch (M) {
+            throw t2 && t2.free(), M;
+          } finally {
+            wa(r2);
           }
-        }
-      }
-    };
-    Error.captureStackTrace(dummy);
-    dummy.stack;
-    Error.prepareStackTrace = origPST;
-    Error.stackTraceLimit = origSTL;
-    var fileSchema = "file://";
-    if (fileName.indexOf(fileSchema) === 0) {
-      fileName = fileURLToPath(fileName);
-    }
-    return fileName;
-  };
-  exports.getRoot = function getRoot(file2) {
-    var dir = dirname2(file2), prev;
-    while (true) {
-      if (dir === ".") {
-        dir = process.cwd();
+        };
+        e2.prototype.each = function(g, l, n, r2, t2) {
+          typeof l === "function" && (r2 = n, n = l, l = undefined);
+          g = this.prepare(g, l);
+          try {
+            for (;g.step(); )
+              n(g.getAsObject(null, t2));
+          } finally {
+            g.free();
+          }
+          if (typeof r2 === "function")
+            return r2();
+        };
+        e2.prototype.prepare = function(g, l) {
+          ta(h2);
+          this.handleError(G(this.db, g, -1, h2, 0));
+          g = m2(h2, "i32");
+          if (g === 0)
+            throw "Nothing to prepare";
+          var n = new c(g, this);
+          l != null && n.bind(l);
+          return this.fb[g] = n;
+        };
+        e2.prototype.iterateStatements = function(g) {
+          return new d(g, this);
+        };
+        e2.prototype["export"] = function() {
+          Object.values(this.fb).forEach(function(l) {
+            l.free();
+          });
+          Object.values(this.Sa).forEach(A2);
+          this.Sa = {};
+          this.handleError(w(this.db));
+          var g = ya(this.filename);
+          this.handleError(q(this.filename, h2));
+          this.db = m2(h2, "i32");
+          ob(this.db);
+          return g;
+        };
+        e2.prototype.close = function() {
+          this.db !== null && (Object.values(this.fb).forEach(function(g) {
+            g.free();
+          }), Object.values(this.Sa).forEach(A2), this.Sa = {}, this.Ya && (A2(this.Ya), this.Ya = undefined), this.handleError(w(this.db)), za("/" + this.filename), this.db = null);
+        };
+        e2.prototype.handleError = function(g) {
+          if (g === 0)
+            return null;
+          g = tc(this.db);
+          throw Error(g);
+        };
+        e2.prototype.getRowsModified = function() {
+          return C(this.db);
+        };
+        e2.prototype.create_function = function(g, l) {
+          Object.prototype.hasOwnProperty.call(this.Sa, g) && (A2(this.Sa[g]), delete this.Sa[g]);
+          var n = Aa(function(r2, t2, y) {
+            t2 = b(t2, y);
+            try {
+              var L = l.apply(null, t2);
+            } catch (J) {
+              va(r2, J, -1);
+              return;
+            }
+            a(r2, L);
+          }, "viii");
+          this.Sa[g] = n;
+          this.handleError(tb(this.db, g, l.length, 1, 0, n, 0, 0, 0));
+          return this;
+        };
+        e2.prototype.create_aggregate = function(g, l) {
+          var n = l.init || function() {
+            return null;
+          }, r2 = l.finalize || function(I) {
+            return I;
+          }, t2 = l.step;
+          if (!t2)
+            throw "An aggregate function must have a step function in " + g;
+          var y = {};
+          Object.hasOwnProperty.call(this.Sa, g) && (A2(this.Sa[g]), delete this.Sa[g]);
+          l = g + "__finalize";
+          Object.hasOwnProperty.call(this.Sa, l) && (A2(this.Sa[l]), delete this.Sa[l]);
+          var L = Aa(function(I, M, Ra) {
+            var X = ub(I, 1);
+            Object.hasOwnProperty.call(y, X) || (y[X] = n());
+            M = b(M, Ra);
+            M = [y[X]].concat(M);
+            try {
+              y[X] = t2.apply(null, M);
+            } catch (Fc) {
+              delete y[X], va(I, Fc, -1);
+            }
+          }, "viii"), J = Aa(function(I) {
+            var M = ub(I, 1);
+            try {
+              var Ra = r2(y[M]);
+            } catch (X) {
+              delete y[M];
+              va(I, X, -1);
+              return;
+            }
+            a(I, Ra);
+            delete y[M];
+          }, "vi");
+          this.Sa[g] = L;
+          this.Sa[l] = J;
+          this.handleError(tb(this.db, g, t2.length - 1, 1, 0, 0, L, J, 0));
+          return this;
+        };
+        e2.prototype.updateHook = function(g) {
+          this.Ya && (vb(this.db, 0, 0), A2(this.Ya), this.Ya = undefined);
+          g && (this.Ya = Aa(function(l, n, r2, t2, y) {
+            switch (n) {
+              case 18:
+                l = "insert";
+                break;
+              case 23:
+                l = "update";
+                break;
+              case 9:
+                l = "delete";
+                break;
+              default:
+                throw "unknown operationCode in updateHook callback: " + n;
+            }
+            r2 = r2 ? B(x2, r2) : "";
+            t2 = t2 ? B(x2, t2) : "";
+            if (y > Number.MAX_SAFE_INTEGER)
+              throw "rowId too big to fit inside a Number";
+            g(l, r2, t2, Number(y));
+          }, "viiiij"), vb(this.db, this.Ya, 0));
+        };
+        f3.Database = e2;
+      };
+      var Ba = { ...f3 }, Ca = "./this.program", Da = (a, b) => {
+        throw b;
+      }, D = "", Ea, Fa;
+      if (ca) {
+        var fs4 = __require("fs");
+        __require("path");
+        D = __dirname + "/";
+        Fa = (a) => {
+          a = Ga(a) ? new URL(a) : a;
+          return fs4.readFileSync(a);
+        };
+        Ea = async (a) => {
+          a = Ga(a) ? new URL(a) : a;
+          return fs4.readFileSync(a, undefined);
+        };
+        !f3.thisProgram && 1 < process.argv.length && (Ca = process.argv[1].replace(/\\/g, "/"));
+        process.argv.slice(2);
+        typeof module != "undefined" && (module.exports = f3);
+        Da = (a, b) => {
+          process.exitCode = a;
+          throw b;
+        };
+      } else if (aa || ba)
+        ba ? D = self.location.href : typeof document != "undefined" && document.currentScript && (D = document.currentScript.src), D = D.startsWith("blob:") ? "" : D.slice(0, D.replace(/[?#].*/, "").lastIndexOf("/") + 1), ba && (Fa = (a) => {
+          var b = new XMLHttpRequest;
+          b.open("GET", a, false);
+          b.responseType = "arraybuffer";
+          b.send(null);
+          return new Uint8Array(b.response);
+        }), Ea = async (a) => {
+          if (Ga(a))
+            return new Promise((c, d) => {
+              var e2 = new XMLHttpRequest;
+              e2.open("GET", a, true);
+              e2.responseType = "arraybuffer";
+              e2.onload = () => {
+                e2.status == 200 || e2.status == 0 && e2.response ? c(e2.response) : d(e2.status);
+              };
+              e2.onerror = d;
+              e2.send(null);
+            });
+          var b = await fetch(a, { credentials: "same-origin" });
+          if (b.ok)
+            return b.arrayBuffer();
+          throw Error(b.status + " : " + b.url);
+        };
+      var Ha = f3.print || console.log.bind(console), Ia = f3.printErr || console.error.bind(console);
+      Object.assign(f3, Ba);
+      Ba = null;
+      f3.thisProgram && (Ca = f3.thisProgram);
+      var Ja = f3.wasmBinary, Ka, La = false, Ma, p, x2, Na, E, F2, Oa, H, Pa, Ga = (a) => a.startsWith("file://");
+      function Qa() {
+        var a = Ka.buffer;
+        f3.HEAP8 = p = new Int8Array(a);
+        f3.HEAP16 = Na = new Int16Array(a);
+        f3.HEAPU8 = x2 = new Uint8Array(a);
+        f3.HEAPU16 = new Uint16Array(a);
+        f3.HEAP32 = E = new Int32Array(a);
+        f3.HEAPU32 = F2 = new Uint32Array(a);
+        f3.HEAPF32 = Oa = new Float32Array(a);
+        f3.HEAPF64 = Pa = new Float64Array(a);
+        f3.HEAP64 = H = new BigInt64Array(a);
+        f3.HEAPU64 = new BigUint64Array(a);
+      }
+      var K = 0, Sa = null;
+      function Ta(a) {
+        f3.onAbort?.(a);
+        a = "Aborted(" + a + ")";
+        Ia(a);
+        La = true;
+        throw new WebAssembly.RuntimeError(a + ". Build with -sASSERTIONS for more info.");
+      }
+      var Ua;
+      async function Va(a) {
+        if (!Ja)
+          try {
+            var b = await Ea(a);
+            return new Uint8Array(b);
+          } catch {}
+        if (a == Ua && Ja)
+          a = new Uint8Array(Ja);
+        else if (Fa)
+          a = Fa(a);
+        else
+          throw "both async and sync fetching of the wasm failed";
+        return a;
       }
-      if (exists(join3(dir, "package.json")) || exists(join3(dir, "node_modules"))) {
-        return dir;
+      async function Wa(a, b) {
+        try {
+          var c = await Va(a);
+          return await WebAssembly.instantiate(c, b);
+        } catch (d) {
+          Ia(`failed to asynchronously prepare wasm: ${d}`), Ta(d);
+        }
       }
-      if (prev === dir) {
-        throw new Error('Could not find module root given file: "' + file2 + '". Do you have a `package.json` file? ');
+      async function Xa(a) {
+        var b = Ua;
+        if (!Ja && typeof WebAssembly.instantiateStreaming == "function" && !Ga(b) && !ca)
+          try {
+            var c = fetch(b, { credentials: "same-origin" });
+            return await WebAssembly.instantiateStreaming(c, a);
+          } catch (d) {
+            Ia(`wasm streaming compile failed: ${d}`), Ia("falling back to ArrayBuffer instantiation");
+          }
+        return Wa(b, a);
       }
-      prev = dir;
-      dir = join3(dir, "..");
-    }
-  };
-});
-
-// ../../node_modules/better-sqlite3/lib/methods/wrappers.js
-var require_wrappers = __commonJS((exports) => {
-  var { cppdb } = require_util3();
-  exports.prepare = function prepare(sql) {
-    return this[cppdb].prepare(sql, this, false);
-  };
-  exports.exec = function exec(sql) {
-    this[cppdb].exec(sql);
-    return this;
-  };
-  exports.close = function close() {
-    this[cppdb].close();
-    return this;
-  };
-  exports.loadExtension = function loadExtension(...args) {
-    this[cppdb].loadExtension(...args);
-    return this;
-  };
-  exports.defaultSafeIntegers = function defaultSafeIntegers(...args) {
-    this[cppdb].defaultSafeIntegers(...args);
-    return this;
-  };
-  exports.unsafeMode = function unsafeMode(...args) {
-    this[cppdb].unsafeMode(...args);
-    return this;
-  };
-  exports.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
-    }
-  };
-});
 
-// ../../node_modules/better-sqlite3/lib/methods/transaction.js
-var require_transaction = __commonJS((exports, module) => {
-  var { cppdb } = require_util3();
-  var controllers = new WeakMap;
-  module.exports = function transaction(fn) {
-    if (typeof fn !== "function")
-      throw new TypeError("Expected first argument to be a function");
-    const db2 = this[cppdb];
-    const controller = getController(db2, this);
-    const { apply: apply2 } = Function.prototype;
-    const properties = {
-      default: { value: wrapTransaction(apply2, fn, db2, controller.default) },
-      deferred: { value: wrapTransaction(apply2, fn, db2, controller.deferred) },
-      immediate: { value: wrapTransaction(apply2, fn, db2, controller.immediate) },
-      exclusive: { value: wrapTransaction(apply2, fn, db2, 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 getController = (db2, self2) => {
-    let controller = controllers.get(db2);
-    if (!controller) {
-      const shared = {
-        commit: db2.prepare("COMMIT", self2, false),
-        rollback: db2.prepare("ROLLBACK", self2, false),
-        savepoint: db2.prepare("SAVEPOINT `\t_bs3.\t`", self2, false),
-        release: db2.prepare("RELEASE `\t_bs3.\t`", self2, false),
-        rollbackTo: db2.prepare("ROLLBACK TO `\t_bs3.\t`", self2, false)
-      };
-      controllers.set(db2, controller = {
-        default: Object.assign({ begin: db2.prepare("BEGIN", self2, false) }, shared),
-        deferred: Object.assign({ begin: db2.prepare("BEGIN DEFERRED", self2, false) }, shared),
-        immediate: Object.assign({ begin: db2.prepare("BEGIN IMMEDIATE", self2, false) }, shared),
-        exclusive: Object.assign({ begin: db2.prepare("BEGIN EXCLUSIVE", self2, false) }, shared)
-      });
-    }
-    return controller;
-  };
-  var wrapTransaction = (apply2, fn, db2, { begin, commit, rollback, savepoint, release, rollbackTo }) => function sqliteTransaction() {
-    let before, after, undo;
-    if (db2.inTransaction) {
-      before = savepoint;
-      after = release;
-      undo = rollbackTo;
-    } else {
-      before = begin;
-      after = commit;
-      undo = rollback;
-    }
-    before.run();
-    try {
-      const result = apply2.call(fn, this, arguments);
-      if (result && typeof result.then === "function") {
-        throw new TypeError("Transaction function cannot return a promise");
+      class Ya {
+        name = "ExitStatus";
+        constructor(a) {
+          this.message = `Program terminated with exit(${a})`;
+          this.status = a;
+        }
       }
-      after.run();
-      return result;
-    } catch (ex) {
-      if (db2.inTransaction) {
-        undo.run();
-        if (undo !== rollback)
-          after.run();
+      var Za = (a) => {
+        for (;0 < a.length; )
+          a.shift()(f3);
+      }, $a = [], ab = [], bb = () => {
+        var a = f3.preRun.shift();
+        ab.unshift(a);
+      };
+      function m2(a, b = "i8") {
+        b.endsWith("*") && (b = "*");
+        switch (b) {
+          case "i1":
+            return p[a];
+          case "i8":
+            return p[a];
+          case "i16":
+            return Na[a >> 1];
+          case "i32":
+            return E[a >> 2];
+          case "i64":
+            return H[a >> 3];
+          case "float":
+            return Oa[a >> 2];
+          case "double":
+            return Pa[a >> 3];
+          case "*":
+            return F2[a >> 2];
+          default:
+            Ta(`invalid type for getValue: ${b}`);
+        }
       }
-      throw ex;
-    }
-  };
-});
-
-// ../../node_modules/better-sqlite3/lib/methods/pragma.js
-var require_pragma = __commonJS((exports, module) => {
-  var { getBooleanOption, cppdb } = require_util3();
-  module.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();
-  };
-});
-
-// ../../node_modules/better-sqlite3/lib/methods/backup.js
-var require_backup = __commonJS((exports, module) => {
-  var fs4 = __require("fs");
-  var path = __require("path");
-  var { promisify: promisify2 } = __require("util");
-  var { cppdb } = require_util3();
-  var fsAccess = promisify2(fs4.access);
-  module.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 handler13 = "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 (handler13 != null && typeof handler13 !== "function")
-      throw new TypeError('Expected the "progress" option to be a function');
-    await fsAccess(path.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), handler13 || null);
-  };
-  var runBackup = (backup, handler13) => {
-    let rate = 0;
-    let useDefault = true;
-    return new Promise((resolve4, reject) => {
-      setImmediate(function step() {
-        try {
-          const progress = backup.transfer(rate);
-          if (!progress.remainingPages) {
-            backup.close();
-            resolve4(progress);
-            return;
+      var cb = f3.noExitRuntime || true;
+      function ta(a) {
+        var b = "i32";
+        b.endsWith("*") && (b = "*");
+        switch (b) {
+          case "i1":
+            p[a] = 0;
+            break;
+          case "i8":
+            p[a] = 0;
+            break;
+          case "i16":
+            Na[a >> 1] = 0;
+            break;
+          case "i32":
+            E[a >> 2] = 0;
+            break;
+          case "i64":
+            H[a >> 3] = BigInt(0);
+            break;
+          case "float":
+            Oa[a >> 2] = 0;
+            break;
+          case "double":
+            Pa[a >> 3] = 0;
+            break;
+          case "*":
+            F2[a >> 2] = 0;
+            break;
+          default:
+            Ta(`invalid type for setValue: ${b}`);
+        }
+      }
+      var db2 = typeof TextDecoder != "undefined" ? new TextDecoder : undefined, B = (a, b = 0, c = NaN) => {
+        var d = b + c;
+        for (c = b;a[c] && !(c >= d); )
+          ++c;
+        if (16 < c - b && a.buffer && db2)
+          return db2.decode(a.subarray(b, c));
+        for (d = "";b < c; ) {
+          var e2 = a[b++];
+          if (e2 & 128) {
+            var h2 = a[b++] & 63;
+            if ((e2 & 224) == 192)
+              d += String.fromCharCode((e2 & 31) << 6 | h2);
+            else {
+              var k = a[b++] & 63;
+              e2 = (e2 & 240) == 224 ? (e2 & 15) << 12 | h2 << 6 | k : (e2 & 7) << 18 | h2 << 12 | k << 6 | a[b++] & 63;
+              65536 > e2 ? d += String.fromCharCode(e2) : (e2 -= 65536, d += String.fromCharCode(55296 | e2 >> 10, 56320 | e2 & 1023));
+            }
+          } else
+            d += String.fromCharCode(e2);
+        }
+        return d;
+      }, ua = (a, b) => a ? B(x2, a, b) : "", eb = (a, b) => {
+        for (var c = 0, d = a.length - 1;0 <= d; d--) {
+          var e2 = a[d];
+          e2 === "." ? a.splice(d, 1) : e2 === ".." ? (a.splice(d, 1), c++) : c && (a.splice(d, 1), c--);
+        }
+        if (b)
+          for (;c; c--)
+            a.unshift("..");
+        return a;
+      }, ka = (a) => {
+        var b = a.charAt(0) === "/", c = a.slice(-1) === "/";
+        (a = eb(a.split("/").filter((d) => !!d), !b).join("/")) || b || (a = ".");
+        a && c && (a += "/");
+        return (b ? "/" : "") + a;
+      }, fb = (a) => {
+        var b = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/.exec(a).slice(1);
+        a = b[0];
+        b = b[1];
+        if (!a && !b)
+          return ".";
+        b &&= b.slice(0, -1);
+        return a + b;
+      }, gb = (a) => a && a.match(/([^\/]+|\/)\/*$/)[1], hb = () => {
+        if (ca) {
+          var a = __require("crypto");
+          return (b) => a.randomFillSync(b);
+        }
+        return (b) => crypto.getRandomValues(b);
+      }, ib = (a) => {
+        (ib = hb())(a);
+      }, jb = (...a) => {
+        for (var b = "", c = false, d = a.length - 1;-1 <= d && !c; d--) {
+          c = 0 <= d ? a[d] : "/";
+          if (typeof c != "string")
+            throw new TypeError("Arguments to path.resolve must be strings");
+          if (!c)
+            return "";
+          b = c + "/" + b;
+          c = c.charAt(0) === "/";
+        }
+        b = eb(b.split("/").filter((e2) => !!e2), !c).join("/");
+        return (c ? "/" : "") + b || ".";
+      }, kb = [], ha = (a) => {
+        for (var b = 0, c = 0;c < a.length; ++c) {
+          var d = a.charCodeAt(c);
+          127 >= d ? b++ : 2047 >= d ? b += 2 : 55296 <= d && 57343 >= d ? (b += 4, ++c) : b += 3;
+        }
+        return b;
+      }, u = (a, b, c, d) => {
+        if (!(0 < d))
+          return 0;
+        var e2 = c;
+        d = c + d - 1;
+        for (var h2 = 0;h2 < a.length; ++h2) {
+          var k = a.charCodeAt(h2);
+          if (55296 <= k && 57343 >= k) {
+            var q = a.charCodeAt(++h2);
+            k = 65536 + ((k & 1023) << 10) | q & 1023;
           }
-          if (useDefault) {
-            useDefault = false;
-            rate = 100;
+          if (127 >= k) {
+            if (c >= d)
+              break;
+            b[c++] = k;
+          } else {
+            if (2047 >= k) {
+              if (c + 1 >= d)
+                break;
+              b[c++] = 192 | k >> 6;
+            } else {
+              if (65535 >= k) {
+                if (c + 2 >= d)
+                  break;
+                b[c++] = 224 | k >> 12;
+              } else {
+                if (c + 3 >= d)
+                  break;
+                b[c++] = 240 | k >> 18;
+                b[c++] = 128 | k >> 12 & 63;
+              }
+              b[c++] = 128 | k >> 6 & 63;
+            }
+            b[c++] = 128 | k & 63;
           }
-          if (handler13) {
-            const ret = handler13(progress);
-            if (ret !== undefined) {
-              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");
+        }
+        b[c] = 0;
+        return c - e2;
+      }, ra = (a, b) => {
+        var c = Array(ha(a) + 1);
+        a = u(a, c, 0, c.length);
+        b && (c.length = a);
+        return c;
+      }, mb = [];
+      function nb(a, b) {
+        mb[a] = { input: [], output: [], cb: b };
+        wb(a, xb);
+      }
+      var xb = { open(a) {
+        var b = mb[a.node.rdev];
+        if (!b)
+          throw new N(43);
+        a.tty = b;
+        a.seekable = false;
+      }, close(a) {
+        a.tty.cb.fsync(a.tty);
+      }, fsync(a) {
+        a.tty.cb.fsync(a.tty);
+      }, read(a, b, c, d) {
+        if (!a.tty || !a.tty.cb.xb)
+          throw new N(60);
+        for (var e2 = 0, h2 = 0;h2 < d; h2++) {
+          try {
+            var k = a.tty.cb.xb(a.tty);
+          } catch (q) {
+            throw new N(29);
+          }
+          if (k === undefined && e2 === 0)
+            throw new N(6);
+          if (k === null || k === undefined)
+            break;
+          e2++;
+          b[c + h2] = k;
+        }
+        e2 && (a.node.atime = Date.now());
+        return e2;
+      }, write(a, b, c, d) {
+        if (!a.tty || !a.tty.cb.qb)
+          throw new N(60);
+        try {
+          for (var e2 = 0;e2 < d; e2++)
+            a.tty.cb.qb(a.tty, b[c + e2]);
+        } catch (h2) {
+          throw new N(29);
+        }
+        d && (a.node.mtime = a.node.ctime = Date.now());
+        return e2;
+      } }, yb = { xb() {
+        a: {
+          if (!kb.length) {
+            var a = null;
+            if (ca) {
+              var b = Buffer.alloc(256), c = 0, d = process.stdin.fd;
+              try {
+                c = fs4.readSync(d, b, 0, 256);
+              } catch (e2) {
+                if (e2.toString().includes("EOF"))
+                  c = 0;
+                else
+                  throw e2;
+              }
+              0 < c && (a = b.slice(0, c).toString("utf-8"));
+            } else
+              typeof window != "undefined" && typeof window.prompt == "function" && (a = window.prompt("Input: "), a !== null && (a += `
+`));
+            if (!a) {
+              a = null;
+              break a;
             }
+            kb = ra(a, true);
           }
-          setImmediate(step);
-        } catch (err) {
-          backup.close();
-          reject(err);
+          a = kb.shift();
+        }
+        return a;
+      }, qb(a, b) {
+        b === null || b === 10 ? (Ha(B(a.output)), a.output = []) : b != 0 && a.output.push(b);
+      }, fsync(a) {
+        0 < a.output?.length && (Ha(B(a.output)), a.output = []);
+      }, Tb() {
+        return { Ob: 25856, Qb: 5, Nb: 191, Pb: 35387, Mb: [3, 28, 127, 21, 4, 0, 1, 0, 17, 19, 26, 0, 18, 15, 23, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] };
+      }, Ub() {
+        return 0;
+      }, Vb() {
+        return [24, 80];
+      } }, zb = { qb(a, b) {
+        b === null || b === 10 ? (Ia(B(a.output)), a.output = []) : b != 0 && a.output.push(b);
+      }, fsync(a) {
+        0 < a.output?.length && (Ia(B(a.output)), a.output = []);
+      } }, O = { Wa: null, Xa() {
+        return O.createNode(null, "/", 16895, 0);
+      }, createNode(a, b, c, d) {
+        if ((c & 61440) === 24576 || (c & 61440) === 4096)
+          throw new N(63);
+        O.Wa || (O.Wa = { dir: { node: { Ta: O.La.Ta, Ua: O.La.Ua, lookup: O.La.lookup, hb: O.La.hb, rename: O.La.rename, unlink: O.La.unlink, rmdir: O.La.rmdir, readdir: O.La.readdir, symlink: O.La.symlink }, stream: { Va: O.Ma.Va } }, file: { node: { Ta: O.La.Ta, Ua: O.La.Ua }, stream: { Va: O.Ma.Va, read: O.Ma.read, write: O.Ma.write, ib: O.Ma.ib, jb: O.Ma.jb } }, link: { node: { Ta: O.La.Ta, Ua: O.La.Ua, readlink: O.La.readlink }, stream: {} }, ub: { node: { Ta: O.La.Ta, Ua: O.La.Ua }, stream: Ab } });
+        c = Bb(a, b, c, d);
+        P(c.mode) ? (c.La = O.Wa.dir.node, c.Ma = O.Wa.dir.stream, c.Na = {}) : (c.mode & 61440) === 32768 ? (c.La = O.Wa.file.node, c.Ma = O.Wa.file.stream, c.Ra = 0, c.Na = null) : (c.mode & 61440) === 40960 ? (c.La = O.Wa.link.node, c.Ma = O.Wa.link.stream) : (c.mode & 61440) === 8192 && (c.La = O.Wa.ub.node, c.Ma = O.Wa.ub.stream);
+        c.atime = c.mtime = c.ctime = Date.now();
+        a && (a.Na[b] = c, a.atime = a.mtime = a.ctime = c.atime);
+        return c;
+      }, Sb(a) {
+        return a.Na ? a.Na.subarray ? a.Na.subarray(0, a.Ra) : new Uint8Array(a.Na) : new Uint8Array(0);
+      }, La: { Ta(a) {
+        var b = {};
+        b.dev = (a.mode & 61440) === 8192 ? a.id : 1;
+        b.ino = a.id;
+        b.mode = a.mode;
+        b.nlink = 1;
+        b.uid = 0;
+        b.gid = 0;
+        b.rdev = a.rdev;
+        P(a.mode) ? b.size = 4096 : (a.mode & 61440) === 32768 ? b.size = a.Ra : (a.mode & 61440) === 40960 ? b.size = a.link.length : b.size = 0;
+        b.atime = new Date(a.atime);
+        b.mtime = new Date(a.mtime);
+        b.ctime = new Date(a.ctime);
+        b.blksize = 4096;
+        b.blocks = Math.ceil(b.size / b.blksize);
+        return b;
+      }, Ua(a, b) {
+        for (var c of ["mode", "atime", "mtime", "ctime"])
+          b[c] != null && (a[c] = b[c]);
+        b.size !== undefined && (b = b.size, a.Ra != b && (b == 0 ? (a.Na = null, a.Ra = 0) : (c = a.Na, a.Na = new Uint8Array(b), c && a.Na.set(c.subarray(0, Math.min(b, a.Ra))), a.Ra = b)));
+      }, lookup() {
+        throw O.vb;
+      }, hb(a, b, c, d) {
+        return O.createNode(a, b, c, d);
+      }, rename(a, b, c) {
+        try {
+          var d = Q(b, c);
+        } catch (h2) {}
+        if (d) {
+          if (P(a.mode))
+            for (var e2 in d.Na)
+              throw new N(55);
+          Cb(d);
+        }
+        delete a.parent.Na[a.name];
+        b.Na[c] = a;
+        a.name = c;
+        b.ctime = b.mtime = a.parent.ctime = a.parent.mtime = Date.now();
+      }, unlink(a, b) {
+        delete a.Na[b];
+        a.ctime = a.mtime = Date.now();
+      }, rmdir(a, b) {
+        var c = Q(a, b), d;
+        for (d in c.Na)
+          throw new N(55);
+        delete a.Na[b];
+        a.ctime = a.mtime = Date.now();
+      }, readdir(a) {
+        return [".", "..", ...Object.keys(a.Na)];
+      }, symlink(a, b, c) {
+        a = O.createNode(a, b, 41471, 0);
+        a.link = c;
+        return a;
+      }, readlink(a) {
+        if ((a.mode & 61440) !== 40960)
+          throw new N(28);
+        return a.link;
+      } }, Ma: { read(a, b, c, d, e2) {
+        var h2 = a.node.Na;
+        if (e2 >= a.node.Ra)
+          return 0;
+        a = Math.min(a.node.Ra - e2, d);
+        if (8 < a && h2.subarray)
+          b.set(h2.subarray(e2, e2 + a), c);
+        else
+          for (d = 0;d < a; d++)
+            b[c + d] = h2[e2 + d];
+        return a;
+      }, write(a, b, c, d, e2, h2) {
+        b.buffer === p.buffer && (h2 = false);
+        if (!d)
+          return 0;
+        a = a.node;
+        a.mtime = a.ctime = Date.now();
+        if (b.subarray && (!a.Na || a.Na.subarray)) {
+          if (h2)
+            return a.Na = b.subarray(c, c + d), a.Ra = d;
+          if (a.Ra === 0 && e2 === 0)
+            return a.Na = b.slice(c, c + d), a.Ra = d;
+          if (e2 + d <= a.Ra)
+            return a.Na.set(b.subarray(c, c + d), e2), d;
+        }
+        h2 = e2 + d;
+        var k = a.Na ? a.Na.length : 0;
+        k >= h2 || (h2 = Math.max(h2, k * (1048576 > k ? 2 : 1.125) >>> 0), k != 0 && (h2 = Math.max(h2, 256)), k = a.Na, a.Na = new Uint8Array(h2), 0 < a.Ra && a.Na.set(k.subarray(0, a.Ra), 0));
+        if (a.Na.subarray && b.subarray)
+          a.Na.set(b.subarray(c, c + d), e2);
+        else
+          for (h2 = 0;h2 < d; h2++)
+            a.Na[e2 + h2] = b[c + h2];
+        a.Ra = Math.max(a.Ra, e2 + d);
+        return d;
+      }, Va(a, b, c) {
+        c === 1 ? b += a.position : c === 2 && (a.node.mode & 61440) === 32768 && (b += a.node.Ra);
+        if (0 > b)
+          throw new N(28);
+        return b;
+      }, ib(a, b, c, d, e2) {
+        if ((a.node.mode & 61440) !== 32768)
+          throw new N(43);
+        a = a.node.Na;
+        if (e2 & 2 || !a || a.buffer !== p.buffer) {
+          e2 = true;
+          d = 65536 * Math.ceil(b / 65536);
+          var h2 = Db(65536, d);
+          h2 && x2.fill(0, h2, h2 + d);
+          d = h2;
+          if (!d)
+            throw new N(48);
+          if (a) {
+            if (0 < c || c + b < a.length)
+              a.subarray ? a = a.subarray(c, c + b) : a = Array.prototype.slice.call(a, c, c + b);
+            p.set(a, d);
+          }
+        } else
+          e2 = false, d = a.byteOffset;
+        return { Kb: d, Ab: e2 };
+      }, jb(a, b, c, d) {
+        O.Ma.write(a, b, 0, d, c, false);
+        return 0;
+      } } }, la = (a, b) => {
+        var c = 0;
+        a && (c |= 365);
+        b && (c |= 146);
+        return c;
+      }, Eb = null, Fb = {}, Gb = [], Hb = 1, R = null, Ib = false, Jb = true, Kb = {}, N = class {
+        name = "ErrnoError";
+        constructor(a) {
+          this.Pa = a;
+        }
+      }, Lb = class {
+        gb = {};
+        node = null;
+        get flags() {
+          return this.gb.flags;
+        }
+        set flags(a) {
+          this.gb.flags = a;
+        }
+        get position() {
+          return this.gb.position;
+        }
+        set position(a) {
+          this.gb.position = a;
+        }
+      }, Mb = class {
+        La = {};
+        Ma = {};
+        ab = null;
+        constructor(a, b, c, d) {
+          a ||= this;
+          this.parent = a;
+          this.Xa = a.Xa;
+          this.id = Hb++;
+          this.name = b;
+          this.mode = c;
+          this.rdev = d;
+          this.atime = this.mtime = this.ctime = Date.now();
+        }
+        get read() {
+          return (this.mode & 365) === 365;
+        }
+        set read(a) {
+          a ? this.mode |= 365 : this.mode &= -366;
+        }
+        get write() {
+          return (this.mode & 146) === 146;
+        }
+        set write(a) {
+          a ? this.mode |= 146 : this.mode &= -147;
         }
-      });
-    });
-  };
-});
-
-// ../../node_modules/better-sqlite3/lib/methods/serialize.js
-var require_serialize = __commonJS((exports, module) => {
-  var { cppdb } = require_util3();
-  module.exports = function serialize(options) {
-    if (options == null)
-      options = {};
-    if (typeof options !== "object")
-      throw new TypeError("Expected first argument to be an options object");
-    const attachedName = "attached" in options ? options.attached : "main";
-    if (typeof attachedName !== "string")
-      throw new TypeError('Expected the "attached" option to be a string');
-    if (!attachedName)
-      throw new TypeError('The "attached" option cannot be an empty string');
-    return this[cppdb].serialize(attachedName);
-  };
-});
-
-// ../../node_modules/better-sqlite3/lib/methods/function.js
-var require_function = __commonJS((exports, module) => {
-  var { getBooleanOption, cppdb } = require_util3();
-  module.exports = function defineFunction(name17, options, fn) {
-    if (options == null)
-      options = {};
-    if (typeof options === "function") {
-      fn = options;
-      options = {};
-    }
-    if (typeof name17 !== "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 (!name17)
-      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, name17, argCount, safeIntegers, deterministic, directOnly);
-    return this;
-  };
-});
-
-// ../../node_modules/better-sqlite3/lib/methods/aggregate.js
-var require_aggregate = __commonJS((exports, module) => {
-  var { getBooleanOption, cppdb } = require_util3();
-  module.exports = function defineAggregate(name17, options) {
-    if (typeof name17 !== "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 (!name17)
-      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, name17, argCount, safeIntegers, deterministic, directOnly);
-    return this;
-  };
-  var getFunctionOption = (options, key, required2) => {
-    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 (required2)
-      throw new TypeError(`Missing required option "${key}"`);
-    return null;
-  };
-  var getLength = ({ length }) => {
-    if (Number.isInteger(length) && length >= 0)
-      return length;
-    throw new TypeError("Expected function.length to be a positive integer");
-  };
-});
-
-// ../../node_modules/better-sqlite3/lib/methods/table.js
-var require_table = __commonJS((exports, module) => {
-  var { cppdb } = require_util3();
-  module.exports = function defineTable(name17, factory) {
-    if (typeof name17 !== "string")
-      throw new TypeError("Expected first argument to be a string");
-    if (!name17)
-      throw new TypeError("Virtual table module name cannot be an empty string");
-    let eponymous = false;
-    if (typeof factory === "object" && factory !== null) {
-      eponymous = true;
-      factory = defer(parseTableDefinition(factory, "used", name17));
-    } else {
-      if (typeof factory !== "function")
-        throw new TypeError("Expected second argument to be a function or a table definition object");
-      factory = wrapFactory(factory);
-    }
-    this[cppdb].table(factory, name17, eponymous);
-    return this;
-  };
-  function wrapFactory(factory) {
-    return function virtualTableFactory(moduleName, databaseName, tableName, ...args) {
-      const thisObject = {
-        module: moduleName,
-        database: databaseName,
-        table: tableName
       };
-      const def = apply2.call(factory, thisObject, args);
-      if (typeof def !== "object" || def === null) {
-        throw new TypeError(`Virtual table module "${moduleName}" did not return a table definition object`);
+      function S2(a, b = {}) {
+        if (!a)
+          throw new N(44);
+        b.nb ?? (b.nb = true);
+        a.charAt(0) === "/" || (a = "//" + a);
+        var c = 0;
+        a:
+          for (;40 > c; c++) {
+            a = a.split("/").filter((q) => !!q);
+            for (var d = Eb, e2 = "/", h2 = 0;h2 < a.length; h2++) {
+              var k = h2 === a.length - 1;
+              if (k && b.parent)
+                break;
+              if (a[h2] !== ".")
+                if (a[h2] === "..")
+                  e2 = fb(e2), d = d.parent;
+                else {
+                  e2 = ka(e2 + "/" + a[h2]);
+                  try {
+                    d = Q(d, a[h2]);
+                  } catch (q) {
+                    if (q?.Pa === 44 && k && b.Jb)
+                      return { path: e2 };
+                    throw q;
+                  }
+                  !d.ab || k && !b.nb || (d = d.ab.root);
+                  if ((d.mode & 61440) === 40960 && (!k || b.$a)) {
+                    if (!d.La.readlink)
+                      throw new N(52);
+                    d = d.La.readlink(d);
+                    d.charAt(0) === "/" || (d = fb(e2) + "/" + d);
+                    a = d + "/" + a.slice(h2 + 1).join("/");
+                    continue a;
+                  }
+                }
+            }
+            return { path: e2, node: d };
+          }
+        throw new N(32);
       }
-      return parseTableDefinition(def, "returned", moduleName);
-    };
-  }
-  function parseTableDefinition(def, verb, moduleName) {
-    if (!hasOwnProperty10.call(def, "rows")) {
-      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "rows" property`);
-    }
-    if (!hasOwnProperty10.call(def, "columns")) {
-      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "columns" property`);
-    }
-    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)`);
-    }
-    let columns = def.columns;
-    if (!Array.isArray(columns) || !(columns = [...columns]).every((x2) => typeof x2 === "string")) {
-      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "columns" property (should be an array of strings)`);
-    }
-    if (columns.length !== new Set(columns).size) {
-      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate column names`);
-    }
-    if (!columns.length) {
-      throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with zero columns`);
-    }
-    let parameters;
-    if (hasOwnProperty10.call(def, "parameters")) {
-      parameters = def.parameters;
-      if (!Array.isArray(parameters) || !(parameters = [...parameters]).every((x2) => typeof x2 === "string")) {
-        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "parameters" property (should be an array of strings)`);
+      function ja(a) {
+        for (var b;; ) {
+          if (a === a.parent)
+            return a = a.Xa.zb, b ? a[a.length - 1] !== "/" ? `${a}/${b}` : a + b : a;
+          b = b ? `${a.name}/${b}` : a.name;
+          a = a.parent;
+        }
       }
-    } else {
-      parameters = inferParameters(rows);
-    }
-    if (parameters.length !== new Set(parameters).size) {
-      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate parameter names`);
-    }
-    if (parameters.length > 32) {
-      throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with more than the maximum number of 32 parameters`);
-    }
-    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`);
+      function Nb(a, b) {
+        for (var c = 0, d = 0;d < b.length; d++)
+          c = (c << 5) - c + b.charCodeAt(d) | 0;
+        return (a + c >>> 0) % R.length;
       }
-    }
-    let safeIntegers = 2;
-    if (hasOwnProperty10.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)`);
+      function Cb(a) {
+        var b = Nb(a.parent.id, a.name);
+        if (R[b] === a)
+          R[b] = a.bb;
+        else
+          for (b = R[b];b; ) {
+            if (b.bb === a) {
+              b.bb = a.bb;
+              break;
+            }
+            b = b.bb;
+          }
       }
-      safeIntegers = +bool;
-    }
-    let directOnly = false;
-    if (hasOwnProperty10.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)`);
+      function Q(a, b) {
+        var c = P(a.mode) ? (c = Ob(a, "x")) ? c : a.La.lookup ? 0 : 2 : 54;
+        if (c)
+          throw new N(c);
+        for (c = R[Nb(a.id, b)];c; c = c.bb) {
+          var d = c.name;
+          if (c.parent.id === a.id && d === b)
+            return c;
+        }
+        return a.La.lookup(a, b);
+      }
+      function Bb(a, b, c, d) {
+        a = new Mb(a, b, c, d);
+        b = Nb(a.parent.id, a.name);
+        a.bb = R[b];
+        return R[b] = a;
+      }
+      function P(a) {
+        return (a & 61440) === 16384;
+      }
+      function Pb(a) {
+        var b = ["r", "w", "rw"][a & 3];
+        a & 512 && (b += "w");
+        return b;
       }
-    }
-    const columnDefinitions = [
-      ...parameters.map(identifier).map((str) => `${str} HIDDEN`),
-      ...columns.map(identifier)
-    ];
-    return [
-      `CREATE TABLE x(${columnDefinitions.join(", ")});`,
-      wrapGenerator(rows, new Map(columns.map((x2, i2) => [x2, parameters.length + i2])), moduleName),
-      parameters,
-      safeIntegers,
-      directOnly
-    ];
-  }
-  function wrapGenerator(generator, columnMap, moduleName) {
-    return function* virtualTable(...args) {
-      const output = args.map((x2) => Buffer.isBuffer(x2) ? Buffer.from(x2) : x2);
-      for (let i2 = 0;i2 < columnMap.size; ++i2) {
-        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 {
-          throw new TypeError(`Virtual table module "${moduleName}" yielded something that isn't a valid row object`);
+      function Ob(a, b) {
+        if (Jb)
+          return 0;
+        if (!b.includes("r") || a.mode & 292) {
+          if (b.includes("w") && !(a.mode & 146) || b.includes("x") && !(a.mode & 73))
+            return 2;
+        } else
+          return 2;
+        return 0;
+      }
+      function Qb(a, b) {
+        if (!P(a.mode))
+          return 54;
+        try {
+          return Q(a, b), 20;
+        } catch (c) {}
+        return Ob(a, "wx");
+      }
+      function Rb(a, b, c) {
+        try {
+          var d = Q(a, b);
+        } catch (e2) {
+          return e2.Pa;
         }
+        if (a = Ob(a, "wx"))
+          return a;
+        if (c) {
+          if (!P(d.mode))
+            return 54;
+          if (d === d.parent || ja(d) === "/")
+            return 10;
+        } else if (P(d.mode))
+          return 31;
+        return 0;
       }
-    };
-  }
-  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`);
-    }
-    const offset = output.length - columnCount;
-    for (let i2 = 0;i2 < columnCount; ++i2) {
-      output[i2 + offset] = row[i2];
-    }
-  }
-  function extractRowObject(row, output, columnMap, moduleName) {
-    let count = 0;
-    for (const key of Object.keys(row)) {
-      const index = columnMap.get(key);
-      if (index === undefined) {
-        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an undeclared column "${key}"`);
+      function Sb(a) {
+        if (!a)
+          throw new N(63);
+        return a;
+      }
+      function T(a) {
+        a = Gb[a];
+        if (!a)
+          throw new N(8);
+        return a;
+      }
+      function Tb(a, b = -1) {
+        a = Object.assign(new Lb, a);
+        if (b == -1)
+          a: {
+            for (b = 0;4096 >= b; b++)
+              if (!Gb[b])
+                break a;
+            throw new N(33);
+          }
+        a.fd = b;
+        return Gb[b] = a;
+      }
+      function Ub(a, b = -1) {
+        a = Tb(a, b);
+        a.Ma?.Rb?.(a);
+        return a;
+      }
+      function Vb(a, b, c) {
+        var d = a?.Ma.Ua;
+        a = d ? a : b;
+        d ??= b.La.Ua;
+        Sb(d);
+        d(a, c);
+      }
+      var Ab = { open(a) {
+        a.Ma = Fb[a.node.rdev].Ma;
+        a.Ma.open?.(a);
+      }, Va() {
+        throw new N(70);
+      } };
+      function wb(a, b) {
+        Fb[a] = { Ma: b };
+      }
+      function Wb(a, b) {
+        var c = b === "/";
+        if (c && Eb)
+          throw new N(10);
+        if (!c && b) {
+          var d = S2(b, { nb: false });
+          b = d.path;
+          d = d.node;
+          if (d.ab)
+            throw new N(10);
+          if (!P(d.mode))
+            throw new N(54);
+        }
+        b = { type: a, Wb: {}, zb: b, Ib: [] };
+        a = a.Xa(b);
+        a.Xa = b;
+        b.root = a;
+        c ? Eb = a : d && (d.ab = b, d.Xa && d.Xa.Ib.push(b));
+      }
+      function Xb(a, b, c) {
+        var d = S2(a, { parent: true }).node;
+        a = gb(a);
+        if (!a)
+          throw new N(28);
+        if (a === "." || a === "..")
+          throw new N(20);
+        var e2 = Qb(d, a);
+        if (e2)
+          throw new N(e2);
+        if (!d.La.hb)
+          throw new N(63);
+        return d.La.hb(d, a, b, c);
+      }
+      function ma(a, b = 438) {
+        return Xb(a, b & 4095 | 32768, 0);
+      }
+      function U(a, b = 511) {
+        return Xb(a, b & 1023 | 16384, 0);
+      }
+      function Yb(a, b, c) {
+        typeof c == "undefined" && (c = b, b = 438);
+        Xb(a, b | 8192, c);
+      }
+      function Zb(a, b) {
+        if (!jb(a))
+          throw new N(44);
+        var c = S2(b, { parent: true }).node;
+        if (!c)
+          throw new N(44);
+        b = gb(b);
+        var d = Qb(c, b);
+        if (d)
+          throw new N(d);
+        if (!c.La.symlink)
+          throw new N(63);
+        c.La.symlink(c, b, a);
+      }
+      function $b(a) {
+        var b = S2(a, { parent: true }).node;
+        a = gb(a);
+        var c = Q(b, a), d = Rb(b, a, true);
+        if (d)
+          throw new N(d);
+        if (!b.La.rmdir)
+          throw new N(63);
+        if (c.ab)
+          throw new N(10);
+        b.La.rmdir(b, a);
+        Cb(c);
+      }
+      function za(a) {
+        var b = S2(a, { parent: true }).node;
+        if (!b)
+          throw new N(44);
+        a = gb(a);
+        var c = Q(b, a), d = Rb(b, a, false);
+        if (d)
+          throw new N(d);
+        if (!b.La.unlink)
+          throw new N(63);
+        if (c.ab)
+          throw new N(10);
+        b.La.unlink(b, a);
+        Cb(c);
+      }
+      function ac(a, b) {
+        a = S2(a, { $a: !b }).node;
+        return Sb(a.La.Ta)(a);
+      }
+      function bc(a, b, c, d) {
+        Vb(a, b, { mode: c & 4095 | b.mode & -4096, ctime: Date.now(), Fb: d });
+      }
+      function na(a, b) {
+        a = typeof a == "string" ? S2(a, { $a: true }).node : a;
+        bc(null, a, b);
+      }
+      function cc(a, b, c) {
+        if (P(b.mode))
+          throw new N(31);
+        if ((b.mode & 61440) !== 32768)
+          throw new N(28);
+        var d = Ob(b, "w");
+        if (d)
+          throw new N(d);
+        Vb(a, b, { size: c, timestamp: Date.now() });
+      }
+      function oa(a, b, c = 438) {
+        if (a === "")
+          throw new N(44);
+        if (typeof b == "string") {
+          var d = { r: 0, "r+": 2, w: 577, "w+": 578, a: 1089, "a+": 1090 }[b];
+          if (typeof d == "undefined")
+            throw Error(`Unknown file open mode: ${b}`);
+          b = d;
+        }
+        c = b & 64 ? c & 4095 | 32768 : 0;
+        if (typeof a == "object")
+          d = a;
+        else {
+          var e2 = a.endsWith("/");
+          a = S2(a, { $a: !(b & 131072), Jb: true });
+          d = a.node;
+          a = a.path;
+        }
+        var h2 = false;
+        if (b & 64)
+          if (d) {
+            if (b & 128)
+              throw new N(20);
+          } else {
+            if (e2)
+              throw new N(31);
+            d = Xb(a, c | 511, 0);
+            h2 = true;
+          }
+        if (!d)
+          throw new N(44);
+        (d.mode & 61440) === 8192 && (b &= -513);
+        if (b & 65536 && !P(d.mode))
+          throw new N(54);
+        if (!h2 && (e2 = d ? (d.mode & 61440) === 40960 ? 32 : P(d.mode) && (Pb(b) !== "r" || b & 576) ? 31 : Ob(d, Pb(b)) : 44))
+          throw new N(e2);
+        b & 512 && !h2 && (e2 = d, e2 = typeof e2 == "string" ? S2(e2, { $a: true }).node : e2, cc(null, e2, 0));
+        b &= -131713;
+        e2 = Tb({ node: d, path: ja(d), flags: b, seekable: true, position: 0, Ma: d.Ma, Lb: [], error: false });
+        e2.Ma.open && e2.Ma.open(e2);
+        h2 && na(d, c & 511);
+        !f3.logReadFiles || b & 1 || a in Kb || (Kb[a] = 1);
+        return e2;
+      }
+      function qa(a) {
+        if (a.fd === null)
+          throw new N(8);
+        a.ob && (a.ob = null);
+        try {
+          a.Ma.close && a.Ma.close(a);
+        } catch (b) {
+          throw b;
+        } finally {
+          Gb[a.fd] = null;
+        }
+        a.fd = null;
+      }
+      function mc(a, b, c) {
+        if (a.fd === null)
+          throw new N(8);
+        if (!a.seekable || !a.Ma.Va)
+          throw new N(70);
+        if (c != 0 && c != 1 && c != 2)
+          throw new N(28);
+        a.position = a.Ma.Va(a, b, c);
+        a.Lb = [];
+      }
+      function Ec(a, b, c, d, e2) {
+        if (0 > d || 0 > e2)
+          throw new N(28);
+        if (a.fd === null)
+          throw new N(8);
+        if ((a.flags & 2097155) === 1)
+          throw new N(8);
+        if (P(a.node.mode))
+          throw new N(31);
+        if (!a.Ma.read)
+          throw new N(28);
+        var h2 = typeof e2 != "undefined";
+        if (!h2)
+          e2 = a.position;
+        else if (!a.seekable)
+          throw new N(70);
+        b = a.Ma.read(a, b, c, d, e2);
+        h2 || (a.position += b);
+        return b;
       }
-      output[index] = row[key];
-      count += 1;
-    }
-    if (count !== columnMap.size) {
-      throw new TypeError(`Virtual table module "${moduleName}" yielded a row with missing columns`);
-    }
-  }
-  function inferParameters({ length }) {
-    if (!Number.isInteger(length) || length < 0) {
-      throw new TypeError("Expected function.length to be a positive integer");
-    }
-    const params = [];
-    for (let i2 = 0;i2 < length; ++i2) {
-      params.push(`$${i2 + 1}`);
-    }
-    return params;
-  }
-  var { hasOwnProperty: hasOwnProperty10 } = Object.prototype;
-  var { apply: apply2 } = Function.prototype;
-  var GeneratorFunctionPrototype = Object.getPrototypeOf(function* () {});
-  var identifier = (str) => `"${str.replace(/"/g, '""')}"`;
-  var defer = (x2) => () => x2;
-});
-
-// ../../node_modules/better-sqlite3/lib/methods/inspect.js
-var require_inspect = __commonJS((exports, module) => {
-  var DatabaseInspection = function Database() {};
-  module.exports = function inspect(depth, opts) {
-    return Object.assign(new DatabaseInspection, this);
-  };
-});
-
-// ../../node_modules/better-sqlite3/lib/database.js
-var require_database = __commonJS((exports, module) => {
-  var fs4 = __require("fs");
-  var path = __require("path");
-  var util2 = require_util3();
-  var SqliteError = require_sqlite_error();
-  var DEFAULT_ADDON;
-  function Database(filenameGiven, options) {
-    if (new.target == null) {
-      return new Database(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 readonly2 = util2.getBooleanOption(options, "readonly");
-    const fileMustExist = util2.getBooleanOption(options, "fileMustExist");
-    const timeout = "timeout" in options ? options.timeout : 5000;
-    const verbose = "verbose" in options ? options.verbose : null;
-    const nativeBinding = "nativeBinding" in options ? options.nativeBinding : null;
-    if (readonly2 && 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(path.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
-    } else {
-      addon = nativeBinding;
-    }
-    if (!addon.isInitialized) {
-      addon.setErrorConstructor(SqliteError);
-      addon.isInitialized = true;
-    }
-    if (!anonymous && !filename.startsWith("file:") && !fs4.existsSync(path.dirname(filename))) {
-      throw new TypeError("Cannot open database because the directory does not exist");
-    }
-    Object.defineProperties(this, {
-      [util2.cppdb]: { value: new addon.Database(filename, filenameGiven, anonymous, readonly2, fileMustExist, timeout, verbose || null, buffer || null) },
-      ...wrappers.getters
+      function pa(a, b, c, d, e2) {
+        if (0 > d || 0 > e2)
+          throw new N(28);
+        if (a.fd === null)
+          throw new N(8);
+        if ((a.flags & 2097155) === 0)
+          throw new N(8);
+        if (P(a.node.mode))
+          throw new N(31);
+        if (!a.Ma.write)
+          throw new N(28);
+        a.seekable && a.flags & 1024 && mc(a, 0, 2);
+        var h2 = typeof e2 != "undefined";
+        if (!h2)
+          e2 = a.position;
+        else if (!a.seekable)
+          throw new N(70);
+        b = a.Ma.write(a, b, c, d, e2, undefined);
+        h2 || (a.position += b);
+        return b;
+      }
+      function ya(a) {
+        var b = "binary";
+        if (b !== "utf8" && b !== "binary")
+          throw Error(`Invalid encoding type "${b}"`);
+        var c;
+        var d = oa(a, d || 0);
+        a = ac(a).size;
+        var e2 = new Uint8Array(a);
+        Ec(d, e2, 0, a, 0);
+        b === "utf8" ? c = B(e2) : b === "binary" && (c = e2);
+        qa(d);
+        return c;
+      }
+      function V(a, b, c) {
+        a = ka("/dev/" + a);
+        var d = la(!!b, !!c);
+        V.yb ?? (V.yb = 64);
+        var e2 = V.yb++ << 8 | 0;
+        wb(e2, { open(h2) {
+          h2.seekable = false;
+        }, close() {
+          c?.buffer?.length && c(10);
+        }, read(h2, k, q, w) {
+          for (var v = 0, C = 0;C < w; C++) {
+            try {
+              var G = b();
+            } catch (pb) {
+              throw new N(29);
+            }
+            if (G === undefined && v === 0)
+              throw new N(6);
+            if (G === null || G === undefined)
+              break;
+            v++;
+            k[q + C] = G;
+          }
+          v && (h2.node.atime = Date.now());
+          return v;
+        }, write(h2, k, q, w) {
+          for (var v = 0;v < w; v++)
+            try {
+              c(k[q + v]);
+            } catch (C) {
+              throw new N(29);
+            }
+          w && (h2.node.mtime = h2.node.ctime = Date.now());
+          return v;
+        } });
+        Yb(a, d, e2);
+      }
+      var W = {};
+      function Gc(a, b, c) {
+        if (b.charAt(0) === "/")
+          return b;
+        a = a === -100 ? "/" : T(a).path;
+        if (b.length == 0) {
+          if (!c)
+            throw new N(44);
+          return a;
+        }
+        return a + "/" + b;
+      }
+      function Hc(a, b) {
+        E[a >> 2] = b.dev;
+        E[a + 4 >> 2] = b.mode;
+        F2[a + 8 >> 2] = b.nlink;
+        E[a + 12 >> 2] = b.uid;
+        E[a + 16 >> 2] = b.gid;
+        E[a + 20 >> 2] = b.rdev;
+        H[a + 24 >> 3] = BigInt(b.size);
+        E[a + 32 >> 2] = 4096;
+        E[a + 36 >> 2] = b.blocks;
+        var c = b.atime.getTime(), d = b.mtime.getTime(), e2 = b.ctime.getTime();
+        H[a + 40 >> 3] = BigInt(Math.floor(c / 1000));
+        F2[a + 48 >> 2] = c % 1000 * 1e6;
+        H[a + 56 >> 3] = BigInt(Math.floor(d / 1000));
+        F2[a + 64 >> 2] = d % 1000 * 1e6;
+        H[a + 72 >> 3] = BigInt(Math.floor(e2 / 1000));
+        F2[a + 80 >> 2] = e2 % 1000 * 1e6;
+        H[a + 88 >> 3] = BigInt(b.ino);
+        return 0;
+      }
+      var Ic = undefined, Jc = () => {
+        var a = E[+Ic >> 2];
+        Ic += 4;
+        return a;
+      }, Kc = 0, Lc = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335], Mc = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334], Nc = {}, Oc = (a) => {
+        Ma = a;
+        cb || 0 < Kc || (f3.onExit?.(a), La = true);
+        Da(a, new Ya(a));
+      }, Pc = (a) => {
+        if (!La)
+          try {
+            if (a(), !(cb || 0 < Kc))
+              try {
+                Ma = a = Ma, Oc(a);
+              } catch (b) {
+                b instanceof Ya || b == "unwind" || Da(1, b);
+              }
+          } catch (b) {
+            b instanceof Ya || b == "unwind" || Da(1, b);
+          }
+      }, Qc = {}, Sc = () => {
+        if (!Rc) {
+          var a = { USER: "web_user", LOGNAME: "web_user", PATH: "/", PWD: "/", HOME: "/home/web_user", LANG: (typeof navigator == "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8", _: Ca || "./this.program" }, b;
+          for (b in Qc)
+            Qc[b] === undefined ? delete a[b] : a[b] = Qc[b];
+          var c = [];
+          for (b in a)
+            c.push(`${b}=${a[b]}`);
+          Rc = c;
+        }
+        return Rc;
+      }, Rc, xa = (a) => {
+        var b = ha(a) + 1, c = z2(b);
+        u(a, x2, c, b);
+        return c;
+      }, Tc = (a, b, c, d) => {
+        var e2 = { string: (v) => {
+          var C = 0;
+          v !== null && v !== undefined && v !== 0 && (C = xa(v));
+          return C;
+        }, array: (v) => {
+          var C = z2(v.length);
+          p.set(v, C);
+          return C;
+        } };
+        a = f3["_" + a];
+        var h2 = [], k = 0;
+        if (d)
+          for (var q = 0;q < d.length; q++) {
+            var w = e2[c[q]];
+            w ? (k === 0 && (k = sa()), h2[q] = w(d[q])) : h2[q] = d[q];
+          }
+        c = a(...h2);
+        return c = function(v) {
+          k !== 0 && wa(k);
+          return b === "string" ? v ? B(x2, v) : "" : b === "boolean" ? !!v : v;
+        }(c);
+      }, ea = 0, da = (a, b) => {
+        b = b == 1 ? z2(a.length) : ia(a.length);
+        a.subarray || a.slice || (a = new Uint8Array(a));
+        x2.set(a, b);
+        return b;
+      }, Uc, Vc = [], Y, A2 = (a) => {
+        Uc.delete(Y.get(a));
+        Y.set(a, null);
+        Vc.push(a);
+      }, Aa = (a, b) => {
+        if (!Uc) {
+          Uc = new WeakMap;
+          var c = Y.length;
+          if (Uc)
+            for (var d = 0;d < 0 + c; d++) {
+              var e2 = Y.get(d);
+              e2 && Uc.set(e2, d);
+            }
+        }
+        if (c = Uc.get(a) || 0)
+          return c;
+        if (Vc.length)
+          c = Vc.pop();
+        else {
+          try {
+            Y.grow(1);
+          } catch (w) {
+            if (!(w instanceof RangeError))
+              throw w;
+            throw "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.";
+          }
+          c = Y.length - 1;
+        }
+        try {
+          Y.set(c, a);
+        } catch (w) {
+          if (!(w instanceof TypeError))
+            throw w;
+          if (typeof WebAssembly.Function == "function") {
+            var h2 = WebAssembly.Function;
+            d = { i: "i32", j: "i64", f: "f32", d: "f64", e: "externref", p: "i32" };
+            e2 = { parameters: [], results: b[0] == "v" ? [] : [d[b[0]]] };
+            for (var k = 1;k < b.length; ++k)
+              e2.parameters.push(d[b[k]]);
+            b = new h2(e2, a);
+          } else {
+            d = [1];
+            e2 = b.slice(0, 1);
+            b = b.slice(1);
+            k = { i: 127, p: 127, j: 126, f: 125, d: 124, e: 111 };
+            d.push(96);
+            var q = b.length;
+            128 > q ? d.push(q) : d.push(q % 128 | 128, q >> 7);
+            for (h2 of b)
+              d.push(k[h2]);
+            e2 == "v" ? d.push(0) : d.push(1, k[e2]);
+            b = [0, 97, 115, 109, 1, 0, 0, 0, 1];
+            h2 = d.length;
+            128 > h2 ? b.push(h2) : b.push(h2 % 128 | 128, h2 >> 7);
+            b.push(...d);
+            b.push(2, 7, 1, 1, 101, 1, 102, 0, 0, 7, 5, 1, 1, 102, 0, 0);
+            b = new WebAssembly.Module(new Uint8Array(b));
+            b = new WebAssembly.Instance(b, { e: { f: a } }).exports.f;
+          }
+          Y.set(c, b);
+        }
+        Uc.set(a, c);
+        return c;
+      };
+      R = Array(4096);
+      Wb(O, "/");
+      U("/tmp");
+      U("/home");
+      U("/home/web_user");
+      (function() {
+        U("/dev");
+        wb(259, { read: () => 0, write: (d, e2, h2, k) => k, Va: () => 0 });
+        Yb("/dev/null", 259);
+        nb(1280, yb);
+        nb(1536, zb);
+        Yb("/dev/tty", 1280);
+        Yb("/dev/tty1", 1536);
+        var a = new Uint8Array(1024), b = 0, c = () => {
+          b === 0 && (ib(a), b = a.byteLength);
+          return a[--b];
+        };
+        V("random", c);
+        V("urandom", c);
+        U("/dev/shm");
+        U("/dev/shm/tmp");
+      })();
+      (function() {
+        U("/proc");
+        var a = U("/proc/self");
+        U("/proc/self/fd");
+        Wb({ Xa() {
+          var b = Bb(a, "fd", 16895, 73);
+          b.Ma = { Va: O.Ma.Va };
+          b.La = { lookup(c, d) {
+            c = +d;
+            var e2 = T(c);
+            c = { parent: null, Xa: { zb: "fake" }, La: { readlink: () => e2.path }, id: c + 1 };
+            return c.parent = c;
+          }, readdir() {
+            return Array.from(Gb.entries()).filter(([, c]) => c).map(([c]) => c.toString());
+          } };
+          return b;
+        } }, "/proc/self/fd");
+      })();
+      O.vb = new N(44);
+      O.vb.stack = "<generic error, no stack>";
+      var Xc = { a: (a, b, c, d) => Ta(`Assertion failed: ${a ? B(x2, a) : ""}, at: ` + [b ? b ? B(x2, b) : "" : "unknown filename", c, d ? d ? B(x2, d) : "" : "unknown function"]), i: function(a, b) {
+        try {
+          return a = a ? B(x2, a) : "", na(a, b), 0;
+        } catch (c) {
+          if (typeof W == "undefined" || c.name !== "ErrnoError")
+            throw c;
+          return -c.Pa;
+        }
+      }, L: function(a, b, c) {
+        try {
+          b = b ? B(x2, b) : "";
+          b = Gc(a, b);
+          if (c & -8)
+            return -28;
+          var d = S2(b, { $a: true }).node;
+          if (!d)
+            return -44;
+          a = "";
+          c & 4 && (a += "r");
+          c & 2 && (a += "w");
+          c & 1 && (a += "x");
+          return a && Ob(d, a) ? -2 : 0;
+        } catch (e2) {
+          if (typeof W == "undefined" || e2.name !== "ErrnoError")
+            throw e2;
+          return -e2.Pa;
+        }
+      }, j: function(a, b) {
+        try {
+          var c = T(a);
+          bc(c, c.node, b, false);
+          return 0;
+        } catch (d) {
+          if (typeof W == "undefined" || d.name !== "ErrnoError")
+            throw d;
+          return -d.Pa;
+        }
+      }, h: function(a) {
+        try {
+          var b = T(a);
+          Vb(b, b.node, { timestamp: Date.now(), Fb: false });
+          return 0;
+        } catch (c) {
+          if (typeof W == "undefined" || c.name !== "ErrnoError")
+            throw c;
+          return -c.Pa;
+        }
+      }, b: function(a, b, c) {
+        Ic = c;
+        try {
+          var d = T(a);
+          switch (b) {
+            case 0:
+              var e2 = Jc();
+              if (0 > e2)
+                break;
+              for (;Gb[e2]; )
+                e2++;
+              return Ub(d, e2).fd;
+            case 1:
+            case 2:
+              return 0;
+            case 3:
+              return d.flags;
+            case 4:
+              return e2 = Jc(), d.flags |= e2, 0;
+            case 12:
+              return e2 = Jc(), Na[e2 + 0 >> 1] = 2, 0;
+            case 13:
+            case 14:
+              return 0;
+          }
+          return -28;
+        } catch (h2) {
+          if (typeof W == "undefined" || h2.name !== "ErrnoError")
+            throw h2;
+          return -h2.Pa;
+        }
+      }, g: function(a, b) {
+        try {
+          var c = T(a), d = c.node, e2 = c.Ma.Ta;
+          a = e2 ? c : d;
+          e2 ??= d.La.Ta;
+          Sb(e2);
+          var h2 = e2(a);
+          return Hc(b, h2);
+        } catch (k) {
+          if (typeof W == "undefined" || k.name !== "ErrnoError")
+            throw k;
+          return -k.Pa;
+        }
+      }, H: function(a, b) {
+        b = -9007199254740992 > b || 9007199254740992 < b ? NaN : Number(b);
+        try {
+          if (isNaN(b))
+            return 61;
+          var c = T(a);
+          if (0 > b || (c.flags & 2097155) === 0)
+            throw new N(28);
+          cc(c, c.node, b);
+          return 0;
+        } catch (d) {
+          if (typeof W == "undefined" || d.name !== "ErrnoError")
+            throw d;
+          return -d.Pa;
+        }
+      }, G: function(a, b) {
+        try {
+          if (b === 0)
+            return -28;
+          var c = ha("/") + 1;
+          if (b < c)
+            return -68;
+          u("/", x2, a, b);
+          return c;
+        } catch (d) {
+          if (typeof W == "undefined" || d.name !== "ErrnoError")
+            throw d;
+          return -d.Pa;
+        }
+      }, K: function(a, b) {
+        try {
+          return a = a ? B(x2, a) : "", Hc(b, ac(a, true));
+        } catch (c) {
+          if (typeof W == "undefined" || c.name !== "ErrnoError")
+            throw c;
+          return -c.Pa;
+        }
+      }, C: function(a, b, c) {
+        try {
+          return b = b ? B(x2, b) : "", b = Gc(a, b), U(b, c), 0;
+        } catch (d) {
+          if (typeof W == "undefined" || d.name !== "ErrnoError")
+            throw d;
+          return -d.Pa;
+        }
+      }, J: function(a, b, c, d) {
+        try {
+          b = b ? B(x2, b) : "";
+          var e2 = d & 256;
+          b = Gc(a, b, d & 4096);
+          return Hc(c, e2 ? ac(b, true) : ac(b));
+        } catch (h2) {
+          if (typeof W == "undefined" || h2.name !== "ErrnoError")
+            throw h2;
+          return -h2.Pa;
+        }
+      }, x: function(a, b, c, d) {
+        Ic = d;
+        try {
+          b = b ? B(x2, b) : "";
+          b = Gc(a, b);
+          var e2 = d ? Jc() : 0;
+          return oa(b, c, e2).fd;
+        } catch (h2) {
+          if (typeof W == "undefined" || h2.name !== "ErrnoError")
+            throw h2;
+          return -h2.Pa;
+        }
+      }, v: function(a, b, c, d) {
+        try {
+          b = b ? B(x2, b) : "";
+          b = Gc(a, b);
+          if (0 >= d)
+            return -28;
+          var e2 = S2(b).node;
+          if (!e2)
+            throw new N(44);
+          if (!e2.La.readlink)
+            throw new N(28);
+          var h2 = e2.La.readlink(e2);
+          var k = Math.min(d, ha(h2)), q = p[c + k];
+          u(h2, x2, c, d + 1);
+          p[c + k] = q;
+          return k;
+        } catch (w) {
+          if (typeof W == "undefined" || w.name !== "ErrnoError")
+            throw w;
+          return -w.Pa;
+        }
+      }, u: function(a) {
+        try {
+          return a = a ? B(x2, a) : "", $b(a), 0;
+        } catch (b) {
+          if (typeof W == "undefined" || b.name !== "ErrnoError")
+            throw b;
+          return -b.Pa;
+        }
+      }, f: function(a, b) {
+        try {
+          return a = a ? B(x2, a) : "", Hc(b, ac(a));
+        } catch (c) {
+          if (typeof W == "undefined" || c.name !== "ErrnoError")
+            throw c;
+          return -c.Pa;
+        }
+      }, r: function(a, b, c) {
+        try {
+          return b = b ? B(x2, b) : "", b = Gc(a, b), c === 0 ? za(b) : c === 512 ? $b(b) : Ta("Invalid flags passed to unlinkat"), 0;
+        } catch (d) {
+          if (typeof W == "undefined" || d.name !== "ErrnoError")
+            throw d;
+          return -d.Pa;
+        }
+      }, q: function(a, b, c) {
+        try {
+          b = b ? B(x2, b) : "";
+          b = Gc(a, b, true);
+          var d = Date.now(), e2, h2;
+          if (c) {
+            var k = F2[c >> 2] + 4294967296 * E[c + 4 >> 2], q = E[c + 8 >> 2];
+            q == 1073741823 ? e2 = d : q == 1073741822 ? e2 = null : e2 = 1000 * k + q / 1e6;
+            c += 16;
+            k = F2[c >> 2] + 4294967296 * E[c + 4 >> 2];
+            q = E[c + 8 >> 2];
+            q == 1073741823 ? h2 = d : q == 1073741822 ? h2 = null : h2 = 1000 * k + q / 1e6;
+          } else
+            h2 = e2 = d;
+          if ((h2 ?? e2) !== null) {
+            a = e2;
+            var w = S2(b, { $a: true }).node;
+            Sb(w.La.Ua)(w, { atime: a, mtime: h2 });
+          }
+          return 0;
+        } catch (v) {
+          if (typeof W == "undefined" || v.name !== "ErrnoError")
+            throw v;
+          return -v.Pa;
+        }
+      }, m: () => Ta(""), l: () => {
+        cb = false;
+        Kc = 0;
+      }, A: function(a, b) {
+        a = -9007199254740992 > a || 9007199254740992 < a ? NaN : Number(a);
+        a = new Date(1000 * a);
+        E[b >> 2] = a.getSeconds();
+        E[b + 4 >> 2] = a.getMinutes();
+        E[b + 8 >> 2] = a.getHours();
+        E[b + 12 >> 2] = a.getDate();
+        E[b + 16 >> 2] = a.getMonth();
+        E[b + 20 >> 2] = a.getFullYear() - 1900;
+        E[b + 24 >> 2] = a.getDay();
+        var c = a.getFullYear();
+        E[b + 28 >> 2] = (c % 4 !== 0 || c % 100 === 0 && c % 400 !== 0 ? Mc : Lc)[a.getMonth()] + a.getDate() - 1 | 0;
+        E[b + 36 >> 2] = -(60 * a.getTimezoneOffset());
+        c = new Date(a.getFullYear(), 6, 1).getTimezoneOffset();
+        var d = new Date(a.getFullYear(), 0, 1).getTimezoneOffset();
+        E[b + 32 >> 2] = (c != d && a.getTimezoneOffset() == Math.min(d, c)) | 0;
+      }, y: function(a, b, c, d, e2, h2, k) {
+        e2 = -9007199254740992 > e2 || 9007199254740992 < e2 ? NaN : Number(e2);
+        try {
+          if (isNaN(e2))
+            return 61;
+          var q = T(d);
+          if ((b & 2) !== 0 && (c & 2) === 0 && (q.flags & 2097155) !== 2)
+            throw new N(2);
+          if ((q.flags & 2097155) === 1)
+            throw new N(2);
+          if (!q.Ma.ib)
+            throw new N(43);
+          if (!a)
+            throw new N(28);
+          var w = q.Ma.ib(q, a, e2, b, c);
+          var v = w.Kb;
+          E[h2 >> 2] = w.Ab;
+          F2[k >> 2] = v;
+          return 0;
+        } catch (C) {
+          if (typeof W == "undefined" || C.name !== "ErrnoError")
+            throw C;
+          return -C.Pa;
+        }
+      }, z: function(a, b, c, d, e2, h2) {
+        h2 = -9007199254740992 > h2 || 9007199254740992 < h2 ? NaN : Number(h2);
+        try {
+          var k = T(e2);
+          if (c & 2) {
+            c = h2;
+            if ((k.node.mode & 61440) !== 32768)
+              throw new N(43);
+            if (!(d & 2)) {
+              var q = x2.slice(a, a + b);
+              k.Ma.jb && k.Ma.jb(k, q, c, b, d);
+            }
+          }
+        } catch (w) {
+          if (typeof W == "undefined" || w.name !== "ErrnoError")
+            throw w;
+          return -w.Pa;
+        }
+      }, n: (a, b) => {
+        Nc[a] && (clearTimeout(Nc[a].id), delete Nc[a]);
+        if (!b)
+          return 0;
+        var c = setTimeout(() => {
+          delete Nc[a];
+          Pc(() => Wc(a, performance.now()));
+        }, b);
+        Nc[a] = {
+          id: c,
+          Xb: b
+        };
+        return 0;
+      }, B: (a, b, c, d) => {
+        var e2 = new Date().getFullYear(), h2 = new Date(e2, 0, 1).getTimezoneOffset();
+        e2 = new Date(e2, 6, 1).getTimezoneOffset();
+        F2[a >> 2] = 60 * Math.max(h2, e2);
+        E[b >> 2] = Number(h2 != e2);
+        b = (k) => {
+          var q = Math.abs(k);
+          return `UTC${0 <= k ? "-" : "+"}${String(Math.floor(q / 60)).padStart(2, "0")}${String(q % 60).padStart(2, "0")}`;
+        };
+        a = b(h2);
+        b = b(e2);
+        e2 < h2 ? (u(a, x2, c, 17), u(b, x2, d, 17)) : (u(a, x2, d, 17), u(b, x2, c, 17));
+      }, d: () => Date.now(), s: () => 2147483648, c: () => performance.now(), o: (a) => {
+        var b = x2.length;
+        a >>>= 0;
+        if (2147483648 < a)
+          return false;
+        for (var c = 1;4 >= c; c *= 2) {
+          var d = b * (1 + 0.2 / c);
+          d = Math.min(d, a + 100663296);
+          a: {
+            d = (Math.min(2147483648, 65536 * Math.ceil(Math.max(a, d) / 65536)) - Ka.buffer.byteLength + 65535) / 65536 | 0;
+            try {
+              Ka.grow(d);
+              Qa();
+              var e2 = 1;
+              break a;
+            } catch (h2) {}
+            e2 = undefined;
+          }
+          if (e2)
+            return true;
+        }
+        return false;
+      }, E: (a, b) => {
+        var c = 0;
+        Sc().forEach((d, e2) => {
+          var h2 = b + c;
+          e2 = F2[a + 4 * e2 >> 2] = h2;
+          for (h2 = 0;h2 < d.length; ++h2)
+            p[e2++] = d.charCodeAt(h2);
+          p[e2] = 0;
+          c += d.length + 1;
+        });
+        return 0;
+      }, F: (a, b) => {
+        var c = Sc();
+        F2[a >> 2] = c.length;
+        var d = 0;
+        c.forEach((e2) => d += e2.length + 1);
+        F2[b >> 2] = d;
+        return 0;
+      }, e: function(a) {
+        try {
+          var b = T(a);
+          qa(b);
+          return 0;
+        } catch (c) {
+          if (typeof W == "undefined" || c.name !== "ErrnoError")
+            throw c;
+          return c.Pa;
+        }
+      }, p: function(a, b) {
+        try {
+          var c = T(a);
+          p[b] = c.tty ? 2 : P(c.mode) ? 3 : (c.mode & 61440) === 40960 ? 7 : 4;
+          Na[b + 2 >> 1] = 0;
+          H[b + 8 >> 3] = BigInt(0);
+          H[b + 16 >> 3] = BigInt(0);
+          return 0;
+        } catch (d) {
+          if (typeof W == "undefined" || d.name !== "ErrnoError")
+            throw d;
+          return d.Pa;
+        }
+      }, w: function(a, b, c, d) {
+        try {
+          a: {
+            var e2 = T(a);
+            a = b;
+            for (var h2, k = b = 0;k < c; k++) {
+              var q = F2[a >> 2], w = F2[a + 4 >> 2];
+              a += 8;
+              var v = Ec(e2, p, q, w, h2);
+              if (0 > v) {
+                var C = -1;
+                break a;
+              }
+              b += v;
+              if (v < w)
+                break;
+              typeof h2 != "undefined" && (h2 += v);
+            }
+            C = b;
+          }
+          F2[d >> 2] = C;
+          return 0;
+        } catch (G) {
+          if (typeof W == "undefined" || G.name !== "ErrnoError")
+            throw G;
+          return G.Pa;
+        }
+      }, D: function(a, b, c, d) {
+        b = -9007199254740992 > b || 9007199254740992 < b ? NaN : Number(b);
+        try {
+          if (isNaN(b))
+            return 61;
+          var e2 = T(a);
+          mc(e2, b, c);
+          H[d >> 3] = BigInt(e2.position);
+          e2.ob && b === 0 && c === 0 && (e2.ob = null);
+          return 0;
+        } catch (h2) {
+          if (typeof W == "undefined" || h2.name !== "ErrnoError")
+            throw h2;
+          return h2.Pa;
+        }
+      }, I: function(a) {
+        try {
+          var b = T(a);
+          return b.Ma?.fsync ? b.Ma.fsync(b) : 0;
+        } catch (c) {
+          if (typeof W == "undefined" || c.name !== "ErrnoError")
+            throw c;
+          return c.Pa;
+        }
+      }, t: function(a, b, c, d) {
+        try {
+          a: {
+            var e2 = T(a);
+            a = b;
+            for (var h2, k = b = 0;k < c; k++) {
+              var q = F2[a >> 2], w = F2[a + 4 >> 2];
+              a += 8;
+              var v = pa(e2, p, q, w, h2);
+              if (0 > v) {
+                var C = -1;
+                break a;
+              }
+              b += v;
+              if (v < w)
+                break;
+              typeof h2 != "undefined" && (h2 += v);
+            }
+            C = b;
+          }
+          F2[d >> 2] = C;
+          return 0;
+        } catch (G) {
+          if (typeof W == "undefined" || G.name !== "ErrnoError")
+            throw G;
+          return G.Pa;
+        }
+      }, k: Oc }, Z2;
+      (async function() {
+        function a(c) {
+          Z2 = c.exports;
+          Ka = Z2.M;
+          Qa();
+          Y = Z2.O;
+          K--;
+          f3.monitorRunDependencies?.(K);
+          K == 0 && Sa && (c = Sa, Sa = null, c());
+          return Z2;
+        }
+        K++;
+        f3.monitorRunDependencies?.(K);
+        var b = { a: Xc };
+        if (f3.instantiateWasm)
+          return new Promise((c) => {
+            f3.instantiateWasm(b, (d, e2) => {
+              a(d, e2);
+              c(d.exports);
+            });
+          });
+        Ua ??= f3.locateFile ? f3.locateFile("sql-wasm.wasm", D) : D + "sql-wasm.wasm";
+        return a((await Xa(b)).instance);
+      })();
+      f3._sqlite3_free = (a) => (f3._sqlite3_free = Z2.P)(a);
+      f3._sqlite3_value_text = (a) => (f3._sqlite3_value_text = Z2.Q)(a);
+      f3._sqlite3_prepare_v2 = (a, b, c, d, e2) => (f3._sqlite3_prepare_v2 = Z2.R)(a, b, c, d, e2);
+      f3._sqlite3_step = (a) => (f3._sqlite3_step = Z2.S)(a);
+      f3._sqlite3_reset = (a) => (f3._sqlite3_reset = Z2.T)(a);
+      f3._sqlite3_exec = (a, b, c, d, e2) => (f3._sqlite3_exec = Z2.U)(a, b, c, d, e2);
+      f3._sqlite3_finalize = (a) => (f3._sqlite3_finalize = Z2.V)(a);
+      f3._sqlite3_column_name = (a, b) => (f3._sqlite3_column_name = Z2.W)(a, b);
+      f3._sqlite3_column_text = (a, b) => (f3._sqlite3_column_text = Z2.X)(a, b);
+      f3._sqlite3_column_type = (a, b) => (f3._sqlite3_column_type = Z2.Y)(a, b);
+      f3._sqlite3_errmsg = (a) => (f3._sqlite3_errmsg = Z2.Z)(a);
+      f3._sqlite3_clear_bindings = (a) => (f3._sqlite3_clear_bindings = Z2._)(a);
+      f3._sqlite3_value_blob = (a) => (f3._sqlite3_value_blob = Z2.$)(a);
+      f3._sqlite3_value_bytes = (a) => (f3._sqlite3_value_bytes = Z2.aa)(a);
+      f3._sqlite3_value_double = (a) => (f3._sqlite3_value_double = Z2.ba)(a);
+      f3._sqlite3_value_int = (a) => (f3._sqlite3_value_int = Z2.ca)(a);
+      f3._sqlite3_value_type = (a) => (f3._sqlite3_value_type = Z2.da)(a);
+      f3._sqlite3_result_blob = (a, b, c, d) => (f3._sqlite3_result_blob = Z2.ea)(a, b, c, d);
+      f3._sqlite3_result_double = (a, b) => (f3._sqlite3_result_double = Z2.fa)(a, b);
+      f3._sqlite3_result_error = (a, b, c) => (f3._sqlite3_result_error = Z2.ga)(a, b, c);
+      f3._sqlite3_result_int = (a, b) => (f3._sqlite3_result_int = Z2.ha)(a, b);
+      f3._sqlite3_result_int64 = (a, b) => (f3._sqlite3_result_int64 = Z2.ia)(a, b);
+      f3._sqlite3_result_null = (a) => (f3._sqlite3_result_null = Z2.ja)(a);
+      f3._sqlite3_result_text = (a, b, c, d) => (f3._sqlite3_result_text = Z2.ka)(a, b, c, d);
+      f3._sqlite3_aggregate_context = (a, b) => (f3._sqlite3_aggregate_context = Z2.la)(a, b);
+      f3._sqlite3_column_count = (a) => (f3._sqlite3_column_count = Z2.ma)(a);
+      f3._sqlite3_data_count = (a) => (f3._sqlite3_data_count = Z2.na)(a);
+      f3._sqlite3_column_blob = (a, b) => (f3._sqlite3_column_blob = Z2.oa)(a, b);
+      f3._sqlite3_column_bytes = (a, b) => (f3._sqlite3_column_bytes = Z2.pa)(a, b);
+      f3._sqlite3_column_double = (a, b) => (f3._sqlite3_column_double = Z2.qa)(a, b);
+      f3._sqlite3_bind_blob = (a, b, c, d, e2) => (f3._sqlite3_bind_blob = Z2.ra)(a, b, c, d, e2);
+      f3._sqlite3_bind_double = (a, b, c) => (f3._sqlite3_bind_double = Z2.sa)(a, b, c);
+      f3._sqlite3_bind_int = (a, b, c) => (f3._sqlite3_bind_int = Z2.ta)(a, b, c);
+      f3._sqlite3_bind_text = (a, b, c, d, e2) => (f3._sqlite3_bind_text = Z2.ua)(a, b, c, d, e2);
+      f3._sqlite3_bind_parameter_index = (a, b) => (f3._sqlite3_bind_parameter_index = Z2.va)(a, b);
+      f3._sqlite3_sql = (a) => (f3._sqlite3_sql = Z2.wa)(a);
+      f3._sqlite3_normalized_sql = (a) => (f3._sqlite3_normalized_sql = Z2.xa)(a);
+      f3._sqlite3_changes = (a) => (f3._sqlite3_changes = Z2.ya)(a);
+      f3._sqlite3_close_v2 = (a) => (f3._sqlite3_close_v2 = Z2.za)(a);
+      f3._sqlite3_create_function_v2 = (a, b, c, d, e2, h2, k, q, w) => (f3._sqlite3_create_function_v2 = Z2.Aa)(a, b, c, d, e2, h2, k, q, w);
+      f3._sqlite3_update_hook = (a, b, c) => (f3._sqlite3_update_hook = Z2.Ba)(a, b, c);
+      f3._sqlite3_open = (a, b) => (f3._sqlite3_open = Z2.Ca)(a, b);
+      var ia = f3._malloc = (a) => (ia = f3._malloc = Z2.Da)(a), fa = f3._free = (a) => (fa = f3._free = Z2.Ea)(a);
+      f3._RegisterExtensionFunctions = (a) => (f3._RegisterExtensionFunctions = Z2.Fa)(a);
+      var Db = (a, b) => (Db = Z2.Ga)(a, b), Wc = (a, b) => (Wc = Z2.Ha)(a, b), wa = (a) => (wa = Z2.Ia)(a), z2 = (a) => (z2 = Z2.Ja)(a), sa = () => (sa = Z2.Ka)();
+      f3.stackSave = () => sa();
+      f3.stackRestore = (a) => wa(a);
+      f3.stackAlloc = (a) => z2(a);
+      f3.cwrap = (a, b, c, d) => {
+        var e2 = !c || c.every((h2) => h2 === "number" || h2 === "boolean");
+        return b !== "string" && e2 && !d ? f3["_" + a] : (...h2) => Tc(a, b, c, h2);
+      };
+      f3.addFunction = Aa;
+      f3.removeFunction = A2;
+      f3.UTF8ToString = ua;
+      f3.ALLOC_NORMAL = ea;
+      f3.allocate = da;
+      f3.allocateUTF8OnStack = xa;
+      function Yc() {
+        function a() {
+          f3.calledRun = true;
+          if (!La) {
+            if (!f3.noFSInit && !Ib) {
+              var b, c;
+              Ib = true;
+              d ??= f3.stdin;
+              b ??= f3.stdout;
+              c ??= f3.stderr;
+              d ? V("stdin", d) : Zb("/dev/tty", "/dev/stdin");
+              b ? V("stdout", null, b) : Zb("/dev/tty", "/dev/stdout");
+              c ? V("stderr", null, c) : Zb("/dev/tty1", "/dev/stderr");
+              oa("/dev/stdin", 0);
+              oa("/dev/stdout", 1);
+              oa("/dev/stderr", 1);
+            }
+            Z2.N();
+            Jb = false;
+            f3.onRuntimeInitialized?.();
+            if (f3.postRun)
+              for (typeof f3.postRun == "function" && (f3.postRun = [f3.postRun]);f3.postRun.length; ) {
+                var d = f3.postRun.shift();
+                $a.unshift(d);
+              }
+            Za($a);
+          }
+        }
+        if (0 < K)
+          Sa = Yc;
+        else {
+          if (f3.preRun)
+            for (typeof f3.preRun == "function" && (f3.preRun = [f3.preRun]);f3.preRun.length; )
+              bb();
+          Za(ab);
+          0 < K ? Sa = Yc : f3.setStatus ? (f3.setStatus("Running..."), setTimeout(() => {
+            setTimeout(() => f3.setStatus(""), 1);
+            a();
+          }, 1)) : a();
+        }
+      }
+      if (f3.preInit)
+        for (typeof f3.preInit == "function" && (f3.preInit = [f3.preInit]);0 < f3.preInit.length; )
+          f3.preInit.pop()();
+      Yc();
+      return Module;
     });
+    return initSqlJsPromise;
+  };
+  if (typeof exports === "object" && typeof module === "object") {
+    module.exports = initSqlJs;
+    module.exports.default = initSqlJs;
+  } else if (typeof define === "function" && define["amd"]) {
+    define([], function() {
+      return initSqlJs;
+    });
+  } else if (typeof exports === "object") {
+    exports["Module"] = initSqlJs;
   }
-  var wrappers = require_wrappers();
-  Database.prototype.prepare = wrappers.prepare;
-  Database.prototype.transaction = require_transaction();
-  Database.prototype.pragma = require_pragma();
-  Database.prototype.backup = require_backup();
-  Database.prototype.serialize = require_serialize();
-  Database.prototype.function = require_function();
-  Database.prototype.aggregate = require_aggregate();
-  Database.prototype.table = require_table();
-  Database.prototype.loadExtension = wrappers.loadExtension;
-  Database.prototype.exec = wrappers.exec;
-  Database.prototype.close = wrappers.close;
-  Database.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
-  Database.prototype.unsafeMode = wrappers.unsafeMode;
-  Database.prototype[util2.inspect] = require_inspect();
-  module.exports = Database;
-});
-
-// ../../node_modules/better-sqlite3/lib/index.js
-var require_lib2 = __commonJS((exports, module) => {
-  module.exports = require_database();
-  module.exports.SqliteError = require_sqlite_error();
 });
 
 // ../../node_modules/ws/lib/constants.js
@@ -41264,7 +42783,7 @@ var {
   Help
 } = import__.default;
 // package.json
-var version = "0.9.89";
+var version = "0.9.90";
 
 // src/runner.ts
 import { execSync } from "node:child_process";
@@ -54888,13 +56407,57 @@ function date4(params) {
 
 // ../../node_modules/zod/v4/classic/external.js
 config(en_default());
+// ../core/src/config/base.ts
+var baseModelConfigSchema = exports_external.object({
+  provider: exports_external.string().optional(),
+  model: exports_external.string().optional(),
+  parameters: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
+});
+var baseApprovalConfigSchema = exports_external.object({
+  level: exports_external.enum(["none", "destructive", "commits", "all"]).optional(),
+  autoApprove: exports_external.boolean().optional(),
+  maxCost: exports_external.number().positive().optional()
+});
+var providerConfigSchema = exports_external.object({
+  apiKey: exports_external.string().optional(),
+  defaultModel: exports_external.string().optional(),
+  defaultParameters: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
+  location: exports_external.string().optional(),
+  project: exports_external.string().optional(),
+  keyFile: exports_external.string().optional(),
+  baseUrl: exports_external.string().optional(),
+  name: exports_external.string().optional()
+});
+var modelConfigSchema = baseModelConfigSchema.extend({
+  budget: exports_external.number().positive().optional(),
+  rules: exports_external.union([exports_external.string(), exports_external.array(exports_external.string()).optional()]).optional()
+});
+var toolConfigSchema = exports_external.union([
+  exports_external.boolean(),
+  baseModelConfigSchema
+]);
+
 // ../core/src/config/memory.ts
 var memoryConfigSchema = exports_external.object({
   enabled: exports_external.boolean().optional().default(true),
   type: exports_external.enum(["sqlite", "memory"]).optional().default("sqlite"),
   path: exports_external.string().optional().default("~/.config/polka-codes/memory.sqlite")
 }).strict().optional();
-
+var DEFAULT_MEMORY_CONFIG = {
+  enabled: true,
+  type: "sqlite",
+  path: "~/.config/polka-codes/memory.sqlite"
+};
+function resolveHomePath(path) {
+  if (path.startsWith("~")) {
+    const home = process.env.HOME || process.env.USERPROFILE || ".";
+    if (home === ".") {
+      throw new Error("Cannot resolve home directory: HOME and USERPROFILE environment variables are not set");
+    }
+    return `${home}${path.slice(1)}`;
+  }
+  return path;
+}
 // ../core/src/config.ts
 var ruleSchema = exports_external.union([
   exports_external.string(),
@@ -54908,20 +56471,10 @@ var ruleSchema = exports_external.union([
     branch: exports_external.string().optional()
   }).strict()
 ]);
-var providerConfigSchema = exports_external.object({
-  apiKey: exports_external.string().optional(),
-  defaultModel: exports_external.string().optional(),
-  defaultParameters: exports_external.record(exports_external.string(), exports_external.any()).optional(),
-  location: exports_external.string().optional(),
-  project: exports_external.string().optional(),
-  keyFile: exports_external.string().optional(),
-  baseUrl: exports_external.string().optional(),
-  name: exports_external.string().optional()
-});
 var providerModelSchema = exports_external.object({
   provider: exports_external.string().optional(),
   model: exports_external.string().optional(),
-  parameters: exports_external.record(exports_external.string(), exports_external.any()).optional(),
+  parameters: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
   budget: exports_external.number().positive().optional(),
   rules: exports_external.array(ruleSchema).optional().or(exports_external.string()).optional()
 });
@@ -54934,7 +56487,7 @@ var scriptSchema = exports_external.union([
   exports_external.object({
     workflow: exports_external.string(),
     description: exports_external.string().optional(),
-    input: exports_external.record(exports_external.string(), exports_external.any()).optional()
+    input: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
   }).strict(),
   exports_external.object({
     script: exports_external.string(),
@@ -55013,7 +56566,7 @@ var configSchema = exports_external.object({
   providers: exports_external.record(exports_external.string(), providerConfigSchema).optional(),
   defaultProvider: exports_external.string().optional(),
   defaultModel: exports_external.string().optional(),
-  defaultParameters: exports_external.record(exports_external.string(), exports_external.any()).optional(),
+  defaultParameters: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
   maxMessageCount: exports_external.number().int().positive().optional(),
   budget: exports_external.number().positive().optional(),
   retryCount: exports_external.number().int().min(0).optional(),
@@ -66099,7 +67652,7 @@ var uiMessagesSchema = lazyValidator(() => zodSchema(exports_external.array(expo
 var WorkflowInputDefinitionSchema = exports_external.object({
   id: exports_external.string(),
   description: exports_external.string().nullish(),
-  default: exports_external.any().nullish()
+  default: exports_external.unknown().nullish()
 });
 var WorkflowStepDefinitionSchema = exports_external.object({
   id: exports_external.string(),
@@ -66107,7 +67660,7 @@ var WorkflowStepDefinitionSchema = exports_external.object({
   task: exports_external.string(),
   output: exports_external.string().nullish(),
   expected_outcome: exports_external.string().nullish(),
-  outputSchema: exports_external.any().nullish(),
+  outputSchema: exports_external.unknown().nullish(),
   timeout: exports_external.number().positive().nullish()
 });
 var WhileLoopStepSchema = exports_external.object({
@@ -67226,7 +68779,7 @@ function mergeConfigs(configs) {
     merged.rules = mergeArray(accRules, configRules);
     merged.excludeFiles = mergeArray(acc.excludeFiles, config3.excludeFiles);
     return merged;
-  });
+  }, {});
   return mergedConfig;
 }
 async function resolveRules(rules) {
@@ -69426,12 +70979,12 @@ function isPlainObject3(value) {
   }
   return Object.getPrototypeOf(value) === proto;
 }
-function deepMerge(...objects) {
+function deepMerge2(...objects) {
   const output = {};
   for (const obj of objects) {
     for (const [key, value] of Object.entries(obj)) {
       const prevValue = output[key];
-      output[key] = isPlainObject3(prevValue) && isPlainObject3(value) ? deepMerge(prevValue, value) : value;
+      output[key] = isPlainObject3(prevValue) && isPlainObject3(value) ? deepMerge2(prevValue, value) : value;
     }
   }
   return output;
@@ -69441,7 +70994,7 @@ function makeTheme(...themes) {
     defaultTheme,
     ...themes.filter((theme) => theme != null)
   ];
-  return deepMerge(...themesToMerge);
+  return deepMerge2(...themesToMerge);
 }
 
 // ../../node_modules/@inquirer/core/dist/lib/use-prefix.js
@@ -70923,12 +72476,59 @@ class InMemoryStore {
     this.#data = data;
   }
 }
+function isIMemoryStore(store) {
+  return "readMemory" in store && "updateMemory" in store;
+}
 var getProvider = (options = {}) => {
   const ig = import_ignore2.default().add(options.excludeFiles ?? []);
   const memoryStore = options.memoryStore ?? new InMemoryStore;
   const todoItemStore = options.todoItemStore ?? new InMemoryStore;
   const defaultMemoryTopic = ":default:";
   const searchModel = options.getModel?.("search");
+  const readMemoryKV = async (topic) => {
+    if (!isIMemoryStore(memoryStore)) {
+      const data = await memoryStore.read() ?? {};
+      return data[topic];
+    }
+    return memoryStore.readMemory(topic);
+  };
+  const updateMemoryKV = async (operation, topic, content) => {
+    if (!isIMemoryStore(memoryStore)) {
+      const data = await memoryStore.read() ?? {};
+      switch (operation) {
+        case "append":
+          if (content === undefined) {
+            throw new Error("Content is required for append operation.");
+          }
+          data[topic] = `${data[topic] || ""}
+${content}`;
+          break;
+        case "replace":
+          if (content === undefined) {
+            throw new Error("Content is required for replace operation.");
+          }
+          data[topic] = content;
+          break;
+        case "remove":
+          delete data[topic];
+          break;
+      }
+      await memoryStore.write(data);
+      return;
+    }
+    await memoryStore.updateMemory(operation, topic, content);
+  };
+  const listMemoryTopicsKV = async () => {
+    if (!isIMemoryStore(memoryStore)) {
+      const data = await memoryStore.read() ?? {};
+      return Object.keys(data);
+    }
+    const entries = await memoryStore.queryMemory({});
+    if (Array.isArray(entries)) {
+      return entries.map((e2) => e2.name);
+    }
+    return [];
+  };
   const provider2 = {
     listTodoItems: async (id, status) => {
       const todoItems = await todoItemStore.read() ?? [];
@@ -71027,35 +72627,14 @@ var getProvider = (options = {}) => {
       }
     },
     listMemoryTopics: async () => {
-      const memory2 = await memoryStore.read() ?? {};
-      return Object.keys(memory2);
+      return listMemoryTopicsKV();
     },
     readMemory: async (topic = defaultMemoryTopic) => {
-      const memory2 = await memoryStore.read() ?? {};
-      return memory2[topic];
+      return readMemoryKV(topic);
     },
     updateMemory: async (operation, topic, content) => {
       const memoryTopic = topic ?? defaultMemoryTopic;
-      const memory2 = await memoryStore.read() ?? {};
-      switch (operation) {
-        case "append":
-          if (content === undefined) {
-            throw new Error("Content is required for append operation.");
-          }
-          memory2[memoryTopic] = `${memory2[memoryTopic] || ""}
-${content}`;
-          break;
-        case "replace":
-          if (content === undefined) {
-            throw new Error("Content is required for replace operation.");
-          }
-          memory2[memoryTopic] = content;
-          break;
-        case "remove":
-          delete memory2[memoryTopic];
-          break;
-      }
-      await memoryStore.write(memory2);
+      await updateMemoryKV(operation, memoryTopic, content);
     },
     readFile: async (path, includeIgnored) => {
       if (!includeIgnored && ig.ignores(path)) {
@@ -71223,7 +72802,666 @@ ${content}`;
   return provider2;
 };
 // ../cli-shared/src/sqlite-memory-store.ts
-var import_better_sqlite3 = __toESM(require_lib2(), 1);
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+import { randomUUID } from "node:crypto";
+import { existsSync as existsSync2 } from "node:fs";
+import { mkdir as mkdir2, readFile as readFile3, rename as rename2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname2, resolve as resolve4 } from "node:path";
+var import_sql = __toESM(require_sql_wasm(), 1);
+
+class FileLock {
+  lockfilePath;
+  static LOCK_TIMEOUT = 30000;
+  constructor(dbPath) {
+    this.lockfilePath = `${dbPath}.lock`;
+  }
+  async acquire(retries = 10, delay2 = 100) {
+    for (let i2 = 0;i2 < retries; i2++) {
+      try {
+        const lockData = JSON.stringify({
+          pid: process.pid,
+          acquiredAt: Date.now()
+        });
+        await writeFile2(this.lockfilePath, lockData, {
+          flag: "wx",
+          mode: 384
+        });
+        return;
+      } catch (error48) {
+        const errorCode = error48?.code;
+        if (errorCode === "EEXIST") {
+          try {
+            const lockContent = await readFile3(this.lockfilePath, "utf-8");
+            const lockData = JSON.parse(lockContent);
+            if (!lockData || typeof lockData.acquiredAt !== "number" || lockData.acquiredAt <= 0) {
+              console.warn(`[FileLock] Lock file has invalid acquiredAt, treating as stale`);
+              await rename2(this.lockfilePath, `${this.lockfilePath}.invalid.${Date.now()}`);
+              continue;
+            }
+            const lockAge = Date.now() - lockData.acquiredAt;
+            if (lockAge > FileLock.LOCK_TIMEOUT) {
+              console.warn(`[FileLock] Breaking stale lock (age: ${lockAge}ms)`);
+              await rename2(this.lockfilePath, `${this.lockfilePath}.stale.${Date.now()}`);
+              continue;
+            }
+          } catch (readError) {
+            if (readError instanceof SyntaxError) {
+              console.warn(`[FileLock] Lock file contains invalid JSON, treating as stale`);
+              await rename2(this.lockfilePath, `${this.lockfilePath}.corrupt.${Date.now()}`);
+              continue;
+            }
+          }
+          if (i2 < retries - 1) {
+            await new Promise((resolve5) => setTimeout(resolve5, delay2));
+          } else {
+            throw new Error(`Cannot acquire lock after ${retries} retries (file: ${this.lockfilePath})`);
+          }
+        } else {
+          throw error48;
+        }
+      }
+    }
+  }
+  async release() {
+    try {
+      await rename2(this.lockfilePath, `${this.lockfilePath}.released.${Date.now()}`);
+    } catch (error48) {
+      const errorCode = error48.code;
+      if (errorCode !== "ENOENT") {
+        console.warn(`[FileLock] Error releasing lock: ${error48 instanceof Error ? error48.message : String(error48)}`);
+      }
+    }
+  }
+}
+
+class ReentrantMutex {
+  queue = [];
+  locked = false;
+  lockCount = 0;
+  owner = null;
+  async acquire(owner) {
+    if (this.locked && this.owner === owner) {
+      this.lockCount++;
+      return () => this.release(owner);
+    }
+    while (this.locked) {
+      await new Promise((resolve5) => this.queue.push(resolve5));
+    }
+    this.locked = true;
+    this.owner = owner;
+    this.lockCount = 1;
+    return () => this.release(owner);
+  }
+  release(owner) {
+    if (this.owner !== owner) {
+      return;
+    }
+    this.lockCount--;
+    if (this.lockCount === 0) {
+      this.locked = false;
+      this.owner = null;
+      const next = this.queue.shift();
+      if (next) {
+        next();
+      }
+    }
+  }
+}
+var SqlJs = null;
+var SqlJsInitPromise = null;
+async function getSqlJs() {
+  if (SqlJs) {
+    return SqlJs;
+  }
+  if (SqlJsInitPromise) {
+    return SqlJsInitPromise;
+  }
+  SqlJsInitPromise = import_sql.default({});
+  SqlJs = await SqlJsInitPromise;
+  return SqlJs;
+}
+var transactionOwnerStorage = new AsyncLocalStorage2;
+
+class SQLiteMemoryStore {
+  db = null;
+  dbPromise = null;
+  config;
+  currentScope;
+  inTransaction = false;
+  transactionMutex = new ReentrantMutex;
+  fileLock;
+  getDbPath() {
+    return this.config.path || DEFAULT_MEMORY_CONFIG.path;
+  }
+  getFileLock() {
+    if (!this.fileLock) {
+      const dbPath = this.resolvePath(this.getDbPath());
+      this.fileLock = new FileLock(dbPath);
+    }
+    return this.fileLock;
+  }
+  static SORT_COLUMNS = {
+    created: "created_at",
+    updated: "updated_at",
+    accessed: "last_accessed",
+    name: "name"
+  };
+  static ALLOWED_SORT_ORDERS = ["asc", "desc"];
+  static ALLOWED_PRIORITIES = ["low", "medium", "high", "critical"];
+  constructor(config3, scope) {
+    this.config = config3;
+    this.currentScope = scope;
+  }
+  async initializeDatabase() {
+    if (this.dbPromise) {
+      return this.dbPromise;
+    }
+    this.dbPromise = (async () => {
+      if (this.db) {
+        return this.db;
+      }
+      const dbPath = this.resolvePath(this.getDbPath());
+      try {
+        const dir = dirname2(dbPath);
+        if (!existsSync2(dir)) {
+          await mkdir2(dir, { recursive: true, mode: 448 });
+        }
+        let dbData;
+        if (existsSync2(dbPath)) {
+          const lock = this.getFileLock();
+          await lock.acquire();
+          try {
+            try {
+              dbData = await readFile3(dbPath);
+              if (dbData.length >= 16) {
+                const header = String.fromCharCode(...dbData.subarray(0, 15));
+                if (header !== "SQLite format 3") {
+                  console.warn("[SQLiteMemoryStore] Invalid SQLite database header, will recreate");
+                  dbData = undefined;
+                }
+              }
+            } catch (error48) {
+              const errorCode = error48?.code;
+              if (errorCode === "ENOENT") {
+                dbData = undefined;
+              } else {
+                throw new Error(`Failed to read database file at ${dbPath}: ${error48 instanceof Error ? error48.message : String(error48)}`);
+              }
+            }
+          } finally {
+            await lock.release();
+          }
+        }
+        const SqlJs2 = await getSqlJs();
+        const db2 = new SqlJs2.Database(dbData);
+        this.configurePragmas(db2);
+        this.checkIntegrity(db2);
+        this.initializeSchema(db2);
+        this.db = db2;
+        return db2;
+      } catch (error48) {
+        console.error("[SQLiteMemoryStore] Initialization failed:", error48);
+        if (existsSync2(dbPath)) {
+          const backupPath = `${dbPath}.corrupted.${Date.now()}`;
+          console.warn(`[SQLiteMemoryStore] Backing up corrupted database to: ${backupPath}`);
+          try {
+            await rename2(dbPath, backupPath);
+          } catch (backupError) {
+            console.error("[SQLiteMemoryStore] Failed to backup corrupted database:", backupError);
+            this.dbPromise = null;
+            throw backupError;
+          }
+          this.dbPromise = null;
+          return this.initializeDatabase();
+        }
+        this.dbPromise = null;
+        throw error48;
+      }
+    })();
+    return this.dbPromise;
+  }
+  async saveDatabase() {
+    if (!this.db) {
+      return;
+    }
+    const lock = this.getFileLock();
+    await lock.acquire();
+    try {
+      const dbPath = this.resolvePath(this.getDbPath());
+      const tempPath = `${dbPath}.tmp`;
+      const data = this.db.export();
+      await writeFile2(tempPath, data, { mode: 384 });
+      await rename2(tempPath, dbPath);
+    } finally {
+      await lock.release();
+    }
+  }
+  configurePragmas(db2) {
+    db2.run("PRAGMA synchronous = NORMAL");
+    db2.run("PRAGMA busy_timeout = 5000");
+    db2.run("PRAGMA foreign_keys = ON");
+    db2.run("PRAGMA temp_store = MEMORY");
+  }
+  checkIntegrity(db2) {
+    try {
+      const results = db2.exec("SELECT 1");
+      if (results.length === 0) {
+        throw new Error("Database query returned no results");
+      }
+    } catch (error48) {
+      console.error("[SQLiteMemoryStore] Integrity check failed:", error48);
+      throw new Error("Database is corrupted");
+    }
+  }
+  initializeSchema(db2) {
+    db2.run(`
+      CREATE TABLE IF NOT EXISTS memory_entries (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL CHECK(length(name) > 0),
+        scope TEXT NOT NULL CHECK(scope IN ('global') OR scope LIKE 'project:%'),
+        content TEXT NOT NULL CHECK(length(content) > 0),
+        entry_type TEXT NOT NULL CHECK(length(entry_type) > 0),
+        status TEXT CHECK(status IS NULL OR length(status) > 0),
+        priority TEXT CHECK(priority IS NULL OR priority IN ('low', 'medium', 'high', 'critical')),
+        tags TEXT CHECK(tags IS NULL OR length(tags) > 0),
+        metadata TEXT CHECK(metadata IS NULL OR json_valid(metadata)),
+        created_at INTEGER NOT NULL CHECK(created_at > 0),
+        updated_at INTEGER NOT NULL CHECK(updated_at > 0),
+        last_accessed INTEGER NOT NULL CHECK(last_accessed > 0),
+        UNIQUE(name, scope)
+      )
+    `);
+    db2.run("CREATE INDEX IF NOT EXISTS idx_memory_entries_scope_type ON memory_entries(scope, entry_type)");
+    db2.run("CREATE INDEX IF NOT EXISTS idx_memory_entries_updated ON memory_entries(updated_at)");
+  }
+  async getDatabase() {
+    if (!this.db) {
+      this.db = await this.initializeDatabase();
+    }
+    return this.db;
+  }
+  resolvePath(path) {
+    const resolved = resolveHomePath(path);
+    return resolve4(resolved);
+  }
+  generateUUID() {
+    return randomUUID();
+  }
+  now() {
+    return Date.now();
+  }
+  async transaction(callback) {
+    let owner = transactionOwnerStorage.getStore();
+    if (!owner) {
+      owner = Symbol("transaction");
+    }
+    const release = await this.transactionMutex.acquire(owner);
+    return transactionOwnerStorage.run(owner, async () => {
+      try {
+        const db2 = await this.getDatabase();
+        const shouldBegin = !this.inTransaction;
+        try {
+          if (shouldBegin) {
+            db2.run("BEGIN TRANSACTION");
+            this.inTransaction = true;
+          }
+          const result = await callback();
+          if (shouldBegin) {
+            db2.run("COMMIT");
+            this.inTransaction = false;
+            try {
+              await this.saveDatabase();
+            } catch (saveError) {
+              console.error("[SQLiteMemoryStore] Failed to save database after commit, closing:", saveError);
+              await this.close(true);
+              throw saveError;
+            }
+          }
+          return result;
+        } catch (error48) {
+          if (this.inTransaction) {
+            try {
+              db2.run("ROLLBACK");
+            } catch (rollbackError) {
+              console.error("[SQLiteMemoryStore] ROLLBACK failed:", rollbackError);
+            }
+            this.inTransaction = false;
+          }
+          throw error48;
+        }
+      } finally {
+        release();
+      }
+    });
+  }
+  async readMemory(topic) {
+    const db2 = await this.getDatabase();
+    const scope = this.currentScope;
+    const stmt = db2.prepare("SELECT content FROM memory_entries WHERE name = ? AND scope = ?");
+    stmt.bind([topic, scope]);
+    if (stmt.step()) {
+      const row = stmt.getAsObject();
+      const content = row.content;
+      stmt.free();
+      return content;
+    }
+    stmt.free();
+    return;
+  }
+  async updateMemoryInternal(db2, operation, topic, content, metadata) {
+    const scope = this.currentScope;
+    const now = this.now();
+    const createdAt = metadata?.created_at ?? now;
+    const updatedAt = metadata?.updated_at ?? now;
+    const lastAccessed = metadata?.last_accessed ?? now;
+    if (operation === "remove") {
+      const stmt2 = db2.prepare("DELETE FROM memory_entries WHERE name = ? AND scope = ?");
+      stmt2.run([topic, scope]);
+      stmt2.free();
+      return;
+    }
+    const stmt = db2.prepare("SELECT content, entry_type, status, priority, tags FROM memory_entries WHERE name = ? AND scope = ?");
+    stmt.bind([topic, scope]);
+    let existing;
+    if (stmt.step()) {
+      const row = stmt.getAsObject();
+      existing = {
+        content: row.content,
+        entry_type: row.entry_type,
+        status: row.status,
+        priority: row.priority,
+        tags: row.tags
+      };
+      stmt.free();
+    } else {
+      existing = undefined;
+      stmt.free();
+    }
+    let finalContent;
+    let entry_type;
+    let status;
+    let priority;
+    let tags;
+    if (existing) {
+      if (operation === "append") {
+        if (!content) {
+          throw new Error("Content is required for append operation.");
+        }
+        finalContent = `${existing.content}
+${content}`;
+      } else {
+        if (!content) {
+          throw new Error("Content is required for replace operation.");
+        }
+        finalContent = content;
+      }
+      entry_type = metadata?.entry_type || existing.entry_type;
+      status = (metadata?.status || existing.status) ?? undefined;
+      priority = (metadata?.priority || existing.priority) ?? undefined;
+      tags = (metadata?.tags || existing.tags) ?? undefined;
+    } else {
+      if (!content) {
+        throw new Error("Content is required for new memory entries.");
+      }
+      finalContent = content;
+      entry_type = metadata?.entry_type || "note";
+      status = metadata?.status;
+      priority = metadata?.priority;
+      tags = metadata?.tags;
+    }
+    const upsertStmt = db2.prepare(`
+      INSERT INTO memory_entries (id, name, scope, content, entry_type, status, priority, tags, created_at, updated_at, last_accessed)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(name, scope) DO UPDATE SET
+        content = excluded.content,
+        entry_type = excluded.entry_type,
+        status = excluded.status,
+        priority = excluded.priority,
+        tags = excluded.tags,
+        updated_at = excluded.updated_at,
+        last_accessed = excluded.last_accessed
+    `);
+    upsertStmt.run([
+      this.generateUUID(),
+      topic,
+      scope,
+      finalContent,
+      entry_type,
+      status ?? null,
+      priority ?? null,
+      tags ?? null,
+      createdAt,
+      updatedAt,
+      lastAccessed
+    ]);
+    upsertStmt.free();
+  }
+  async updateMemory(operation, topic, content, metadata) {
+    return this.transaction(async () => {
+      const db2 = await this.getDatabase();
+      await this.updateMemoryInternal(db2, operation, topic, content, metadata);
+    });
+  }
+  async queryMemory(query = {}, options = {}) {
+    if (options.operation === "delete") {
+      return this.transaction(async () => {
+        const db3 = await this.getDatabase();
+        const { sql: sql2, params: params2 } = this.buildQuery(query);
+        const deleteSql = `DELETE FROM memory_entries WHERE id IN (SELECT id FROM (${sql2}))`;
+        const stmt2 = db3.prepare(deleteSql);
+        stmt2.bind(params2);
+        stmt2.step();
+        stmt2.free();
+        return db3.getRowsModified();
+      });
+    }
+    const db2 = await this.getDatabase();
+    const { sql, params } = this.buildQuery(query);
+    if (options.operation === "count") {
+      const countSql = `SELECT COUNT(*) as count FROM (${sql})`;
+      const stmt2 = db2.prepare(countSql);
+      stmt2.bind(params);
+      let count = 0;
+      if (stmt2.step()) {
+        const row = stmt2.getAsObject();
+        count = row.count;
+      }
+      stmt2.free();
+      return count;
+    }
+    const stmt = db2.prepare(sql);
+    stmt.bind(params);
+    const entries = [];
+    while (stmt.step()) {
+      entries.push(stmt.getAsObject());
+    }
+    stmt.free();
+    return entries;
+  }
+  buildQuery(query) {
+    const conditions = [];
+    const params = [];
+    let sql = "SELECT * FROM memory_entries WHERE 1=1";
+    const scope = query.scope === "auto" ? this.currentScope : query.scope;
+    if (scope === "global") {
+      conditions.push(`scope = ?`);
+      params.push("global");
+    } else if (scope === "project" || !scope && this.currentScope !== "global") {
+      conditions.push(`scope = ?`);
+      params.push(this.currentScope);
+    }
+    if (query.name) {
+      if (!query.name.trim()) {
+        throw new Error("Name cannot be empty");
+      }
+      conditions.push(`name = ?`);
+      params.push(query.name.trim());
+    }
+    if (query.type) {
+      if (!query.type.trim()) {
+        throw new Error("Type cannot be empty");
+      }
+      conditions.push(`entry_type = ?`);
+      params.push(query.type.trim());
+    }
+    if (query.status) {
+      conditions.push(`status = ?`);
+      params.push(query.status);
+    }
+    if (query.priority) {
+      if (!SQLiteMemoryStore.ALLOWED_PRIORITIES.includes(query.priority)) {
+        throw new Error(`Invalid priority: ${query.priority}`);
+      }
+      conditions.push(`priority = ?`);
+      params.push(query.priority);
+    }
+    if (query.tags) {
+      const tags = Array.isArray(query.tags) ? query.tags : [query.tags];
+      for (const tag of tags) {
+        const trimmed = tag.trim();
+        if (!trimmed) {
+          throw new Error("Tags cannot be empty");
+        }
+        const escaped = trimmed.replace(/[\\_%]/g, "\\$&");
+        conditions.push(`(tags = ? OR tags LIKE ? ESCAPE '\\' OR tags LIKE ? ESCAPE '\\' OR tags LIKE ? ESCAPE '\\')`);
+        params.push(trimmed, `${escaped},%`, `%,${escaped}`, `%,${escaped},%`);
+      }
+    }
+    if (query.search) {
+      const searchTerm = query.search.trim();
+      conditions.push(`(content LIKE ? ESCAPE '\\' OR name LIKE ? ESCAPE '\\')`);
+      const searchPattern = `%${searchTerm.replace(/[\\_%]/g, "\\$&")}%`;
+      params.push(searchPattern, searchPattern);
+    }
+    if (query.createdAfter) {
+      conditions.push(`created_at >= ?`);
+      params.push(query.createdAfter);
+    }
+    if (query.createdBefore) {
+      conditions.push(`created_at <= ?`);
+      params.push(query.createdBefore);
+    }
+    if (query.updatedAfter) {
+      conditions.push(`updated_at >= ?`);
+      params.push(query.updatedAfter);
+    }
+    if (query.updatedBefore) {
+      conditions.push(`updated_at <= ?`);
+      params.push(query.updatedBefore);
+    }
+    if (conditions.length > 0) {
+      sql += ` AND ${conditions.join(" AND ")}`;
+    }
+    if (query.sortBy) {
+      const column = SQLiteMemoryStore.SORT_COLUMNS[query.sortBy];
+      if (!column) {
+        throw new Error(`Invalid sortBy: ${query.sortBy}`);
+      }
+      const order = query.sortOrder || "desc";
+      if (!SQLiteMemoryStore.ALLOWED_SORT_ORDERS.includes(order)) {
+        throw new Error(`Invalid sortOrder: ${order}`);
+      }
+      sql += ` ORDER BY ${column} ${order.toUpperCase()}`;
+    }
+    if (query.limit) {
+      const limit = Number(query.limit);
+      if (Number.isNaN(limit) || limit < 1 || limit > 1e4) {
+        throw new Error("Limit must be between 1 and 10000");
+      }
+      sql += ` LIMIT ?`;
+      params.push(limit);
+    }
+    if (query.offset) {
+      const offset = Number(query.offset);
+      if (Number.isNaN(offset) || offset < 0) {
+        throw new Error("Offset must be >= 0");
+      }
+      sql += ` OFFSET ?`;
+      params.push(offset);
+    }
+    return { sql, params };
+  }
+  async batchUpdateMemory(operations) {
+    return this.transaction(async () => {
+      const db2 = await this.getDatabase();
+      for (const op of operations) {
+        await this.updateMemoryInternal(db2, op.operation, op.name, op.content, op.metadata);
+      }
+    });
+  }
+  async close(skipSave = false) {
+    const db2 = this.db;
+    if (db2) {
+      try {
+        if (!skipSave) {
+          await this.saveDatabase();
+        }
+      } finally {
+        if (this.db === db2) {
+          db2.close();
+          this.db = null;
+        }
+      }
+    }
+    this.dbPromise = null;
+  }
+  async getStats() {
+    const db2 = await this.getDatabase();
+    const results = db2.exec("SELECT COUNT(*) as count FROM memory_entries");
+    const totalEntries = results[0]?.values[0]?.[0] || 0;
+    const typeResults = db2.exec("SELECT entry_type, COUNT(*) as count FROM memory_entries GROUP BY entry_type");
+    const entriesByType = {};
+    if (typeResults.length > 0) {
+      for (const row of typeResults[0].values) {
+        entriesByType[row[0]] = row[1];
+      }
+    }
+    const dbPath = this.resolvePath(this.getDbPath());
+    let databaseSize = 0;
+    try {
+      const stats = await import("node:fs/promises").then((fs4) => fs4.stat(dbPath));
+      databaseSize = stats.size;
+    } catch {}
+    return {
+      totalEntries,
+      entriesByType,
+      databaseSize
+    };
+  }
+}
+// ../cli-shared/src/utils/parameterSimplifier.ts
+function createSimplifier(keepFields) {
+  return (params) => {
+    const result = {};
+    for (const field of keepFields) {
+      if (params[field] !== undefined) {
+        result[field] = params[field];
+      }
+    }
+    return result;
+  };
+}
+function createCustomSimplifier(transform2) {
+  return transform2;
+}
+var SIMPLIFIERS = {
+  replaceInFile: createSimplifier(["path"]),
+  writeToFile: createSimplifier(["path"]),
+  readFile: createSimplifier(["path", "includeIgnored"]),
+  executeCommand: createSimplifier(["command", "requiresApproval"]),
+  updateMemory: createSimplifier(["operation", "topic"]),
+  searchFiles: createCustomSimplifier((params) => ({ ...params })),
+  listFiles: createCustomSimplifier((params) => {
+    const DEFAULT_MAX_COUNT = 2000;
+    const maxCount = params.maxCount;
+    return {
+      path: params.path,
+      recursive: params.recursive,
+      ...maxCount !== DEFAULT_MAX_COUNT && { maxCount }
+    };
+  })
+};
+
 // ../cli-shared/src/utils/eventHandler.ts
 var taskToolCallStats = new Map;
 var globalToolCallStats = new Map;