@neuralsea/workspace-indexer 0.3.5 → 0.4.0

package/dist/index.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,6 +30,2099 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// node_modules/sql.js/dist/sql-wasm.js
+var require_sql_wasm = __commonJS({
+  "node_modules/sql.js/dist/sql-wasm.js"(exports2, module2) {
+    "use strict";
+    var initSqlJsPromise = void 0;
+    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);
+        });
+        module2 = void 0;
+        var f;
+        f ||= typeof Module != "undefined" ? Module : {};
+        var aa = "object" == typeof window, ba = "undefined" != typeof WorkerGlobalScope, ca = "object" == typeof process && "object" == typeof process.versions && "string" == typeof process.versions.node && "renderer" != process.type;
+        "use strict";
+        f.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 (null === l) lb(g);
+                else if (null != l.length) {
+                  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 = [], r = 0; r < g; r += 1) {
+              var t = m(l + 4 * r, "i32"), y = hc(t);
+              if (1 === y || 2 === y) t = ic(t);
+              else if (3 === y) t = jc(t);
+              else if (4 === y) {
+                y = t;
+                t = kc(y);
+                y = lc(y);
+                for (var L = new Uint8Array(t), J = 0; J < t; J += 1) L[J] = p[y + J];
+                t = L;
+              } else t = null;
+              n.push(t);
+            }
+            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 (null === this.eb) throw Error("Unable to allocate memory for the SQL string");
+            u(g, x, this.eb, l);
+            this.kb = this.eb;
+            this.Za = this.pb = null;
+          }
+          function e(g) {
+            this.filename = "dbfile_" + (4294967295 * Math.random() >>> 0);
+            if (null != g) {
+              var l = this.filename, n = "/", r = l;
+              n && (n = "string" == typeof n ? n : ja(n), r = l ? ka(n + "/" + l) : n);
+              l = la(true, true);
+              r = ma(r, l);
+              if (g) {
+                if ("string" == typeof g) {
+                  n = Array(g.length);
+                  for (var t = 0, y = g.length; t < y; ++t) n[t] = g.charCodeAt(t);
+                  g = n;
+                }
+                na(r, l | 146);
+                n = oa(r, 577);
+                pa(n, g, 0, g.length, 0);
+                qa(n);
+                na(r, l);
+              }
+            }
+            this.handleError(q(this.filename, h));
+            this.db = m(h, "i32");
+            ob(this.db);
+            this.fb = {};
+            this.Sa = {};
+          }
+          var h = z(4), k = f.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) : null != g && "object" === typeof g ? 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) {
+            null == g && (g = this.Oa, this.Oa += 1);
+            return wc(this.Qa, g);
+          };
+          c.prototype.Gb = function(g) {
+            null == g && (g = this.Oa, this.Oa += 1);
+            g = sb(this.Qa, g);
+            if ("function" !== typeof BigInt) throw Error("BigInt is not supported");
+            return BigInt(g);
+          };
+          c.prototype.Hb = function(g) {
+            null == g && (g = this.Oa, this.Oa += 1);
+            return sb(this.Qa, g);
+          };
+          c.prototype.getBlob = function(g) {
+            null == g && (g = this.Oa, this.Oa += 1);
+            var l = yc(this.Qa, g);
+            g = xc(this.Qa, g);
+            for (var n = new Uint8Array(l), r = 0; r < l; r += 1) n[r] = p[g + r];
+            return n;
+          };
+          c.prototype.get = function(g, l) {
+            l = l || {};
+            null != g && this.bind(g) && this.step();
+            g = [];
+            for (var n = vc(this.Qa), r = 0; r < n; r += 1) switch (zc(this.Qa, r)) {
+              case 1:
+                var t = l.useBigInt ? this.Gb(r) : this.wb(r);
+                g.push(t);
+                break;
+              case 2:
+                g.push(this.wb(r));
+                break;
+              case 3:
+                g.push(this.Hb(r));
+                break;
+              case 4:
+                g.push(this.getBlob(r));
+                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 = {}, r = 0; r < l.length; r += 1) n[l[r]] = g[r];
+            return n;
+          };
+          c.prototype.getSQL = function() {
+            return pb(this.Qa);
+          };
+          c.prototype.getNormalizedSQL = function() {
+            return nc(this.Qa);
+          };
+          c.prototype.run = function(g) {
+            null != g && this.bind(g);
+            this.step();
+            return this.reset();
+          };
+          c.prototype.sb = function(g, l) {
+            null == l && (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) {
+            null == l && (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) {
+            null == l && (l = this.Oa, this.Oa += 1);
+            this.db.handleError((g === (g | 0) ? qc : pc)(this.Qa, l, g));
+          };
+          c.prototype.Eb = function(g) {
+            null == g && (g = this.Oa, this.Oa += 1);
+            rb(this.Qa, g, 0, 0, 0);
+          };
+          c.prototype.tb = function(g, l) {
+            null == l && (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 (null === g) {
+                  this.Eb(l);
+                  return;
+                }
+                if (null != g.length) {
+                  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 r = rc(l.Qa, n);
+              0 !== r && l.tb(g[n], r);
+            });
+            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 0 === Cc(this.Qa) && 0 === Bc(this.Qa);
+          };
+          c.prototype.freemem = function() {
+            for (var g; void 0 !== (g = this.lb.pop()); ) fa(g);
+          };
+          c.prototype.free = function() {
+            this.freemem();
+            var g = 0 === Dc(this.Qa);
+            delete this.db.fb[this.Qa];
+            this.Qa = 0;
+            return g;
+          };
+          d.prototype.next = function() {
+            if (null === this.eb) return { done: true };
+            null !== this.Za && (this.Za.free(), this.Za = null);
+            if (!this.db.db) throw this.mb(), Error("Database closed");
+            var g = sa(), l = z(4);
+            ta(h);
+            ta(l);
+            try {
+              this.db.handleError(qb(this.db.db, this.kb, -1, h, l));
+              this.kb = m(l, "i32");
+              var n = m(h, "i32");
+              if (0 === n) 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 (r) {
+              throw this.pb = ua(this.kb), this.mb(), r;
+            } finally {
+              wa(g);
+            }
+          };
+          d.prototype.mb = function() {
+            fa(this.eb);
+            this.eb = null;
+          };
+          d.prototype.getRemainingSQL = function() {
+            return null !== this.pb ? this.pb : ua(this.kb);
+          };
+          "function" === typeof Symbol && "symbol" === typeof Symbol.iterator && (d.prototype[Symbol.iterator] = function() {
+            return this;
+          });
+          e.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, h));
+            return this;
+          };
+          e.prototype.exec = function(g, l, n) {
+            if (!this.db) throw "Database closed";
+            var r = sa(), t = null;
+            try {
+              var y = xa(g), L = z(4);
+              for (g = []; 0 !== m(y, "i8"); ) {
+                ta(h);
+                ta(L);
+                this.handleError(qb(this.db, y, -1, h, L));
+                var J = m(h, "i32");
+                y = m(L, "i32");
+                if (0 !== J) {
+                  var I = null;
+                  t = new c(J, this);
+                  for (null != l && t.bind(l); t.step(); ) null === I && (I = { columns: t.getColumnNames(), values: [] }, g.push(I)), I.values.push(t.get(null, n));
+                  t.free();
+                }
+              }
+              return g;
+            } catch (M) {
+              throw t && t.free(), M;
+            } finally {
+              wa(r);
+            }
+          };
+          e.prototype.each = function(g, l, n, r, t) {
+            "function" === typeof l && (r = n, n = l, l = void 0);
+            g = this.prepare(g, l);
+            try {
+              for (; g.step(); ) n(g.getAsObject(
+                null,
+                t
+              ));
+            } finally {
+              g.free();
+            }
+            if ("function" === typeof r) return r();
+          };
+          e.prototype.prepare = function(g, l) {
+            ta(h);
+            this.handleError(G(this.db, g, -1, h, 0));
+            g = m(h, "i32");
+            if (0 === g) throw "Nothing to prepare";
+            var n = new c(g, this);
+            null != l && n.bind(l);
+            return this.fb[g] = n;
+          };
+          e.prototype.iterateStatements = function(g) {
+            return new d(g, this);
+          };
+          e.prototype["export"] = function() {
+            Object.values(this.fb).forEach(function(l) {
+              l.free();
+            });
+            Object.values(this.Sa).forEach(A);
+            this.Sa = {};
+            this.handleError(w(this.db));
+            var g = ya(this.filename);
+            this.handleError(q(
+              this.filename,
+              h
+            ));
+            this.db = m(h, "i32");
+            ob(this.db);
+            return g;
+          };
+          e.prototype.close = function() {
+            null !== this.db && (Object.values(this.fb).forEach(function(g) {
+              g.free();
+            }), Object.values(this.Sa).forEach(A), this.Sa = {}, this.Ya && (A(this.Ya), this.Ya = void 0), this.handleError(w(this.db)), za("/" + this.filename), this.db = null);
+          };
+          e.prototype.handleError = function(g) {
+            if (0 === g) return null;
+            g = tc(this.db);
+            throw Error(g);
+          };
+          e.prototype.getRowsModified = function() {
+            return C(this.db);
+          };
+          e.prototype.create_function = function(g, l) {
+            Object.prototype.hasOwnProperty.call(
+              this.Sa,
+              g
+            ) && (A(this.Sa[g]), delete this.Sa[g]);
+            var n = Aa(function(r, t, y) {
+              t = b(t, y);
+              try {
+                var L = l.apply(null, t);
+              } catch (J) {
+                va(r, J, -1);
+                return;
+              }
+              a(r, L);
+            }, "viii");
+            this.Sa[g] = n;
+            this.handleError(tb(this.db, g, l.length, 1, 0, n, 0, 0, 0));
+            return this;
+          };
+          e.prototype.create_aggregate = function(g, l) {
+            var n = l.init || function() {
+              return null;
+            }, r = l.finalize || function(I) {
+              return I;
+            }, t = l.step;
+            if (!t) throw "An aggregate function must have a step function in " + g;
+            var y = {};
+            Object.hasOwnProperty.call(this.Sa, g) && (A(this.Sa[g]), delete this.Sa[g]);
+            l = g + "__finalize";
+            Object.hasOwnProperty.call(this.Sa, l) && (A(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] = t.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 = r(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, t.length - 1, 1, 0, 0, L, J, 0));
+            return this;
+          };
+          e.prototype.updateHook = function(g) {
+            this.Ya && (vb(this.db, 0, 0), A(this.Ya), this.Ya = void 0);
+            g && (this.Ya = Aa(function(l, n, r, t, 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;
+              }
+              r = r ? B(x, r) : "";
+              t = t ? B(x, t) : "";
+              if (y > Number.MAX_SAFE_INTEGER) throw "rowId too big to fit inside a Number";
+              g(l, r, t, Number(y));
+            }, "viiiij"), vb(this.db, this.Ya, 0));
+          };
+          f.Database = e;
+        };
+        var Ba = { ...f }, Ca = "./this.program", Da = (a, b) => {
+          throw b;
+        }, D = "", Ea, Fa;
+        if (ca) {
+          var fs17 = require("fs");
+          require("path");
+          D = __dirname + "/";
+          Fa = (a) => {
+            a = Ga(a) ? new URL(a) : a;
+            return fs17.readFileSync(a);
+          };
+          Ea = async (a) => {
+            a = Ga(a) ? new URL(a) : a;
+            return fs17.readFileSync(a, void 0);
+          };
+          !f.thisProgram && 1 < process.argv.length && (Ca = process.argv[1].replace(/\\/g, "/"));
+          process.argv.slice(2);
+          "undefined" != typeof module2 && (module2.exports = f);
+          Da = (a, b) => {
+            process.exitCode = a;
+            throw b;
+          };
+        } else if (aa || ba) ba ? D = self.location.href : "undefined" != typeof document && 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 e = new XMLHttpRequest();
+            e.open("GET", a, true);
+            e.responseType = "arraybuffer";
+            e.onload = () => {
+              200 == e.status || 0 == e.status && e.response ? c(e.response) : d(e.status);
+            };
+            e.onerror = d;
+            e.send(null);
+          });
+          var b = await fetch(a, { credentials: "same-origin" });
+          if (b.ok) return b.arrayBuffer();
+          throw Error(b.status + " : " + b.url);
+        };
+        var Ha = f.print || console.log.bind(console), Ia = f.printErr || console.error.bind(console);
+        Object.assign(f, Ba);
+        Ba = null;
+        f.thisProgram && (Ca = f.thisProgram);
+        var Ja = f.wasmBinary, Ka, La = false, Ma, p, x, Na, E, F, Oa, H, Pa, Ga = (a) => a.startsWith("file://");
+        function Qa() {
+          var a = Ka.buffer;
+          f.HEAP8 = p = new Int8Array(a);
+          f.HEAP16 = Na = new Int16Array(a);
+          f.HEAPU8 = x = new Uint8Array(a);
+          f.HEAPU16 = new Uint16Array(a);
+          f.HEAP32 = E = new Int32Array(a);
+          f.HEAPU32 = F = new Uint32Array(a);
+          f.HEAPF32 = Oa = new Float32Array(a);
+          f.HEAPF64 = Pa = new Float64Array(a);
+          f.HEAP64 = H = new BigInt64Array(a);
+          f.HEAPU64 = new BigUint64Array(a);
+        }
+        var K = 0, Sa = null;
+        function Ta(a) {
+          f.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 && "function" == typeof WebAssembly.instantiateStreaming && !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()(f);
+        }, $a = [], ab = [], bb = () => {
+          var a = f.preRun.shift();
+          ab.unshift(a);
+        };
+        function m(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 F[a >> 2];
+            default:
+              Ta(`invalid type for getValue: ${b}`);
+          }
+        }
+        var cb = f.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 "*":
+              F[a >> 2] = 0;
+              break;
+            default:
+              Ta(`invalid type for setValue: ${b}`);
+          }
+        }
+        var db = "undefined" != typeof TextDecoder ? new TextDecoder() : void 0, B = (a, b = 0, c = NaN) => {
+          var d = b + c;
+          for (c = b; a[c] && !(c >= d); ) ++c;
+          if (16 < c - b && a.buffer && db) return db.decode(a.subarray(b, c));
+          for (d = ""; b < c; ) {
+            var e = a[b++];
+            if (e & 128) {
+              var h = a[b++] & 63;
+              if (192 == (e & 224)) d += String.fromCharCode((e & 31) << 6 | h);
+              else {
+                var k = a[b++] & 63;
+                e = 224 == (e & 240) ? (e & 15) << 12 | h << 6 | k : (e & 7) << 18 | h << 12 | k << 6 | a[b++] & 63;
+                65536 > e ? d += String.fromCharCode(e) : (e -= 65536, d += String.fromCharCode(55296 | e >> 10, 56320 | e & 1023));
+              }
+            } else d += String.fromCharCode(e);
+          }
+          return d;
+        }, ua = (a, b) => a ? B(x, a, b) : "", eb = (a, b) => {
+          for (var c = 0, d = a.length - 1; 0 <= d; d--) {
+            var e = a[d];
+            "." === e ? a.splice(d, 1) : ".." === e ? (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 ("string" != typeof c) 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((e) => !!e), !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 e = c;
+          d = c + d - 1;
+          for (var h = 0; h < a.length; ++h) {
+            var k = a.charCodeAt(h);
+            if (55296 <= k && 57343 >= k) {
+              var q = a.charCodeAt(++h);
+              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 - e;
+        }, 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 e = 0, h = 0; h < d; h++) {
+            try {
+              var k = a.tty.cb.xb(a.tty);
+            } catch (q) {
+              throw new N(29);
+            }
+            if (void 0 === k && 0 === e) throw new N(6);
+            if (null === k || void 0 === k) break;
+            e++;
+            b[c + h] = k;
+          }
+          e && (a.node.atime = Date.now());
+          return e;
+        }, write(a, b, c, d) {
+          if (!a.tty || !a.tty.cb.qb) throw new N(60);
+          try {
+            for (var e = 0; e < d; e++) a.tty.cb.qb(a.tty, b[c + e]);
+          } catch (h) {
+            throw new N(29);
+          }
+          d && (a.node.mtime = a.node.ctime = Date.now());
+          return e;
+        } }, yb = { xb() {
+          a: {
+            if (!kb.length) {
+              var a = null;
+              if (ca) {
+                var b = Buffer.alloc(256), c = 0, d = process.stdin.fd;
+                try {
+                  c = fs17.readSync(d, b, 0, 256);
+                } catch (e) {
+                  if (e.toString().includes("EOF")) c = 0;
+                  else throw e;
+                }
+                0 < c && (a = b.slice(0, c).toString("utf-8"));
+              } else "undefined" != typeof window && "function" == typeof window.prompt && (a = window.prompt("Input: "), null !== a && (a += "\n"));
+              if (!a) {
+                a = null;
+                break a;
+              }
+              kb = ra(a, true);
+            }
+            a = kb.shift();
+          }
+          return a;
+        }, qb(a, b) {
+          null === b || 10 === b ? (Ha(B(a.output)), a.output = []) : 0 != b && 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) {
+          null === b || 10 === b ? (Ia(B(a.output)), a.output = []) : 0 != b && 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 (24576 === (c & 61440) || 4096 === (c & 61440)) 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 = {}) : 32768 === (c.mode & 61440) ? (c.La = O.Wa.file.node, c.Ma = O.Wa.file.stream, c.Ra = 0, c.Na = null) : 40960 === (c.mode & 61440) ? (c.La = O.Wa.link.node, c.Ma = O.Wa.link.stream) : 8192 === (c.mode & 61440) && (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 = 8192 === (a.mode & 61440) ? 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 : 32768 === (a.mode & 61440) ? b.size = a.Ra : 40960 === (a.mode & 61440) ? 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"]) null != b[c] && (a[c] = b[c]);
+          void 0 !== b.size && (b = b.size, a.Ra != b && (0 == b ? (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 (h) {
+          }
+          if (d) {
+            if (P(a.mode)) for (var e 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 (40960 !== (a.mode & 61440)) throw new N(28);
+          return a.link;
+        } }, Ma: { read(a, b, c, d, e) {
+          var h = a.node.Na;
+          if (e >= a.node.Ra) return 0;
+          a = Math.min(a.node.Ra - e, d);
+          if (8 < a && h.subarray) b.set(h.subarray(e, e + a), c);
+          else for (d = 0; d < a; d++) b[c + d] = h[e + d];
+          return a;
+        }, write(a, b, c, d, e, h) {
+          b.buffer === p.buffer && (h = false);
+          if (!d) return 0;
+          a = a.node;
+          a.mtime = a.ctime = Date.now();
+          if (b.subarray && (!a.Na || a.Na.subarray)) {
+            if (h) return a.Na = b.subarray(c, c + d), a.Ra = d;
+            if (0 === a.Ra && 0 === e) return a.Na = b.slice(c, c + d), a.Ra = d;
+            if (e + d <= a.Ra) return a.Na.set(b.subarray(
+              c,
+              c + d
+            ), e), d;
+          }
+          h = e + d;
+          var k = a.Na ? a.Na.length : 0;
+          k >= h || (h = Math.max(h, k * (1048576 > k ? 2 : 1.125) >>> 0), 0 != k && (h = Math.max(h, 256)), k = a.Na, a.Na = new Uint8Array(h), 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), e);
+          else for (h = 0; h < d; h++) a.Na[e + h] = b[c + h];
+          a.Ra = Math.max(a.Ra, e + d);
+          return d;
+        }, Va(a, b, c) {
+          1 === c ? b += a.position : 2 === c && 32768 === (a.node.mode & 61440) && (b += a.node.Ra);
+          if (0 > b) throw new N(28);
+          return b;
+        }, ib(a, b, c, d, e) {
+          if (32768 !== (a.node.mode & 61440)) throw new N(43);
+          a = a.node.Na;
+          if (e & 2 || !a || a.buffer !== p.buffer) {
+            e = true;
+            d = 65536 * Math.ceil(b / 65536);
+            var h = Db(65536, d);
+            h && x.fill(0, h, h + d);
+            d = h;
+            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 e = false, d = a.byteOffset;
+          return { Kb: d, Ab: e };
+        }, 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 365 === (this.mode & 365);
+          }
+          set read(a) {
+            a ? this.mode |= 365 : this.mode &= -366;
+          }
+          get write() {
+            return 146 === (this.mode & 146);
+          }
+          set write(a) {
+            a ? this.mode |= 146 : this.mode &= -147;
+          }
+        };
+        function S(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, e = "/", h = 0; h < a.length; h++) {
+              var k = h === a.length - 1;
+              if (k && b.parent) break;
+              if ("." !== a[h]) if (".." === a[h]) e = fb(e), d = d.parent;
+              else {
+                e = ka(e + "/" + a[h]);
+                try {
+                  d = Q(d, a[h]);
+                } catch (q) {
+                  if (44 === q?.Pa && k && b.Jb) return { path: e };
+                  throw q;
+                }
+                !d.ab || k && !b.nb || (d = d.ab.root);
+                if (40960 === (d.mode & 61440) && (!k || b.$a)) {
+                  if (!d.La.readlink) throw new N(52);
+                  d = d.La.readlink(d);
+                  "/" === d.charAt(0) || (d = fb(e) + "/" + d);
+                  a = d + "/" + a.slice(h + 1).join("/");
+                  continue a;
+                }
+              }
+            }
+            return { path: e, 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 16384 === (a & 61440);
+        }
+        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 (e) {
+            return e.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 (-1 == b) 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 = S(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 = S(a, { parent: true }).node;
+          a = gb(a);
+          if (!a) throw new N(28);
+          if ("." === a || ".." === a) throw new N(20);
+          var e = Qb(d, a);
+          if (e) throw new N(e);
+          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) {
+          "undefined" == typeof c && (c = b, b = 438);
+          Xb(a, b | 8192, c);
+        }
+        function Zb(a, b) {
+          if (!jb(a)) throw new N(44);
+          var c = S(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 = S(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 = S(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 = S(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 = "string" == typeof a ? S(a, { $a: true }).node : a;
+          bc(null, a, b);
+        }
+        function cc(a, b, c) {
+          if (P(b.mode)) throw new N(31);
+          if (32768 !== (b.mode & 61440)) 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 ("string" == typeof b) {
+            var d = { r: 0, "r+": 2, w: 577, "w+": 578, a: 1089, "a+": 1090 }[b];
+            if ("undefined" == typeof d) throw Error(`Unknown file open mode: ${b}`);
+            b = d;
+          }
+          c = b & 64 ? c & 4095 | 32768 : 0;
+          if ("object" == typeof a) d = a;
+          else {
+            var e = a.endsWith("/");
+            a = S(a, { $a: !(b & 131072), Jb: true });
+            d = a.node;
+            a = a.path;
+          }
+          var h = false;
+          if (b & 64) if (d) {
+            if (b & 128) throw new N(20);
+          } else {
+            if (e) throw new N(31);
+            d = Xb(a, c | 511, 0);
+            h = true;
+          }
+          if (!d) throw new N(44);
+          8192 === (d.mode & 61440) && (b &= -513);
+          if (b & 65536 && !P(d.mode)) throw new N(54);
+          if (!h && (e = d ? 40960 === (d.mode & 61440) ? 32 : P(d.mode) && ("r" !== Pb(b) || b & 576) ? 31 : Ob(d, Pb(b)) : 44)) throw new N(e);
+          b & 512 && !h && (e = d, e = "string" == typeof e ? S(e, { $a: true }).node : e, cc(null, e, 0));
+          b &= -131713;
+          e = Tb({ node: d, path: ja(d), flags: b, seekable: true, position: 0, Ma: d.Ma, Lb: [], error: false });
+          e.Ma.open && e.Ma.open(e);
+          h && na(d, c & 511);
+          !f.logReadFiles || b & 1 || a in Kb || (Kb[a] = 1);
+          return e;
+        }
+        function qa(a) {
+          if (null === a.fd) 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 (null === a.fd) throw new N(8);
+          if (!a.seekable || !a.Ma.Va) throw new N(70);
+          if (0 != c && 1 != c && 2 != c) throw new N(28);
+          a.position = a.Ma.Va(a, b, c);
+          a.Lb = [];
+        }
+        function Ec(a, b, c, d, e) {
+          if (0 > d || 0 > e) throw new N(28);
+          if (null === a.fd) throw new N(8);
+          if (1 === (a.flags & 2097155)) throw new N(8);
+          if (P(a.node.mode)) throw new N(31);
+          if (!a.Ma.read) throw new N(28);
+          var h = "undefined" != typeof e;
+          if (!h) e = a.position;
+          else if (!a.seekable) throw new N(70);
+          b = a.Ma.read(a, b, c, d, e);
+          h || (a.position += b);
+          return b;
+        }
+        function pa(a, b, c, d, e) {
+          if (0 > d || 0 > e) throw new N(28);
+          if (null === a.fd) throw new N(8);
+          if (0 === (a.flags & 2097155)) 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 h = "undefined" != typeof e;
+          if (!h) e = a.position;
+          else if (!a.seekable) throw new N(70);
+          b = a.Ma.write(a, b, c, d, e, void 0);
+          h || (a.position += b);
+          return b;
+        }
+        function ya(a) {
+          var b = "binary";
+          if ("utf8" !== b && "binary" !== b) throw Error(`Invalid encoding type "${b}"`);
+          var c;
+          var d = oa(a, d || 0);
+          a = ac(a).size;
+          var e = new Uint8Array(a);
+          Ec(d, e, 0, a, 0);
+          "utf8" === b ? c = B(e) : "binary" === b && (c = e);
+          qa(d);
+          return c;
+        }
+        function V(a, b, c) {
+          a = ka("/dev/" + a);
+          var d = la(!!b, !!c);
+          V.yb ?? (V.yb = 64);
+          var e = V.yb++ << 8 | 0;
+          wb(e, { open(h) {
+            h.seekable = false;
+          }, close() {
+            c?.buffer?.length && c(10);
+          }, read(h, k, q, w) {
+            for (var v = 0, C = 0; C < w; C++) {
+              try {
+                var G = b();
+              } catch (pb) {
+                throw new N(29);
+              }
+              if (void 0 === G && 0 === v) throw new N(6);
+              if (null === G || void 0 === G) break;
+              v++;
+              k[q + C] = G;
+            }
+            v && (h.node.atime = Date.now());
+            return v;
+          }, write(h, k, q, w) {
+            for (var v = 0; v < w; v++) try {
+              c(k[q + v]);
+            } catch (C) {
+              throw new N(29);
+            }
+            w && (h.node.mtime = h.node.ctime = Date.now());
+            return v;
+          } });
+          Yb(a, d, e);
+        }
+        var W = {};
+        function Gc(a, b, c) {
+          if ("/" === b.charAt(0)) return b;
+          a = -100 === a ? "/" : T(a).path;
+          if (0 == b.length) {
+            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;
+          F[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(), e = b.ctime.getTime();
+          H[a + 40 >> 3] = BigInt(Math.floor(c / 1e3));
+          F[a + 48 >> 2] = c % 1e3 * 1e6;
+          H[a + 56 >> 3] = BigInt(Math.floor(d / 1e3));
+          F[a + 64 >> 2] = d % 1e3 * 1e6;
+          H[a + 72 >> 3] = BigInt(Math.floor(e / 1e3));
+          F[a + 80 >> 2] = e % 1e3 * 1e6;
+          H[a + 88 >> 3] = BigInt(b.ino);
+          return 0;
+        }
+        var Ic = void 0, 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 || (f.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 || "unwind" == b || Da(1, b);
+            }
+          } catch (b) {
+            b instanceof Ya || "unwind" == b || Da(1, b);
+          }
+        }, Qc = {}, Sc = () => {
+          if (!Rc) {
+            var a = { USER: "web_user", LOGNAME: "web_user", PATH: "/", PWD: "/", HOME: "/home/web_user", LANG: ("object" == typeof navigator && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8", _: Ca || "./this.program" }, b;
+            for (b in Qc) void 0 === Qc[b] ? 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 = z(b);
+          u(a, x, c, b);
+          return c;
+        }, Tc = (a, b, c, d) => {
+          var e = { string: (v) => {
+            var C = 0;
+            null !== v && void 0 !== v && 0 !== v && (C = xa(v));
+            return C;
+          }, array: (v) => {
+            var C = z(v.length);
+            p.set(v, C);
+            return C;
+          } };
+          a = f["_" + a];
+          var h = [], k = 0;
+          if (d) for (var q = 0; q < d.length; q++) {
+            var w = e[c[q]];
+            w ? (0 === k && (k = sa()), h[q] = w(d[q])) : h[q] = d[q];
+          }
+          c = a(...h);
+          return c = (function(v) {
+            0 !== k && wa(k);
+            return "string" === b ? v ? B(x, v) : "" : "boolean" === b ? !!v : v;
+          })(c);
+        }, ea = 0, da = (a, b) => {
+          b = 1 == b ? z(a.length) : ia(a.length);
+          a.subarray || a.slice || (a = new Uint8Array(a));
+          x.set(a, b);
+          return b;
+        }, Uc, Vc = [], Y, A = (a) => {
+          Uc.delete(Y.get(a));
+          Y.set(a, null);
+          Vc.push(a);
+        }, Aa = (a, b) => {
+          if (!Uc) {
+            Uc = /* @__PURE__ */ new WeakMap();
+            var c = Y.length;
+            if (Uc) for (var d = 0; d < 0 + c; d++) {
+              var e = Y.get(d);
+              e && Uc.set(e, 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 ("function" == typeof WebAssembly.Function) {
+              var h = WebAssembly.Function;
+              d = { i: "i32", j: "i64", f: "f32", d: "f64", e: "externref", p: "i32" };
+              e = { parameters: [], results: "v" == b[0] ? [] : [d[b[0]]] };
+              for (var k = 1; k < b.length; ++k) e.parameters.push(d[b[k]]);
+              b = new h(e, a);
+            } else {
+              d = [1];
+              e = 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 (h of b) d.push(k[h]);
+              "v" == e ? d.push(0) : d.push(1, k[e]);
+              b = [0, 97, 115, 109, 1, 0, 0, 0, 1];
+              h = d.length;
+              128 > h ? b.push(h) : b.push(h % 128 | 128, h >> 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, e, h, 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 = () => {
+            0 === b && (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 e = T(c);
+              c = { parent: null, Xa: { zb: "fake" }, La: { readlink: () => e.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(x, a) : ""}, at: ` + [b ? b ? B(x, b) : "" : "unknown filename", c, d ? d ? B(x, d) : "" : "unknown function"]), i: function(a, b) {
+          try {
+            return a = a ? B(x, a) : "", na(a, b), 0;
+          } catch (c) {
+            if ("undefined" == typeof W || "ErrnoError" !== c.name) throw c;
+            return -c.Pa;
+          }
+        }, L: function(a, b, c) {
+          try {
+            b = b ? B(x, b) : "";
+            b = Gc(a, b);
+            if (c & -8) return -28;
+            var d = S(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 (e) {
+            if ("undefined" == typeof W || "ErrnoError" !== e.name) throw e;
+            return -e.Pa;
+          }
+        }, j: function(a, b) {
+          try {
+            var c = T(a);
+            bc(c, c.node, b, false);
+            return 0;
+          } catch (d) {
+            if ("undefined" == typeof W || "ErrnoError" !== d.name) 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 ("undefined" == typeof W || "ErrnoError" !== c.name) throw c;
+            return -c.Pa;
+          }
+        }, b: function(a, b, c) {
+          Ic = c;
+          try {
+            var d = T(a);
+            switch (b) {
+              case 0:
+                var e = Jc();
+                if (0 > e) break;
+                for (; Gb[e]; ) e++;
+                return Ub(d, e).fd;
+              case 1:
+              case 2:
+                return 0;
+              case 3:
+                return d.flags;
+              case 4:
+                return e = Jc(), d.flags |= e, 0;
+              case 12:
+                return e = Jc(), Na[e + 0 >> 1] = 2, 0;
+              case 13:
+              case 14:
+                return 0;
+            }
+            return -28;
+          } catch (h) {
+            if ("undefined" == typeof W || "ErrnoError" !== h.name) throw h;
+            return -h.Pa;
+          }
+        }, g: function(a, b) {
+          try {
+            var c = T(a), d = c.node, e = c.Ma.Ta;
+            a = e ? c : d;
+            e ??= d.La.Ta;
+            Sb(e);
+            var h = e(a);
+            return Hc(b, h);
+          } catch (k) {
+            if ("undefined" == typeof W || "ErrnoError" !== k.name) 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 || 0 === (c.flags & 2097155)) throw new N(28);
+            cc(c, c.node, b);
+            return 0;
+          } catch (d) {
+            if ("undefined" == typeof W || "ErrnoError" !== d.name) throw d;
+            return -d.Pa;
+          }
+        }, G: function(a, b) {
+          try {
+            if (0 === b) return -28;
+            var c = ha("/") + 1;
+            if (b < c) return -68;
+            u("/", x, a, b);
+            return c;
+          } catch (d) {
+            if ("undefined" == typeof W || "ErrnoError" !== d.name) throw d;
+            return -d.Pa;
+          }
+        }, K: function(a, b) {
+          try {
+            return a = a ? B(x, a) : "", Hc(b, ac(a, true));
+          } catch (c) {
+            if ("undefined" == typeof W || "ErrnoError" !== c.name) throw c;
+            return -c.Pa;
+          }
+        }, C: function(a, b, c) {
+          try {
+            return b = b ? B(x, b) : "", b = Gc(a, b), U(b, c), 0;
+          } catch (d) {
+            if ("undefined" == typeof W || "ErrnoError" !== d.name) throw d;
+            return -d.Pa;
+          }
+        }, J: function(a, b, c, d) {
+          try {
+            b = b ? B(x, b) : "";
+            var e = d & 256;
+            b = Gc(a, b, d & 4096);
+            return Hc(c, e ? ac(b, true) : ac(b));
+          } catch (h) {
+            if ("undefined" == typeof W || "ErrnoError" !== h.name) throw h;
+            return -h.Pa;
+          }
+        }, x: function(a, b, c, d) {
+          Ic = d;
+          try {
+            b = b ? B(x, b) : "";
+            b = Gc(a, b);
+            var e = d ? Jc() : 0;
+            return oa(b, c, e).fd;
+          } catch (h) {
+            if ("undefined" == typeof W || "ErrnoError" !== h.name) throw h;
+            return -h.Pa;
+          }
+        }, v: function(a, b, c, d) {
+          try {
+            b = b ? B(x, b) : "";
+            b = Gc(a, b);
+            if (0 >= d) return -28;
+            var e = S(b).node;
+            if (!e) throw new N(44);
+            if (!e.La.readlink) throw new N(28);
+            var h = e.La.readlink(e);
+            var k = Math.min(d, ha(h)), q = p[c + k];
+            u(h, x, c, d + 1);
+            p[c + k] = q;
+            return k;
+          } catch (w) {
+            if ("undefined" == typeof W || "ErrnoError" !== w.name) throw w;
+            return -w.Pa;
+          }
+        }, u: function(a) {
+          try {
+            return a = a ? B(x, a) : "", $b(a), 0;
+          } catch (b) {
+            if ("undefined" == typeof W || "ErrnoError" !== b.name) throw b;
+            return -b.Pa;
+          }
+        }, f: function(a, b) {
+          try {
+            return a = a ? B(x, a) : "", Hc(b, ac(a));
+          } catch (c) {
+            if ("undefined" == typeof W || "ErrnoError" !== c.name) throw c;
+            return -c.Pa;
+          }
+        }, r: function(a, b, c) {
+          try {
+            return b = b ? B(x, b) : "", b = Gc(a, b), 0 === c ? za(b) : 512 === c ? $b(b) : Ta("Invalid flags passed to unlinkat"), 0;
+          } catch (d) {
+            if ("undefined" == typeof W || "ErrnoError" !== d.name) throw d;
+            return -d.Pa;
+          }
+        }, q: function(a, b, c) {
+          try {
+            b = b ? B(x, b) : "";
+            b = Gc(a, b, true);
+            var d = Date.now(), e, h;
+            if (c) {
+              var k = F[c >> 2] + 4294967296 * E[c + 4 >> 2], q = E[c + 8 >> 2];
+              1073741823 == q ? e = d : 1073741822 == q ? e = null : e = 1e3 * k + q / 1e6;
+              c += 16;
+              k = F[c >> 2] + 4294967296 * E[c + 4 >> 2];
+              q = E[c + 8 >> 2];
+              1073741823 == q ? h = d : 1073741822 == q ? h = null : h = 1e3 * k + q / 1e6;
+            } else h = e = d;
+            if (null !== (h ?? e)) {
+              a = e;
+              var w = S(b, { $a: true }).node;
+              Sb(w.La.Ua)(w, { atime: a, mtime: h });
+            }
+            return 0;
+          } catch (v) {
+            if ("undefined" == typeof W || "ErrnoError" !== v.name) 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(1e3 * 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] = (0 !== c % 4 || 0 === c % 100 && 0 !== c % 400 ? 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, e, h, k) {
+          e = -9007199254740992 > e || 9007199254740992 < e ? NaN : Number(e);
+          try {
+            if (isNaN(e)) return 61;
+            var q = T(d);
+            if (0 !== (b & 2) && 0 === (c & 2) && 2 !== (q.flags & 2097155)) throw new N(2);
+            if (1 === (q.flags & 2097155)) 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, e, b, c);
+            var v = w.Kb;
+            E[h >> 2] = w.Ab;
+            F[k >> 2] = v;
+            return 0;
+          } catch (C) {
+            if ("undefined" == typeof W || "ErrnoError" !== C.name) throw C;
+            return -C.Pa;
+          }
+        }, z: function(a, b, c, d, e, h) {
+          h = -9007199254740992 > h || 9007199254740992 < h ? NaN : Number(h);
+          try {
+            var k = T(e);
+            if (c & 2) {
+              c = h;
+              if (32768 !== (k.node.mode & 61440)) throw new N(43);
+              if (!(d & 2)) {
+                var q = x.slice(a, a + b);
+                k.Ma.jb && k.Ma.jb(k, q, c, b, d);
+              }
+            }
+          } catch (w) {
+            if ("undefined" == typeof W || "ErrnoError" !== w.name) 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 e = (/* @__PURE__ */ new Date()).getFullYear(), h = new Date(e, 0, 1).getTimezoneOffset();
+          e = new Date(e, 6, 1).getTimezoneOffset();
+          F[a >> 2] = 60 * Math.max(h, e);
+          E[b >> 2] = Number(h != e);
+          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(h);
+          b = b(e);
+          e < h ? (u(a, x, c, 17), u(b, x, d, 17)) : (u(a, x, d, 17), u(b, x, c, 17));
+        }, d: () => Date.now(), s: () => 2147483648, c: () => performance.now(), o: (a) => {
+          var b = x.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 e = 1;
+                break a;
+              } catch (h) {
+              }
+              e = void 0;
+            }
+            if (e) return true;
+          }
+          return false;
+        }, E: (a, b) => {
+          var c = 0;
+          Sc().forEach((d, e) => {
+            var h = b + c;
+            e = F[a + 4 * e >> 2] = h;
+            for (h = 0; h < d.length; ++h) p[e++] = d.charCodeAt(h);
+            p[e] = 0;
+            c += d.length + 1;
+          });
+          return 0;
+        }, F: (a, b) => {
+          var c = Sc();
+          F[a >> 2] = c.length;
+          var d = 0;
+          c.forEach((e) => d += e.length + 1);
+          F[b >> 2] = d;
+          return 0;
+        }, e: function(a) {
+          try {
+            var b = T(a);
+            qa(b);
+            return 0;
+          } catch (c) {
+            if ("undefined" == typeof W || "ErrnoError" !== c.name) throw c;
+            return c.Pa;
+          }
+        }, p: function(a, b) {
+          try {
+            var c = T(a);
+            p[b] = c.tty ? 2 : P(c.mode) ? 3 : 40960 === (c.mode & 61440) ? 7 : 4;
+            Na[b + 2 >> 1] = 0;
+            H[b + 8 >> 3] = BigInt(0);
+            H[b + 16 >> 3] = BigInt(0);
+            return 0;
+          } catch (d) {
+            if ("undefined" == typeof W || "ErrnoError" !== d.name) throw d;
+            return d.Pa;
+          }
+        }, w: function(a, b, c, d) {
+          try {
+            a: {
+              var e = T(a);
+              a = b;
+              for (var h, k = b = 0; k < c; k++) {
+                var q = F[a >> 2], w = F[a + 4 >> 2];
+                a += 8;
+                var v = Ec(e, p, q, w, h);
+                if (0 > v) {
+                  var C = -1;
+                  break a;
+                }
+                b += v;
+                if (v < w) break;
+                "undefined" != typeof h && (h += v);
+              }
+              C = b;
+            }
+            F[d >> 2] = C;
+            return 0;
+          } catch (G) {
+            if ("undefined" == typeof W || "ErrnoError" !== G.name) 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 e = T(a);
+            mc(e, b, c);
+            H[d >> 3] = BigInt(e.position);
+            e.ob && 0 === b && 0 === c && (e.ob = null);
+            return 0;
+          } catch (h) {
+            if ("undefined" == typeof W || "ErrnoError" !== h.name) throw h;
+            return h.Pa;
+          }
+        }, I: function(a) {
+          try {
+            var b = T(a);
+            return b.Ma?.fsync ? b.Ma.fsync(b) : 0;
+          } catch (c) {
+            if ("undefined" == typeof W || "ErrnoError" !== c.name) throw c;
+            return c.Pa;
+          }
+        }, t: function(a, b, c, d) {
+          try {
+            a: {
+              var e = T(a);
+              a = b;
+              for (var h, k = b = 0; k < c; k++) {
+                var q = F[a >> 2], w = F[a + 4 >> 2];
+                a += 8;
+                var v = pa(e, p, q, w, h);
+                if (0 > v) {
+                  var C = -1;
+                  break a;
+                }
+                b += v;
+                if (v < w) break;
+                "undefined" != typeof h && (h += v);
+              }
+              C = b;
+            }
+            F[d >> 2] = C;
+            return 0;
+          } catch (G) {
+            if ("undefined" == typeof W || "ErrnoError" !== G.name) throw G;
+            return G.Pa;
+          }
+        }, k: Oc }, Z;
+        (async function() {
+          function a(c) {
+            Z = c.exports;
+            Ka = Z.M;
+            Qa();
+            Y = Z.O;
+            K--;
+            f.monitorRunDependencies?.(K);
+            0 == K && Sa && (c = Sa, Sa = null, c());
+            return Z;
+          }
+          K++;
+          f.monitorRunDependencies?.(K);
+          var b = { a: Xc };
+          if (f.instantiateWasm) return new Promise((c) => {
+            f.instantiateWasm(b, (d, e) => {
+              a(d, e);
+              c(d.exports);
+            });
+          });
+          Ua ??= f.locateFile ? f.locateFile("sql-wasm.wasm", D) : D + "sql-wasm.wasm";
+          return a((await Xa(b)).instance);
+        })();
+        f._sqlite3_free = (a) => (f._sqlite3_free = Z.P)(a);
+        f._sqlite3_value_text = (a) => (f._sqlite3_value_text = Z.Q)(a);
+        f._sqlite3_prepare_v2 = (a, b, c, d, e) => (f._sqlite3_prepare_v2 = Z.R)(a, b, c, d, e);
+        f._sqlite3_step = (a) => (f._sqlite3_step = Z.S)(a);
+        f._sqlite3_reset = (a) => (f._sqlite3_reset = Z.T)(a);
+        f._sqlite3_exec = (a, b, c, d, e) => (f._sqlite3_exec = Z.U)(a, b, c, d, e);
+        f._sqlite3_finalize = (a) => (f._sqlite3_finalize = Z.V)(a);
+        f._sqlite3_column_name = (a, b) => (f._sqlite3_column_name = Z.W)(a, b);
+        f._sqlite3_column_text = (a, b) => (f._sqlite3_column_text = Z.X)(a, b);
+        f._sqlite3_column_type = (a, b) => (f._sqlite3_column_type = Z.Y)(a, b);
+        f._sqlite3_errmsg = (a) => (f._sqlite3_errmsg = Z.Z)(a);
+        f._sqlite3_clear_bindings = (a) => (f._sqlite3_clear_bindings = Z._)(a);
+        f._sqlite3_value_blob = (a) => (f._sqlite3_value_blob = Z.$)(a);
+        f._sqlite3_value_bytes = (a) => (f._sqlite3_value_bytes = Z.aa)(a);
+        f._sqlite3_value_double = (a) => (f._sqlite3_value_double = Z.ba)(a);
+        f._sqlite3_value_int = (a) => (f._sqlite3_value_int = Z.ca)(a);
+        f._sqlite3_value_type = (a) => (f._sqlite3_value_type = Z.da)(a);
+        f._sqlite3_result_blob = (a, b, c, d) => (f._sqlite3_result_blob = Z.ea)(a, b, c, d);
+        f._sqlite3_result_double = (a, b) => (f._sqlite3_result_double = Z.fa)(a, b);
+        f._sqlite3_result_error = (a, b, c) => (f._sqlite3_result_error = Z.ga)(a, b, c);
+        f._sqlite3_result_int = (a, b) => (f._sqlite3_result_int = Z.ha)(a, b);
+        f._sqlite3_result_int64 = (a, b) => (f._sqlite3_result_int64 = Z.ia)(a, b);
+        f._sqlite3_result_null = (a) => (f._sqlite3_result_null = Z.ja)(a);
+        f._sqlite3_result_text = (a, b, c, d) => (f._sqlite3_result_text = Z.ka)(a, b, c, d);
+        f._sqlite3_aggregate_context = (a, b) => (f._sqlite3_aggregate_context = Z.la)(a, b);
+        f._sqlite3_column_count = (a) => (f._sqlite3_column_count = Z.ma)(a);
+        f._sqlite3_data_count = (a) => (f._sqlite3_data_count = Z.na)(a);
+        f._sqlite3_column_blob = (a, b) => (f._sqlite3_column_blob = Z.oa)(a, b);
+        f._sqlite3_column_bytes = (a, b) => (f._sqlite3_column_bytes = Z.pa)(a, b);
+        f._sqlite3_column_double = (a, b) => (f._sqlite3_column_double = Z.qa)(a, b);
+        f._sqlite3_bind_blob = (a, b, c, d, e) => (f._sqlite3_bind_blob = Z.ra)(a, b, c, d, e);
+        f._sqlite3_bind_double = (a, b, c) => (f._sqlite3_bind_double = Z.sa)(a, b, c);
+        f._sqlite3_bind_int = (a, b, c) => (f._sqlite3_bind_int = Z.ta)(a, b, c);
+        f._sqlite3_bind_text = (a, b, c, d, e) => (f._sqlite3_bind_text = Z.ua)(a, b, c, d, e);
+        f._sqlite3_bind_parameter_index = (a, b) => (f._sqlite3_bind_parameter_index = Z.va)(a, b);
+        f._sqlite3_sql = (a) => (f._sqlite3_sql = Z.wa)(a);
+        f._sqlite3_normalized_sql = (a) => (f._sqlite3_normalized_sql = Z.xa)(a);
+        f._sqlite3_changes = (a) => (f._sqlite3_changes = Z.ya)(a);
+        f._sqlite3_close_v2 = (a) => (f._sqlite3_close_v2 = Z.za)(a);
+        f._sqlite3_create_function_v2 = (a, b, c, d, e, h, k, q, w) => (f._sqlite3_create_function_v2 = Z.Aa)(a, b, c, d, e, h, k, q, w);
+        f._sqlite3_update_hook = (a, b, c) => (f._sqlite3_update_hook = Z.Ba)(a, b, c);
+        f._sqlite3_open = (a, b) => (f._sqlite3_open = Z.Ca)(a, b);
+        var ia = f._malloc = (a) => (ia = f._malloc = Z.Da)(a), fa = f._free = (a) => (fa = f._free = Z.Ea)(a);
+        f._RegisterExtensionFunctions = (a) => (f._RegisterExtensionFunctions = Z.Fa)(a);
+        var Db = (a, b) => (Db = Z.Ga)(a, b), Wc = (a, b) => (Wc = Z.Ha)(a, b), wa = (a) => (wa = Z.Ia)(a), z = (a) => (z = Z.Ja)(a), sa = () => (sa = Z.Ka)();
+        f.stackSave = () => sa();
+        f.stackRestore = (a) => wa(a);
+        f.stackAlloc = (a) => z(a);
+        f.cwrap = (a, b, c, d) => {
+          var e = !c || c.every((h) => "number" === h || "boolean" === h);
+          return "string" !== b && e && !d ? f["_" + a] : (...h) => Tc(a, b, c, h);
+        };
+        f.addFunction = Aa;
+        f.removeFunction = A;
+        f.UTF8ToString = ua;
+        f.ALLOC_NORMAL = ea;
+        f.allocate = da;
+        f.allocateUTF8OnStack = xa;
+        function Yc() {
+          function a() {
+            f.calledRun = true;
+            if (!La) {
+              if (!f.noFSInit && !Ib) {
+                var b, c;
+                Ib = true;
+                d ??= f.stdin;
+                b ??= f.stdout;
+                c ??= f.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);
+              }
+              Z.N();
+              Jb = false;
+              f.onRuntimeInitialized?.();
+              if (f.postRun) for ("function" == typeof f.postRun && (f.postRun = [f.postRun]); f.postRun.length; ) {
+                var d = f.postRun.shift();
+                $a.unshift(d);
+              }
+              Za($a);
+            }
+          }
+          if (0 < K) Sa = Yc;
+          else {
+            if (f.preRun) for ("function" == typeof f.preRun && (f.preRun = [f.preRun]); f.preRun.length; ) bb();
+            Za(ab);
+            0 < K ? Sa = Yc : f.setStatus ? (f.setStatus("Running..."), setTimeout(() => {
+              setTimeout(() => f.setStatus(""), 1);
+              a();
+            }, 1)) : a();
+          }
+        }
+        if (f.preInit) for ("function" == typeof f.preInit && (f.preInit = [f.preInit]); 0 < f.preInit.length; ) f.preInit.pop()();
+        Yc();
+        return Module;
+      });
+      return initSqlJsPromise;
+    };
+    if (typeof exports2 === "object" && typeof module2 === "object") {
+      module2.exports = initSqlJs;
+      module2.exports.default = initSqlJs;
+    } else if (typeof define === "function" && define["amd"]) {
+      define([], function() {
+        return initSqlJs;
+      });
+    } else if (typeof exports2 === "object") {
+      exports2["Module"] = initSqlJs;
+    }
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -47,11 +2143,14 @@ __export(index_exports, {
   WorkspaceLinker: () => WorkspaceLinker,
   WorkspaceStore: () => WorkspaceStore,
   asProgressSink: () => asProgressSink,
+  betterSqlite3Adapter: () => betterSqlite3Adapter,
   chunkSource: () => chunkSource,
   createAnnIndex: () => createAnnIndex,
   createNeo4jGraphStore: () => createNeo4jGraphStore,
   createVSCodeSymbolGraphProvider: () => createVSCodeSymbolGraphProvider,
   createVectorIndex: () => createVectorIndex,
+  createWorkspaceStore: () => createWorkspaceStore,
+  createWorkspaceStoreAsync: () => createWorkspaceStoreAsync,
   deepMergeProfile: () => deepMergeProfile,
   discoverGitRepos: () => discoverGitRepos,
   languageFromPath: () => languageFromPath,
@@ -59,6 +2158,7 @@ __export(index_exports, {
   loadConfigFile: () => loadConfigFile,
   mergeIndexerConfig: () => mergeIndexerConfig,
   pickRepoOverride: () => pickRepoOverride,
+  sqlJsAdapter: () => sqlJsAdapter,
   stableSymbolId: () => stableSymbolId
 });
 module.exports = __toCommonJS(index_exports);
@@ -1263,8 +3363,8 @@ function mergeIndexerConfig(target, patch) {
 }
 
 // src/store/workspaceStore.ts
-var import_node_fs5 = __toESM(require("fs"), 1);
-var import_node_path7 = __toESM(require("path"), 1);
+var import_node_fs7 = __toESM(require("fs"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
 
 // src/store/workspace/unitOfWork.ts
 var UnitOfWork = class {
@@ -1484,15 +3584,35 @@ var RepoLinksRepository = class {
 };
 
 // src/store/workspace/factory.ts
-var import_node_fs4 = __toESM(require("fs"), 1);
-var import_node_path6 = __toESM(require("path"), 1);
+var import_node_fs5 = __toESM(require("fs"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
 
 // src/store/workspace/db.ts
 var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+function detectFts5Support(db) {
+  try {
+    const rows = db.prepare(`PRAGMA compile_options`).all();
+    if (rows.some((r) => String(r.compile_options ?? "").includes("ENABLE_FTS5"))) return true;
+  } catch {
+  }
+  try {
+    db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS __fts5_probe USING fts5(x);
+      DROP TABLE __fts5_probe;
+    `);
+    return true;
+  } catch {
+    return false;
+  }
+}
 var BetterSqlite3Adapter = class {
   db;
+  capabilities;
   constructor(dbPath) {
     this.db = new import_better_sqlite3.default(dbPath);
+    this.capabilities = { supportsFts5: detectFts5Support(this.db) };
   }
   pragma(sql) {
     this.db.pragma(sql);
@@ -1510,6 +3630,17 @@ var BetterSqlite3Adapter = class {
     this.db.close();
   }
 };
+var betterSqlite3Adapter = {
+  open(dbPath) {
+    import_node_fs4.default.mkdirSync(import_node_path6.default.dirname(dbPath), { recursive: true });
+    const db = new BetterSqlite3Adapter(dbPath);
+    db.pragma("journal_mode = WAL");
+    return db;
+  }
+};
+
+// src/store/workspace/fts5.sql
+var fts5_default = "CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(\n  id UNINDEXED,\n  repo_id UNINDEXED,\n  repo_root UNINDEXED,\n  path,\n  language,\n  kind,\n  text,\n  tokenize='unicode61'\n);\n\n";
 
 // src/store/workspace/fts.ts
 var NoopFtsStrategy = class {
@@ -1533,18 +3664,7 @@ var Fts5Strategy = class {
   enabled = true;
   ins = null;
   init(db) {
-    db.exec(`
-      CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
-        id UNINDEXED,
-        repo_id UNINDEXED,
-        repo_root UNINDEXED,
-        path,
-        language,
-        kind,
-        text,
-        tokenize='unicode61'
-      );
-    `);
+    db.exec(fts5_default);
   }
   clearRepo(repoId) {
     this.db.prepare(`DELETE FROM chunks_fts WHERE repo_id = ?`).run(repoId);
@@ -1628,109 +3748,26 @@ var WorkspaceMigrator = class {
   }
 };
 
+// src/store/workspace/baseSchema.sql
+var baseSchema_default = "CREATE TABLE IF NOT EXISTS meta (\n  k TEXT PRIMARY KEY,\n  v TEXT NOT NULL\n);\n\nCREATE TABLE IF NOT EXISTS repos (\n  repo_id TEXT PRIMARY KEY,\n  repo_root TEXT NOT NULL,\n  head_commit TEXT NOT NULL,\n  head_branch TEXT NOT NULL,\n  updated_at INTEGER NOT NULL\n);\n\nCREATE UNIQUE INDEX IF NOT EXISTS idx_repos_root ON repos(repo_root);\n\nCREATE TABLE IF NOT EXISTS files (\n  repo_id TEXT NOT NULL,\n  path TEXT NOT NULL,\n  hash TEXT NOT NULL,\n  mtime INTEGER NOT NULL,\n  language TEXT NOT NULL,\n  size INTEGER NOT NULL,\n  PRIMARY KEY(repo_id, path)\n);\n\nCREATE INDEX IF NOT EXISTS idx_files_repo ON files(repo_id);\n\nCREATE TABLE IF NOT EXISTS chunks (\n  id TEXT PRIMARY KEY,\n  repo_id TEXT NOT NULL,\n  repo_root TEXT NOT NULL,\n  path TEXT NOT NULL,\n  language TEXT NOT NULL,\n  kind TEXT NOT NULL DEFAULT 'chunk',\n  start_line INTEGER NOT NULL,\n  end_line INTEGER NOT NULL,\n  content_hash TEXT NOT NULL,\n  tokens INTEGER NOT NULL,\n  file_mtime INTEGER NOT NULL,\n  text TEXT NOT NULL,\n  embedding BLOB NOT NULL\n);\n\nCREATE INDEX IF NOT EXISTS idx_chunks_repo_path ON chunks(repo_id, path);\nCREATE INDEX IF NOT EXISTS idx_chunks_kind_repo_path ON chunks(kind, repo_id, path);\n\nCREATE TABLE IF NOT EXISTS edges (\n  repo_id TEXT NOT NULL,\n  from_path TEXT NOT NULL,\n  kind TEXT NOT NULL,\n  value TEXT NOT NULL,\n  PRIMARY KEY(repo_id, from_path, kind, value)\n);\n\nCREATE INDEX IF NOT EXISTS idx_edges_repo_from ON edges(repo_id, from_path);\n\nCREATE TABLE IF NOT EXISTS symbols (\n  id TEXT PRIMARY KEY,\n  repo_id TEXT NOT NULL,\n  repo_root TEXT NOT NULL,\n  path TEXT NOT NULL,\n  language TEXT NOT NULL,\n  name TEXT NOT NULL,\n  kind TEXT NOT NULL,\n  start_line INTEGER NOT NULL,\n  start_char INTEGER NOT NULL,\n  end_line INTEGER NOT NULL,\n  end_char INTEGER NOT NULL,\n  container_name TEXT NOT NULL DEFAULT '',\n  detail TEXT NOT NULL DEFAULT ''\n);\n\nCREATE INDEX IF NOT EXISTS idx_symbols_repo_path ON symbols(repo_id, path);\nCREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);\n\nCREATE TABLE IF NOT EXISTS symbol_edges (\n  repo_id TEXT NOT NULL,\n  from_id TEXT NOT NULL,\n  to_id TEXT NOT NULL,\n  kind TEXT NOT NULL,\n  from_path TEXT NOT NULL,\n  to_path TEXT NOT NULL,\n  PRIMARY KEY(repo_id, from_id, to_id, kind)\n);\n\nCREATE INDEX IF NOT EXISTS idx_symbol_edges_from ON symbol_edges(repo_id, from_id);\nCREATE INDEX IF NOT EXISTS idx_symbol_edges_paths ON symbol_edges(repo_id, from_path);\n\n";
+
 // src/store/workspace/factory.ts
-function createWorkspaceDb(dbPath) {
-  import_node_fs4.default.mkdirSync(import_node_path6.default.dirname(dbPath), { recursive: true });
-  const db = new BetterSqlite3Adapter(dbPath);
-  db.pragma("journal_mode = WAL");
-  return db;
+function createWorkspaceDb(dbPath, opts = {}) {
+  import_node_fs5.default.mkdirSync(import_node_path7.default.dirname(dbPath), { recursive: true });
+  return (opts.db ?? betterSqlite3Adapter).open(dbPath);
 }
 function createWorkspaceBaseSchema(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS meta (
-      k TEXT PRIMARY KEY,
-      v TEXT NOT NULL
-    );
-
-    CREATE TABLE IF NOT EXISTS repos (
-      repo_id TEXT PRIMARY KEY,
-      repo_root TEXT NOT NULL,
-      head_commit TEXT NOT NULL,
-      head_branch TEXT NOT NULL,
-      updated_at INTEGER NOT NULL
-    );
-
-    CREATE UNIQUE INDEX IF NOT EXISTS idx_repos_root ON repos(repo_root);
-
-    CREATE TABLE IF NOT EXISTS files (
-      repo_id TEXT NOT NULL,
-      path TEXT NOT NULL,
-      hash TEXT NOT NULL,
-      mtime INTEGER NOT NULL,
-      language TEXT NOT NULL,
-      size INTEGER NOT NULL,
-      PRIMARY KEY(repo_id, path)
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_files_repo ON files(repo_id);
-
-    CREATE TABLE IF NOT EXISTS chunks (
-      id TEXT PRIMARY KEY,
-      repo_id TEXT NOT NULL,
-      repo_root TEXT NOT NULL,
-      path TEXT NOT NULL,
-      language TEXT NOT NULL,
-      kind TEXT NOT NULL DEFAULT 'chunk',
-      start_line INTEGER NOT NULL,
-      end_line INTEGER NOT NULL,
-      content_hash TEXT NOT NULL,
-      tokens INTEGER NOT NULL,
-      file_mtime INTEGER NOT NULL,
-      text TEXT NOT NULL,
-      embedding BLOB NOT NULL
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_chunks_repo_path ON chunks(repo_id, path);
-    CREATE INDEX IF NOT EXISTS idx_chunks_kind_repo_path ON chunks(kind, repo_id, path);
-
-    CREATE TABLE IF NOT EXISTS edges (
-      repo_id TEXT NOT NULL,
-      from_path TEXT NOT NULL,
-      kind TEXT NOT NULL,
-      value TEXT NOT NULL,
-      PRIMARY KEY(repo_id, from_path, kind, value)
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_edges_repo_from ON edges(repo_id, from_path);
-
-    CREATE TABLE IF NOT EXISTS symbols (
-      id TEXT PRIMARY KEY,
-      repo_id TEXT NOT NULL,
-      repo_root TEXT NOT NULL,
-      path TEXT NOT NULL,
-      language TEXT NOT NULL,
-      name TEXT NOT NULL,
-      kind TEXT NOT NULL,
-      start_line INTEGER NOT NULL,
-      start_char INTEGER NOT NULL,
-      end_line INTEGER NOT NULL,
-      end_char INTEGER NOT NULL,
-      container_name TEXT NOT NULL DEFAULT '',
-      detail TEXT NOT NULL DEFAULT ''
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_symbols_repo_path ON symbols(repo_id, path);
-    CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);
-
-    CREATE TABLE IF NOT EXISTS symbol_edges (
-      repo_id TEXT NOT NULL,
-      from_id TEXT NOT NULL,
-      to_id TEXT NOT NULL,
-      kind TEXT NOT NULL,
-      from_path TEXT NOT NULL,
-      to_path TEXT NOT NULL,
-      PRIMARY KEY(repo_id, from_id, to_id, kind)
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_symbol_edges_from ON symbol_edges(repo_id, from_id);
-    CREATE INDEX IF NOT EXISTS idx_symbol_edges_paths ON symbol_edges(repo_id, from_path);
-  `);
+  db.exec(baseSchema_default);
 }
 function createWorkspaceFts(db, meta, opts = {}) {
   if (opts.fts === "off") {
     meta.set("fts", "0");
     return new NoopFtsStrategy();
   }
+  if (!db.capabilities.supportsFts5) {
+    meta.set("fts", "0");
+    return new NoopFtsStrategy();
+  }
   try {
     const fts = new Fts5Strategy(db);
     fts.init(db);
@@ -1746,17 +3783,134 @@ function migrateWorkspaceDb(db, meta) {
   migrator.migrateToLatest();
 }
 
+// src/store/workspace/sqlJsAdapter.ts
+var import_node_fs6 = __toESM(require("fs"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
+function detectFts5Support2(db) {
+  try {
+    db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS __fts5_probe USING fts5(x);
+      DROP TABLE __fts5_probe;
+    `);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var SqlJsStatement = class {
+  constructor(stmt) {
+    this.stmt = stmt;
+  }
+  run(...args) {
+    this.stmt.run(args);
+    return void 0;
+  }
+  get(...args) {
+    this.stmt.bind(args);
+    const hasRow = this.stmt.step();
+    if (!hasRow) {
+      this.stmt.reset();
+      return void 0;
+    }
+    const row = this.stmt.getAsObject();
+    this.stmt.reset();
+    return row;
+  }
+  all(...args) {
+    this.stmt.bind(args);
+    const rows = [];
+    while (this.stmt.step()) rows.push(this.stmt.getAsObject());
+    this.stmt.reset();
+    return rows;
+  }
+};
+var SqlJsDbAdapter = class {
+  constructor(db, dbPath) {
+    this.db = db;
+    this.dbPath = dbPath;
+    this.capabilities = { supportsFts5: detectFts5Support2(db) };
+  }
+  capabilities;
+  pragma(sql) {
+    this.exec(`PRAGMA ${sql}`);
+  }
+  exec(sql) {
+    this.db.exec(sql);
+  }
+  prepare(sql) {
+    return new SqlJsStatement(this.db.prepare(sql));
+  }
+  transaction(fn) {
+    return () => {
+      this.db.exec("BEGIN");
+      try {
+        const out = fn();
+        this.db.exec("COMMIT");
+        return out;
+      } catch (e) {
+        try {
+          this.db.exec("ROLLBACK");
+        } catch {
+        }
+        throw e;
+      }
+    };
+  }
+  close() {
+    if (this.dbPath && this.dbPath !== ":memory:") {
+      import_node_fs6.default.mkdirSync(import_node_path8.default.dirname(this.dbPath), { recursive: true });
+      const bytes = this.db.export();
+      import_node_fs6.default.writeFileSync(this.dbPath, Buffer.from(bytes));
+    }
+    this.db.close();
+  }
+};
+async function sqlJsAdapter(opts = {}) {
+  let init;
+  try {
+    const mod = await Promise.resolve().then(() => __toESM(require_sql_wasm(), 1));
+    init = mod?.default ?? mod;
+  } catch (e) {
+    throw new Error(`sqlJsAdapter requires optional dependency 'sql.js' (install it to use this adapter): ${String(e?.message ?? e)}`);
+  }
+  const SQL = await init({ locateFile: opts.locateFile, wasmBinary: opts.wasmBinary });
+  return {
+    open(dbPath) {
+      const abs = import_node_path8.default.resolve(dbPath);
+      const exists = import_node_fs6.default.existsSync(abs);
+      const bytes = exists ? new Uint8Array(import_node_fs6.default.readFileSync(abs)) : void 0;
+      const db = bytes ? new SQL.Database(bytes) : new SQL.Database();
+      return new SqlJsDbAdapter(db, abs);
+    }
+  };
+}
+
 // src/store/workspaceStore.ts
+function createWorkspaceStore(dbPath, opts = {}) {
+  return new WorkspaceStore(dbPath, opts);
+}
+async function defaultWorkspaceDbFactory() {
+  try {
+    return await sqlJsAdapter();
+  } catch {
+    return betterSqlite3Adapter;
+  }
+}
+async function createWorkspaceStoreAsync(dbPath, opts = {}) {
+  const dbFactory = opts.db ? await Promise.resolve(opts.db) : await defaultWorkspaceDbFactory();
+  return new WorkspaceStore(dbPath, { ...opts, db: dbFactory });
+}
 var WorkspaceStore = class {
   constructor(dbPath, opts = {}) {
     this.dbPath = dbPath;
     this.opts = opts;
-    this.db = createWorkspaceDb(dbPath);
+    this.db = createWorkspaceDb(dbPath, { db: opts.db });
     this.uow = new UnitOfWork(this.db);
     createWorkspaceBaseSchema(this.db);
     this.meta = new MetaRepository(this.db);
     migrateWorkspaceDb(this.db, this.meta);
     const fts = createWorkspaceFts(this.db, this.meta, opts);
+    this.ftsEnabledInternal = fts.enabled;
     this.repoHeads = new RepoHeadsRepository(this.db);
     this.files = new FilesRepository(this.db);
     this.edges = new EdgesRepository(this.db);
@@ -1766,6 +3920,7 @@ var WorkspaceStore = class {
   }
   db;
   uow;
+  ftsEnabledInternal;
   meta;
   repoHeads;
   files;
@@ -1774,6 +3929,9 @@ var WorkspaceStore = class {
   symbols;
   chunks;
   opts;
+  get ftsEnabled() {
+    return this.ftsEnabledInternal;
+  }
   setMeta(k, v) {
     this.meta.set(k, v);
   }
@@ -1857,9 +4015,9 @@ var WorkspaceStore = class {
    * The chunk boundaries are approximate; the stored row includes start/end line.
    */
   getChunkTextFallback(row) {
-    const abs = import_node_path7.default.join(row.repo_root, row.path.split("/").join(import_node_path7.default.sep));
+    const abs = import_node_path9.default.join(row.repo_root, row.path.split("/").join(import_node_path9.default.sep));
     try {
-      const raw = import_node_fs5.default.readFileSync(abs, "utf8");
+      const raw = import_node_fs7.default.readFileSync(abs, "utf8");
       const lines = raw.split(/\r?\n/);
       const start = Math.max(1, row.start_line);
       const end = Math.max(start, row.end_line);
@@ -1886,17 +4044,17 @@ range:${r.startLine}:${r.startCharacter}-${r.endLine}:${r.endCharacter}`;
 }
 
 // src/symbolGraph/vscodeProvider.ts
-var import_node_path9 = __toESM(require("path"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
 var import_node_module2 = require("module");
 
 // src/symbolGraph/strategies.ts
-var import_node_path8 = __toESM(require("path"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
 function toPosixRel(repoRoot, absPath) {
-  const abs = import_node_path8.default.resolve(absPath);
-  const root = import_node_path8.default.resolve(repoRoot);
-  const rel = import_node_path8.default.relative(root, abs);
-  if (!rel || rel.startsWith("..") || import_node_path8.default.isAbsolute(rel)) return null;
-  return rel.split(import_node_path8.default.sep).join("/");
+  const abs = import_node_path10.default.resolve(absPath);
+  const root = import_node_path10.default.resolve(repoRoot);
+  const rel = import_node_path10.default.relative(root, abs);
+  if (!rel || rel.startsWith("..") || import_node_path10.default.isAbsolute(rel)) return null;
+  return rel.split(import_node_path10.default.sep).join("/");
 }
 function fromLspRange(r) {
   return {
@@ -1963,7 +4121,7 @@ var SymbolGraphIndexer = class {
   }
   cache = /* @__PURE__ */ new Map();
   async indexDocument(input, cancel = {}) {
-    const doc = await this.lsp.openTextDocument(import_node_path8.default.join(input.repoRoot, input.path.split("/").join(import_node_path8.default.sep)));
+    const doc = await this.lsp.openTextDocument(import_node_path10.default.join(input.repoRoot, input.path.split("/").join(import_node_path10.default.sep)));
     const key = cacheKeyFor(doc, input);
     const cached2 = this.cache.get(key);
     if (cached2) {
@@ -1997,7 +4155,7 @@ var SymbolGraphIndexer = class {
    * Intended for staged indexing and on-demand expansion during retrieval.
    */
   async expandDocumentEdges(input, cancel = {}) {
-    const doc = await this.lsp.openTextDocument(import_node_path8.default.join(input.repoRoot, input.path.split("/").join(import_node_path8.default.sep)));
+    const doc = await this.lsp.openTextDocument(import_node_path10.default.join(input.repoRoot, input.path.split("/").join(import_node_path10.default.sep)));
     const key = cacheKeyFor(doc, input);
     const cached2 = this.cache.get(key);
     if (!cached2) {
@@ -2119,10 +4277,10 @@ function findSymbolAt(syms, pos) {
 // src/symbolGraph/vscodeProvider.ts
 var import_meta3 = {};
 function fromPosixPath2(posixRelPath) {
-  return posixRelPath.split("/").join(import_node_path9.default.sep);
+  return posixRelPath.split("/").join(import_node_path11.default.sep);
 }
 function toPosixPath(p) {
-  return p.split(import_node_path9.default.sep).join("/");
+  return p.split(import_node_path11.default.sep).join("/");
 }
 function kindFromVscode(vscode, k) {
   const SK = vscode?.SymbolKind;
@@ -2183,7 +4341,7 @@ function toLspSymbols(vscode, res) {
   return res.map(visit);
 }
 function toIndexInput(doc, input) {
-  const rel = toPosixPath(import_node_path9.default.relative(import_node_path9.default.resolve(input.repoRoot), import_node_path9.default.resolve(doc.fsPath)));
+  const rel = toPosixPath(import_node_path11.default.relative(import_node_path11.default.resolve(input.repoRoot), import_node_path11.default.resolve(doc.fsPath)));
   return { ...input, path: rel || input.path };
 }
 function makeVscodeFacade(vscode) {
@@ -2239,12 +4397,12 @@ async function createVSCodeSymbolGraphProvider(opts) {
     id: "vscode.symbolGraph",
     supports: (language) => languages.has(language),
     async indexDocument(input) {
-      const absPath = import_node_path9.default.join(input.repoRoot, fromPosixPath2(input.path));
+      const absPath = import_node_path11.default.join(input.repoRoot, fromPosixPath2(input.path));
       const doc = await lsp.openTextDocument(absPath);
       return await indexer.indexDocument(toIndexInput(doc, input), { signal: input.signal });
     },
     async expandDocumentEdges(input, o) {
-      const absPath = import_node_path9.default.join(input.repoRoot, fromPosixPath2(input.path));
+      const absPath = import_node_path11.default.join(input.repoRoot, fromPosixPath2(input.path));
       const doc = await lsp.openTextDocument(absPath);
       return await indexer.expandDocumentEdges(toIndexInput(doc, input), { signal: o?.signal });
     }
@@ -2737,8 +4895,8 @@ function createAnnIndex(config) {
 }
 
 // src/indexer/repoIndexer.ts
-var import_node_fs12 = __toESM(require("fs"), 1);
-var import_node_path17 = __toESM(require("path"), 1);
+var import_node_fs14 = __toESM(require("fs"), 1);
+var import_node_path19 = __toESM(require("path"), 1);
 var import_p_limit2 = __toESM(require("p-limit"), 1);
 
 // src/git.ts
@@ -2774,28 +4932,28 @@ async function listChangedFiles(repoRoot, baseRef = "HEAD~1") {
 }
 
 // src/ignore.ts
-var import_node_fs6 = __toESM(require("fs"), 1);
-var import_node_path10 = __toESM(require("path"), 1);
+var import_node_fs8 = __toESM(require("fs"), 1);
+var import_node_path12 = __toESM(require("path"), 1);
 var import_ignore = __toESM(require("ignore"), 1);
 function loadExtraIgnore(repoRoot, ignoreFiles) {
   const ig = (0, import_ignore.default)();
   for (const name of ignoreFiles) {
-    const p = import_node_path10.default.join(repoRoot, name);
-    if (!import_node_fs6.default.existsSync(p)) continue;
-    const raw = import_node_fs6.default.readFileSync(p, "utf8");
+    const p = import_node_path12.default.join(repoRoot, name);
+    if (!import_node_fs8.default.existsSync(p)) continue;
+    const raw = import_node_fs8.default.readFileSync(p, "utf8");
     ig.add(raw.split(/\r?\n/));
   }
   return (posixRelPath) => ig.ignores(posixRelPath);
 }
 
 // src/store/embeddingCache.ts
-var import_node_fs7 = __toESM(require("fs"), 1);
-var import_node_path11 = __toESM(require("path"), 1);
+var import_node_fs9 = __toESM(require("fs"), 1);
+var import_node_path13 = __toESM(require("path"), 1);
 var import_better_sqlite32 = __toESM(require("better-sqlite3"), 1);
 var EmbeddingCache = class {
   db;
   constructor(cacheFilePath) {
-    import_node_fs7.default.mkdirSync(import_node_path11.default.dirname(cacheFilePath), { recursive: true });
+    import_node_fs9.default.mkdirSync(import_node_path13.default.dirname(cacheFilePath), { recursive: true });
     this.db = new import_better_sqlite32.default(cacheFilePath);
     this.db.pragma("journal_mode = WAL");
     this.db.exec(`
@@ -2831,13 +4989,13 @@ var EmbeddingCache = class {
 };
 
 // src/store/repoStore.ts
-var import_node_fs8 = __toESM(require("fs"), 1);
-var import_node_path12 = __toESM(require("path"), 1);
+var import_node_fs10 = __toESM(require("fs"), 1);
+var import_node_path14 = __toESM(require("path"), 1);
 var import_better_sqlite33 = __toESM(require("better-sqlite3"), 1);
 var RepoStore = class {
   db;
   constructor(dbPath) {
-    import_node_fs8.default.mkdirSync(import_node_path12.default.dirname(dbPath), { recursive: true });
+    import_node_fs10.default.mkdirSync(import_node_path14.default.dirname(dbPath), { recursive: true });
     this.db = new import_better_sqlite33.default(dbPath);
     this.db.pragma("journal_mode = WAL");
     this.db.exec(`
@@ -3132,10 +5290,10 @@ function resolveIndexerConfig(config = {}) {
 }
 
 // src/indexer/repoIndexer/utils.ts
-var import_node_fs9 = __toESM(require("fs"), 1);
-var import_node_path13 = __toESM(require("path"), 1);
+var import_node_fs11 = __toESM(require("fs"), 1);
+var import_node_path15 = __toESM(require("path"), 1);
 function repoIdFromRoot(repoRoot) {
-  return sha256Hex(import_node_path13.default.resolve(repoRoot)).slice(0, 16);
+  return sha256Hex(import_node_path15.default.resolve(repoRoot)).slice(0, 16);
 }
 function looksBinary(buf) {
   let nul = 0;
@@ -3222,8 +5380,8 @@ var VectorManager = class {
 };
 
 // src/indexer/repoIndexer/fileIndexer.ts
-var import_node_fs10 = __toESM(require("fs"), 1);
-var import_node_path14 = __toESM(require("path"), 1);
+var import_node_fs12 = __toESM(require("fs"), 1);
+var import_node_path16 = __toESM(require("path"), 1);
 
 // src/relations.ts
 function extractTsRelations(virtualFileName, sourceText) {
@@ -3462,10 +5620,10 @@ var RepoFileIndexer = class {
       });
     };
     const readStartedAt = Date.now();
-    const abs = import_node_path14.default.join(this.repoRoot, fromPosixPath(posixRelPath));
+    const abs = import_node_path16.default.join(this.repoRoot, fromPosixPath(posixRelPath));
     let stat;
     try {
-      stat = import_node_fs10.default.statSync(abs);
+      stat = import_node_fs12.default.statSync(abs);
     } catch {
       this.emit({ type: "repo/index/file/skip", repoRoot: this.repoRoot, path: posixRelPath, reason: "missing" });
       return;
@@ -3478,7 +5636,7 @@ var RepoFileIndexer = class {
       this.emit({ type: "repo/index/file/skip", repoRoot: this.repoRoot, path: posixRelPath, reason: "too_large" });
       return;
     }
-    const buf = import_node_fs10.default.readFileSync(abs);
+    const buf = import_node_fs12.default.readFileSync(abs);
     if (looksBinary(buf)) {
       this.emit({ type: "repo/index/file/skip", repoRoot: this.repoRoot, path: posixRelPath, reason: "binary" });
       return;
@@ -3564,7 +5722,7 @@ var RepoFileIndexer = class {
         continue;
       }
       embedTexts.push(
-        `repo:${import_node_path14.default.basename(this.repoRoot)}
+        `repo:${import_node_path16.default.basename(this.repoRoot)}
 path:${posixRelPath}
 language:${language}
 kind:${ch.kind}
@@ -3758,8 +5916,8 @@ ${ch.text}`
 };
 
 // src/indexer/repoIndexer/retriever.ts
-var import_node_fs11 = __toESM(require("fs"), 1);
-var import_node_path15 = __toESM(require("path"), 1);
+var import_node_fs13 = __toESM(require("fs"), 1);
+var import_node_path17 = __toESM(require("path"), 1);
 
 // src/retrieval/fts.ts
 function ftsQueryFromText(input) {
@@ -3850,9 +6008,9 @@ var RepoRetriever = class {
     return rows.map((r) => ({ id: r.id, score: bm25ToScore01(r.bm25) }));
   }
   readChunkTextFallback(row) {
-    const abs = import_node_path15.default.join(this.repoRoot, fromPosixPath(row.path));
+    const abs = import_node_path17.default.join(this.repoRoot, fromPosixPath(row.path));
     try {
-      const raw = import_node_fs11.default.readFileSync(abs, "utf8");
+      const raw = import_node_fs13.default.readFileSync(abs, "utf8");
       const lines = raw.split(/\r?\n/);
       const start = Math.max(1, row.start_line);
       const end = Math.max(start, row.end_line);
@@ -3944,7 +6102,7 @@ var RepoRetriever = class {
           `${spec}/index.tsx`,
           `${spec}/index.js`,
           `${spec}/index.jsx`
-        ].map((s) => import_node_path15.default.posix.normalize(import_node_path15.default.posix.join(import_node_path15.default.posix.dirname(row.path), s)));
+        ].map((s) => import_node_path17.default.posix.normalize(import_node_path17.default.posix.join(import_node_path17.default.posix.dirname(row.path), s)));
         for (const c of candidates) {
           const syn = store.listChunksForFile(c, "synopsis")[0];
           if (syn) {
@@ -3971,7 +6129,7 @@ var RepoRetriever = class {
 };
 
 // src/indexer/repoIndexer/watcher.ts
-var import_node_path16 = __toESM(require("path"), 1);
+var import_node_path18 = __toESM(require("path"), 1);
 var import_chokidar = __toESM(require("chokidar"), 1);
 var RepoWatcher = class {
   constructor(repoRoot, debounceMs, ignored, onHeadChanged, onFileChanged, onFileAdded, onFileDeleted, onWatchEvent) {
@@ -3992,14 +6150,14 @@ var RepoWatcher = class {
       if (timer) clearTimeout(timer);
       timer = setTimeout(fn, this.debounceMs);
     };
-    const headPath = import_node_path16.default.join(this.repoRoot, ".git", "HEAD");
+    const headPath = import_node_path18.default.join(this.repoRoot, ".git", "HEAD");
     this.watcher = import_chokidar.default.watch([this.repoRoot, headPath], {
       ignoreInitial: true,
       ignored: this.ignored
     });
     this.watcher.on("change", (p) => {
-      const rel = import_node_path16.default.relative(this.repoRoot, p);
-      const posix = rel.split(import_node_path16.default.sep).join("/");
+      const rel = import_node_path18.default.relative(this.repoRoot, p);
+      const posix = rel.split(import_node_path18.default.sep).join("/");
       if (posix === ".git/HEAD") {
         this.onWatchEvent?.("head", posix);
         schedule(() => this.onHeadChanged());
@@ -4009,14 +6167,14 @@ var RepoWatcher = class {
       schedule(() => this.onFileChanged(posix));
     });
     this.watcher.on("add", (p) => {
-      const rel = import_node_path16.default.relative(this.repoRoot, p);
-      const posix = rel.split(import_node_path16.default.sep).join("/");
+      const rel = import_node_path18.default.relative(this.repoRoot, p);
+      const posix = rel.split(import_node_path18.default.sep).join("/");
       this.onWatchEvent?.("add", posix);
       schedule(() => this.onFileAdded(posix));
     });
     this.watcher.on("unlink", (p) => {
-      const rel = import_node_path16.default.relative(this.repoRoot, p);
-      const posix = rel.split(import_node_path16.default.sep).join("/");
+      const rel = import_node_path18.default.relative(this.repoRoot, p);
+      const posix = rel.split(import_node_path18.default.sep).join("/");
       this.onWatchEvent?.("unlink", posix);
       schedule(() => this.onFileDeleted(posix));
     });
@@ -4031,7 +6189,7 @@ var RepoWatcher = class {
 var RepoIndexer = class {
   constructor(repoRoot, embedder, config = {}, workspaceStore, graphStore) {
     this.embedder = embedder;
-    this.repoRoot = import_node_path17.default.resolve(repoRoot);
+    this.repoRoot = import_node_path19.default.resolve(repoRoot);
     this.repoId = repoIdFromRoot(this.repoRoot);
     this.rawConfig = { ...config };
     if (!this.rawConfig.cacheDir) this.rawConfig.cacheDir = defaultCacheDir();
@@ -4041,7 +6199,7 @@ var RepoIndexer = class {
     this.workspaceStore = workspaceStore ?? null;
     this.graphStore = graphStore ?? null;
     this.ann = createAnnIndex(this.rawConfig.ann);
-    this.embeddingCache = new EmbeddingCache(import_node_path17.default.join(this.config.cacheDir, "embedding-cache.sqlite"));
+    this.embeddingCache = new EmbeddingCache(import_node_path19.default.join(this.config.cacheDir, "embedding-cache.sqlite"));
     this.vector = new VectorManager(
       this.config.vector,
       this.vectorMetric(),
@@ -4105,7 +6263,7 @@ var RepoIndexer = class {
     return this.store;
   }
   dbPathForCommit(commit) {
-    return import_node_path17.default.join(this.config.cacheDir, "index", this.repoId, `${commit}.sqlite`);
+    return import_node_path19.default.join(this.config.cacheDir, "index", this.repoId, `${commit}.sqlite`);
   }
   vectorMetric() {
     return this.config.vector.metric ?? "cosine";
@@ -4232,8 +6390,8 @@ var RepoIndexer = class {
     return this.serial(async () => {
       await this.openForCurrentHead();
       if (!this.store || !this.fileIndexer) throw new Error("RepoStore not initialised");
-      const abs = import_node_path17.default.join(this.repoRoot, posixRelPath.split("/").join(import_node_path17.default.sep));
-      if (!import_node_fs12.default.existsSync(abs)) {
+      const abs = import_node_path19.default.join(this.repoRoot, posixRelPath.split("/").join(import_node_path19.default.sep));
+      if (!import_node_fs14.default.existsSync(abs)) {
         await this.deleteFile(posixRelPath);
         return;
       }
@@ -4293,10 +6451,10 @@ var RepoIndexer = class {
       if (opts?.signal?.aborted) return;
       const startedAt = Date.now();
       this.emitProgress({ type: "repo/symbolGraph/expand/start", repoRoot: this.repoRoot, path: p });
-      const abs = import_node_path17.default.join(this.repoRoot, p.split("/").join(import_node_path17.default.sep));
+      const abs = import_node_path19.default.join(this.repoRoot, p.split("/").join(import_node_path19.default.sep));
       let text = "";
       try {
-        text = import_node_fs12.default.readFileSync(abs, "utf8");
+        text = import_node_fs14.default.readFileSync(abs, "utf8");
       } catch {
         this.emitProgress({ type: "repo/symbolGraph/expand/done", repoRoot: this.repoRoot, path: p, edges: 0, ms: Date.now() - startedAt });
         continue;
@@ -4337,9 +6495,9 @@ var RepoIndexer = class {
     await this.openForCurrentHead();
     this.emitProgress({ type: "repo/watch/start", repoRoot: this.repoRoot });
     const ignored = (p) => {
-      const rel = import_node_path17.default.relative(this.repoRoot, p);
+      const rel = import_node_path19.default.relative(this.repoRoot, p);
       if (!rel) return false;
-      const posix = rel.split(import_node_path17.default.sep).join("/");
+      const posix = rel.split(import_node_path19.default.sep).join("/");
       if (posix.startsWith(".git/")) return true;
       if (posix.includes("node_modules/")) return true;
       if (posix.includes("/.cache/")) return true;
@@ -4380,14 +6538,14 @@ var RepoIndexer = class {
 };
 
 // src/indexer/workspaceIndexer.ts
-var import_node_path19 = __toESM(require("path"), 1);
+var import_node_path22 = __toESM(require("path"), 1);
 
 // src/indexer/workspaceLinker.ts
-var import_node_fs13 = __toESM(require("fs"), 1);
-var import_node_path18 = __toESM(require("path"), 1);
+var import_node_fs15 = __toESM(require("fs"), 1);
+var import_node_path20 = __toESM(require("path"), 1);
 function readText(absPath) {
   try {
-    return import_node_fs13.default.readFileSync(absPath, "utf8");
+    return import_node_fs15.default.readFileSync(absPath, "utf8");
   } catch {
     return null;
   }
@@ -4417,7 +6575,7 @@ var NestedRepoLinkStrategy = class {
     for (const child of sorted) {
       for (const parent of sorted) {
         if (child.repoId === parent.repoId) continue;
-        if (child.absRoot.startsWith(parent.absRoot + import_node_path18.default.sep)) {
+        if (child.absRoot.startsWith(parent.absRoot + import_node_path20.default.sep)) {
           out.push({
             fromRepoId: child.repoId,
             toRepoId: parent.repoId,
@@ -4437,7 +6595,7 @@ var NpmDependencyLinkStrategy = class {
     const out = [];
     const depSections = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
     for (const r of ctx.repos) {
-      const pkg = readJson(import_node_path18.default.join(r.absRoot, "package.json"));
+      const pkg = readJson(import_node_path20.default.join(r.absRoot, "package.json"));
       if (!pkg) continue;
       for (const sec of depSections) {
         const deps = pkg?.[sec];
@@ -4455,13 +6613,13 @@ var NpmDependencyLinkStrategy = class {
   }
 };
 function parseGoModule(absRepoRoot) {
-  const raw = readText(import_node_path18.default.join(absRepoRoot, "go.mod"));
+  const raw = readText(import_node_path20.default.join(absRepoRoot, "go.mod"));
   if (!raw) return null;
   const m = raw.match(/^\s*module\s+(.+)\s*$/m);
   return m ? String(m[1]).trim() : null;
 }
 function parseGoRequires(absRepoRoot) {
-  const raw = readText(import_node_path18.default.join(absRepoRoot, "go.mod"));
+  const raw = readText(import_node_path20.default.join(absRepoRoot, "go.mod"));
   if (!raw) return [];
   const out = [];
   for (const line of raw.split(/\r?\n/)) {
@@ -4501,13 +6659,13 @@ function walkFiles(root, opts, onFile) {
     if (depth > maxDepth) return;
     let ents = [];
     try {
-      ents = import_node_fs13.default.readdirSync(dir, { withFileTypes: true });
+      ents = import_node_fs15.default.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of ents) {
       if (seen >= maxFiles) return;
-      const abs = import_node_path18.default.join(dir, e.name);
+      const abs = import_node_path20.default.join(dir, e.name);
       if (opts.shouldVisit && !opts.shouldVisit(abs, e)) continue;
       if (e.isDirectory()) {
         if (isSkippableDir(e.name)) continue;
@@ -4531,7 +6689,7 @@ function collectVsCodeLanguagesForRepo(absRepoRoot) {
       shouldVisit: (_abs, dirent) => !(dirent.isDirectory() && isSkippableDir(dirent.name))
     },
     (absPath) => {
-      if (import_node_path18.default.basename(absPath) !== "package.json") return;
+      if (import_node_path20.default.basename(absPath) !== "package.json") return;
       const pkg = readJson(absPath);
       const langs = pkg?.contributes?.languages;
       if (!Array.isArray(langs)) return;
@@ -4560,7 +6718,7 @@ function repoUsedExtensions(absRepoRoot, exts) {
       shouldVisit: (_abs, dirent) => !(dirent.isDirectory() && isSkippableDir(dirent.name))
     },
     (absPath) => {
-      const ext = import_node_path18.default.extname(absPath).toLowerCase();
+      const ext = import_node_path20.default.extname(absPath).toLowerCase();
       if (!ext) return;
       if (exts.has(ext)) used.add(ext);
     }
@@ -4632,12 +6790,12 @@ var WorkspaceLinker = class _WorkspaceLinker {
     const repos = repoRoots.map((repoRoot) => ({
       repoRoot,
       repoId: repoIdFromRoot(repoRoot),
-      absRoot: import_node_path18.default.resolve(repoRoot)
+      absRoot: import_node_path20.default.resolve(repoRoot)
     }));
     const npmNameToRepoId = /* @__PURE__ */ new Map();
     const goModuleToRepoId = /* @__PURE__ */ new Map();
     for (const r of repos) {
-      const pkg = readJson(import_node_path18.default.join(r.absRoot, "package.json"));
+      const pkg = readJson(import_node_path20.default.join(r.absRoot, "package.json"));
       const name = typeof pkg?.name === "string" ? pkg.name : null;
       if (name) npmNameToRepoId.set(name, r.repoId);
       const mod = parseGoModule(r.absRoot);
@@ -4681,13 +6839,205 @@ async function linkWorkspaceRepos(args) {
   return { repos: ctx.repos, links };
 }
 
-// src/indexer/workspaceIndexer.ts
+// src/indexer/workspaceRetrieveCandidates.ts
+var import_node_path21 = __toESM(require("path"), 1);
+function resolveWorkspaceProfile(config, opts) {
+  const name = opts?.profile ?? "search";
+  const base = DEFAULT_PROFILES[name] ?? DEFAULT_PROFILES.search;
+  const configPatch = config.profiles?.[name] ?? {};
+  const merged1 = deepMergeProfile(base, configPatch);
+  const merged2 = deepMergeProfile(merged1, opts?.profileOverrides);
+  const w = merged2.weights;
+  const sum = Math.max(1e-6, w.vector + w.lexical + w.recency);
+  merged2.weights = { vector: w.vector / sum, lexical: w.lexical / sum, recency: w.recency / sum };
+  return merged2;
+}
 function halfLifeDaysForProfile(profileName) {
   if (profileName === "rca") return 7;
   if (profileName === "review") return 14;
   if (profileName === "refactor") return 21;
   return 30;
 }
+function buildWorkspaceLexByRepoRoot(args) {
+  const { workspaceStore, repos, query, lexicalK, repoFilters } = args;
+  const ftq = ftsQueryFromText(query);
+  if (!ftq) return { lexByRepoRoot: /* @__PURE__ */ new Map(), count: 0 };
+  const allowRoots = repoFilters ? new Set(repoFilters.map((r) => import_node_path21.default.resolve(r))) : null;
+  const repoIds = allowRoots ? repos.filter((r) => allowRoots.has(import_node_path21.default.resolve(r.repoRoot))).map((r) => r.repoId) : void 0;
+  const rows = workspaceStore.searchFts(ftq, lexicalK, repoIds);
+  const lexByRepoRoot = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const row = workspaceStore.getChunkById(r.id);
+    if (!row) continue;
+    const rootKey = import_node_path21.default.resolve(row.repo_root);
+    const arr = lexByRepoRoot.get(rootKey) ?? [];
+    arr.push({ id: r.id, score: bm25ToScore01(r.bm25) });
+    lexByRepoRoot.set(rootKey, arr);
+  }
+  return { lexByRepoRoot, count: rows.length };
+}
+async function collectWorkspaceCandidates(args) {
+  const { repos, qVec, query, vectorK, lexicalK, profile, opts, lexByRepoRoot, canUseWorkspaceLex } = args;
+  const repoFilters = opts.filters?.repoRoots;
+  const langFilter = opts.filters?.language;
+  const pathPrefix = opts.filters?.pathPrefix;
+  const candidates = [];
+  let vecCount = 0;
+  let lexCount = 0;
+  for (const repo of repos) {
+    if (repoFilters && !repoFilters.includes(repo.repoRoot)) continue;
+    let includePaths = opts.scope?.includePaths?.slice();
+    if (opts.scope?.changedOnly) {
+      try {
+        const changed = await listChangedFiles(repo.repoRoot, opts.scope.baseRef ?? "HEAD~1");
+        includePaths = includePaths ? includePaths.filter((p) => changed.includes(p)) : changed;
+      } catch {
+      }
+    }
+    const [vHits, lHits] = await Promise.all([
+      repo.vectorCandidates(qVec, vectorK, includePaths),
+      canUseWorkspaceLex ? Promise.resolve(lexByRepoRoot?.get(import_node_path21.default.resolve(repo.repoRoot)) ?? []) : repo.lexicalCandidates(query, lexicalK, includePaths)
+    ]);
+    vecCount += vHits.length;
+    if (!canUseWorkspaceLex) lexCount += lHits.length;
+    const m = /* @__PURE__ */ new Map();
+    for (const vh of vHits) {
+      const id = vh.id;
+      const vector01 = vectorCosineToScore01(vh.score);
+      m.set(id, { repo, id, vector01, combined: 0 });
+    }
+    for (const lh of lHits) {
+      const id = lh.id;
+      const prev = m.get(id);
+      if (prev) prev.lexical01 = lh.score;
+      else m.set(id, { repo, id, lexical01: lh.score, combined: 0 });
+    }
+    const halfLife = halfLifeDaysForProfile(profile.name);
+    for (const c of m.values()) {
+      const meta = repo.getChunkMeta(c.id);
+      if (!meta) continue;
+      if (langFilter && meta.language !== langFilter) continue;
+      if (pathPrefix && !meta.path.startsWith(pathPrefix)) continue;
+      c.recency01 = profile.weights.recency > 0 ? recencyScore(meta.fileMtimeMs, halfLife) : 0;
+      let kindFactor = 1;
+      if (meta.kind === "synopsis" && profile.name === "search") kindFactor = 0.85;
+      if (meta.kind === "synopsis" && profile.name === "architecture") kindFactor = 1.05;
+      const v = c.vector01 ?? 0;
+      const l = c.lexical01 ?? 0;
+      const r = c.recency01 ?? 0;
+      c.combined = clamp(kindFactor * (profile.weights.vector * v + profile.weights.lexical * l + profile.weights.recency * r), 0, 1);
+      candidates.push(c);
+    }
+  }
+  return { candidates, vecCount, lexCount };
+}
+function rankWorkspaceCandidates(args) {
+  const { candidates, maxMerged, k } = args;
+  candidates.sort((a, b) => b.combined - a.combined);
+  const merged = candidates.slice(0, maxMerged);
+  const top = merged.slice(0, k);
+  const hits = top.map((c) => {
+    const meta = c.repo.getChunkMeta(c.id);
+    const preview = makePreview(c.repo.getChunkText(c.id));
+    return {
+      score: c.combined,
+      scoreBreakdown: { vector: c.vector01, lexical: c.lexical01, recency: c.recency01 },
+      chunk: { ...meta, preview }
+    };
+  });
+  return { merged, hits };
+}
+
+// src/indexer/workspaceRetrieveContext.ts
+async function warmSymbolGraphForHits(repos, hits) {
+  const byRepo = /* @__PURE__ */ new Map();
+  for (const h of hits) {
+    const s = byRepo.get(h.chunk.repoRoot) ?? /* @__PURE__ */ new Set();
+    s.add(h.chunk.path);
+    byRepo.set(h.chunk.repoRoot, s);
+  }
+  for (const [repoRoot, paths] of byRepo) {
+    const repo = repos.find((r) => r.repoRoot === repoRoot);
+    if (!repo) continue;
+    await repo.warmSymbolGraphEdges(Array.from(paths), { maxFiles: 6 });
+  }
+}
+async function fetchGraphNeighborFiles(args) {
+  const { graphStore, repos, hits, profile, workspaceRoot, emitProgress } = args;
+  if (!graphStore?.neighborFiles) return [];
+  const seeds = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const h of hits) {
+    const repo = repos.find((r) => r.repoRoot === h.chunk.repoRoot);
+    if (!repo) continue;
+    const key = `${repo.repoId}:${h.chunk.path}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    seeds.push({ repoId: repo.repoId, path: h.chunk.path });
+    if (seeds.length >= 4) break;
+  }
+  if (seeds.length === 0) return [];
+  const startedAt = Date.now();
+  emitProgress({ type: "workspace/retrieve/graph/start", workspaceRoot, seeds: seeds.length });
+  try {
+    const neighbors = await graphStore.neighborFiles({
+      seeds,
+      limit: profile.name === "architecture" ? 16 : 10,
+      kinds: ["definition", "reference", "implementation", "typeDefinition"]
+    });
+    emitProgress({ type: "workspace/retrieve/graph/done", workspaceRoot, neighbors: neighbors.length, ms: Date.now() - startedAt });
+    return neighbors;
+  } catch {
+    return [];
+  }
+}
+async function buildContextBlocks(args) {
+  const { repos, hits, graphNeighborFiles, profile } = args;
+  const contextBlocks = [];
+  const seenKey = /* @__PURE__ */ new Set();
+  const addBlock = (repoRoot, filePath, startLine, endLine, text, reason) => {
+    const key = `${repoRoot}:${filePath}:${startLine}:${endLine}:${text.length}:${reason}`;
+    if (seenKey.has(key)) return;
+    seenKey.add(key);
+    if (!text.trim()) return;
+    contextBlocks.push({ repoRoot, path: filePath, startLine, endLine, text, reason });
+  };
+  try {
+    const byRepoId = /* @__PURE__ */ new Map();
+    for (const r of repos) byRepoId.set(r.repoId, r);
+    for (const n of graphNeighborFiles.slice(0, 10)) {
+      const repo = byRepoId.get(n.repoId);
+      if (!repo) continue;
+      const chunkId = await repo.getRepresentativeChunkIdForFile(n.path, true);
+      if (!chunkId) continue;
+      const meta = repo.getChunkMeta(chunkId);
+      if (!meta) continue;
+      const text = repo.getChunkText(chunkId);
+      addBlock(meta.repoRoot, meta.path, meta.startLine, meta.endLine, text, `graph neighbor (${n.weight})`);
+    }
+  } catch {
+  }
+  for (const h of hits) {
+    const repo = repos.find((r) => r.repoRoot === h.chunk.repoRoot);
+    if (!repo) continue;
+    const hitText = repo.getChunkText(h.chunk.id);
+    addBlock(h.chunk.repoRoot, h.chunk.path, h.chunk.startLine, h.chunk.endLine, hitText, "primary hit");
+    const expanded = await repo.expandContext(h.chunk.id, {
+      adjacentChunks: profile.expand.adjacentChunks ?? 0,
+      followImports: profile.expand.followImports ?? 0,
+      includeFileSynopsis: profile.expand.includeFileSynopsis ?? false
+    });
+    for (const ex of expanded) {
+      const meta = repo.getChunkMeta(ex.id);
+      if (!meta) continue;
+      const text = repo.getChunkText(ex.id);
+      addBlock(meta.repoRoot, meta.path, meta.startLine, meta.endLine, text, ex.reason);
+    }
+  }
+  return contextBlocks;
+}
+
+// src/indexer/workspaceIndexer.ts
 var WorkspaceIndexer = class {
   constructor(workspaceRoot, embedder, config = {}) {
     this.workspaceRoot = workspaceRoot;
@@ -4695,23 +7045,30 @@ var WorkspaceIndexer = class {
     this.config = { ...config };
     if (!this.config.cacheDir) this.config.cacheDir = defaultCacheDir();
     this.progress = asProgressSink(this.config.progress);
-    const wsId = sha256Hex(import_node_path19.default.resolve(this.workspaceRoot)).slice(0, 16);
-    const dbPath = import_node_path19.default.join(this.config.cacheDir, "workspace", wsId, "workspace.sqlite");
-    this.workspaceStore = new WorkspaceStore(dbPath);
-    this.workspaceStore.setMeta("workspaceRoot", import_node_path19.default.resolve(this.workspaceRoot));
+    const wsId = sha256Hex(import_node_path22.default.resolve(this.workspaceRoot)).slice(0, 16);
+    this.workspaceDbPath = import_node_path22.default.join(this.config.cacheDir, "workspace", wsId, "workspace.sqlite");
   }
   repos = [];
   config;
   progress = asProgressSink();
   workspaceStore = null;
   graphStore = null;
+  workspaceDbPath;
   emitProgress(event) {
     try {
       this.progress?.emit(event);
     } catch {
     }
   }
+  async ensureWorkspaceStore() {
+    if (this.workspaceStore) return this.workspaceStore;
+    const ws = await createWorkspaceStoreAsync(this.workspaceDbPath, { db: this.config.workspace?.db });
+    ws.setMeta("workspaceRoot", import_node_path22.default.resolve(this.workspaceRoot));
+    this.workspaceStore = ws;
+    return ws;
+  }
   async open() {
+    await this.ensureWorkspaceStore();
     if (!this.graphStore && this.config.workspace?.graph?.provider === "neo4j") {
       try {
         const n = this.config.workspace.graph.neo4j;
@@ -4783,195 +7140,49 @@ var WorkspaceIndexer = class {
   getRepoIndexers() {
     return this.repos.slice();
   }
-  resolveProfile(opts) {
-    const name = opts?.profile ?? "search";
-    const base = DEFAULT_PROFILES[name] ?? DEFAULT_PROFILES.search;
-    const configPatch = this.config.profiles?.[name] ?? {};
-    const merged1 = deepMergeProfile(base, configPatch);
-    const merged2 = deepMergeProfile(merged1, opts?.profileOverrides);
-    const w = merged2.weights;
-    const sum = Math.max(1e-6, w.vector + w.lexical + w.recency);
-    merged2.weights = { vector: w.vector / sum, lexical: w.lexical / sum, recency: w.recency / sum };
-    return merged2;
-  }
   async retrieve(query, opts = {}) {
     if (this.repos.length === 0) await this.open();
-    const profile = this.resolveProfile(opts);
+    const profile = resolveWorkspaceProfile(this.config, opts);
     const startedAt = Date.now();
     this.emitProgress({ type: "workspace/retrieve/start", workspaceRoot: this.workspaceRoot, profile: profile.name, query });
     const qVec = (await this.embedder.embed([query]))[0];
     const vectorK = profile.candidates?.vectorK ?? Math.max(profile.k * 3, 30);
     const lexicalK = profile.candidates?.lexicalK ?? Math.max(profile.k * 3, 30);
     const maxMerged = profile.candidates?.maxMergedCandidates ?? Math.max(profile.k * 8, 120);
-    const repoFilters = opts.filters?.repoRoots;
-    const langFilter = opts.filters?.language;
-    const pathPrefix = opts.filters?.pathPrefix;
-    const candidates = [];
-    let vecCount = 0;
-    let lexCount = 0;
-    const canUseWorkspaceLex = !!this.workspaceStore && this.config.storage?.ftsMode !== "off" && !opts.scope?.includePaths && !opts.scope?.changedOnly;
-    const workspaceLexByRepoRoot = /* @__PURE__ */ new Map();
-    if (canUseWorkspaceLex && profile.weights.lexical > 0) {
-      const ftq = ftsQueryFromText(query);
-      const allowRoots = repoFilters ? new Set(repoFilters.map((r) => import_node_path19.default.resolve(r))) : null;
-      const repoIds = allowRoots ? this.repos.filter((r) => allowRoots.has(import_node_path19.default.resolve(r.repoRoot))).map((r) => r.repoId) : void 0;
-      if (ftq) {
-        const rows = this.workspaceStore.searchFts(ftq, lexicalK, repoIds);
-        lexCount += rows.length;
-        for (const r of rows) {
-          const row = this.workspaceStore.getChunkById(r.id);
-          if (!row) continue;
-          const rootKey = import_node_path19.default.resolve(row.repo_root);
-          const arr = workspaceLexByRepoRoot.get(rootKey) ?? [];
-          arr.push({ id: r.id, score: bm25ToScore01(r.bm25) });
-          workspaceLexByRepoRoot.set(rootKey, arr);
-        }
-      }
-    }
-    for (const repo of this.repos) {
-      if (repoFilters && !repoFilters.includes(repo.repoRoot)) continue;
-      let includePaths = opts.scope?.includePaths?.slice();
-      if (opts.scope?.changedOnly) {
-        try {
-          const changed = await listChangedFiles(repo.repoRoot, opts.scope.baseRef ?? "HEAD~1");
-          includePaths = includePaths ? includePaths.filter((p) => changed.includes(p)) : changed;
-        } catch {
-        }
-      }
-      const [vHits, lHits] = await Promise.all([
-        repo.vectorCandidates(qVec, vectorK, includePaths),
-        canUseWorkspaceLex ? Promise.resolve(workspaceLexByRepoRoot.get(import_node_path19.default.resolve(repo.repoRoot)) ?? []) : repo.lexicalCandidates(query, lexicalK, includePaths)
-      ]);
-      vecCount += vHits.length;
-      if (!canUseWorkspaceLex) lexCount += lHits.length;
-      const m = /* @__PURE__ */ new Map();
-      for (const vh of vHits) {
-        const id = vh.id;
-        const vector01 = vectorCosineToScore01(vh.score);
-        m.set(id, { repo, id, vector01, combined: 0 });
-      }
-      for (const lh of lHits) {
-        const id = lh.id;
-        const prev = m.get(id);
-        if (prev) prev.lexical01 = lh.score;
-        else m.set(id, { repo, id, lexical01: lh.score, combined: 0 });
-      }
-      const halfLife = halfLifeDaysForProfile(profile.name);
-      for (const c of m.values()) {
-        const meta = repo.getChunkMeta(c.id);
-        if (!meta) continue;
-        if (langFilter && meta.language !== langFilter) continue;
-        if (pathPrefix && !meta.path.startsWith(pathPrefix)) continue;
-        c.recency01 = profile.weights.recency > 0 ? recencyScore(meta.fileMtimeMs, halfLife) : 0;
-        let kindFactor = 1;
-        if (meta.kind === "synopsis" && profile.name === "search") kindFactor = 0.85;
-        if (meta.kind === "synopsis" && profile.name === "architecture") kindFactor = 1.05;
-        const v = c.vector01 ?? 0;
-        const l = c.lexical01 ?? 0;
-        const r = c.recency01 ?? 0;
-        c.combined = clamp(
-          kindFactor * (profile.weights.vector * v + profile.weights.lexical * l + profile.weights.recency * r),
-          0,
-          1
-        );
-        candidates.push(c);
-      }
-    }
-    candidates.sort((a, b) => b.combined - a.combined);
-    const merged = candidates.slice(0, maxMerged);
-    const top = merged.slice(0, profile.k);
-    const hits = top.map((c) => {
-      const meta = c.repo.getChunkMeta(c.id);
-      const preview = makePreview(c.repo.getChunkText(c.id));
-      return {
-        score: c.combined,
-        scoreBreakdown: { vector: c.vector01, lexical: c.lexical01, recency: c.recency01 },
-        chunk: { ...meta, preview }
-      };
+    const canUseWorkspaceLex = !!this.workspaceStore && this.workspaceStore.ftsEnabled && this.config.storage?.ftsMode !== "off" && !opts.scope?.includePaths && !opts.scope?.changedOnly;
+    const { lexByRepoRoot, count: workspaceLexCount } = canUseWorkspaceLex && profile.weights.lexical > 0 && this.workspaceStore ? buildWorkspaceLexByRepoRoot({
+      workspaceStore: this.workspaceStore,
+      repos: this.repos,
+      query,
+      lexicalK,
+      repoFilters: opts.filters?.repoRoots
+    }) : { lexByRepoRoot: void 0, count: 0 };
+    const { candidates, vecCount, lexCount } = await collectWorkspaceCandidates({
+      repos: this.repos,
+      qVec,
+      query,
+      vectorK,
+      lexicalK,
+      profile,
+      opts,
+      lexByRepoRoot,
+      canUseWorkspaceLex
     });
+    const { merged, hits } = rankWorkspaceCandidates({ candidates, maxMerged, k: profile.k });
+    const totalLexCount = (canUseWorkspaceLex ? workspaceLexCount : 0) + lexCount;
     try {
-      const byRepo = /* @__PURE__ */ new Map();
-      for (const h of hits) {
-        const s = byRepo.get(h.chunk.repoRoot) ?? /* @__PURE__ */ new Set();
-        s.add(h.chunk.path);
-        byRepo.set(h.chunk.repoRoot, s);
-      }
-      for (const [repoRoot, paths] of byRepo) {
-        const repo = this.repos.find((r) => r.repoRoot === repoRoot);
-        if (!repo) continue;
-        await repo.warmSymbolGraphEdges(Array.from(paths), { maxFiles: 6 });
-      }
-    } catch {
-    }
-    let graphNeighborFiles = [];
-    try {
-      if (this.graphStore?.neighborFiles) {
-        const seeds = [];
-        const seen = /* @__PURE__ */ new Set();
-        for (const h of hits) {
-          const repo = this.repos.find((r) => r.repoRoot === h.chunk.repoRoot);
-          if (!repo) continue;
-          const key = `${repo.repoId}:${h.chunk.path}`;
-          if (seen.has(key)) continue;
-          seen.add(key);
-          seeds.push({ repoId: repo.repoId, path: h.chunk.path });
-          if (seeds.length >= 4) break;
-        }
-        if (seeds.length > 0) {
-          const gs = Date.now();
-          this.emitProgress({ type: "workspace/retrieve/graph/start", workspaceRoot: this.workspaceRoot, seeds: seeds.length });
-          graphNeighborFiles = await this.graphStore.neighborFiles({
-            seeds,
-            limit: profile.name === "architecture" ? 16 : 10,
-            kinds: ["definition", "reference", "implementation", "typeDefinition"]
-          });
-          this.emitProgress({ type: "workspace/retrieve/graph/done", workspaceRoot: this.workspaceRoot, neighbors: graphNeighborFiles.length, ms: Date.now() - gs });
-        }
-      }
-    } catch {
-      graphNeighborFiles = [];
-    }
-    const contextBlocks = [];
-    const seenKey = /* @__PURE__ */ new Set();
-    const addBlock = (repoRoot, path21, startLine, endLine, text, reason) => {
-      const key = `${repoRoot}:${path21}:${startLine}:${endLine}:${text.length}:${reason}`;
-      if (seenKey.has(key)) return;
-      seenKey.add(key);
-      if (!text.trim()) return;
-      contextBlocks.push({ repoRoot, path: path21, startLine, endLine, text, reason });
-    };
-    try {
-      const byRepoId = /* @__PURE__ */ new Map();
-      for (const r of this.repos) byRepoId.set(r.repoId, r);
-      for (const n of graphNeighborFiles.slice(0, 10)) {
-        const repo = byRepoId.get(n.repoId);
-        if (!repo) continue;
-        const chunkId = await repo.getRepresentativeChunkIdForFile(n.path, true);
-        if (!chunkId) continue;
-        const meta = repo.getChunkMeta(chunkId);
-        if (!meta) continue;
-        const text = repo.getChunkText(chunkId);
-        addBlock(meta.repoRoot, meta.path, meta.startLine, meta.endLine, text, `graph neighbor (${n.weight})`);
-      }
+      await warmSymbolGraphForHits(this.repos, hits);
     } catch {
     }
-    for (const h of hits) {
-      const repo = this.repos.find((r) => r.repoRoot === h.chunk.repoRoot);
-      if (!repo) continue;
-      const text = repo.getChunkText(h.chunk.id);
-      addBlock(h.chunk.repoRoot, h.chunk.path, h.chunk.startLine, h.chunk.endLine, text, "primary hit");
-      const expanded = await repo.expandContext(h.chunk.id, {
-        adjacentChunks: profile.expand.adjacentChunks ?? 0,
-        followImports: profile.expand.followImports ?? 0,
-        includeFileSynopsis: profile.expand.includeFileSynopsis ?? false
-      });
-      for (const ex of expanded) {
-        const meta = repo.getChunkMeta(ex.id);
-        if (!meta) continue;
-        const t = repo.getChunkText(ex.id);
-        addBlock(meta.repoRoot, meta.path, meta.startLine, meta.endLine, t, ex.reason);
-      }
-    }
+    const graphNeighborFiles = await fetchGraphNeighborFiles({
+      graphStore: this.graphStore,
+      repos: this.repos,
+      hits,
+      profile,
+      workspaceRoot: this.workspaceRoot,
+      emitProgress: (e) => this.emitProgress(e)
+    });
+    const contextBlocks = await buildContextBlocks({ repos: this.repos, hits, graphNeighborFiles, profile });
     const bundle = {
       hits,
       context: contextBlocks,
@@ -4980,7 +7191,7 @@ var WorkspaceIndexer = class {
         reposSearched: this.repos.length,
         candidates: {
           vector: vecCount,
-          lexical: lexCount,
+          lexical: totalLexCount,
           merged: merged.length,
           returned: hits.length
         }
@@ -4992,7 +7203,7 @@ var WorkspaceIndexer = class {
       profile: profile.name,
       ms: Date.now() - startedAt,
       hits: hits.length,
-      candidates: { vector: vecCount, lexical: lexCount, merged: merged.length }
+      candidates: { vector: vecCount, lexical: totalLexCount, merged: merged.length }
     });
     return bundle;
   }
@@ -5016,11 +7227,11 @@ var WorkspaceIndexer = class {
 };
 
 // src/config.ts
-var import_node_fs14 = __toESM(require("fs"), 1);
-var import_node_path20 = __toESM(require("path"), 1);
+var import_node_fs16 = __toESM(require("fs"), 1);
+var import_node_path23 = __toESM(require("path"), 1);
 function loadConfigFile(filePath) {
-  const abs = import_node_path20.default.resolve(filePath);
-  const raw = import_node_fs14.default.readFileSync(abs, "utf8");
+  const abs = import_node_path23.default.resolve(filePath);
+  const raw = import_node_fs16.default.readFileSync(abs, "utf8");
   const json = JSON.parse(raw);
   const cfg = { ...json };
   if (json.redact?.patterns && Array.isArray(json.redact.patterns)) {
@@ -5058,11 +7269,14 @@ function loadConfigFile(filePath) {
   WorkspaceLinker,
   WorkspaceStore,
   asProgressSink,
+  betterSqlite3Adapter,
   chunkSource,
   createAnnIndex,
   createNeo4jGraphStore,
   createVSCodeSymbolGraphProvider,
   createVectorIndex,
+  createWorkspaceStore,
+  createWorkspaceStoreAsync,
   deepMergeProfile,
   discoverGitRepos,
   languageFromPath,
@@ -5070,5 +7284,6 @@ function loadConfigFile(filePath) {
   loadConfigFile,
   mergeIndexerConfig,
   pickRepoOverride,
+  sqlJsAdapter,
   stableSymbolId
 });