@polka-codes/runner 0.9.88 → 0.9.90

package/dist/index.js

@@ -17900,7 +17900,7 @@ var init_multipart_parser = __esm(() => {
 
 // ../../node_modules/node-fetch/src/body.js
 import Stream, { PassThrough } from "node:stream";
-import { types as types3, deprecate, promisify } from "node:util";
+import { types as types4, deprecate, promisify } from "node:util";
 import { Buffer as Buffer4 } from "node:buffer";
 
 class Body {
@@ -17912,7 +17912,7 @@ class Body {
       body = null;
     } else if (isURLSearchParameters(body)) {
       body = Buffer4.from(body.toString());
-    } else if (isBlob(body)) {} else if (Buffer4.isBuffer(body)) {} else if (types3.isAnyArrayBuffer(body)) {
+    } else if (isBlob(body)) {} else if (Buffer4.isBuffer(body)) {} else if (types4.isAnyArrayBuffer(body)) {
       body = Buffer4.from(body);
     } else if (ArrayBuffer.isView(body)) {
       body = Buffer4.from(body.buffer, body.byteOffset, body.byteLength);
@@ -18058,7 +18058,7 @@ var pipeline, INTERNALS, clone2 = (instance, highWaterMark) => {
   if (isBlob(body)) {
     return body.type || null;
   }
-  if (Buffer4.isBuffer(body) || types3.isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
+  if (Buffer4.isBuffer(body) || types4.isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
     return null;
   }
   if (body instanceof FormData2) {
@@ -18115,7 +18115,7 @@ var init_body = __esm(() => {
 });
 
 // ../../node_modules/node-fetch/src/headers.js
-import { types as types4 } from "node:util";
+import { types as types5 } from "node:util";
 import http from "node:http";
 function fromRawHeaders(headers = []) {
   return new Headers2(headers.reduce((result, value, index, array2) => {
@@ -18157,7 +18157,7 @@ var init_headers = __esm(() => {
         for (const [name17, values] of Object.entries(raw)) {
           result.push(...values.map((value) => [name17, value]));
         }
-      } else if (init == null) {} else if (typeof init === "object" && !types4.isBoxedPrimitive(init)) {
+      } else if (init == null) {} else if (typeof init === "object" && !types5.isBoxedPrimitive(init)) {
         const method = init[Symbol.iterator];
         if (method == null) {
           result.push(...Object.entries(init));
@@ -18166,7 +18166,7 @@ var init_headers = __esm(() => {
             throw new TypeError("Header pairs must be iterable");
           }
           result = [...init].map((pair) => {
-            if (typeof pair !== "object" || types4.isBoxedPrimitive(pair)) {
+            if (typeof pair !== "object" || types5.isBoxedPrimitive(pair)) {
               throw new TypeError("Each header pair must be an iterable object");
             }
             return [...pair];
@@ -37641,6 +37641,2290 @@ var require_mimeScore = __commonJS((exports, module) => {
   };
 });
 
+// ../../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);
+        }
+      };
+      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);
+          }
+        }
+        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
+            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);
+          }
+        };
+        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;
+      }
+      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);
+        }
+      }
+      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);
+      }
+
+      class Ya {
+        name = "ExitStatus";
+        constructor(a) {
+          this.message = `Program terminated with exit(${a})`;
+          this.status = a;
+        }
+      }
+      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}`);
+        }
+      }
+      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 (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;
+          }
+        }
+        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);
+          }
+          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;
+        }
+      };
+      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);
+      }
+      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;
+        }
+      }
+      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;
+      }
+      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;
+          }
+      }
+      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;
+      }
+      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 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;
+      }
+      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;
+  }
+});
+
 // ../../node_modules/ws/lib/constants.js
 var require_constants = __commonJS((exports, module) => {
   var BINARY_TYPES = ["nodebuffer", "arraybuffer", "fragments"];
@@ -40499,7 +42783,7 @@ var {
   Help
 } = import__.default;
 // package.json
-var version = "0.9.88";
+var version = "0.9.90";
 
 // src/runner.ts
 import { execSync } from "node:child_process";
@@ -54123,6 +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(),
@@ -54136,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()
 });
@@ -54162,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(),
@@ -54241,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(),
@@ -54255,7 +56580,8 @@ var configSchema = exports_external.object({
   mcpServers: exports_external.record(exports_external.string(), mcpServerConfigSchema).optional(),
   rules: exports_external.array(ruleSchema).optional().or(exports_external.string()).optional(),
   excludeFiles: exports_external.array(exports_external.string()).optional(),
-  agent: agentSchema
+  agent: agentSchema,
+  memory: memoryConfigSchema
 }).strict().nullish();
 // ../core/src/skills/constants.ts
 var SKILL_LIMITS = {
@@ -54728,14 +57054,40 @@ var readBinaryFile_default = {
 // ../core/src/tools/readFile.ts
 var toolInfo6 = {
   name: "readFile",
-  description: "Request to read the contents of one or multiple files at the specified paths. Use comma separated paths to read multiple files. Use this when you need to examine the contents of an existing file you do not know the contents of, for example to analyze code, review text files, or extract information from configuration files. May not be suitable for other types of binary files, as it returns the raw content as a string. Try to list all the potential files are relevent to the task, and then use this tool to read all the relevant files.",
+  description: `Request to read the contents of one or multiple files at the specified paths.
+
+When to use:
+- Examining file contents you don't know
+- Analyzing code, reviewing text files, extracting configuration info
+- Reading multiple files at once (use comma-separated paths)
+- Understanding file structure before editing
+
+When NOT to use:
+- For file existence checks: Use listFiles instead
+- For searching within files: Use grep instead
+- For file name searches: Use searchFiles instead
+- Prefer this tool over executeCommand with cat/head/tail
+
+Features:
+- Supports comma-separated paths for multiple files
+- Line numbers included for easy reference
+- Optional offset/limit for partial file reading
+- Automatically handles different file types
+
+IMPORTANT:
+- Line numbers are included for easy reference
+- Use offset/limit for large files to read specific sections`,
   parameters: exports_external.object({
     path: exports_external.preprocess((val) => {
       if (!val)
         return [];
-      const values = Array.isArray(val) ? val : [val];
-      return values.flatMap((i) => typeof i === "string" ? i.split(",") : []).filter((s) => s.length > 0);
+      if (Array.isArray(val)) {
+        return val.filter((s) => typeof s === "string" && s.length > 0);
+      }
+      return val.split(",").filter((s) => s.length > 0);
     }, exports_external.array(exports_external.string())).describe("The path of the file to read").meta({ usageValue: "Comma separated paths here" }),
+    offset: exports_external.number().optional().describe("Skip first N lines (for partial file reading)").meta({ usageValue: "100" }),
+    limit: exports_external.number().optional().describe("Read at most N lines (for partial file reading)").meta({ usageValue: "50" }),
     includeIgnored: exports_external.preprocess(preprocessBoolean, exports_external.boolean().nullish().default(false)).describe("Whether to include ignored files. Use true to include files ignored by .gitignore.").meta({ usageValue: "true or false (optional)" })
   }).meta({
     examples: [
@@ -54750,6 +57102,14 @@ var toolInfo6 = {
         input: {
           path: "src/main.js,src/index.js"
         }
+      },
+      {
+        description: "Read partial file (lines 100-150)",
+        input: {
+          path: "src/large-file.ts",
+          offset: 100,
+          limit: 50
+        }
       }
     ]
   })
@@ -54758,15 +57118,39 @@ var handler6 = async (provider, args) => {
   if (!provider.readFile) {
     return createProviderErrorResponse("read file");
   }
-  const { path: paths, includeIgnored } = toolInfo6.parameters.parse(args);
+  const parsed = toolInfo6.parameters.safeParse(args);
+  if (!parsed.success) {
+    return {
+      success: false,
+      message: {
+        type: "error-text",
+        value: `Invalid arguments for readFile: ${parsed.error.message}`
+      }
+    };
+  }
+  const { path: paths, offset, limit, includeIgnored } = parsed.data;
   const resp = [];
   for (const path of paths) {
     const fileContent = await provider.readFile(path, includeIgnored ?? false);
     if (!fileContent) {
       resp.push(createFileElement("read_file_file_content", path, undefined, { file_not_found: "true" }));
-    } else {
-      resp.push(createFileElement("read_file_file_content", path, fileContent));
+      continue;
     }
+    let lines = fileContent.split(`
+`);
+    const start = offset ?? 0;
+    const end = limit ? start + limit : lines.length;
+    if (offset !== undefined || limit !== undefined) {
+      lines = lines.slice(start, end);
+    }
+    const lineOffset = offset ?? 0;
+    const numberedContent = lines.map((line, i) => {
+      const lineNumber = lineOffset + i + 1;
+      const paddedNumber = String(lineNumber).padStart(6, " ");
+      return `${paddedNumber}→${line}`;
+    }).join(`
+`);
+    resp.push(createFileElement("read_file_file_content", path, numberedContent));
   }
   return {
     success: true,
@@ -54963,7 +57347,43 @@ var replaceInFile = (fileContent, diff) => {
 // ../core/src/tools/replaceInFile.ts
 var toolInfo9 = {
   name: "replaceInFile",
-  description: "Request to replace sections of content in an existing file using SEARCH/REPLACE blocks that define exact changes to specific parts of the file. This tool should be used when you need to make targeted changes to specific parts of a file.",
+  description: `Request to replace sections of content in an existing file using
+SEARCH/REPLACE blocks.
+
+When to use:
+- Making targeted changes to specific parts of a file
+- Replacing variable names, function signatures, imports
+- Fixing bugs in existing code
+- When you know the exact content to replace
+
+When NOT to use:
+- For creating new files: Use writeToFile instead
+- For completely replacing file contents: Use writeToFile instead
+- When you don't know the exact content: Read file first
+
+SEARCH/REPLACE FORMAT:
+<<<<<<< SEARCH
+[exact content to find]
+=======
+[new content to replace with]
+>>>>>>> REPLACE
+
+Critical rules:
+1. SEARCH content must match EXACTLY (character-for-character including whitespace)
+2. Each block replaces only first occurrence
+3. Include just enough lines for uniqueness (not too many, not too few)
+4. Keep blocks concise (don't include long unchanged sections)
+5. List blocks in order they appear in file
+6. Use multiple blocks for multiple independent changes
+
+Special operations:
+- Move code: Two blocks (delete from original + insert at new location)
+- Delete code: Empty REPLACE section
+
+IMPORTANT CONSTRAINTS:
+- SEARCH text must match file content exactly
+- Each block is independent (doesn't affect other blocks)
+- Cannot use for appending or inserting without SEARCH context`,
   parameters: exports_external.object({
     path: exports_external.string().describe("The path of the file to modify").meta({ usageValue: "File path here" }),
     diff: exports_external.string().describe(`One or more SEARCH/REPLACE blocks following this exact format:
@@ -54989,7 +57409,7 @@ Critical rules:
     * Each line must be complete. Never truncate lines mid-way through as this can cause matching failures.
 4. Special operations:
     * To move code: Use two SEARCH/REPLACE blocks (one to delete from original + one to insert at new location)
-    * To delete code: Use empty REPLACE section`).meta({ usageValue: "Search and replace blocks here" })
+    * To delete code: Empty REPLACE section`).meta({ usageValue: "Search and replace blocks here" })
   }).meta({
     examples: [
       {
@@ -55317,7 +57737,27 @@ var UpdateTodoItemOutputSchema = exports_external.object({
 // ../core/src/tools/writeToFile.ts
 var toolInfo12 = {
   name: "writeToFile",
-  description: "Request to write content to a file at the specified path. If the file exists, it will be overwritten with the provided content. If the file doesn't exist, it will be created. This tool will automatically create any directories needed to write the file. Ensure that the output content does not include incorrect escaped character patterns such as `&lt;`, `&gt;`, or `&amp;`. Also ensure there is no unwanted CDATA tags in the content.",
+  description: `Request to write content to a file at the specified path.
+
+When to use:
+- Creating new files
+- Completely replacing file contents
+- When you have the complete intended content
+
+When NOT to use:
+- For modifying existing files: Use replaceInFile instead
+- For appending content: Use executeCommand with echo >> instead
+- For targeted edits: Use replaceInFile instead
+
+Features:
+- Automatically creates any directories needed
+- Overwrites existing files completely
+- Must provide complete file content (no truncation)
+
+IMPORTANT CONSTRAINT:
+- Always provide COMPLETE intended content (no omissions)
+- Ensure no incorrect escape sequences (&lt;, &gt;, &amp;)
+- Ensure no unwanted CDATA tags in content`,
   parameters: exports_external.object({
     path: exports_external.string().describe("The path of the file to write to").meta({ usageValue: "File path here" }),
     content: exports_external.string().describe("The content to write to the file. ALWAYS provide the COMPLETE intended content of the file, without any truncation or omissions. You MUST include ALL parts of the file, even if they haven't been modified.").meta({ usageValue: "Your file content here" })
@@ -55358,10 +57798,7 @@ var handler12 = async (provider, args) => {
       }
     };
   }
-  let { path, content } = parsed.data;
-  const trimmedContent = content.trim();
-  if (trimmedContent.startsWith("<![CDATA[") && trimmedContent.endsWith("]]>"))
-    content = trimmedContent.slice(9, -3);
+  const { path, content } = parsed.data;
   await provider.writeFile(path, content);
   return {
     success: true,
@@ -58510,9 +60947,9 @@ class ZodUnion2 extends ZodType2 {
     return this._def.options;
   }
 }
-ZodUnion2.create = (types2, params) => {
+ZodUnion2.create = (types3, params) => {
   return new ZodUnion2({
-    options: types2,
+    options: types3,
     typeName: ZodFirstPartyTypeKind2.ZodUnion,
     ...processCreateParams(params)
   });
@@ -61006,15 +63443,15 @@ var primitiveMappings = {
 function parseUnionDef(def, refs) {
   const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
   if (options.every((x) => (x._def.typeName in primitiveMappings) && (!x._def.checks || !x._def.checks.length))) {
-    const types2 = options.reduce((types22, x) => {
+    const types3 = options.reduce((types22, x) => {
       const type = primitiveMappings[x._def.typeName];
       return type && !types22.includes(type) ? [...types22, type] : types22;
     }, []);
     return {
-      type: types2.length > 1 ? types2 : types2[0]
+      type: types3.length > 1 ? types3 : types3[0]
     };
   } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
-    const types2 = options.reduce((acc, x) => {
+    const types3 = options.reduce((acc, x) => {
       const type = typeof x._def.value;
       switch (type) {
         case "string":
@@ -61033,8 +63470,8 @@ function parseUnionDef(def, refs) {
           return acc;
       }
     }, []);
-    if (types2.length === options.length) {
-      const uniqueTypes = types2.filter((x, i, a) => a.indexOf(x) === i);
+    if (types3.length === options.length) {
+      const uniqueTypes = types3.filter((x, i, a) => a.indexOf(x) === i);
       return {
         type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
         enum: options.reduce((acc, x) => {
@@ -65215,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(),
@@ -65223,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({
@@ -65772,9 +68209,9 @@ var moduleExports2 = freeModule2 && freeModule2.exports === freeExports2;
 var freeProcess = moduleExports2 && _freeGlobal_default.process;
 var nodeUtil = function() {
   try {
-    var types3 = freeModule2 && freeModule2.require && freeModule2.require("util").types;
-    if (types3) {
-      return types3;
+    var types4 = freeModule2 && freeModule2.require && freeModule2.require("util").types;
+    if (types4) {
+      return types4;
     }
     return freeProcess && freeProcess.binding && freeProcess.binding("util");
   } catch (e) {}
@@ -66342,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) {
@@ -68542,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;
@@ -68557,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
@@ -69825,7 +72262,7 @@ function lookup(path) {
   }
   return $types[extension2] || false;
 }
-function populateMaps(extensions, types5) {
+function populateMaps(extensions, types6) {
   Object.keys(db).forEach(function forEachMimeType(type) {
     var mime = db[type];
     var exts = mime.extensions;
@@ -69835,10 +72272,10 @@ function populateMaps(extensions, types5) {
     extensions[type] = exts;
     for (var i2 = 0;i2 < exts.length; i2++) {
       var extension2 = exts[i2];
-      types5[extension2] = _preferredType(extension2, types5[extension2], type);
-      const legacyType = _preferredTypeLegacy(extension2, types5[extension2], type);
-      if (legacyType !== types5[extension2]) {
-        $_extensionConflicts.push([extension2, legacyType, types5[extension2]]);
+      types6[extension2] = _preferredType(extension2, types6[extension2], type);
+      const legacyType = _preferredTypeLegacy(extension2, types6[extension2], type);
+      if (legacyType !== types6[extension2]) {
+        $_extensionConflicts.push([extension2, legacyType, types6[extension2]]);
       }
     }
   });
@@ -70039,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() ?? [];
@@ -70143,35 +72627,14 @@ var getProvider = (options = {}) => {
       }
     },
     listMemoryTopics: async () => {
-      const memory = await memoryStore.read() ?? {};
-      return Object.keys(memory);
+      return listMemoryTopicsKV();
     },
     readMemory: async (topic = defaultMemoryTopic) => {
-      const memory = await memoryStore.read() ?? {};
-      return memory[topic];
+      return readMemoryKV(topic);
     },
     updateMemory: async (operation, topic, content) => {
       const memoryTopic = topic ?? defaultMemoryTopic;
-      const memory = await memoryStore.read() ?? {};
-      switch (operation) {
-        case "append":
-          if (content === undefined) {
-            throw new Error("Content is required for append operation.");
-          }
-          memory[memoryTopic] = `${memory[memoryTopic] || ""}
-${content}`;
-          break;
-        case "replace":
-          if (content === undefined) {
-            throw new Error("Content is required for replace operation.");
-          }
-          memory[memoryTopic] = content;
-          break;
-        case "remove":
-          delete memory[memoryTopic];
-          break;
-      }
-      await memoryStore.write(memory);
+      await updateMemoryKV(operation, memoryTopic, content);
     },
     readFile: async (path, includeIgnored) => {
       if (!includeIgnored && ig.ignores(path)) {
@@ -70338,6 +72801,667 @@ ${content}`;
   }
   return provider2;
 };
+// ../cli-shared/src/sqlite-memory-store.ts
+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;