@namzu/cli 37.0.1 → 37.1.0

package/dist/chunks/dist-KGLSBIES.js

@@ -0,0 +1,2182 @@
+import { createRequire as __namzuCreateRequire } from 'node:module';
+const require = __namzuCreateRequire(import.meta.url);
+import {
+  EMPTY_ROWS,
+  ParserUnavailableError,
+  isDeclarationFile,
+  languageOf
+} from "./chunk-7WKQQOKK.js";
+import {
+  __name
+} from "./chunk-76FLAFCG.js";
+
+// ../analysis/dist/provider.js
+import { lstat as lstat4, realpath as realpath3, stat as stat3 } from "node:fs/promises";
+
+// ../analysis/dist/context.js
+import { createHash as createHash3 } from "node:crypto";
+import { lstat as lstat3 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+
+// ../analysis/dist/fsafe.js
+import { constants } from "node:fs";
+import { lstat, open, readlink, realpath, stat } from "node:fs/promises";
+import { sep } from "node:path";
+function isInside(rootReal, candidate) {
+  return candidate === rootReal || candidate.startsWith(rootReal.endsWith(sep) ? rootReal : rootReal + sep);
+}
+__name(isInside, "isInside");
+var NOFOLLOW = constants.O_NOFOLLOW ?? 0;
+var NONBLOCK = constants.O_NONBLOCK ?? 0;
+async function descriptorInside(rootReal, fd, path, opened) {
+  if (process.platform === "linux") {
+    try {
+      const target = await readlink(`/proc/self/fd/${fd}`);
+      return !target.endsWith(" (deleted)") && isInside(rootReal, target);
+    } catch {
+    }
+  }
+  try {
+    const canonical = await realpath(path);
+    if (!isInside(rootReal, canonical))
+      return false;
+    const now = await stat(canonical);
+    return now.ino === opened.ino && now.dev === opened.dev;
+  } catch {
+    return false;
+  }
+}
+__name(descriptorInside, "descriptorInside");
+async function readRegular(rootReal, abs) {
+  let before;
+  try {
+    before = await lstat(abs);
+  } catch (err) {
+    return {
+      ok: false,
+      why: err.code === "ENOENT" ? "missing" : "unreadable"
+    };
+  }
+  if (before.isSymbolicLink())
+    return { ok: false, why: "link" };
+  if (!before.isFile())
+    return { ok: false, why: "not-file" };
+  try {
+    if (!isInside(rootReal, await realpath(abs)))
+      return { ok: false, why: "outside" };
+    const handle = await open(abs, constants.O_RDONLY | NOFOLLOW | NONBLOCK);
+    try {
+      const opened = await handle.stat();
+      if (!opened.isFile())
+        return { ok: false, why: "not-file" };
+      if (before.ino !== 0 && (opened.ino !== before.ino || opened.dev !== before.dev)) {
+        return { ok: false, why: "link" };
+      }
+      if (!await descriptorInside(rootReal, handle.fd, abs, opened))
+        return { ok: false, why: "outside" };
+      const buffer = await handle.readFile();
+      if (!isInside(rootReal, await realpath(abs)))
+        return { ok: false, why: "outside" };
+      return { ok: true, buffer, stat: opened };
+    } finally {
+      await handle.close();
+    }
+  } catch (err) {
+    const code = err.code;
+    if (code === "ELOOP")
+      return { ok: false, why: "link" };
+    if (code === "ENOENT")
+      return { ok: false, why: "missing" };
+    return { ok: false, why: "unreadable" };
+  }
+}
+__name(readRegular, "readRegular");
+async function conditionOf(rootReal, abs, recorded) {
+  let s;
+  try {
+    s = await lstat(abs);
+  } catch {
+    return "deleted";
+  }
+  if (!s.isFile())
+    return "violation";
+  try {
+    if (!isInside(rootReal, await realpath(abs)))
+      return "violation";
+  } catch {
+    return "deleted";
+  }
+  return s.size === recorded.size && s.mtimeMs === recorded.mtimeMs ? "same" : "changed";
+}
+__name(conditionOf, "conditionOf");
+
+// ../analysis/dist/indexer.js
+import { createHash as createHash2 } from "node:crypto";
+import { lstat as lstat2, readdir as readdir2, realpath as realpath2 } from "node:fs/promises";
+import { join as join3, sep as sep3 } from "node:path";
+import { setImmediate as nextTurn } from "node:timers/promises";
+import { TextDecoder } from "node:util";
+
+// ../analysis/dist/host.js
+import { fork } from "node:child_process";
+import { existsSync, realpathSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { dirname, resolve, sep as sep2 } from "node:path";
+import { fileURLToPath } from "node:url";
+var PARSE_TIMEOUT_MS = 12e4;
+var MIN_PARSE_MS = 1e4;
+var BOOT_TIMEOUT_MS = 15e3;
+function hostScript(override) {
+  if (override !== void 0) {
+    if (existsSync(override))
+      return resolve(override);
+    throw new Error(`The indexer host script ${override} does not exist.`);
+  }
+  const beside = fileURLToPath(new URL("./indexer-host.js", import.meta.url));
+  if (existsSync(beside))
+    return beside;
+  const built = fileURLToPath(new URL("../dist/indexer-host.js", import.meta.url));
+  if (existsSync(built))
+    return built;
+  throw new Error("The indexer host (dist/indexer-host.js) is not built. Run the package build.");
+}
+__name(hostScript, "hostScript");
+function childEnvironment(env = process.env) {
+  const keep = ["PATH", "TMPDIR", "TEMP", "TMP", "SYSTEMROOT", "SystemRoot", "LANG", "LC_ALL"];
+  const out = {};
+  for (const key of keep)
+    if (env[key] !== void 0)
+      out[key] = env[key];
+  return out;
+}
+__name(childEnvironment, "childEnvironment");
+function withoutCoreDump(pid) {
+  if (process.platform !== "linux" || pid === void 0)
+    return;
+  try {
+    writeFileSync(`/proc/${pid}/coredump_filter`, "0");
+  } catch {
+  }
+}
+__name(withoutCoreDump, "withoutCoreDump");
+function permissionArguments(script, parserModule) {
+  if (parserModule !== void 0)
+    return [];
+  try {
+    const real = realpathSync(createRequire(script).resolve("oxc-parser"));
+    const marker = `${sep2}node_modules${sep2}`;
+    const at = real.indexOf(marker);
+    if (at < 0)
+      return [];
+    const modules = real.slice(0, at + marker.length - 1);
+    const scriptDir = dirname(realpathSync(script));
+    return [
+      "--permission",
+      "--allow-addons",
+      `--allow-fs-read=${scriptDir}`,
+      `--allow-fs-read=${dirname(scriptDir)}`,
+      `--allow-fs-read=${modules}`
+    ];
+  } catch {
+    return [];
+  }
+}
+__name(permissionArguments, "permissionArguments");
+var ParserHost = class {
+  static {
+    __name(this, "ParserHost");
+  }
+  script;
+  parserModule;
+  /** The child being started or running; only events from THIS one may reset state. */
+  current;
+  ready;
+  queue = Promise.resolve();
+  disposed = false;
+  /** Children this host killed on purpose, so their exit is not read as a crash. */
+  killed = /* @__PURE__ */ new WeakSet();
+  constructor(script, parserModule) {
+    this.script = script;
+    this.parserModule = parserModule;
+  }
+  spawn() {
+    if (this.disposed)
+      return Promise.reject(abortError());
+    this.ready ??= new Promise((resolve2, reject) => {
+      const script = hostScript(this.script);
+      const child = fork(script, this.parserModule !== void 0 ? [this.parserModule] : [], {
+        // Not the project: a crash handler that writes `core` into the
+        // crashed process's working directory must not write it there.
+        cwd: tmpdir(),
+        // A heap big enough for the AST of the largest file allowed, none of
+        // the parent's debugger / loader flags, and the permission model.
+        execArgv: ["--max-old-space-size=4096", ...permissionArguments(script, this.parserModule)],
+        env: childEnvironment(),
+        serialization: "advanced",
+        stdio: ["ignore", "ignore", "ignore", "ipc"]
+      });
+      withoutCoreDump(child.pid);
+      this.current = child;
+      const timer = setTimeout(() => {
+        this.kill(child);
+        reject(new Error("The indexer host did not start."));
+      }, BOOT_TIMEOUT_MS);
+      const onMessage = /* @__PURE__ */ __name((m) => {
+        if (m.t !== "ready")
+          return;
+        clearTimeout(timer);
+        child.off("message", onMessage);
+        this.idle(child);
+        resolve2(child);
+      }, "onMessage");
+      const forget = /* @__PURE__ */ __name(() => {
+        if (this.current === child) {
+          this.current = void 0;
+          this.ready = void 0;
+        }
+      }, "forget");
+      child.on("message", onMessage);
+      child.once("exit", () => {
+        clearTimeout(timer);
+        forget();
+        reject(new Error("The indexer host exited before it was ready."));
+      });
+      child.once("error", (err) => {
+        clearTimeout(timer);
+        forget();
+        reject(err);
+      });
+    });
+    return this.ready;
+  }
+  /** Between requests the child must not keep the parent's event loop alive. */
+  idle(child) {
+    child.unref();
+    child.channel?.unref();
+  }
+  busy(child) {
+    child.ref();
+    child.channel?.ref();
+  }
+  /**
+   * Parse one file's text in the child. Never throws for a crash; throws an
+   * abort error when cancelled or disposed. `timeoutMs` bounds this parse.
+   */
+  parse(job, signal, timeoutMs = PARSE_TIMEOUT_MS) {
+    const run = /* @__PURE__ */ __name(async () => {
+      if (signal?.aborted || this.disposed)
+        throw abortError();
+      const child = await this.spawn();
+      if (signal?.aborted || this.disposed)
+        throw abortError();
+      return await new Promise((resolve2, reject) => {
+        let started = false;
+        this.busy(child);
+        const cleanup = /* @__PURE__ */ __name(() => {
+          clearTimeout(timer);
+          child.off("message", onMessage);
+          child.off("exit", onExit);
+          signal?.removeEventListener("abort", onAbort);
+          if (!child.killed)
+            this.idle(child);
+        }, "cleanup");
+        const onMessage = /* @__PURE__ */ __name((m) => {
+          if (m.t === "start") {
+            started = true;
+            return;
+          }
+          if (m.t === "done" && m.rel === job.rel) {
+            cleanup();
+            resolve2({ kind: "rows", parseErrors: m.parseErrors, rows: m.rows });
+          } else if (m.t === "fail" && m.rel === job.rel) {
+            cleanup();
+            if (m.unavailable)
+              reject(new ParserUnavailableError(m.error));
+            else
+              resolve2({ kind: "error", error: m.error });
+          }
+        }, "onMessage");
+        const onExit = /* @__PURE__ */ __name((code, sig) => {
+          cleanup();
+          if (this.current === child) {
+            this.current = void 0;
+            this.ready = void 0;
+          }
+          if (this.killed.has(child)) {
+            reject(abortError());
+            return;
+          }
+          resolve2({
+            kind: "crash",
+            detail: `the parser process ended ${sig ? `with ${sig}` : `with exit code ${code}`}${started ? "" : " before it began"}`
+          });
+        }, "onExit");
+        const onAbort = /* @__PURE__ */ __name(() => {
+          cleanup();
+          this.kill(child);
+          reject(abortError());
+        }, "onAbort");
+        const limit = Math.min(timeoutMs, PARSE_TIMEOUT_MS);
+        const timer = setTimeout(() => {
+          cleanup();
+          this.kill(child);
+          resolve2({
+            kind: "crash",
+            detail: `the parser ran past ${Math.round(limit / 1e3)} seconds and was stopped`
+          });
+        }, limit);
+        child.on("message", onMessage);
+        child.once("exit", onExit);
+        signal?.addEventListener("abort", onAbort, { once: true });
+        child.send({ t: "parse", ...job });
+      });
+    }, "run");
+    const next = this.queue.then(run, run);
+    this.queue = next.catch(() => void 0);
+    return next;
+  }
+  kill(child) {
+    if (!child)
+      return;
+    this.killed.add(child);
+    if (this.current === child) {
+      this.current = void 0;
+      this.ready = void 0;
+    }
+    child.kill("SIGKILL");
+  }
+  /** Stop the child now, without closing the host: the next parse starts a new one. */
+  killChild() {
+    this.kill(this.current);
+  }
+  /** Close the host: nothing parses after this, and a parse in flight is cancelled. */
+  dispose() {
+    this.disposed = true;
+    this.kill(this.current);
+  }
+};
+function abortError() {
+  const err = new Error("The operation was cancelled.");
+  err.name = "AbortError";
+  return err;
+}
+__name(abortError, "abortError");
+
+// ../analysis/dist/lines.js
+function lineStarts(text) {
+  let count = 1;
+  for (let i = text.indexOf("\n"); i !== -1; i = text.indexOf("\n", i + 1))
+    count++;
+  const starts = new Uint32Array(count);
+  let n = 1;
+  for (let i = text.indexOf("\n"); i !== -1; i = text.indexOf("\n", i + 1))
+    starts[n++] = i + 1;
+  return starts;
+}
+__name(lineStarts, "lineStarts");
+function position(starts, offset) {
+  let lo = 0;
+  let hi = starts.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (starts[mid] <= offset)
+      lo = mid;
+    else
+      hi = mid - 1;
+  }
+  return { line: lo + 1, column: offset - starts[lo] + 1 };
+}
+__name(position, "position");
+function offsetOf(starts, chars, line, column) {
+  if (!Number.isInteger(line) || line < 1 || line > starts.length) {
+    return { error: `line ${line} is outside the file, which has ${starts.length} line(s)` };
+  }
+  const lineStart = starts[line - 1];
+  const lineEnd = line < starts.length ? starts[line] - 1 : chars;
+  const width = lineEnd - lineStart;
+  if (!Number.isInteger(column) || column < 1 || column - 1 > width) {
+    return {
+      error: `column ${column} is outside line ${line}, which is ${width} character(s) wide (columns are one-based UTF-16 units)`
+    };
+  }
+  return { offset: lineStart + column - 1 };
+}
+__name(offsetOf, "offsetOf");
+function encodeLineStarts(starts) {
+  return new Uint8Array(starts.buffer.slice(starts.byteOffset, starts.byteOffset + starts.byteLength));
+}
+__name(encodeLineStarts, "encodeLineStarts");
+function decodeLineStarts(blob) {
+  return new Uint32Array(blob.slice().buffer);
+}
+__name(decodeLineStarts, "decodeLineStarts");
+
+// ../analysis/dist/store.js
+import { mkdirSync, rmSync } from "node:fs";
+import { join as join2 } from "node:path";
+import { setTimeout as sleep } from "node:timers/promises";
+
+// ../analysis/dist/cache-key.js
+import { createHash } from "node:crypto";
+function cacheKey(root) {
+  return createHash("sha256").update(root).digest("hex").slice(0, 16);
+}
+__name(cacheKey, "cacheKey");
+
+// ../analysis/dist/evict.js
+import { readdir, rm, stat as stat2, utimes } from "node:fs/promises";
+import { join } from "node:path";
+var DEFAULT_CACHE_MAX_AGE_DAYS = 30;
+var DEFAULT_CACHE_MAX_BYTES = 2 * 1024 * 1024 * 1024;
+var RECENT_MS = 60 * 60 * 1e3;
+async function touchCache(location) {
+  const now = /* @__PURE__ */ new Date();
+  await utimes(location, now, now).catch(() => void 0);
+}
+__name(touchCache, "touchCache");
+async function evictCaches(cacheDir, keep, policy, now = Date.now()) {
+  const removed = [];
+  let names;
+  try {
+    names = (await readdir(cacheDir)).filter((n) => n.endsWith(".sqlite"));
+  } catch {
+    return removed;
+  }
+  const entries = [];
+  for (const name of names) {
+    try {
+      const main = await stat2(join(cacheDir, name));
+      const wal = await stat2(join(cacheDir, `${name}-wal`)).catch(() => void 0);
+      entries.push({ name, mtime: main.mtimeMs, bytes: main.size + (wal?.size ?? 0) });
+    } catch {
+    }
+  }
+  const drop = /* @__PURE__ */ __name(async (name) => {
+    for (const suffix of ["", "-wal", "-shm"])
+      await rm(join(cacheDir, `${name}${suffix}`), { force: true }).catch(() => void 0);
+    removed.push(name);
+  }, "drop");
+  const evictable = /* @__PURE__ */ __name((e) => e.name !== keep && now - e.mtime > RECENT_MS, "evictable");
+  const cutoff = now - policy.maxAgeDays * 24 * 60 * 60 * 1e3;
+  let live = entries;
+  for (const e of entries) {
+    if (evictable(e) && e.mtime < cutoff)
+      await drop(e.name);
+  }
+  live = entries.filter((e) => !removed.includes(e.name));
+  let total = live.reduce((sum, e) => sum + e.bytes, 0);
+  for (const e of [...live].sort((a, b) => a.mtime - b.mtime)) {
+    if (total <= policy.maxBytes)
+      break;
+    if (!evictable(e))
+      continue;
+    await drop(e.name);
+    total -= e.bytes;
+  }
+  return removed;
+}
+__name(evictCaches, "evictCaches");
+
+// ../analysis/dist/store.js
+var SCHEMA_VERSION = 1;
+var sqlite;
+async function loadSqlite() {
+  sqlite ??= import("node:sqlite").catch(() => void 0);
+  return await sqlite;
+}
+__name(loadSqlite, "loadSqlite");
+var TABLES = `
+CREATE TABLE IF NOT EXISTS meta(key TEXT PRIMARY KEY, value TEXT NOT NULL);
+CREATE TABLE IF NOT EXISTS files(
+	id INTEGER PRIMARY KEY, path TEXT NOT NULL UNIQUE, chars INTEGER NOT NULL, lang TEXT NOT NULL,
+	parse_errors INTEGER NOT NULL, line_starts BLOB NOT NULL, size INTEGER NOT NULL,
+	mtime_ms REAL NOT NULL, hash TEXT NOT NULL);
+CREATE TABLE IF NOT EXISTS dirs(path TEXT PRIMARY KEY, mtime_ms REAL NOT NULL);
+CREATE TABLE IF NOT EXISTS functions(
+	id INTEGER PRIMARY KEY, file_id INTEGER NOT NULL, parent_id INTEGER, kind TEXT NOT NULL, name TEXT,
+	start INTEGER NOT NULL, "end" INTEGER NOT NULL, sline INTEGER NOT NULL, eline INTEGER NOT NULL);
+CREATE TABLE IF NOT EXISTS strings(
+	id INTEGER PRIMARY KEY, file_id INTEGER NOT NULL, fn_id INTEGER, start INTEGER NOT NULL,
+	"end" INTEGER NOT NULL, kind TEXT NOT NULL, value TEXT NOT NULL);
+CREATE TABLE IF NOT EXISTS calls(
+	file_id INTEGER NOT NULL, fn_id INTEGER, start INTEGER NOT NULL, "end" INTEGER NOT NULL,
+	callee TEXT NOT NULL, kind TEXT NOT NULL, nargs INTEGER NOT NULL);
+CREATE TABLE IF NOT EXISTS imports(
+	file_id INTEGER NOT NULL, kind TEXT NOT NULL, source TEXT NOT NULL, names TEXT NOT NULL, start INTEGER NOT NULL);
+CREATE TABLE IF NOT EXISTS exports(
+	file_id INTEGER NOT NULL, kind TEXT NOT NULL, name TEXT NOT NULL, source TEXT, start INTEGER NOT NULL);
+`;
+var SECONDARY_INDEXES = `
+CREATE INDEX IF NOT EXISTS fn_file_start ON functions(file_id, start);
+CREATE INDEX IF NOT EXISTS fn_name ON functions(name);
+CREATE INDEX IF NOT EXISTS str_fn ON strings(fn_id);
+CREATE INDEX IF NOT EXISTS str_file ON strings(file_id, start);
+CREATE INDEX IF NOT EXISTS call_callee ON calls(callee);
+CREATE INDEX IF NOT EXISTS call_file ON calls(file_id, start);
+CREATE INDEX IF NOT EXISTS imp_file ON imports(file_id);
+CREATE INDEX IF NOT EXISTS exp_file ON exports(file_id);
+`;
+var CRASHED = -1;
+var WRITE_LOCK_WAIT_MS = 12e4;
+function isBusy(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return /database is locked|database table is locked|SQLITE_BUSY|SQLITE_LOCKED/i.test(message);
+}
+__name(isBusy, "isBusy");
+function isCorrupt(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return /file is not a database|database disk image is malformed|SQLITE_NOTADB|SQLITE_CORRUPT/i.test(message);
+}
+__name(isCorrupt, "isCorrupt");
+var Store = class _Store {
+  static {
+    __name(this, "Store");
+  }
+  db;
+  persisted;
+  fts;
+  chain = Promise.resolve();
+  cache = /* @__PURE__ */ new Map();
+  constructor(db, persisted, fts) {
+    this.db = db;
+    this.persisted = persisted;
+    this.fts = fts;
+  }
+  /**
+   * Open (or create) the database for `root`.
+   *
+   * `cacheDir` of `undefined` is an in-memory database. A directory that
+   * cannot be written falls back to memory rather than failing the tool: an
+   * index that does not persist is slower next launch, not wrong.
+   */
+  static async open(root, cacheDir, allowFts = true, eviction) {
+    const mod = await loadSqlite();
+    if (!mod)
+      return void 0;
+    const fts = allowFts && probeFts(mod);
+    if (cacheDir !== void 0) {
+      const location = join2(cacheDir, `${cacheKey(root)}-v${SCHEMA_VERSION}-${fts ? "fts" : "scan"}.sqlite`);
+      const deadline = Date.now() + WRITE_LOCK_WAIT_MS;
+      let corruptSeen = false;
+      for (; ; ) {
+        try {
+          const store = _Store.openAt(mod, root, location, fts);
+          await touchCache(location);
+          if (eviction)
+            void evictCaches(cacheDir, location.slice(cacheDir.length + 1), eviction);
+          return store;
+        } catch (err) {
+          if (isBusy(err) && Date.now() < deadline) {
+            await sleep(50);
+            continue;
+          }
+          if (isCorrupt(err) && !corruptSeen) {
+            corruptSeen = true;
+            for (const suffix of ["", "-wal", "-shm"])
+              rmSync(`${location}${suffix}`, { force: true });
+            continue;
+          }
+          break;
+        }
+      }
+    }
+    return _Store.openAt(mod, root, void 0, fts);
+  }
+  static openAt(mod, root, location, fts) {
+    if (location !== void 0)
+      mkdirSync(join2(location, ".."), { recursive: true, mode: 448 });
+    const db = new mod.DatabaseSync(location ?? ":memory:");
+    try {
+      db.exec("PRAGMA busy_timeout=250");
+      if (location !== void 0)
+        db.exec("PRAGMA journal_mode=WAL; PRAGMA synchronous=NORMAL;");
+      const existing = readRoot(db);
+      if (existing !== void 0) {
+        if (existing !== root)
+          throw new Error("cache file belongs to a different root");
+        return new _Store(db, location !== void 0, fts);
+      }
+      db.exec("BEGIN IMMEDIATE");
+      try {
+        db.exec(TABLES);
+        if (fts) {
+          db.exec("CREATE VIRTUAL TABLE IF NOT EXISTS lit USING fts5(value, content='strings', content_rowid='id', tokenize='trigram');");
+        }
+        const put = db.prepare("INSERT OR IGNORE INTO meta(key, value) VALUES(?, ?)");
+        put.run("schema", String(SCHEMA_VERSION));
+        put.run("root", root);
+        put.run("fts", fts ? "1" : "0");
+        put.run("generation", "0");
+        put.run("next_fn_id", "1");
+        put.run("covered", "[]");
+        const stored = db.prepare("SELECT value FROM meta WHERE key = 'root'").get();
+        if (stored.value !== root)
+          throw new Error("cache file belongs to a different root");
+        db.exec("COMMIT");
+      } catch (err) {
+        try {
+          db.exec("ROLLBACK");
+        } catch {
+        }
+        throw err;
+      }
+    } catch (err) {
+      db.close();
+      throw err;
+    }
+    return new _Store(db, location !== void 0, fts);
+  }
+  /** Run `work` with this process's use of the database to itself; calls queue in order. */
+  run(work) {
+    const next = this.chain.then(work, work);
+    this.chain = next.catch(() => void 0);
+    return next;
+  }
+  /**
+   * Take the write lock, waiting for another process if it holds it.
+   *
+   * `BEGIN IMMEDIATE`: a deferred `BEGIN` reads first and fails with
+   * "database is locked" at the first write when another process got there,
+   * which is the shape the concurrent-refresh failures took.
+   */
+  async begin(signal) {
+    const deadline = Date.now() + WRITE_LOCK_WAIT_MS;
+    for (; ; ) {
+      if (signal?.aborted)
+        throw abortError();
+      try {
+        this.db.exec("BEGIN IMMEDIATE");
+        return;
+      } catch (err) {
+        if (!isBusy(err) || Date.now() >= deadline)
+          throw err;
+        await sleep(40, void 0, signal ? { signal } : void 0).catch(() => {
+          throw abortError();
+        });
+      }
+    }
+  }
+  commit() {
+    this.db.exec("COMMIT");
+  }
+  rollback() {
+    try {
+      this.db.exec("ROLLBACK");
+    } catch {
+    }
+  }
+  prepare(sql) {
+    let stmt = this.cache.get(sql);
+    if (!stmt) {
+      stmt = this.db.prepare(sql);
+      this.cache.set(sql, stmt);
+    }
+    return stmt;
+  }
+  all(sql, ...params) {
+    return this.prepare(sql).all(...params);
+  }
+  get(sql, ...params) {
+    return this.prepare(sql).get(...params);
+  }
+  exec(sql) {
+    this.db.exec(sql);
+  }
+  meta(key) {
+    const row = this.get("SELECT value FROM meta WHERE key = ?", key);
+    return row ? String(row.value) : void 0;
+  }
+  setMeta(key, value) {
+    this.prepare("INSERT OR REPLACE INTO meta(key, value) VALUES(?, ?)").run(key, value);
+  }
+  bumpGeneration() {
+    const next = Number(this.meta("generation") ?? "0") + 1;
+    this.setMeta("generation", String(next));
+    return next;
+  }
+  ensureIndexes() {
+    this.db.exec(SECONDARY_INDEXES);
+  }
+  /** Every stored file at or under `scope` (a relative path; empty is all), keyed by path. */
+  storedFiles(scope) {
+    const map = /* @__PURE__ */ new Map();
+    const rows = scope === "" ? this.all("SELECT id, path, size, mtime_ms, hash FROM files") : this.all("SELECT id, path, size, mtime_ms, hash FROM files WHERE path = ? OR (path >= ? AND path < ?)", scope, `${scope}/`, `${scope}0`);
+    for (const r of rows) {
+      map.set(String(r.path), {
+        id: Number(r.id),
+        size: Number(r.size),
+        mtimeMs: Number(r.mtime_ms),
+        hash: String(r.hash)
+      });
+    }
+    return map;
+  }
+  /** Remove a file and every row that hangs off it. */
+  removeFile(fileId) {
+    if (this.fts) {
+      this.prepare("INSERT INTO lit(lit, rowid, value) SELECT 'delete', id, value FROM strings WHERE file_id = ? AND length(value) >= 3").run(fileId);
+    }
+    for (const table of ["strings", "calls", "functions", "imports", "exports"]) {
+      this.prepare(`DELETE FROM ${table} WHERE file_id = ?`).run(fileId);
+    }
+    this.prepare("DELETE FROM files WHERE id = ?").run(fileId);
+  }
+  removeByPath(path) {
+    const row = this.get("SELECT id FROM files WHERE path = ?", path);
+    if (!row)
+      return false;
+    this.removeFile(Number(row.id));
+    return true;
+  }
+  /**
+   * Write one parsed file and return how many function ids it used.
+   *
+   * Must run inside a transaction that holds the write lock: the first id is
+   * read from `meta` here, so two processes can never hand out the same one,
+   * and a row another process wrote for this path in the meantime is replaced
+   * rather than colliding with it.
+   */
+  writeFile(record) {
+    const { rows, lineStarts: lineStarts2 } = record;
+    this.removeByPath(record.path);
+    const base = Number(this.meta("next_fn_id") ?? "1");
+    const lineOf = /* @__PURE__ */ __name((offset) => {
+      let lo = 0;
+      let hi = lineStarts2.length - 1;
+      while (lo < hi) {
+        const mid = lo + hi + 1 >> 1;
+        if (lineStarts2[mid] <= offset)
+          lo = mid;
+        else
+          hi = mid - 1;
+      }
+      return lo + 1;
+    }, "lineOf");
+    const result = this.prepare("INSERT INTO files(path, chars, lang, parse_errors, line_starts, size, mtime_ms, hash) VALUES(?,?,?,?,?,?,?,?)").run(record.path, record.chars, record.lang, record.parseErrors, encodeLineStarts(lineStarts2), record.size, record.mtimeMs, record.hash);
+    const id = Number(result.lastInsertRowid);
+    const remap = /* @__PURE__ */ __name((local) => local === null ? null : base + local, "remap");
+    const insFn = this.prepare("INSERT INTO functions VALUES(?,?,?,?,?,?,?,?,?)");
+    for (const f of rows.functions) {
+      insFn.run(base + f.id, id, remap(f.parentId), f.kind, f.name, f.start, f.end, lineOf(f.start), lineOf(f.end));
+    }
+    const insStr = this.prepare('INSERT INTO strings(file_id, fn_id, start, "end", kind, value) VALUES(?,?,?,?,?,?)');
+    const insLit = this.fts ? this.prepare("INSERT INTO lit(rowid, value) VALUES(?, ?)") : void 0;
+    for (const s of rows.strings) {
+      const r = insStr.run(id, remap(s.fnId), s.start, s.end, s.kind, s.value);
+      if (insLit && s.value.length >= 3)
+        insLit.run(Number(r.lastInsertRowid), s.value);
+    }
+    const insCall = this.prepare("INSERT INTO calls VALUES(?,?,?,?,?,?,?)");
+    for (const c of rows.calls)
+      insCall.run(id, remap(c.fnId), c.start, c.end, c.callee, c.kind, c.nargs);
+    const insImp = this.prepare("INSERT INTO imports VALUES(?,?,?,?,?)");
+    for (const i of rows.imports)
+      insImp.run(id, i.kind, i.source, i.names, i.start);
+    const insExp = this.prepare("INSERT INTO exports VALUES(?,?,?,?,?)");
+    for (const e of rows.exports)
+      insExp.run(id, e.kind, e.name, e.source, e.start);
+    this.setMeta("next_fn_id", String(base + rows.functions.length));
+  }
+  close() {
+    this.cache.clear();
+    try {
+      this.db.close();
+    } catch {
+    }
+  }
+};
+function readRoot(db) {
+  try {
+    const row = db.prepare("SELECT value FROM meta WHERE key = 'root'").get();
+    return row?.value;
+  } catch {
+    return void 0;
+  }
+}
+__name(readRoot, "readRoot");
+function probeFts(mod) {
+  const db = new mod.DatabaseSync(":memory:");
+  try {
+    db.exec("CREATE VIRTUAL TABLE t USING fts5(x, tokenize='trigram')");
+    return true;
+  } catch {
+    return false;
+  } finally {
+    db.close();
+  }
+}
+__name(probeFts, "probeFts");
+
+// ../analysis/dist/indexer.js
+var DEFAULT_IGNORED_DIRS = [
+  "node_modules",
+  ".git",
+  ".hg",
+  ".svn",
+  ".namzu",
+  ".turbo",
+  ".cache",
+  "coverage"
+];
+var DEFAULT_MAX_FILE_BYTES = 32 * 1024 * 1024;
+var DEFAULT_MAX_FILES = 15e4;
+var DEFAULT_MAX_DIRECTORIES = 2e4;
+var DEFAULT_MAX_MILLIS = 45e3;
+var SLICE_MS = 20;
+var NAMED_LIMIT = 20;
+var decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+function decodeText(buffer) {
+  const head = Math.min(buffer.length, 8192);
+  for (let i = 0; i < head; i++)
+    if (buffer[i] === 0)
+      return void 0;
+  try {
+    return decoder.decode(buffer);
+  } catch {
+    return void 0;
+  }
+}
+__name(decodeText, "decodeText");
+function hashOf(buffer) {
+  return createHash2("sha1").update(buffer).digest("hex");
+}
+__name(hashOf, "hashOf");
+function toRel(root, abs) {
+  if (abs === root)
+    return "";
+  const prefix = root.endsWith(sep3) ? root : root + sep3;
+  if (!abs.startsWith(prefix))
+    return void 0;
+  return abs.slice(prefix.length).split(sep3).join("/");
+}
+__name(toRel, "toRel");
+function checkAbort(signal) {
+  if (signal?.aborted)
+    throw abortError();
+}
+__name(checkAbort, "checkAbort");
+function overTime(b) {
+  return performance.now() - b.started > b.options.maxMillis;
+}
+__name(overTime, "overTime");
+async function collect(root, start, b, skip) {
+  const walk = { files: [], dirs: [], truncated: void 0 };
+  const ignored = new Set(b.options.ignoreDirs);
+  let first;
+  try {
+    first = await lstat2(start);
+  } catch {
+    return walk;
+  }
+  const startRel = toRel(root, start) ?? "";
+  if (first.isSymbolicLink()) {
+    skip("symbolic link");
+    return walk;
+  }
+  if (first.isFile()) {
+    if (languageOf(start) !== void 0 && !isDeclarationFile(start))
+      walk.files.push({ rel: startRel, abs: start });
+    return walk;
+  }
+  if (!first.isDirectory())
+    return walk;
+  const pending = [{ abs: start, rel: startRel }];
+  let lastYield = performance.now();
+  let visited = 0;
+  while (pending.length > 0) {
+    checkAbort(b.signal);
+    if (visited >= b.options.maxDirectories) {
+      walk.truncated = `stopped after walking ${visited.toLocaleString("en-US")} directories`;
+      break;
+    }
+    if (overTime(b)) {
+      walk.truncated = `stopped after ${Math.round(b.options.maxMillis / 1e3)} seconds`;
+      break;
+    }
+    const dir = pending.pop();
+    visited++;
+    let entries;
+    try {
+      entries = await readdir2(dir.abs, { withFileTypes: true });
+      walk.dirs.push({ rel: dir.rel, mtimeMs: (await lstat2(dir.abs)).mtimeMs });
+    } catch {
+      skip("unreadable directory");
+      continue;
+    }
+    entries.sort((x, y) => x.name < y.name ? -1 : x.name > y.name ? 1 : 0);
+    const subdirs = [];
+    for (const entry of entries) {
+      const rel = dir.rel === "" ? entry.name : `${dir.rel}/${entry.name}`;
+      if (entry.isSymbolicLink()) {
+        if (languageOf(entry.name) !== void 0)
+          skip("symbolic link");
+        continue;
+      }
+      if (entry.isDirectory()) {
+        if (!ignored.has(entry.name))
+          subdirs.push({ abs: join3(dir.abs, entry.name), rel });
+        continue;
+      }
+      if (!entry.isFile() || languageOf(entry.name) === void 0)
+        continue;
+      if (isDeclarationFile(entry.name)) {
+        skip("declaration file");
+        continue;
+      }
+      if (walk.files.length >= b.options.maxFiles) {
+        walk.truncated = `stopped at the ${b.options.maxFiles.toLocaleString("en-US")}-file limit`;
+        break;
+      }
+      walk.files.push({ rel, abs: join3(dir.abs, entry.name) });
+    }
+    for (let i = subdirs.length - 1; i >= 0; i--)
+      pending.push(subdirs[i]);
+    if (walk.truncated)
+      break;
+    if (performance.now() - lastYield > SLICE_MS) {
+      await nextTurn();
+      lastYield = performance.now();
+    }
+  }
+  walk.files.sort((x, y) => x.rel < y.rel ? -1 : x.rel > y.rel ? 1 : 0);
+  return walk;
+}
+__name(collect, "collect");
+function jsonList(store, key) {
+  try {
+    const parsed = JSON.parse(store.meta(key) ?? "[]");
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+__name(jsonList, "jsonList");
+function noteNamed(store, key, rel) {
+  const list = jsonList(store, key);
+  if (!list.includes(rel))
+    store.setMeta(key, JSON.stringify([...list, rel].slice(-NAMED_LIMIT)));
+}
+__name(noteNamed, "noteNamed");
+function unnote(store, key, rel) {
+  const list = jsonList(store, key);
+  if (list.includes(rel))
+    store.setMeta(key, JSON.stringify(list.filter((r) => r !== rel)));
+}
+__name(unnote, "unnote");
+var FLUSH_FILES = 50;
+var FLUSH_ROWS = 15e4;
+async function refreshIndex(store, root, scopeAbs, options, host, signal) {
+  const skippedReasons = {};
+  const skip = /* @__PURE__ */ __name((reason) => {
+    skippedReasons[reason] = (skippedReasons[reason] ?? 0) + 1;
+  }, "skip");
+  const budget = { started: performance.now(), options, signal };
+  const scopeRel = toRel(root, scopeAbs) ?? "";
+  try {
+    if (!isInside(root, await realpath2(scopeAbs))) {
+      skip("path outside the root");
+      return outcomeOf(store, skippedReasons, 0, 0, 0, false, void 0);
+    }
+  } catch {
+  }
+  const walk = await collect(root, scopeAbs, budget, skip);
+  let truncated = walk.truncated;
+  const stored = store.storedFiles(scopeRel);
+  const seen = new Set(walk.files.map((f) => f.rel));
+  let parsed = 0;
+  let unchanged = 0;
+  let removed = 0;
+  let changed = false;
+  let dirty = false;
+  let lastYield = performance.now();
+  let pending = [];
+  let pendingRows = 0;
+  const flush = /* @__PURE__ */ __name(async () => {
+    if (pending.length === 0 && !dirty)
+      return;
+    await store.begin();
+    try {
+      for (const write of pending)
+        write();
+      pending = [];
+      pendingRows = 0;
+      if (dirty) {
+        store.bumpGeneration();
+        dirty = false;
+      }
+      store.commit();
+    } catch (err) {
+      store.rollback();
+      throw err;
+    }
+  }, "flush");
+  const queue = /* @__PURE__ */ __name((write, rows = 0) => {
+    pending.push(write);
+    pendingRows += rows;
+    dirty = true;
+  }, "queue");
+  const dropStored = /* @__PURE__ */ __name((before, rel, violation) => {
+    if (!before)
+      return;
+    queue(() => {
+      store.removeFile(before.id);
+      if (violation)
+        noteNamed(store, "violations", rel);
+    });
+    changed = true;
+  }, "dropStored");
+  try {
+    if (scopeRel === "")
+      queue(() => store.setMeta("violations", "[]"));
+    for (const candidate of walk.files) {
+      checkAbort(signal);
+      if (overTime(budget)) {
+        truncated ??= `stopped after ${Math.round(options.maxMillis / 1e3)} seconds`;
+        break;
+      }
+      const before = stored.get(candidate.rel);
+      let lst;
+      try {
+        lst = await lstat2(candidate.abs);
+      } catch {
+        skip("unreadable");
+        continue;
+      }
+      if (!lst.isFile()) {
+        skip("replaced by a link or not a regular file");
+        dropStored(before, candidate.rel, true);
+        seen.delete(candidate.rel);
+        continue;
+      }
+      if (lst.size > options.maxFileBytes) {
+        skip(`over the ${Math.round(options.maxFileBytes / 1048576)} MiB size limit`);
+        dropStored(before, candidate.rel, false);
+        continue;
+      }
+      if (!options.force && before && before.size === lst.size && before.mtimeMs === lst.mtimeMs) {
+        unchanged++;
+        continue;
+      }
+      const read = await readRegular(root, candidate.abs);
+      if (!read.ok) {
+        if (read.why === "link" || read.why === "outside" || read.why === "not-file") {
+          skip("replaced by a link or not a regular file");
+          dropStored(before, candidate.rel, true);
+          seen.delete(candidate.rel);
+        } else
+          skip("unreadable");
+        continue;
+      }
+      const hash = hashOf(read.buffer);
+      if (!options.force && before && before.hash === hash) {
+        const { size, mtimeMs } = read.stat;
+        queue(() => {
+          store.prepare("UPDATE files SET size = ?, mtime_ms = ? WHERE id = ?").run(size, mtimeMs, before.id);
+        });
+        unchanged++;
+        continue;
+      }
+      const text = decodeText(read.buffer);
+      if (text === void 0) {
+        skip("binary or not UTF-8");
+        dropStored(before, candidate.rel, false);
+        continue;
+      }
+      const left = options.maxMillis - (performance.now() - budget.started);
+      const result = await host.parse({ rel: candidate.rel, abs: candidate.abs, text }, signal, Math.max(left, MIN_PARSE_MS));
+      const base = {
+        path: candidate.rel,
+        chars: text.length,
+        lang: languageOf(candidate.abs) ?? "js",
+        lineStarts: lineStarts(text),
+        size: read.stat.size,
+        mtimeMs: read.stat.mtimeMs,
+        hash
+      };
+      if (result.kind === "rows") {
+        const rowCount = result.rows.strings.length + result.rows.calls.length + result.rows.functions.length;
+        queue(() => {
+          store.writeFile({ ...base, parseErrors: result.parseErrors, rows: result.rows });
+          unnote(store, "crashed", candidate.rel);
+        }, rowCount);
+        parsed++;
+      } else if (result.kind === "crash") {
+        queue(() => {
+          store.writeFile({ ...base, parseErrors: CRASHED, rows: EMPTY_ROWS });
+          noteNamed(store, "crashed", candidate.rel);
+        });
+        skip("parser crashed");
+      } else {
+        queue(() => store.writeFile({ ...base, parseErrors: 1, rows: EMPTY_ROWS }));
+        skip("parser failure");
+      }
+      changed = true;
+      if (pending.length >= FLUSH_FILES || pendingRows >= FLUSH_ROWS)
+        await flush();
+      if (performance.now() - lastYield > SLICE_MS) {
+        await nextTurn();
+        lastYield = performance.now();
+      }
+    }
+    if (!walk.truncated) {
+      for (const [path, file] of stored) {
+        if (seen.has(path))
+          continue;
+        const gone = await lstat2(join3(root, ...path.split("/"))).catch(() => void 0);
+        queue(() => {
+          store.removeFile(file.id);
+          if (gone?.isSymbolicLink())
+            noteNamed(store, "violations", path);
+        });
+        removed++;
+        changed = true;
+      }
+    }
+    queue(() => {
+      if (!walk.truncated)
+        recordDirs(store, scopeRel, walk.dirs);
+      store.ensureIndexes();
+      recordCoverage(store, scopeRel, skippedReasons, truncated);
+    });
+    await flush();
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      try {
+        queue(() => recordCoverage(store, scopeRel, skippedReasons, "was cancelled before it finished", true));
+        dirty = true;
+        await flush();
+      } catch {
+        store.rollback();
+      }
+    } else {
+      store.rollback();
+    }
+    throw err;
+  }
+  return outcomeOf(store, skippedReasons, parsed, unchanged, removed, changed, truncated);
+}
+__name(refreshIndex, "refreshIndex");
+function recordDirs(store, scopeRel, dirs) {
+  if (scopeRel === "")
+    store.exec("DELETE FROM dirs");
+  else
+    store.prepare("DELETE FROM dirs WHERE path = ? OR (path >= ? AND path < ?)").run(scopeRel, `${scopeRel}/`, `${scopeRel}0`);
+  const insDir = store.prepare("INSERT OR REPLACE INTO dirs(path, mtime_ms) VALUES(?, ?)");
+  for (const d of dirs)
+    insDir.run(d.rel, d.mtimeMs);
+}
+__name(recordDirs, "recordDirs");
+function outcomeOf(store, skippedReasons, parsed, unchanged, removed, changed, truncated) {
+  const counts = store.get("SELECT count(*) AS indexed, coalesce(sum(parse_errors > 0), 0) AS bad FROM files");
+  return {
+    parsed,
+    unchanged,
+    removed,
+    skipped: Object.values(skippedReasons).reduce((a, b) => a + b, 0),
+    skippedReasons,
+    withParseErrors: Number(counts.bad),
+    indexed: Number(counts.indexed),
+    changed,
+    ...truncated ? { truncated } : {}
+  };
+}
+__name(outcomeOf, "outcomeOf");
+var MAX_COVERED_ENTRIES = 200;
+function readCovered(store) {
+  try {
+    const parsed = JSON.parse(store.meta("covered") ?? "[]");
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+__name(readCovered, "readCovered");
+function coveringEntry(covered, scopeRel) {
+  let best;
+  for (const e of covered) {
+    if (!(e.s === "" || e.s === scopeRel || scopeRel.startsWith(`${e.s}/`)))
+      continue;
+    if (best === void 0 || e.s.length > best.s.length)
+      best = e;
+  }
+  return best;
+}
+__name(coveringEntry, "coveringEntry");
+function recordCoverage(store, scopeRel, skipped, truncated, cancelled = false) {
+  const mine = {
+    s: scopeRel,
+    c: truncated ? 0 : 1,
+    ...truncated ? { r: truncated } : {},
+    ...cancelled ? { k: "cancel" } : {}
+  };
+  let covered = readCovered(store);
+  if (scopeRel === "") {
+    covered = [mine];
+    store.setMeta("skipped", JSON.stringify({ "": skipped }));
+  } else {
+    const without = covered.filter((e) => e.s !== scopeRel);
+    covered = without.length < MAX_COVERED_ENTRIES ? [...without, mine] : without;
+    let all = {};
+    try {
+      all = JSON.parse(store.meta("skipped") ?? "{}");
+    } catch {
+      all = {};
+    }
+    all[scopeRel] = skipped;
+    store.setMeta("skipped", JSON.stringify(all));
+  }
+  store.setMeta("covered", JSON.stringify(covered));
+  store.setMeta("refreshed_at", (/* @__PURE__ */ new Date()).toISOString());
+}
+__name(recordCoverage, "recordCoverage");
+
+// ../analysis/dist/context.js
+async function refreshFile(env, rel) {
+  await refreshIndex(env.store, env.root, join4(env.root, ...rel.split("/")), { ...env.options, force: false }, env.host, env.signal);
+}
+__name(refreshFile, "refreshFile");
+var DEFAULT_LIMIT = 50;
+var MAX_LIMIT = 200;
+var DEFAULT_MAX_CHARS = 2e4;
+var MIN_MAX_CHARS = 200;
+var MAX_MAX_CHARS = 2e5;
+var PREVIEW_CHARS = 200;
+function clampLimit(limit) {
+  if (limit === void 0 || !Number.isFinite(limit))
+    return DEFAULT_LIMIT;
+  return Math.max(1, Math.min(MAX_LIMIT, Math.floor(limit)));
+}
+__name(clampLimit, "clampLimit");
+function clampChars(max) {
+  if (max === void 0 || !Number.isFinite(max))
+    return DEFAULT_MAX_CHARS;
+  return Math.max(MIN_MAX_CHARS, Math.min(MAX_MAX_CHARS, Math.floor(max)));
+}
+__name(clampChars, "clampChars");
+function fingerprint(parts) {
+  return createHash3("sha1").update(JSON.stringify(parts)).digest("hex").slice(0, 10);
+}
+__name(fingerprint, "fingerprint");
+function encodeCursor(body) {
+  return Buffer.from(JSON.stringify(body)).toString("base64url");
+}
+__name(encodeCursor, "encodeCursor");
+function decodeCursor(cursor, generation, q) {
+  if (cursor === void 0 || cursor === "")
+    return { offset: 0 };
+  let body;
+  try {
+    body = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+    if (!Number.isInteger(body.o) || body.o < 0 || !Number.isInteger(body.g) || typeof body.q !== "string") {
+      throw new Error("shape");
+    }
+  } catch {
+    return { error: "The cursor is not one this index issued. Repeat the query without it." };
+  }
+  if (body.q !== q) {
+    return { error: "The cursor belongs to a different query. Repeat the query without it." };
+  }
+  if (body.g !== generation) {
+    return {
+      error: "The index changed since that page was produced, so its position no longer means anything. Repeat the query without a cursor."
+    };
+  }
+  return { offset: body.o };
+}
+__name(decodeCursor, "decodeCursor");
+var StaleIndexError = class extends Error {
+  static {
+    __name(this, "StaleIndexError");
+  }
+  name = "StaleIndexError";
+};
+var Files = class {
+  static {
+    __name(this, "Files");
+  }
+  store;
+  root;
+  byId = /* @__PURE__ */ new Map();
+  constructor(store, root) {
+    this.store = store;
+    this.root = root;
+  }
+  from(row) {
+    const rel = String(row.path);
+    return {
+      id: Number(row.id),
+      rel,
+      abs: join4(this.root, ...rel.split("/")),
+      chars: Number(row.chars),
+      parseErrors: Number(row.parse_errors),
+      size: Number(row.size),
+      mtimeMs: Number(row.mtime_ms),
+      hash: String(row.hash),
+      starts: decodeLineStarts(row.line_starts)
+    };
+  }
+  byIdOrThrow(id) {
+    let info = this.byId.get(id);
+    if (!info) {
+      const row = this.store.get("SELECT * FROM files WHERE id = ?", id);
+      if (!row)
+        throw new StaleIndexError(`file ${id} is not in the index`);
+      info = this.from(row);
+      this.byId.set(id, info);
+    }
+    return info;
+  }
+  byPath(rel) {
+    const row = this.store.get("SELECT * FROM files WHERE path = ?", rel);
+    if (!row)
+      return void 0;
+    const info = this.from(row);
+    this.byId.set(info.id, info);
+    return info;
+  }
+  forget(id) {
+    this.byId.delete(id);
+  }
+};
+async function checkFreshness(store, files, root, candidates) {
+  const marks = /* @__PURE__ */ new Map();
+  const dropped = [];
+  for (const id of new Set(candidates)) {
+    const info = files.byIdOrThrow(id);
+    const condition = await conditionOf(root, info.abs, info);
+    if (condition === "changed" || condition === "deleted")
+      marks.set(id, condition);
+    else if (condition === "violation")
+      dropped.push(info.rel);
+  }
+  if (dropped.length > 0)
+    await dropFiles(store, files, dropped);
+  return { marks, dropped };
+}
+__name(checkFreshness, "checkFreshness");
+async function dropFiles(store, files, rels) {
+  await store.begin();
+  try {
+    for (const rel of rels) {
+      const info = files.byPath(rel);
+      if (info) {
+        store.removeFile(info.id);
+        files.forget(info.id);
+      }
+      noteNamed(store, "violations", rel);
+    }
+    store.bumpGeneration();
+    store.commit();
+  } catch (err) {
+    store.rollback();
+    throw err;
+  }
+}
+__name(dropFiles, "dropFiles");
+function markReasons(marks) {
+  const reasons = [];
+  const changed = [...marks.values()].filter((m) => m === "changed").length;
+  const deleted = marks.size - changed;
+  if (changed > 0) {
+    reasons.push(`${changed} file(s) changed on disk since they were indexed; positions from them may be off. Run the index operation to refresh`);
+  }
+  if (deleted > 0) {
+    reasons.push(`${deleted} file(s) behind these results were deleted since they were indexed`);
+  }
+  return reasons;
+}
+__name(markReasons, "markReasons");
+async function readVerified(env, files, info, options) {
+  const { store, root } = env;
+  const read = await readRegular(root, info.abs);
+  if (!read.ok) {
+    if (read.why === "link" || read.why === "outside" || read.why === "not-file") {
+      await dropFiles(store, files, [info.rel]);
+      return {
+        error: `${info.rel} is no longer a regular file inside the indexed root (it is a link or resolves elsewhere), so it was dropped from the index and nothing was read from it.`
+      };
+    }
+    await refreshFile(env, info.rel);
+    files.forget(info.id);
+    return { error: `${info.rel} no longer exists, so nothing can be read from it.` };
+  }
+  if (hashOf(read.buffer) === info.hash) {
+    const text2 = decodeText(read.buffer);
+    if (text2 === void 0)
+      return { error: `${info.rel} is no longer readable as text.` };
+    return { info, text: text2, refreshed: false };
+  }
+  await refreshFile(env, info.rel);
+  files.forget(info.id);
+  if (!options.refresh) {
+    return {
+      error: `${info.rel} changed since it was indexed, and function ids are re-issued when a file is re-read. The index has been refreshed; look the function up again.`
+    };
+  }
+  const next = files.byPath(info.rel);
+  if (!next)
+    return { error: `${info.rel} changed and can no longer be indexed.` };
+  const again = await readRegular(root, next.abs);
+  if (!again.ok)
+    return { error: `${info.rel} changed while it was being read.` };
+  const text = decodeText(again.buffer);
+  if (text === void 0)
+    return { error: `${info.rel} is not readable as text.` };
+  return { info: next, text, refreshed: true };
+}
+__name(readVerified, "readVerified");
+function toFunction(row, info) {
+  const start = Number(row.start);
+  const at = position(info.starts, start);
+  return {
+    id: Number(row.id),
+    name: row.name === null || row.name === void 0 ? null : String(row.name),
+    kind: String(row.kind),
+    path: info.abs,
+    line: at.line,
+    column: at.column,
+    endLine: Number(row.eline),
+    start,
+    end: Number(row.end)
+  };
+}
+__name(toFunction, "toFunction");
+function parentsOf(store, files, parentId) {
+  const out = [];
+  let next = parentId;
+  while (next !== null && out.length < 64) {
+    const row = store.get("SELECT * FROM functions WHERE id = ?", next);
+    if (!row)
+      break;
+    out.push(toFunction(row, files.byIdOrThrow(Number(row.file_id))));
+    next = row.parent_id === null ? null : Number(row.parent_id);
+  }
+  return out;
+}
+__name(parentsOf, "parentsOf");
+function sliceOf(text, start, end, maxChars) {
+  const chars = end - start;
+  if (chars <= maxChars)
+    return { text: text.slice(start, end), chars, truncated: false };
+  let stop = start + maxChars;
+  const last = text.charCodeAt(stop - 1);
+  if (last >= 55296 && last <= 56319)
+    stop--;
+  return { text: text.slice(start, stop), chars, truncated: true };
+}
+__name(sliceOf, "sliceOf");
+var BENIGN_SKIPS = /* @__PURE__ */ new Set(["declaration file", "symbolic link"]);
+function listOf(store, key) {
+  try {
+    const v = JSON.parse(store.meta(key) ?? "[]");
+    return Array.isArray(v) ? v : [];
+  } catch {
+    return [];
+  }
+}
+__name(listOf, "listOf");
+function named(list) {
+  return list.length > 3 ? `${list.slice(0, 3).join(", ")} and ${list.length - 3} more` : list.join(", ");
+}
+__name(named, "named");
+function workspaceGaps(store, scopeRel = "") {
+  const reasons = [];
+  const covered = readCovered(store);
+  const covering = coveringEntry(covered, scopeRel);
+  if (scopeRel === "") {
+    if (!covering) {
+      const parts = covered.map((e) => e.s === "" ? "the root" : e.s);
+      reasons.push(`only part of the root is indexed (${named(parts)}); call the index operation with a path to cover another part`);
+    }
+  }
+  for (const e of covered) {
+    if (e.c === 0 && (scopeRel === "" || e === covering)) {
+      const where = e.s === "" ? "the root" : e.s;
+      reasons.push(e.k === "cancel" ? `indexing ${where} ${e.r}, so what was indexed is partial. Call the index operation to continue` : `indexing ${where} ${e.r ?? "stopped at a limit"}, so what was indexed is partial. Call the index operation with a narrower path to cover more`);
+    }
+  }
+  let skipped = {};
+  try {
+    skipped = JSON.parse(store.meta("skipped") ?? "{}");
+  } catch {
+    skipped = {};
+  }
+  const totals = /* @__PURE__ */ new Map();
+  for (const [scope, reasonsFor] of Object.entries(skipped)) {
+    if (scopeRel !== "" && scope !== "" && scope !== scopeRel && !scopeRel.startsWith(`${scope}/`))
+      continue;
+    for (const [why, n] of Object.entries(reasonsFor)) {
+      if (!BENIGN_SKIPS.has(why))
+        totals.set(why, (totals.get(why) ?? 0) + n);
+    }
+  }
+  if (totals.size > 0) {
+    reasons.push(`not indexed: ${[...totals].map(([why, n]) => `${n} ${why}`).join(", ")}`);
+  }
+  const crashed = listOf(store, "crashed");
+  if (crashed.length > 0) {
+    reasons.push(`the parser crashed on ${crashed.length} file(s) (${named(crashed)}), which are recorded with no rows`);
+  }
+  const violations = listOf(store, "violations");
+  if (violations.length > 0) {
+    reasons.push(`${violations.length} file(s) (${named(violations)}) became a link or resolved outside the root after they were indexed, and were dropped without being read`);
+  }
+  const bad = store.get("SELECT count(*) AS n FROM files WHERE parse_errors > 0");
+  if (bad && Number(bad.n) > 0) {
+    reasons.push(`${bad.n} file(s) had syntax errors; the parser kept whatever tree it could recover, often none, so rows from them may be missing`);
+  }
+  return reasons;
+}
+__name(workspaceGaps, "workspaceGaps");
+var NEW_FILE_CHECK_DIRS = 400;
+async function newFileReasons(store, root, scopeRel) {
+  const rows = scopeRel === "" ? store.all("SELECT path, mtime_ms FROM dirs ORDER BY path LIMIT ?", NEW_FILE_CHECK_DIRS + 1) : store.all("SELECT path, mtime_ms FROM dirs WHERE path = ? OR (path >= ? AND path < ?) ORDER BY path LIMIT ?", scopeRel, `${scopeRel}/`, `${scopeRel}0`, NEW_FILE_CHECK_DIRS + 1);
+  const changed = [];
+  for (const row of rows.slice(0, NEW_FILE_CHECK_DIRS)) {
+    const rel = String(row.path);
+    try {
+      const s = await lstat3(join4(root, ...rel.split("/").filter(Boolean)));
+      if (s.mtimeMs !== Number(row.mtime_ms))
+        changed.push(rel === "" ? "." : rel);
+    } catch {
+      changed.push(rel === "" ? "." : rel);
+    }
+  }
+  const reasons = [];
+  if (changed.length > 0) {
+    reasons.push(`${changed.length} director${changed.length === 1 ? "y" : "ies"} changed since the index was built (${named(changed)}), so files added there may be missing. Run the index operation to pick them up`);
+  }
+  if (rows.length > NEW_FILE_CHECK_DIRS) {
+    reasons.push(`only the first ${NEW_FILE_CHECK_DIRS} directories were checked for new files`);
+  }
+  return reasons;
+}
+__name(newFileReasons, "newFileReasons");
+function coverageOf(reasons) {
+  return reasons.length === 0 ? { status: "complete" } : { status: "partial", reasons };
+}
+__name(coverageOf, "coverageOf");
+
+// ../analysis/dist/provider.js
+var failed = /* @__PURE__ */ __name((error) => ({ kind: "failed", error }), "failed");
+function explain(err) {
+  if (err instanceof ParserUnavailableError)
+    return { kind: "unsupported", reason: err.message };
+  if (err instanceof Error && err.name === "AbortError") {
+    return failed("The call was cancelled. Anything already indexed is kept, so the next call continues from there.");
+  }
+  return failed(err instanceof Error ? err.message : String(err));
+}
+__name(explain, "explain");
+function createCodeAnalysisProvider(options = {}) {
+  const opened = /* @__PURE__ */ new Map();
+  const host = new ParserHost(options.hostScript, options.parserModule);
+  const lifetime = new AbortController();
+  const withLifetime = /* @__PURE__ */ __name((signal) => signal ? AbortSignal.any([lifetime.signal, signal]) : lifetime.signal, "withLifetime");
+  const indexOptions = /* @__PURE__ */ __name((force) => ({
+    ignoreDirs: options.ignoreDirs ?? DEFAULT_IGNORED_DIRS,
+    maxFileBytes: options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES,
+    maxFiles: options.maxFiles ?? DEFAULT_MAX_FILES,
+    maxDirectories: options.maxDirectories ?? DEFAULT_MAX_DIRECTORIES,
+    maxMillis: options.maxMillis ?? DEFAULT_MAX_MILLIS,
+    force
+  }), "indexOptions");
+  const envOf = /* @__PURE__ */ __name((o, signal, force = false) => ({
+    store: o.store,
+    root: o.root,
+    host,
+    options: indexOptions(force),
+    signal
+  }), "envOf");
+  async function open2(rootInput) {
+    let root;
+    try {
+      root = await realpath3(rootInput);
+      if (!(await stat3(root)).isDirectory())
+        return { error: `${rootInput} is not a directory.` };
+    } catch {
+      return { error: `${rootInput} does not exist.` };
+    }
+    let pending = opened.get(root);
+    if (!pending) {
+      pending = (async () => {
+        const store = await Store.open(root, options.cacheDir, options.substringIndex !== "off", {
+          maxAgeDays: options.cacheMaxAgeDays ?? DEFAULT_CACHE_MAX_AGE_DAYS,
+          maxBytes: options.cacheMaxBytes ?? DEFAULT_CACHE_MAX_BYTES
+        });
+        if (!store) {
+          return {
+            error: "node:sqlite is not available in this Node.js, so there is nowhere to keep an index. It needs Node 22.5 or newer."
+          };
+        }
+        return { store, root };
+      })();
+      opened.set(root, pending);
+      void pending.then((r) => {
+        if ("error" in r)
+          opened.delete(root);
+      }, () => opened.delete(root));
+    }
+    return await pending;
+  }
+  __name(open2, "open");
+  async function queued(o, signal, work) {
+    const guarded = o.store.run(async () => {
+      if (signal?.aborted)
+        throw abortError();
+      return await work();
+    });
+    if (!signal)
+      return await guarded.catch(explain);
+    let onAbort;
+    const cancelled = new Promise((resolve2) => {
+      onAbort = /* @__PURE__ */ __name(() => resolve2(explain(abortError())), "onAbort");
+      if (signal.aborted)
+        onAbort();
+      else
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+    try {
+      return await Promise.race([guarded.catch(explain), cancelled]);
+    } finally {
+      if (onAbort)
+        signal.removeEventListener("abort", onAbort);
+    }
+  }
+  __name(queued, "queued");
+  async function ensureCovered(env, scopeAbs) {
+    const rel = toRel(env.root, scopeAbs);
+    if (rel === void 0)
+      return void 0;
+    if (coveringEntry(readCovered(env.store), rel))
+      return void 0;
+    if (rel !== "" && !await lstat4(scopeAbs).then(() => true, () => false))
+      return void 0;
+    const started = performance.now();
+    const out = await refreshIndex(env.store, env.root, scopeAbs, env.options, env.host, env.signal);
+    return `${rel === "" ? `the index for ${env.root}` : `${rel}`} was not indexed and was built for this call: ${out.indexed} files in ${Math.round(performance.now() - started)} ms${out.truncated ? ` (${out.truncated})` : ""}`;
+  }
+  __name(ensureCovered, "ensureCovered");
+  const evidence = /* @__PURE__ */ __name((observed, inferred, gaps, built) => ({
+    observed: built ? [...observed, built] : observed,
+    inferred,
+    coverage: coverageOf(gaps)
+  }), "evidence");
+  function fileAt(o, files, abs) {
+    const rel = toRel(o.root, abs);
+    if (rel === void 0 || rel === "") {
+      return { error: `${abs} is not a file under the indexed root ${o.root}.` };
+    }
+    const info = files.byPath(rel);
+    if (info)
+      return info;
+    return {
+      error: `${rel} is not in the index. Only .js .mjs .cjs .jsx .ts .mts .cts .tsx files are indexed, and not declaration files, symbolic links, files in ignored directories (${(options.ignoreDirs ?? DEFAULT_IGNORED_DIRS).join(", ")}), or files that are binary, too large or unparseable.`
+    };
+  }
+  __name(fileAt, "fileAt");
+  function scopeSql(o, files, path, column) {
+    if (path === void 0)
+      return { sql: "", params: [], rel: "" };
+    const rel = toRel(o.root, path);
+    if (rel === void 0)
+      return { error: `${path} is outside the indexed root ${o.root}.` };
+    if (rel === "")
+      return { sql: "", params: [], rel };
+    const file = files.byPath(rel);
+    if (file)
+      return { sql: ` AND ${column} = ?`, params: [file.id], rel };
+    return {
+      sql: ` AND ${column} IN (SELECT id FROM files WHERE path >= ? AND path < ?)`,
+      params: [`${rel}/`, `${rel}0`],
+      rel
+    };
+  }
+  __name(scopeSql, "scopeSql");
+  async function withScope(rootInput, scopeAbs, signal, body) {
+    const o = await open2(rootInput);
+    if ("error" in o)
+      return { kind: "unsupported", reason: o.error };
+    const lifetimeSignal = withLifetime(signal);
+    return await queued(o, lifetimeSignal, async () => {
+      const env = envOf(o, lifetimeSignal);
+      const built = await ensureCovered(env, scopeAbs ?? o.root);
+      for (let attempt = 0; ; attempt++) {
+        try {
+          return await body(o, env, built);
+        } catch (err) {
+          if (!(err instanceof StaleIndexError) || attempt >= 4)
+            throw err;
+        }
+      }
+    });
+  }
+  __name(withScope, "withScope");
+  const provider = {
+    async index(request) {
+      const o = await open2(request.root);
+      if ("error" in o)
+        return { kind: "unsupported", reason: o.error };
+      const signal = withLifetime(request.signal);
+      return await queued(o, signal, async () => {
+        const started = performance.now();
+        const scopeAbs = request.scope ?? o.root;
+        const scopeRel = toRel(o.root, scopeAbs);
+        if (scopeRel === void 0)
+          return failed(`${scopeAbs} is outside the indexed root ${o.root}.`);
+        const out = await refreshIndex(o.store, o.root, scopeAbs, indexOptions(request.force === true), host, signal);
+        const count = /* @__PURE__ */ __name((table) => Number(o.store.get(`SELECT count(*) AS n FROM ${table}`).n), "count");
+        const summary = {
+          root: o.root,
+          persisted: o.store.persisted,
+          files: {
+            indexed: out.indexed,
+            parsed: out.parsed,
+            unchanged: out.unchanged,
+            removed: out.removed,
+            skipped: out.skipped,
+            withParseErrors: out.withParseErrors
+          },
+          skippedReasons: out.skippedReasons,
+          functions: count("functions"),
+          strings: count("strings"),
+          calls: count("calls"),
+          durationMs: Math.round(performance.now() - started),
+          ...out.truncated ? {
+            truncated: `Indexing ${scopeRel === "" ? "the root" : scopeRel} ${out.truncated}, so the index is partial. Index a narrower path to cover the rest; what was indexed is kept and answers queries now.`
+          } : {}
+        };
+        return {
+          kind: "ok",
+          value: summary,
+          evidence: evidence([
+            `walked ${scopeRel === "" ? o.root : scopeRel}: ${out.parsed} file(s) parsed, ${out.unchanged} unchanged by size, mtime or content hash, ${out.removed} removed`
+          ], o.store.fts ? [] : [
+            "this Node.js has no FTS5, so find_literal scans every literal instead of using a substring index; answers are the same, slower"
+          ], workspaceGaps(o.store, scopeRel))
+        };
+      });
+    },
+    findLiteral: /* @__PURE__ */ __name((request) => withScope(request.root, request.path, request.signal, async (o, _env, built) => {
+      const files = new Files(o.store, o.root);
+      const scope = scopeSql(o, files, request.path, "s.file_id");
+      if ("error" in scope)
+        return failed(scope.error);
+      const limit = clampLimit(request.limit);
+      const insensitive = request.caseSensitive === false;
+      const codePoints = Array.from(request.text).length;
+      const useFts = o.store.fts && codePoints >= 3;
+      const test = insensitive ? "instr(lower(s.value), lower(?)) > 0" : "instr(s.value, ?) > 0";
+      const prefilter = useFts ? " AND s.id IN (SELECT rowid FROM lit WHERE lit MATCH ?)" : "";
+      const where = `WHERE ${test}${prefilter}${scope.sql}`;
+      const params = [
+        request.text,
+        ...useFts ? [`"${request.text.replaceAll('"', '""')}"`] : [],
+        ...scope.params
+      ];
+      let offset = 0;
+      let rows = [];
+      let total = 0;
+      let generation = 0;
+      let q = "";
+      let fresh = await checkFreshness(o.store, files, o.root, []);
+      for (let attempt = 0; attempt < 3; attempt++) {
+        generation = Number(o.store.meta("generation") ?? "0");
+        q = fingerprint(["find", o.root, request.text, request.path ?? null, insensitive]);
+        const cursor = decodeCursor(request.cursor, generation, q);
+        if ("error" in cursor)
+          return failed(cursor.error);
+        offset = cursor.offset;
+        total = Number(o.store.get(`SELECT count(*) AS n FROM strings s ${where}`, ...params).n);
+        rows = o.store.all(`SELECT s.id, s.file_id, s.fn_id, s.start, s."end", s.kind, s.value FROM strings s ${where} ORDER BY s.id LIMIT ? OFFSET ?`, ...params, limit, offset);
+        fresh = await checkFreshness(o.store, files, o.root, rows.map((r) => Number(r.file_id)));
+        if (fresh.dropped.length === 0)
+          break;
+      }
+      const fnCache = /* @__PURE__ */ new Map();
+      const items = rows.map((r) => {
+        const fileId = Number(r.file_id);
+        const info = files.byIdOrThrow(fileId);
+        const at = position(info.starts, Number(r.start));
+        const value = String(r.value);
+        let fn;
+        if (r.fn_id !== null && r.fn_id !== void 0) {
+          const id = Number(r.fn_id);
+          fn = fnCache.get(id);
+          if (!fn) {
+            const fr = o.store.get("SELECT * FROM functions WHERE id = ?", id);
+            if (fr) {
+              fn = toFunction(fr, info);
+              fnCache.set(id, fn);
+            }
+          }
+        }
+        const mark = fresh.marks.get(fileId);
+        return {
+          path: info.abs,
+          line: at.line,
+          column: at.column,
+          start: Number(r.start),
+          end: Number(r.end),
+          kind: String(r.kind),
+          value: value.length > PREVIEW_CHARS ? value.slice(0, PREVIEW_CHARS) : value,
+          valueTruncated: value.length > PREVIEW_CHARS,
+          ...fn ? { function: fn } : {},
+          ...mark ? { stale: mark } : {}
+        };
+      });
+      const next = offset + items.length;
+      const page = {
+        items,
+        total,
+        ...next < total ? { nextCursor: encodeCursor({ g: generation, o: next, q }) } : {}
+      };
+      return {
+        kind: "ok",
+        value: page,
+        evidence: evidence([
+          `${total} string or template literal(s) contain ${JSON.stringify(request.text)}${insensitive ? " (ASCII case-insensitive)" : ""}`,
+          "each hit lists the innermost function whose source range contains it"
+        ], [
+          "literals are indexed up to 4096 characters, and a template literal is indexed per static chunk, so a match cannot span a ${...} or sit past the cut"
+        ], [
+          ...workspaceGaps(o.store, scope.rel),
+          ...markReasons(fresh.marks),
+          ...await newFileReasons(o.store, o.root, scope.rel)
+        ], built)
+      };
+    }), "findLiteral"),
+    enclosingFunction: /* @__PURE__ */ __name((request) => withScope(request.root, request.path, request.signal, async (o, env, built) => {
+      const files = new Files(o.store, o.root);
+      const found = fileAt(o, files, request.path);
+      if ("error" in found)
+        return failed(found.error);
+      const verified = await readVerified(env, files, found, { refresh: true });
+      if ("error" in verified)
+        return failed(verified.error);
+      const { info, text } = verified;
+      const at = offsetOf(info.starts, info.chars, request.line, request.column ?? 1);
+      if ("error" in at)
+        return failed(`${info.rel}: ${at.error}`);
+      const row = o.store.get('SELECT * FROM functions WHERE file_id = ? AND start <= ? AND "end" > ? ORDER BY start DESC, "end" ASC, id DESC LIMIT 1', info.id, at.offset, at.offset);
+      const gaps = fileGaps(info);
+      const notes = [
+        ...verified.refreshed ? [`${info.rel} had changed since it was indexed and was re-read`] : [],
+        ...built ? [built] : []
+      ];
+      if (!row) {
+        return {
+          kind: "ok",
+          value: { function: null, parents: [] },
+          evidence: {
+            observed: [
+              `${info.rel}:${request.line}:${request.column ?? 1} lies in no function body; it is at the top level of the file`,
+              ...notes
+            ],
+            inferred: [],
+            coverage: coverageOf(gaps)
+          }
+        };
+      }
+      const fn = toFunction(row, info);
+      const parents = parentsOf(o.store, files, row.parent_id === null ? null : Number(row.parent_id));
+      return {
+        kind: "ok",
+        value: {
+          function: fn,
+          parents,
+          source: sliceOf(text, fn.start, fn.end, clampChars(request.maxChars))
+        },
+        evidence: {
+          observed: [
+            `offset ${at.offset} lies in [${fn.start}, ${fn.end}) of ${info.rel}, the innermost function range that contains it`,
+            "the source is the exact slice of the file, verified against its content hash",
+            ...notes
+          ],
+          inferred: fn.name === null ? [
+            "the function has no name of its own and none could be inferred from its context"
+          ] : [],
+          coverage: coverageOf(gaps)
+        }
+      };
+    }), "enclosingFunction"),
+    functionSource: /* @__PURE__ */ __name((request) => withScope(
+      request.root,
+      // An id names a function the index already holds; only a path asks for a build.
+      request.id === void 0 ? request.path : void 0,
+      request.signal,
+      async (o, env, built) => {
+        const files = new Files(o.store, o.root);
+        const maxChars = clampChars(request.maxChars);
+        const limit = clampLimit(request.limit);
+        const generation = Number(o.store.meta("generation") ?? "0");
+        const q = fingerprint([
+          "source",
+          o.root,
+          request.id ?? null,
+          request.path ?? null,
+          request.name ?? null,
+          maxChars
+        ]);
+        const cursor = decodeCursor(request.cursor, generation, q);
+        if ("error" in cursor)
+          return failed(cursor.error);
+        let rows;
+        let total;
+        let info;
+        if (request.id !== void 0) {
+          const row = o.store.get("SELECT * FROM functions WHERE id = ?", request.id);
+          if (!row) {
+            return failed(`There is no function with id ${request.id}. Ids are re-issued when a file is re-read; look the function up again.`);
+          }
+          info = files.byIdOrThrow(Number(row.file_id));
+          rows = [row];
+          total = 1;
+        } else if (request.path !== void 0 && request.name !== void 0) {
+          const found = fileAt(o, files, request.path);
+          if ("error" in found)
+            return failed(found.error);
+          const fresh = await readVerified(env, files, found, { refresh: true });
+          if ("error" in fresh)
+            return failed(fresh.error);
+          info = fresh.info;
+          total = Number(o.store.get("SELECT count(*) AS n FROM functions WHERE file_id = ? AND name = ?", info.id, request.name).n);
+          rows = o.store.all("SELECT * FROM functions WHERE file_id = ? AND name = ? ORDER BY start LIMIT ? OFFSET ?", info.id, request.name, limit, cursor.offset);
+        } else {
+          return failed("functionSource needs `id`, or `path` together with `name`.");
+        }
+        const verified = await readVerified(env, files, info, {
+          refresh: request.id === void 0
+        });
+        if ("error" in verified)
+          return failed(verified.error);
+        const items = rows.map((row) => {
+          const fn = toFunction(row, verified.info);
+          return {
+            function: fn,
+            parents: parentsOf(o.store, files, row.parent_id === null ? null : Number(row.parent_id)),
+            source: sliceOf(verified.text, fn.start, fn.end, maxChars)
+          };
+        });
+        const next = cursor.offset + items.length;
+        return {
+          kind: "ok",
+          value: {
+            items,
+            total,
+            ...next < total ? { nextCursor: encodeCursor({ g: generation, o: next, q }) } : {}
+          },
+          evidence: evidence([
+            `${total} function(s) ${request.id !== void 0 ? `with id ${request.id}` : `named ${JSON.stringify(request.name)} in ${info.rel}`}`,
+            "the source is the exact slice of the file, verified against its content hash"
+          ], request.id === void 0 ? [
+            "a function is matched by the name the index inferred for it, which for an unnamed function is the variable or property it was assigned to"
+          ] : [], fileGaps(info), built)
+        };
+      }
+    ), "functionSource"),
+    callersOf: /* @__PURE__ */ __name((request) => {
+      const scope = request.scope ?? "file";
+      return withScope(request.root, request.path, request.signal, async (o, env, built) => {
+        const files = new Files(o.store, o.root);
+        const member = request.match === "member";
+        let scoped;
+        let scopeRel = "";
+        const gaps = [];
+        const notes = [];
+        if (scope === "file") {
+          if (request.path === void 0) {
+            return failed('callersOf with the default file scope needs `path`. Ask for scope "workspace" to search the whole index.');
+          }
+          const found = fileAt(o, files, request.path);
+          if ("error" in found)
+            return failed(found.error);
+          const fresh = await readVerified(env, files, found, { refresh: true });
+          if ("error" in fresh)
+            return failed(fresh.error);
+          if (fresh.refreshed)
+            notes.push(`${fresh.info.rel} had changed since it was indexed and was re-read`);
+          gaps.push(...fileGaps(fresh.info));
+          scoped = { sql: " AND c.file_id = ?", params: [fresh.info.id] };
+        } else {
+          const s = scopeSql(o, files, request.path, "c.file_id");
+          if ("error" in s)
+            return failed(s.error);
+          scoped = s;
+          scopeRel = s.rel;
+        }
+        const limit = clampLimit(request.limit);
+        const test = member ? "(c.callee = ? OR (length(c.callee) > length(?) AND substr(c.callee, -(length(?) + 1)) = '.' || ?))" : "c.callee = ?";
+        const testParams = member ? [request.name, request.name, request.name, request.name] : [request.name];
+        const where = `WHERE ${test}${scoped.sql}`;
+        const params = [...testParams, ...scoped.params];
+        let offset = 0;
+        let rows = [];
+        let total = 0;
+        let generation = 0;
+        let q = "";
+        let freshness = await checkFreshness(o.store, files, o.root, []);
+        for (let attempt = 0; attempt < 3; attempt++) {
+          generation = Number(o.store.meta("generation") ?? "0");
+          q = fingerprint(["callers", o.root, request.name, scope, request.path ?? null, member]);
+          const cursor = decodeCursor(request.cursor, generation, q);
+          if ("error" in cursor)
+            return failed(cursor.error);
+          offset = cursor.offset;
+          total = Number(o.store.get(`SELECT count(*) AS n FROM calls c ${where}`, ...params).n);
+          rows = o.store.all(`SELECT c.rowid AS rid, c.file_id, c.fn_id, c.start, c.callee, c.kind, c.nargs FROM calls c ${where} ORDER BY c.rowid LIMIT ? OFFSET ?`, ...params, limit, offset);
+          freshness = await checkFreshness(o.store, files, o.root, rows.map((r) => Number(r.file_id)));
+          if (freshness.dropped.length === 0)
+            break;
+        }
+        const fnCache = /* @__PURE__ */ new Map();
+        const items = rows.map((r) => {
+          const fileId = Number(r.file_id);
+          const info = files.byIdOrThrow(fileId);
+          const at = position(info.starts, Number(r.start));
+          let caller;
+          if (r.fn_id !== null && r.fn_id !== void 0) {
+            const id = Number(r.fn_id);
+            caller = fnCache.get(id);
+            if (!caller) {
+              const fr = o.store.get("SELECT * FROM functions WHERE id = ?", id);
+              if (fr) {
+                caller = toFunction(fr, info);
+                fnCache.set(id, caller);
+              }
+            }
+          }
+          const mark = freshness.marks.get(fileId);
+          return {
+            path: info.abs,
+            line: at.line,
+            column: at.column,
+            callee: String(r.callee),
+            kind: String(r.kind),
+            argumentCount: Number(r.nargs),
+            ...caller ? { caller } : {},
+            ...mark ? { stale: mark } : {}
+          };
+        });
+        if (scope === "workspace") {
+          gaps.push(...workspaceGaps(o.store, scopeRel), ...markReasons(freshness.marks), ...await newFileReasons(o.store, o.root, scopeRel));
+        } else {
+          gaps.push(...markReasons(freshness.marks));
+        }
+        const distinct = Number(o.store.get(`SELECT count(DISTINCT c.file_id) AS n FROM calls c ${where}`, ...params).n);
+        const next = offset + items.length;
+        return {
+          kind: "ok",
+          value: {
+            items,
+            total,
+            ...next < total ? { nextCursor: encodeCursor({ g: generation, o: next, q }) } : {}
+          },
+          evidence: evidence([
+            `${total} call expression(s) whose callee text is ${member ? `${JSON.stringify(request.name)} or ends in .${request.name}` : JSON.stringify(request.name)}, in ${distinct} file(s)`,
+            ...notes
+          ], [
+            "callers are matched by the callee TEXT, not by scope or binding: two unrelated functions called by the same name are the same callee here",
+            "a call through an alias, a destructured binding, .call/.apply or computed access (obj[name]()) is not matched",
+            ...scope === "workspace" && distinct > 1 ? [
+              `the matches span ${distinct} files and may be different functions that share a name`
+            ] : []
+          ], gaps, built)
+        };
+      });
+    }, "callersOf"),
+    imports: /* @__PURE__ */ __name((request) => withScope(request.root, request.path, request.signal, async (o, env, built) => {
+      const files = new Files(o.store, o.root);
+      const found = fileAt(o, files, request.path);
+      if ("error" in found)
+        return failed(found.error);
+      const fresh = await readVerified(env, files, found, { refresh: true });
+      if ("error" in fresh)
+        return failed(fresh.error);
+      const info = fresh.info;
+      const limit = clampLimit(request.limit);
+      const generation = Number(o.store.meta("generation") ?? "0");
+      const q = fingerprint(["imports", o.root, request.path]);
+      const cursor = decodeCursor(request.cursor, generation, q);
+      if ("error" in cursor)
+        return failed(cursor.error);
+      const edges = [
+        ...o.store.all("SELECT * FROM imports WHERE file_id = ? ORDER BY start", info.id).map((r) => {
+          const at = position(info.starts, Number(r.start));
+          return {
+            direction: "import",
+            kind: String(r.kind),
+            source: String(r.source),
+            names: String(r.names) === "" ? [] : String(r.names).split(","),
+            line: at.line,
+            column: at.column
+          };
+        }),
+        ...o.store.all("SELECT * FROM exports WHERE file_id = ? ORDER BY start", info.id).map((r) => {
+          const at = position(info.starts, Number(r.start));
+          return {
+            direction: "export",
+            kind: String(r.kind),
+            name: String(r.name),
+            ...r.source !== null && r.source !== void 0 ? { source: String(r.source) } : {},
+            line: at.line,
+            column: at.column
+          };
+        })
+      ];
+      const items = edges.slice(cursor.offset, cursor.offset + limit);
+      const next = cursor.offset + items.length;
+      const imports = edges.filter((e) => e.direction === "import").length;
+      return {
+        kind: "ok",
+        value: {
+          items,
+          total: edges.length,
+          ...next < edges.length ? { nextCursor: encodeCursor({ g: generation, o: next, q }) } : {}
+        },
+        evidence: evidence([
+          `${imports} import(s) and ${edges.length - imports} export(s) in ${info.rel}`,
+          ...fresh.refreshed ? [`${info.rel} had changed since it was indexed and was re-read`] : []
+        ], ["require() and import() are recorded only when their argument is a string literal"], fileGaps(info), built)
+      };
+    }), "imports"),
+    async dispose() {
+      const all = [...opened.values()];
+      opened.clear();
+      lifetime.abort();
+      host.dispose();
+      for (const pending of all) {
+        const o = await pending.catch(() => void 0);
+        if (!o || "error" in o)
+          continue;
+        await o.store.run(async () => o.store.close()).catch(() => void 0);
+      }
+    }
+  };
+  return provider;
+}
+__name(createCodeAnalysisProvider, "createCodeAnalysisProvider");
+function fileGaps(info) {
+  if (info.parseErrors < 0) {
+    return [
+      `${info.rel} crashed the parser and is recorded with no rows, so nothing can be answered from it`
+    ];
+  }
+  if (info.parseErrors > 0) {
+    return [
+      `${info.rel} had syntax errors; the parser kept whatever tree it could recover, which is often none, so rows from it may be missing`
+    ];
+  }
+  return [];
+}
+__name(fileGaps, "fileGaps");
+export {
+  DEFAULT_IGNORED_DIRS,
+  DEFAULT_MAX_DIRECTORIES,
+  DEFAULT_MAX_FILES,
+  DEFAULT_MAX_FILE_BYTES,
+  DEFAULT_MAX_MILLIS,
+  createCodeAnalysisProvider
+};
+//# sourceMappingURL=dist-KGLSBIES.js.map