@wrongstack/tools 0.313.0 → 0.316.1

package/dist/codebase-index/parser-worker-script.js

@@ -1,4001 +1,14 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res, err) => function __init() {
-  if (err) throw err[0];
-  try {
-    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-  } catch (e) {
-    throw err = [e], e;
-  }
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/_win32-resolve.ts
-import * as fs from "node:fs";
-import * as path from "node:path";
-function resolveWin32Command(cmd) {
-  if (process.platform !== "win32") return cmd;
-  if (cmd.includes("/") || cmd.includes("\\") || path.extname(cmd.replace(/\//g, "\\"))) {
-    return cmd;
-  }
-  const pathext = (process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD;.VBS;.JS;.WS;.MSC").toLowerCase().split(";");
-  const pathDirs = (process.env["PATH"] ?? "").split(path.delimiter);
-  for (const dir of pathDirs) {
-    const base = path.join(dir, cmd);
-    for (const ext of pathext) {
-      const full = `${base}${ext}`;
-      try {
-        fs.accessSync(full, fs.constants.X_OK);
-        return full;
-      } catch {
-      }
-    }
-  }
-  return cmd;
-}
-var init_win32_resolve = __esm({
-  "src/_win32-resolve.ts"() {
-    "use strict";
-  }
-});
-
-// src/codebase-index/parser-output.ts
-function coerceSymbols(value) {
-  if (!Array.isArray(value)) return [];
-  return value.flatMap((entry) => {
-    const candidate = entry;
-    if (typeof candidate.name !== "string" || typeof candidate.kind !== "string") return [];
-    return [
-      {
-        name: candidate.name,
-        kind: candidate.kind,
-        line: typeof candidate.line === "number" ? candidate.line : 1,
-        col: typeof candidate.col === "number" ? candidate.col : 0,
-        signature: typeof candidate.signature === "string" ? candidate.signature : "",
-        scope: typeof candidate.scope === "string" ? candidate.scope : ""
-      }
-    ];
-  });
-}
-function coerceRefs(value, lang) {
-  if (!Array.isArray(value)) return [];
-  return value.flatMap((entry) => {
-    const candidate = entry;
-    if (typeof candidate.toName !== "string" || !candidate.toName) return [];
-    if (typeof candidate.callType !== "string" || !CALL_TYPES.has(candidate.callType)) return [];
-    const module = typeof candidate.module === "string" && candidate.module ? candidate.module : void 0;
-    return [
-      {
-        fromId: 0,
-        toName: candidate.toName,
-        callType: candidate.callType,
-        line: typeof candidate.line === "number" ? candidate.line : 1,
-        lang,
-        module
-      }
-    ];
-  });
-}
-function parseParserOutput(stdout, lang) {
-  const trimmed = stdout.trim();
-  if (!trimmed) return { symbols: [], refs: [] };
-  let parsed;
-  try {
-    parsed = JSON.parse(trimmed);
-  } catch {
-    return { symbols: [], refs: [] };
-  }
-  if (Array.isArray(parsed)) return { symbols: coerceSymbols(parsed), refs: [] };
-  const record = parsed;
-  return {
-    symbols: coerceSymbols(record.symbols),
-    refs: dedupeRefs(coerceRefs(record.refs, lang))
-  };
-}
-function parseParserBatchOutput(stdout, lang) {
-  const trimmed = stdout.trim();
-  if (!trimmed) return [];
-  let parsed;
-  try {
-    parsed = JSON.parse(trimmed);
-  } catch {
-    return [];
-  }
-  if (!parsed || typeof parsed !== "object") return [];
-  const results = parsed.results;
-  if (!Array.isArray(results)) return [];
-  return results.flatMap((entry) => {
-    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return [];
-    const candidate = entry;
-    if (typeof candidate.file !== "string" || !candidate.file) return [];
-    return [
-      {
-        file: candidate.file,
-        error: typeof candidate.error === "string" && candidate.error ? candidate.error : void 0,
-        symbols: coerceSymbols(candidate.symbols),
-        refs: dedupeRefs(coerceRefs(candidate.refs, lang))
-      }
-    ];
-  });
-}
-function dedupeRefs(refs) {
-  const seen = /* @__PURE__ */ new Set();
-  return refs.filter((ref) => {
-    const key = `${ref.toName}:${ref.callType}:${ref.line}:${ref.module ?? ""}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-}
-var CALL_TYPES;
-var init_parser_output = __esm({
-  "src/codebase-index/parser-output.ts"() {
-    "use strict";
-    CALL_TYPES = /* @__PURE__ */ new Set([
-      "call",
-      "type_ref",
-      "inherit",
-      "implement",
-      "import"
-    ]);
-  }
-});
-
-// src/codebase-index/spawn-gate.ts
-function withSpawnGate(fn) {
-  const run = chain.then(fn, fn);
-  chain = run.then(
-    () => void 0,
-    () => void 0
-  );
-  return run;
-}
-var chain;
-var init_spawn_gate = __esm({
-  "src/codebase-index/spawn-gate.ts"() {
-    "use strict";
-    chain = Promise.resolve();
-  }
-});
-
-// src/codebase-index/generic-parser.ts
-var generic_parser_exports = {};
-__export(generic_parser_exports, {
-  GENERIC_MAX_FILE_CHARS: () => GENERIC_MAX_FILE_CHARS,
-  GENERIC_MAX_SYMBOLS_DEFAULT: () => GENERIC_MAX_SYMBOLS_DEFAULT,
-  parseGeneric: () => parseGeneric,
-  parseSymbols: () => parseSymbols
-});
-function patternsFor(lang) {
-  return LANG_PATTERNS[lang] ?? LANG_PATTERNS.other ?? [];
-}
-function looksBinary(content) {
-  if (content.includes("\0")) return true;
-  const sample = content.slice(0, 2048);
-  if (sample.length === 0) return false;
-  let bad = 0;
-  for (let i = 0; i < sample.length; i++) {
-    const c = sample.charCodeAt(i);
-    if (c === 9 || c === 10 || c === 13) continue;
-    if (c < 32 || c === 127) bad++;
-  }
-  return bad / sample.length > 0.1;
-}
-function newlineOffsets2(content) {
-  const offsets = [];
-  for (let i = 0; i < content.length; i++) {
-    if (content.charCodeAt(i) === 10) offsets.push(i);
-  }
-  return offsets;
-}
-function lineColAt(offsets, index) {
-  let low = 0;
-  let high = offsets.length;
-  while (low < high) {
-    const mid = low + high >>> 1;
-    if ((offsets[mid] ?? 0) < index) low = mid + 1;
-    else high = mid;
-  }
-  const lastNl = low > 0 ? offsets[low - 1] : -1;
-  return { line: low + 1, col: index - lastNl };
-}
-function parseGeneric(opts) {
-  const { file, lang } = opts;
-  const maxSymbols = opts.maxSymbols ?? GENERIC_MAX_SYMBOLS_DEFAULT;
-  const mtimeMs = Date.now();
-  if (!opts.content || looksBinary(opts.content)) {
-    return { file, lang, symbols: [], mtimeMs };
-  }
-  const content = opts.content.length > GENERIC_MAX_FILE_CHARS ? opts.content.slice(0, GENERIC_MAX_FILE_CHARS) : opts.content;
-  const patterns = patternsFor(lang);
-  const symbols = [];
-  const seen = /* @__PURE__ */ new Set();
-  const nlOffsets = newlineOffsets2(content);
-  for (const pattern of patterns) {
-    const re = new RegExp(
-      pattern.re.source,
-      pattern.re.flags.includes("g") ? pattern.re.flags : `${pattern.re.flags}g`
-    );
-    re.lastIndex = 0;
-    for (const match of content.matchAll(re)) {
-      if (symbols.length >= maxSymbols) break;
-      let name = (match[1] ?? match[2] ?? "").trim();
-      if (lang === "md" && match[2]) name = match[2].trim();
-      if (!name || name.length > 200) continue;
-      name = name.replace(/^#+\s*/, "").replace(/["'`]/g, "");
-      if (!name || KEYWORDS.has(name.toLowerCase())) continue;
-      if (!/^[A-Za-z_#.@/\w][\w.\-:/#!?]*$/.test(name) && lang !== "md" && lang !== "toml") {
-        continue;
-      }
-      const { line, col } = lineColAt(nlOffsets, match.index ?? 0);
-      const key = `${name}\0${line}\0${pattern.kind}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      const nl = content.indexOf("\n", match.index);
-      const lineText = content.slice(match.index, nl === -1 ? content.length : nl);
-      const signature = (lineText || name).trim().slice(0, 500);
-      symbols.push({
-        id: 0,
-        lang,
-        kind: lang === "md" ? "namespace" : pattern.kind,
-        name: name.slice(0, 200),
-        file,
-        line,
-        col,
-        signature,
-        docComment: "",
-        scope: "",
-        text: `${name} ${signature}`.trim().slice(0, 1e3)
-      });
-    }
-    if (symbols.length >= maxSymbols) break;
-  }
-  return { file, lang, symbols, mtimeMs };
-}
-async function parseSymbols(opts) {
-  return parseGeneric(opts);
-}
-var C_LIKE, LANG_PATTERNS, KEYWORDS, GENERIC_MAX_SYMBOLS_DEFAULT, GENERIC_MAX_FILE_CHARS;
-var init_generic_parser = __esm({
-  "src/codebase-index/generic-parser.ts"() {
-    "use strict";
-    C_LIKE = [
-      { re: /\b(?:class|struct|enum|interface|union)\s+([A-Za-z_]\w*)/g, kind: "class" },
-      {
-        re: /\b(?:public|private|protected|static|final|async|override|virtual|inline|export)?\s*(?:[\w:<>[\]\s*&]+)\s+([A-Za-z_]\w*)\s*\([^;{]*\)\s*(?:const)?\s*[{;]/g,
-        kind: "function"
-      },
-      { re: /\b(?:namespace)\s+([A-Za-z_]\w*)/g, kind: "namespace" }
-    ];
-    LANG_PATTERNS = {
-      py: [
-        { re: /^(?:async\s+)?def\s+([A-Za-z_]\w*)/gm, kind: "function" },
-        { re: /^class\s+([A-Za-z_]\w*)/gm, kind: "class" },
-        { re: /^([A-Za-z_]\w*)\s*=/gm, kind: "var" }
-      ],
-      go: [
-        { re: /^func\s+(?:\([^)]*\)\s*)?([A-Za-z_]\w*)\s*\(/gm, kind: "function" },
-        { re: /^type\s+([A-Za-z_]\w*)\b/gm, kind: "type" },
-        { re: /^(?:const|var)\s+([A-Za-z_]\w*)\b/gm, kind: "const" },
-        { re: /^package\s+([A-Za-z_]\w*)/gm, kind: "namespace" }
-      ],
-      rs: [
-        { re: /\bfn\s+([A-Za-z_]\w*)/g, kind: "function" },
-        { re: /\bstruct\s+([A-Za-z_]\w*)/g, kind: "struct" },
-        { re: /\benum\s+([A-Za-z_]\w*)/g, kind: "enum" },
-        { re: /\btrait\s+([A-Za-z_]\w*)/g, kind: "trait" },
-        { re: /\bimpl(?:\s*<[^>]+>)?\s+([A-Za-z_]\w*)/g, kind: "impl" },
-        { re: /\b(?:const|static)\s+([A-Za-z_]\w*)/g, kind: "const" },
-        { re: /\bmod\s+([A-Za-z_]\w*)/g, kind: "mod" }
-      ],
-      c: C_LIKE,
-      cpp: C_LIKE,
-      java: [
-        { re: /\b(?:class|interface|enum|record)\s+([A-Za-z_]\w*)/g, kind: "class" },
-        {
-          re: /\b(?:public|private|protected|static|final|abstract|synchronized|native|default|\s)+\s*[\w.<>,[\]\s]+\s+([A-Za-z_]\w*)\s*\(/g,
-          kind: "method"
-        }
-      ],
-      csharp: [
-        { re: /\b(?:class|interface|struct|enum|record)\s+([A-Za-z_]\w*)/g, kind: "class" },
-        { re: /\bnamespace\s+([A-Za-z_.\w]+)/g, kind: "namespace" },
-        {
-          re: /\b(?:public|private|protected|internal|static|async|override|virtual|\s)+\s*[\w.<>,[\]\s]+\s+([A-Za-z_]\w*)\s*\(/g,
-          kind: "method"
-        }
-      ],
-      php: [
-        { re: /\bfunction\s+([A-Za-z_]\w*)/g, kind: "function" },
-        { re: /\bclass\s+([A-Za-z_]\w*)/g, kind: "class" },
-        { re: /\binterface\s+([A-Za-z_]\w*)/g, kind: "interface" },
-        { re: /\bnamespace\s+([A-Za-z_\\]+)/g, kind: "namespace" }
-      ],
-      ruby: [
-        { re: /^\s*def\s+(?:self\.)?([A-Za-z_]\w*[!?]?)/gm, kind: "function" },
-        { re: /^\s*class\s+([A-Za-z_]\w*)/gm, kind: "class" },
-        { re: /^\s*module\s+([A-Za-z_]\w*)/gm, kind: "namespace" }
-      ],
-      swift: [
-        { re: /\b(?:func)\s+([A-Za-z_]\w*)/g, kind: "function" },
-        { re: /\b(?:class|struct|enum|protocol|actor)\s+([A-Za-z_]\w*)/g, kind: "class" }
-      ],
-      kotlin: [
-        { re: /\b(?:fun)\s+([A-Za-z_]\w*)/g, kind: "function" },
-        {
-          re: /\b(?:class|interface|object|enum\s+class|data\s+class)\s+([A-Za-z_]\w*)/g,
-          kind: "class"
-        }
-      ],
-      scala: [
-        { re: /\b(?:def)\s+([A-Za-z_]\w*)/g, kind: "function" },
-        { re: /\b(?:class|object|trait|enum)\s+([A-Za-z_]\w*)/g, kind: "class" }
-      ],
-      shell: [
-        { re: /^(?:function\s+)?([A-Za-z_]\w*)\s*\(\)\s*\{/gm, kind: "function" },
-        { re: /^([A-Za-z_][\w]*)\s*\(\)\s*\{/gm, kind: "function" }
-      ],
-      sql: [
-        {
-          re: /\bCREATE\s+(?:OR\s+REPLACE\s+)?(?:TABLE|VIEW|INDEX|FUNCTION|PROCEDURE|TRIGGER)\s+(?:IF\s+NOT\s+EXISTS\s+)?([A-Za-z_"][\w."]*)/gi,
-          kind: "type"
-        }
-      ],
-      md: [{ re: /^(#{1,6})\s+(.+)$/gm, kind: "namespace" }],
-      toml: [{ re: /^\[([^\]]+)\]/gm, kind: "namespace" }],
-      html: [
-        { re: /\bid\s*=\s*["']([^"']+)["']/gi, kind: "property" },
-        { re: /<(?:script|template|style)\b/gi, kind: "namespace" }
-      ],
-      css: [
-        { re: /^\s*([.#]?[A-Za-z_][\w-]*)\s*\{/gm, kind: "type" },
-        { re: /@(?:keyframes|media|supports)\s+([^{\s]+)/g, kind: "namespace" }
-      ],
-      vue: [
-        {
-          re: /\b(?:function|const|let|var|class|export\s+(?:default\s+)?(?:function|class|const))\s+([A-Za-z_]\w*)/g,
-          kind: "function"
-        },
-        { re: /<(?:script|template|style)\b/gi, kind: "namespace" }
-      ],
-      svelte: [
-        {
-          re: /\b(?:function|const|let|var|class|export\s+(?:default\s+)?(?:function|class|const))\s+([A-Za-z_]\w*)/g,
-          kind: "function"
-        }
-      ],
-      dart: [
-        { re: /\b(?:class|enum|mixin|extension)\s+([A-Za-z_]\w*)/g, kind: "class" },
-        { re: /\b([A-Za-z_]\w*)\s*\([^;]*\)\s*(?:async\s*)?\{/g, kind: "function" }
-      ],
-      lua: [
-        { re: /\bfunction\s+([A-Za-z_.:]\w*)/g, kind: "function" },
-        { re: /\blocal\s+function\s+([A-Za-z_]\w*)/g, kind: "function" }
-      ],
-      r: [
-        { re: /([A-Za-z.]\w*)\s*<-\s*function\s*\(/g, kind: "function" },
-        { re: /([A-Za-z.]\w*)\s*=\s*function\s*\(/g, kind: "function" }
-      ],
-      proto: [
-        { re: /\b(?:message|service|enum)\s+([A-Za-z_]\w*)/g, kind: "type" },
-        { re: /\brpc\s+([A-Za-z_]\w*)/g, kind: "function" }
-      ],
-      graphql: [
-        { re: /\b(?:type|interface|enum|input|union|scalar)\s+([A-Za-z_]\w*)/g, kind: "type" },
-        { re: /\b(?:query|mutation|subscription)\s+([A-Za-z_]\w*)/g, kind: "function" }
-      ],
-      zig: [
-        { re: /\b(?:fn|pub\s+fn)\s+([A-Za-z_]\w*)/g, kind: "function" },
-        { re: /\b(?:const|var)\s+([A-Za-z_]\w*)/g, kind: "const" },
-        { re: /\b(?:struct|enum|union)\s*\{/g, kind: "type" }
-      ],
-      elixir: [
-        { re: /\bdef(?:p|macro|macrop)?\s+([A-Za-z_]\w*[!?]?)/g, kind: "function" },
-        // Dotted module names must be captured whole: `alias Foo.Bar` resolves
-        // against this symbol, and a `Foo`-only capture never matches it.
-        { re: /\bdefmodule\s+([A-Z][\w.]*)/g, kind: "namespace" }
-      ],
-      haskell: [
-        // Target of `import Data.List`.
-        { re: /^module\s+([A-Z][\w.]*)/gm, kind: "namespace" },
-        { re: /^([A-Za-z_]\w*)\s*::/gm, kind: "function" },
-        { re: /\bdata\s+([A-Za-z_]\w*)/g, kind: "type" },
-        { re: /\btype\s+(?:family\s+)?([A-Za-z_]\w*)/g, kind: "type" },
-        { re: /\bclass\s+([A-Za-z_]\w*)/g, kind: "class" }
-      ],
-      other: [
-        { re: /^(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_]\w*)/gm, kind: "function" },
-        { re: /^(?:export\s+)?class\s+([A-Za-z_]\w*)/gm, kind: "class" },
-        { re: /^(?:export\s+)?(?:const|let|var)\s+([A-Za-z_]\w*)/gm, kind: "const" },
-        { re: /^(?:async\s+)?def\s+([A-Za-z_]\w*)/gm, kind: "function" },
-        { re: /^func\s+(?:\([^)]*\)\s*)?([A-Za-z_]\w*)/gm, kind: "function" },
-        { re: /\bfn\s+([A-Za-z_]\w*)/g, kind: "function" },
-        { re: /^(?:target|PHONY)\s*:/gm, kind: "namespace" }
-      ]
-    };
-    KEYWORDS = /* @__PURE__ */ new Set([
-      "if",
-      "else",
-      "for",
-      "while",
-      "switch",
-      "case",
-      "return",
-      "break",
-      "continue",
-      "new",
-      "delete",
-      "typeof",
-      "instanceof",
-      "void",
-      "null",
-      "true",
-      "false",
-      "this",
-      "super",
-      "import",
-      "export",
-      "from",
-      "as",
-      "default",
-      "public",
-      "private",
-      "protected",
-      "static",
-      "final",
-      "class",
-      "struct",
-      "enum",
-      "interface",
-      "function",
-      "def",
-      "fn",
-      "func",
-      "var",
-      "let",
-      "const",
-      "package",
-      "namespace",
-      "module",
-      "using",
-      "include",
-      "require",
-      "select",
-      "from",
-      "where",
-      "and",
-      "or",
-      "not",
-      "in",
-      "is",
-      "try",
-      "catch",
-      "finally",
-      "throw",
-      "async",
-      "await",
-      "yield"
-    ]);
-    GENERIC_MAX_SYMBOLS_DEFAULT = 500;
-    GENERIC_MAX_FILE_CHARS = 512 * 1024;
-  }
-});
-
-// src/codebase-index/languages.ts
-import * as path3 from "node:path";
-function detectLang(file) {
-  const base = path3.basename(file);
-  const lowerBase = base.toLowerCase();
-  if (lowerBase.endsWith(".d.ts") || lowerBase.endsWith(".d.mts") || lowerBase.endsWith(".d.cts")) {
-    return "ts";
-  }
-  const special = SPECIAL_FILENAMES[lowerBase];
-  if (special) return special;
-  const ext = path3.extname(base).toLowerCase();
-  if (!ext) return null;
-  return EXT_TO_LANG[ext] ?? null;
-}
-var EXT_TO_LANG, INDEXABLE_EXTENSIONS, SPECIAL_FILENAMES, LANG_FAMILY, LANG_FAMILY_ENTRIES;
-var init_languages = __esm({
-  "src/codebase-index/languages.ts"() {
-    "use strict";
-    EXT_TO_LANG = {
-      // TypeScript / JavaScript (first-class TS compiler API)
-      ".ts": "ts",
-      ".mts": "ts",
-      ".cts": "ts",
-      ".tsx": "tsx",
-      ".js": "js",
-      ".mjs": "js",
-      ".cjs": "js",
-      ".jsx": "jsx",
-      // First-class native/spawn parsers (+ regex fallback)
-      ".go": "go",
-      ".py": "py",
-      ".pyi": "py",
-      ".pyw": "py",
-      ".rs": "rs",
-      ".json": "json",
-      ".jsonc": "json",
-      ".yaml": "yaml",
-      ".yml": "yaml",
-      // C family
-      ".c": "c",
-      ".h": "c",
-      ".cc": "cpp",
-      ".cpp": "cpp",
-      ".cxx": "cpp",
-      ".hh": "cpp",
-      ".hpp": "cpp",
-      ".hxx": "cpp",
-      // JVM / .NET
-      ".java": "java",
-      ".cs": "csharp",
-      ".kt": "kotlin",
-      ".kts": "kotlin",
-      ".scala": "scala",
-      ".sc": "scala",
-      // Scripting
-      ".php": "php",
-      ".rb": "ruby",
-      ".swift": "swift",
-      ".dart": "dart",
-      ".lua": "lua",
-      ".r": "r",
-      ".R": "r",
-      ".pl": "other",
-      ".pm": "other",
-      // Systems / functional
-      ".zig": "zig",
-      ".ex": "elixir",
-      ".exs": "elixir",
-      ".hs": "haskell",
-      ".lhs": "haskell",
-      // Shell / data / docs / web
-      ".sh": "shell",
-      ".bash": "shell",
-      ".zsh": "shell",
-      ".ps1": "shell",
-      ".sql": "sql",
-      ".md": "md",
-      ".mdx": "md",
-      ".toml": "toml",
-      ".html": "html",
-      ".htm": "html",
-      ".css": "css",
-      ".scss": "css",
-      ".less": "css",
-      ".vue": "vue",
-      ".svelte": "svelte",
-      ".proto": "proto",
-      ".graphql": "graphql",
-      ".gql": "graphql"
-    };
-    INDEXABLE_EXTENSIONS = Object.freeze(
-      [...new Set(Object.keys(EXT_TO_LANG).map((e) => e.toLowerCase()))].sort()
-    );
-    SPECIAL_FILENAMES = {
-      makefile: "other",
-      gnumakefile: "other",
-      dockerfile: "other",
-      "docker-compose.yml": "yaml",
-      "docker-compose.yaml": "yaml",
-      "cmakelists.txt": "other",
-      gemfile: "ruby",
-      rakefile: "ruby",
-      procfile: "other",
-      justfile: "other"
-    };
-    LANG_FAMILY = {
-      // Single-compilation-unit family: a .vue/.svelte script block is JS/TS and
-      // imports from — and is imported by — plain .ts files.
-      ts: "js",
-      tsx: "js",
-      js: "js",
-      jsx: "js",
-      vue: "js",
-      svelte: "js",
-      go: "go",
-      py: "py",
-      rs: "rs",
-      // The JVM resolves across languages: Kotlin and Scala call Java directly.
-      java: "jvm",
-      kotlin: "jvm",
-      scala: "jvm",
-      csharp: "dotnet",
-      // A .h header is consumed by both C and C++ translation units.
-      c: "c",
-      cpp: "c",
-      ruby: "ruby",
-      php: "php",
-      swift: "swift",
-      dart: "dart",
-      elixir: "elixir",
-      haskell: "haskell",
-      zig: "zig",
-      lua: "lua",
-      r: "r",
-      shell: "shell",
-      sql: "sql",
-      json: "data",
-      yaml: "data",
-      toml: "data",
-      html: "web",
-      css: "web",
-      proto: "proto",
-      graphql: "graphql",
-      md: "other",
-      other: "other"
-    };
-    LANG_FAMILY_ENTRIES = Object.freeze(
-      Object.entries(LANG_FAMILY).map(
-        ([lang, family]) => Object.freeze([lang, family])
-      )
-    );
-  }
-});
-
-// src/codebase-index/py-parser.ts
-var py_parser_exports = {};
-__export(py_parser_exports, {
-  detectLang: () => detectLang,
-  parseSymbols: () => parseSymbols2,
-  resolvePythonBinary: () => resolvePythonBinary
-});
-import { spawn as spawn2 } from "node:child_process";
-import * as fs3 from "node:fs/promises";
-import * as os2 from "node:os";
-import * as path4 from "node:path";
-async function parseSymbols2(opts) {
-  const { file, content, lang } = opts;
-  try {
-    const native = await withSpawnGate(() => syncPyParse(file, content, lang));
-    if (native !== null) return native;
-  } catch {
-  }
-  return parseGeneric({ file, content, lang: lang === "py" ? "py" : lang });
-}
-async function resolvePython() {
-  const candidates = process.platform === "win32" ? ["python3", "python", "py"] : ["python3", "python"];
-  for (const name of candidates) {
-    const resolved = resolveWin32Command(name);
-    if (!await commandIsAvailable(resolved)) continue;
-    return resolved;
-  }
-  return null;
-}
-function commandIsAvailable(command) {
-  return new Promise((resolve) => {
-    let settled = false;
-    const proc = spawn2(command, ["--version"], {
-      stdio: "ignore",
-      windowsHide: true
-    });
-    const finish = (available) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolve(available);
-    };
-    const timer = setTimeout(() => {
-      proc.kill("SIGKILL");
-      finish(false);
-    }, 5e3);
-    timer.unref?.();
-    proc.once("error", () => finish(false));
-    proc.once("close", (code) => finish(code === 0));
-  });
-}
-function spawnPyParser(pyBinary, scriptPath, filePath, content) {
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    const proc = spawn2(pyBinary, [scriptPath, filePath], {
-      stdio: ["pipe", "pipe", "pipe"],
-      windowsHide: true
-    });
-    proc.on("error", (err) => {
-      if (settled) return;
-      settled = true;
-      reject(err);
-    });
-    proc.stdin?.write(content);
-    proc.stdin?.end();
-    let stdout = "";
-    proc.stdout?.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    proc.stderr?.resume();
-    const timer = setTimeout(() => {
-      if (settled) return;
-      settled = true;
-      proc.kill("SIGKILL");
-      reject(new Error("timeout"));
-    }, 15e3);
-    timer.unref?.();
-    proc.on("close", (code) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolve({ code, stdout });
-    });
-  });
-}
-function resolvePythonBinary() {
-  cachedPyBinary ??= resolvePython();
-  return cachedPyBinary;
-}
-async function syncPyParse(filePath, content, lang) {
-  try {
-    if (!_cachedScriptPath) {
-      const tmpDir = path4.join(os2.tmpdir(), "ws-py-parse");
-      await fs3.mkdir(tmpDir, { recursive: true });
-      _cachedScriptPath = path4.join(tmpDir, "parse.py");
-      await fs3.writeFile(_cachedScriptPath, PY_PARSE_SCRIPT, "utf8");
-    }
-    cachedPyBinary ??= resolvePython();
-    const pyBinary = await cachedPyBinary;
-    if (!pyBinary) return null;
-    const { code, stdout } = await spawnPyParser(pyBinary, _cachedScriptPath, filePath, content);
-    if (code !== 0 || !stdout.trim()) {
-      return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
-    }
-    const { symbols: raw, refs } = parseParserOutput(stdout, lang);
-    const symbols = raw.map((s) => ({
-      id: 0,
-      lang,
-      kind: s.kind,
-      name: s.name,
-      file: filePath,
-      line: s.line,
-      col: s.col,
-      signature: s.signature ?? "",
-      docComment: "",
-      scope: s.scope ?? "",
-      text: `${s.name} ${s.signature ?? ""}`.trim()
-    }));
-    return { file: filePath, lang, symbols, refs, mtimeMs: Date.now() };
-  } catch {
-    return null;
-  }
-}
-var PY_PARSE_SCRIPT, _cachedScriptPath, cachedPyBinary;
-var init_py_parser = __esm({
-  "src/codebase-index/py-parser.ts"() {
-    "use strict";
-    init_win32_resolve();
-    init_generic_parser();
-    init_parser_output();
-    init_spawn_gate();
-    init_languages();
-    PY_PARSE_SCRIPT = `import ast, json, sys, os
-
-def get_name(node):
-    if isinstance(node, ast.Name):
-        return node.id
-    elif isinstance(node, ast.Attribute):
-        return get_name(node.value) + "." + node.attr
-    elif isinstance(node, ast.Subscript):
-        return get_name(node.value)
-    elif isinstance(node, ast.Call):
-        return get_name(node.func)
-    elif isinstance(node, ast.Constant):
-        return str(node.value)
-    return ""
-
-def get_decorators(node):
-    decs = []
-    for dec in node.decorator_list:
-        decs.append(get_name(dec))
-    return decs
-
-def get_bases(node):
-    bases = []
-    for base in node.bases:
-        bases.append(get_name(base))
-    return bases
-
-def get_args(args):
-    parts = []
-    for arg in args.args:
-        parts.append(arg.arg)
-    return ", ".join(parts)
-
-def get_returns(node):
-    if node.returns is None:
-        return ""
-    return get_name(node.returns)
-
-class Sym:
-    def __init__(self, name, kind, line, col, signature, scope):
-        self.name = name
-        self.kind = kind
-        self.line = line
-        self.col = col
-        self.signature = signature
-        self.scope = scope
-    def to_dict(self):
-        return {
-            "name": self.name,
-            "kind": self.kind,
-            "line": self.line,
-            "col": self.col,
-            "signature": self.signature,
-            "scope": self.scope,
-        }
-
-def is_private(name):
-    return name.startswith("__") and not name.endswith("__")
-
-def leaf_name(node):
-    # Declared name of the callee: \`join\` of \`os.path.join\`. Matches how the
-    # TypeScript and Go extractors record call refs, so resolution behaves the
-    # same across languages.
-    if isinstance(node, ast.Attribute):
-        return node.attr
-    if isinstance(node, ast.Name):
-        return node.id
-    return get_name(node).split(".")[-1]
-
-syms = []
-refs = []
-errors = []
-
-try:
-    source = sys.stdin.read()
-    tree = ast.parse(source, filename=sys.argv[1])
-except Exception as e:
-    errors.append(str(e))
-    print(json.dumps({"symbols": [], "refs": []}))
-    sys.exit(0)
-
-# Module-level scope
-module_scope = os.path.basename(sys.argv[1])[:-3]  # strip .py
-
-class ModuleVisitor(ast.NodeVisitor):
-    def __init__(self):
-        self.scope_stack = [module_scope]
-
-    def visit_ClassDef(self, node):
-        bases = get_bases(node)
-        decs = get_decorators(node)
-        sig = "class " + node.name
-        if bases:
-            sig += "(" + ", ".join(bases) + ")"
-        sig += ": ..."
-        syms.append(Sym(
-            name=node.name,
-            kind="class",
-            line=node.lineno,
-            col=node.col_offset,
-            signature=sig,
-            scope=".".join(self.scope_stack) + "." + node.name,
-        ))
-        self.scope_stack.append(node.name)
-        self.generic_visit(node)
-        self.scope_stack.pop()
-
-    def visit_FunctionDef(self, node):
-        decs = get_decorators(node)
-        args = get_args(node.args)
-        returns = get_returns(node)
-        is_async = isinstance(node, ast.AsyncFunctionDef)
-
-        kind = "function"
-        prefix = "def "
-        if decs:
-            for d in decs:
-                if d.endswith(".staticmethod"):
-                    kind = "staticmethod"
-                elif d.endswith(".classmethod"):
-                    kind = "classmethod"
-                elif d == "property":
-                    kind = "property"
-
-        if is_async:
-            kind = "async_" + kind
-
-        sig = f"{prefix}{node.name}({args})"
-        if returns:
-            sig += f" -> {returns}"
-        scope = ".".join(self.scope_stack) + "." + node.name
-
-        syms.append(Sym(
-            name=node.name,
-            kind=kind,
-            line=node.lineno,
-            col=node.col_offset,
-            signature=sig,
-            scope=scope,
-        ))
-        # Don't descend into function bodies to avoid local symbols
-        # self.generic_visit(node)
-
-    def visit_AsyncFunctionDef(self, node):
-        # Treat as function
-        self.visit_FunctionDef(node)
-
-    def visit_Assign(self, node):
-        for target in node.targets:
-            if isinstance(target, ast.Name):
-                name = target.id
-                if is_private(name):
-                    continue
-                # Infer constness from UPPER_CASE naming
-                kind = "const" if name.isupper() else "var"
-                col = target.col_offset if hasattr(target, 'col_offset') else 0
-                syms.append(Sym(
-                    name=name,
-                    kind=kind,
-                    line=node.lineno,
-                    col=col,
-                    signature=f"{name} = ...",
-                    scope=".".join(self.scope_stack),
-                ))
-
-    def visit_AnnAssign(self, node):
-        if isinstance(node.target, ast.Name):
-            name = node.target.id
-            if is_private(name):
-                return
-            kind = "const" if name.isupper() else "var"
-            col = node.target.col_offset if hasattr(node.target, 'col_offset') else 0
-            sig = f"{name}: {get_name(node.annotation)}"
-            if node.value:
-                sig += " = ..."
-            syms.append(Sym(
-                name=name,
-                kind=kind,
-                line=node.lineno,
-                col=col,
-                signature=sig,
-                scope=".".join(self.scope_stack),
-            ))
-
-    def visit_Import(self, node):
-        for alias in node.names:
-            name = alias.asname or alias.name
-            syms.append(Sym(
-                name=name,
-                kind="import",
-                line=node.lineno,
-                col=node.col_offset,
-                signature=f"import {alias.name}",
-                scope=".".join(self.scope_stack),
-            ))
-
-    def visit_ImportFrom(self, node):
-        module = node.module or ""
-        for alias in node.names:
-            name = alias.asname or alias.name
-            syms.append(Sym(
-                name=name,
-                kind="import",
-                line=node.lineno,
-                col=node.col_offset,
-                signature=f"from {module} import {alias.name}",
-                scope=".".join(self.scope_stack),
-            ))
-
-visitor = ModuleVisitor()
-visitor.visit(tree)
-
-# Refs need a separate full walk: ModuleVisitor deliberately does not descend
-# into function bodies (it would index locals as symbols), but that is exactly
-# where the calls are.
-for node in ast.walk(tree):
-    if isinstance(node, ast.Call):
-        name = leaf_name(node.func)
-        if name:
-            refs.append({"toName": name, "callType": "call", "line": node.lineno})
-    elif isinstance(node, ast.Import):
-        for alias in node.names:
-            refs.append({
-                "toName": alias.name.split(".")[-1],
-                "callType": "import",
-                "line": node.lineno,
-                "module": alias.name,
-            })
-    elif isinstance(node, ast.ImportFrom):
-        # PEP 328: node.level is the number of leading dots. Preserving them is
-        # what lets the resolver walk up from the importing file's package \u2014
-        # dropping them made \`from .foo import X\` indistinguishable from an
-        # absolute \`foo\`.
-        module = ("." * (node.level or 0)) + (node.module or "")
-        for alias in node.names:
-            refs.append({
-                "toName": alias.name,
-                "callType": "import",
-                "line": node.lineno,
-                "module": module,
-            })
-    elif isinstance(node, ast.ClassDef):
-        for base in node.bases:
-            name = leaf_name(base)
-            if name:
-                refs.append({"toName": name, "callType": "inherit", "line": node.lineno})
-
-print(json.dumps({"symbols": [s.to_dict() for s in syms], "refs": refs}))
-`;
-    _cachedScriptPath = null;
-  }
-});
-
-// src/codebase-index/ts-parser.ts
-var ts_parser_exports = {};
-__export(ts_parser_exports, {
-  detectLang: () => detectLang,
-  parseSymbols: () => parseSymbols3
-});
-function loadTypescript() {
-  tsLoad ??= import("@typescript/typescript6").then((m) => {
-    ts = m.default ?? m;
-    return ts;
-  });
-  return tsLoad;
-}
-function kindMap() {
-  kindMapCache ??= {
-    [ts.SyntaxKind.ClassDeclaration]: "class",
-    [ts.SyntaxKind.InterfaceDeclaration]: "interface",
-    [ts.SyntaxKind.EnumDeclaration]: "enum",
-    [ts.SyntaxKind.TypeAliasDeclaration]: "type",
-    [ts.SyntaxKind.FunctionDeclaration]: "function",
-    [ts.SyntaxKind.MethodDeclaration]: "method",
-    [ts.SyntaxKind.GetAccessor]: "property",
-    [ts.SyntaxKind.SetAccessor]: "property",
-    [ts.SyntaxKind.PropertyDeclaration]: "property",
-    [ts.SyntaxKind.Parameter]: "parameter",
-    [ts.SyntaxKind.NamespaceExportDeclaration]: "namespace"
-  };
-  return kindMapCache;
-}
-function kindOf(node) {
-  if (ts.isVariableDeclaration(node)) {
-    const parent = node.parent;
-    if (ts.isVariableDeclarationList(parent)) {
-      const flags = parent.flags;
-      if (flags & ts.NodeFlags.Let) return "let";
-      if (flags & ts.NodeFlags.Const) return "const";
-      return "var";
-    }
-  }
-  if (ts.isModuleDeclaration(node)) return "namespace";
-  return kindMap()[node.kind] ?? null;
-}
-function getSignature(printer, node, sourceFile) {
-  const raw = printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
-  return raw.replace(/\s+/g, " ").slice(0, 500);
-}
-function getJsDoc(node, sourceFile) {
-  const fullText = sourceFile.getFullText();
-  const nodePos = node.getFullStart();
-  const comments = ts.getLeadingCommentRanges(fullText, nodePos);
-  if (!comments) return "";
-  for (const range of comments) {
-    const commentText = fullText.slice(range.pos, range.end);
-    const trimmed = commentText.trim();
-    if (trimmed.startsWith("/**") && trimmed.endsWith("*/")) {
-      const inner = trimmed.slice(3, -2).replace(/^[ \t]*\*[ ]?/gm, "").trim();
-      return inner.split("\n")[0]?.trim().slice(0, 200) ?? "";
-    }
-  }
-  return "";
-}
-function pushScopeName(node, parts) {
-  if (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isEnumDeclaration(node) || ts.isTypeAliasDeclaration(node)) {
-    parts.push(node.name?.text ?? "Anon");
-  } else if (ts.isMethodDeclaration(node) || ts.isGetAccessor(node) || ts.isSetAccessor(node) || ts.isPropertyDeclaration(node) || ts.isFunctionDeclaration(node)) {
-    if (node.name && ts.isIdentifier(node.name)) {
-      parts.push(node.name.text);
-    }
-  }
-}
-async function parseSymbols3(opts) {
-  const { file, content, lang } = opts;
-  await loadTypescript();
-  let sourceFile;
-  try {
-    sourceFile = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
-  } catch {
-    return { file, lang, symbols: [], mtimeMs: Date.now() };
-  }
-  const symbols = [];
-  const refs = [];
-  const printer = ts.createPrinter({});
-  function visit(node, funcDepth, scopeParts) {
-    const kind = kindOf(node);
-    if (kind) {
-      if ((kind === "const" || kind === "let" || kind === "var" || kind === "parameter") && funcDepth > 0) {
-      } else {
-        const nameNode = node.name;
-        if (!nameNode || !ts.isIdentifier(nameNode)) {
-          return;
-        }
-        const name = nameNode.text;
-        const pos2 = nameNode.getStart(sourceFile);
-        const { line: line2, character } = sourceFile.getLineAndCharacterOfPosition(pos2);
-        const scope = scopeParts.join(".");
-        const signature = getSignature(printer, node, sourceFile);
-        const docComment = getJsDoc(node, sourceFile);
-        const text = [name, signature, docComment].filter(Boolean).join(" | ");
-        symbols.push({
-          id: 0,
-          lang,
-          kind,
-          name,
-          file,
-          line: line2 + 1,
-          col: character,
-          signature,
-          docComment,
-          scope,
-          text
-        });
-      }
-    }
-    const pos = node.getStart(sourceFile);
-    const { line } = sourceFile.getLineAndCharacterOfPosition(pos);
-    const lineNum = line + 1;
-    if (ts.isCallExpression(node)) {
-      const expr = node.expression;
-      if (ts.isIdentifier(expr)) {
-        refs.push({ fromId: 0, toName: expr.text, callType: "call", line: lineNum });
-      }
-    } else if (ts.isPropertyAccessExpression(node)) {
-      if (ts.isIdentifier(node.expression)) {
-        refs.push({ fromId: 0, toName: node.expression.text, callType: "call", line: lineNum });
-      }
-    } else if (ts.isTypeReferenceNode(node)) {
-      const name = getTypeName(node.typeName);
-      if (name) refs.push({ fromId: 0, toName: name, callType: "type_ref", line: lineNum });
-    } else if (ts.isHeritageClause(node)) {
-      for (const t of node.types) {
-        const name = getTypeName(t.expression);
-        if (name)
-          refs.push({
-            fromId: 0,
-            toName: name,
-            callType: node.token === ts.SyntaxKind.ExtendsKeyword ? "inherit" : "implement",
-            line: lineNum
-          });
-      }
-    } else if (ts.isImportDeclaration(node)) {
-      emitImportSpecifierRefs(node, refs, lineNum);
-    } else if (ts.isExportDeclaration(node) && node.moduleSpecifier) {
-      emitExportSpecifierRefs(node, refs, lineNum);
-    }
-    const scopeIdx = scopeParts.length;
-    pushScopeName(node, scopeParts);
-    const childFuncDepth = ts.isFunctionLike(node) ? funcDepth + 1 : funcDepth;
-    ts.forEachChild(node, (child) => visit(child, childFuncDepth, scopeParts));
-    scopeParts.length = scopeIdx;
-  }
-  visit(sourceFile, 0, []);
-  return { file, lang, symbols, refs: deduplicateRefs(refs), mtimeMs: Date.now() };
-}
-function getTypeName(name) {
-  if (ts.isIdentifier(name)) return name.text;
-  if (ts.isQualifiedName(name)) return `${getTypeName(name.left)}.${name.right.text}`;
-  return "";
-}
-function deduplicateRefs(refs) {
-  const seen = /* @__PURE__ */ new Set();
-  return refs.filter((r) => {
-    const key = `${r.toName}:${r.callType}:${r.line}:${r.module ?? ""}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-}
-function getImportSpecifierName(spec) {
-  return spec.propertyName?.text ?? spec.name.text;
-}
-function emitImportSpecifierRefs(node, refs, lineNum) {
-  const module = moduleSpecifierOf(node.moduleSpecifier);
-  const clause = node.importClause;
-  if (!clause) {
-    if (module) {
-      refs.push({ fromId: 0, toName: module, callType: "import", line: lineNum, module });
-    }
-    return;
-  }
-  if (clause.name) {
-    refs.push({ fromId: 0, toName: clause.name.text, callType: "import", line: lineNum, module });
-  }
-  const bindings = clause.namedBindings;
-  if (!bindings) return;
-  if (ts.isNamedImports(bindings)) {
-    for (const element of bindings.elements) {
-      refs.push({
-        fromId: 0,
-        toName: getImportSpecifierName(element),
-        callType: "import",
-        line: lineNum,
-        module
-      });
-    }
-  } else if (ts.isNamespaceImport(bindings)) {
-    refs.push({
-      fromId: 0,
-      toName: bindings.name.text,
-      callType: "import",
-      line: lineNum,
-      module
-    });
-  }
-}
-function moduleSpecifierOf(node) {
-  return node && ts.isStringLiteral(node) ? node.text : void 0;
-}
-function emitExportSpecifierRefs(node, refs, lineNum) {
-  const module = moduleSpecifierOf(node.moduleSpecifier);
-  const clause = node.exportClause;
-  if (clause && ts.isNamespaceExport(clause)) {
-    refs.push({ fromId: 0, toName: clause.name.text, callType: "import", line: lineNum, module });
-    return;
-  }
-  if (clause && ts.isNamedExports(clause)) {
-    for (const element of clause.elements) {
-      const originalName = element.propertyName?.text ?? element.name.text;
-      refs.push({ fromId: 0, toName: originalName, callType: "import", line: lineNum, module });
-    }
-    return;
-  }
-  if (module) {
-    refs.push({ fromId: 0, toName: module, callType: "import", line: lineNum, module });
-  }
-}
-var ts, tsLoad, kindMapCache;
-var init_ts_parser = __esm({
-  "src/codebase-index/ts-parser.ts"() {
-    "use strict";
-    init_languages();
-    tsLoad = null;
-    kindMapCache = null;
-  }
-});
-
-// src/codebase-index/go-parser.ts
-var go_parser_exports = {};
-__export(go_parser_exports, {
-  detectLang: () => detectLang,
-  parseSymbols: () => parseSymbols4
-});
-import { spawn as spawn3 } from "node:child_process";
-import * as os3 from "node:os";
-import * as path5 from "node:path";
-import * as fs4 from "node:fs/promises";
-async function parseSymbols4(opts) {
-  const { file, content, lang } = opts;
-  try {
-    const parsed = await withSpawnGate(() => syncGoParse(file, content, lang));
-    if (parsed.symbols.length > 0) {
-      return parsed;
-    }
-    const fallback = fallbackParse(file, content, lang);
-    return parsed.refs?.length ? { ...fallback, refs: parsed.refs } : fallback;
-  } catch {
-    return fallbackParse(file, content, lang);
-  }
-}
-function fallbackParse(filePath, content, lang) {
-  if (!/^\s*package\s+[A-Za-z_]\w*/m.test(content) || hasUnbalancedDelimiters(content)) {
-    return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
-  }
-  const symbols = [];
-  const packageName = content.match(/^\s*package\s+([A-Za-z_]\w*)/m)?.[1] ?? "";
-  const lines = content.split(/\r?\n/);
-  for (const [idx, line] of lines.entries()) {
-    const trimmed = line.trimStart();
-    const col = line.length - trimmed.length + 1;
-    const fn = /^func\s+(?:\([^)]*\)\s*)?([A-Za-z_]\w*)\s*\(/.exec(trimmed);
-    if (fn?.[1]) {
-      addFallbackSymbol(symbols, {
-        filePath,
-        lang,
-        kind: trimmed.startsWith("func (") ? "method" : "function",
-        name: fn[1],
-        line: idx + 1,
-        col,
-        signature: trimmed,
-        scope: packageName ? `${packageName}.${fn[1]}` : fn[1]
-      });
-      continue;
-    }
-    const typeDecl = /^type\s+([A-Za-z_]\w*)\b/.exec(trimmed);
-    if (typeDecl?.[1]) {
-      addFallbackSymbol(symbols, {
-        filePath,
-        lang,
-        kind: "type",
-        name: typeDecl[1],
-        line: idx + 1,
-        col,
-        signature: trimmed,
-        scope: packageName
-      });
-      continue;
-    }
-    const valueDecl = /^(const|var)\s+([A-Za-z_]\w*)\b/.exec(trimmed);
-    if (valueDecl?.[1] && valueDecl[2]) {
-      addFallbackSymbol(symbols, {
-        filePath,
-        lang,
-        kind: valueDecl[1],
-        name: valueDecl[2],
-        line: idx + 1,
-        col,
-        signature: trimmed,
-        scope: packageName
-      });
-    }
-  }
-  return { file: filePath, lang, symbols, mtimeMs: Date.now() };
-}
-function addFallbackSymbol(symbols, opts) {
-  symbols.push({
-    id: 0,
-    lang: opts.lang,
-    kind: opts.kind,
-    name: opts.name,
-    file: opts.filePath,
-    line: opts.line,
-    col: opts.col,
-    signature: opts.signature,
-    docComment: "",
-    scope: opts.scope,
-    text: `${opts.name} ${opts.signature}`.trim()
-  });
-}
-function hasUnbalancedDelimiters(content) {
-  const pairs = { "(": ")", "[": "]", "{": "}" };
-  const closers = new Set(Object.values(pairs));
-  const stack = [];
-  for (const ch of content) {
-    if (pairs[ch]) {
-      stack.push(pairs[ch]);
-    } else if (closers.has(ch) && stack.pop() !== ch) {
-      return true;
-    }
-  }
-  return stack.length > 0;
-}
-async function syncGoParse(filePath, content, lang) {
-  try {
-    let scriptPath = _cachedGoScriptPath;
-    if (!scriptPath) {
-      const tmpDir = await fs4.mkdtemp(path5.join(os3.tmpdir(), "ws-go-parse-"));
-      scriptPath = path5.join(tmpDir, "parse.go");
-      await fs4.writeFile(scriptPath, GO_PARSE_SCRIPT, "utf8");
-      _cachedGoScriptPath = scriptPath;
-    }
-    const goBinary = resolveWin32Command("go");
-    const goResult = await new Promise(
-      (resolve, reject) => {
-        let settled = false;
-        const proc = spawn3(goBinary, ["run", scriptPath], {
-          stdio: ["pipe", "pipe", "pipe"],
-          windowsHide: true
-        });
-        proc.on("error", (err) => {
-          if (settled) return;
-          settled = true;
-          reject(err);
-        });
-        let stdout2 = "";
-        proc.stdout?.on("data", (chunk) => {
-          stdout2 += chunk.toString();
-        });
-        proc.stderr?.resume();
-        proc.stdin?.write(content);
-        proc.stdin?.end();
-        const timer = setTimeout(() => {
-          if (settled) return;
-          settled = true;
-          proc.kill("SIGKILL");
-          reject(new Error("timeout"));
-        }, 15e3);
-        timer.unref?.();
-        proc.on("close", (code2) => {
-          if (settled) return;
-          settled = true;
-          clearTimeout(timer);
-          resolve({ code: code2, stdout: stdout2 });
-        });
-      }
-    );
-    const { code, stdout } = goResult;
-    if (code !== 0 || !stdout.trim()) {
-      return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
-    }
-    const { symbols: rawSymbols, refs } = parseParserOutput(stdout, lang);
-    const symbols = rawSymbols.map((s) => ({
-      id: 0,
-      lang,
-      kind: s.kind,
-      name: s.name,
-      file: filePath,
-      line: s.line,
-      col: s.col,
-      signature: s.signature ?? "",
-      docComment: "",
-      scope: s.scope ?? "",
-      text: `${s.name} ${s.signature ?? ""}`.trim()
-    }));
-    return { file: filePath, lang, symbols, refs, mtimeMs: Date.now() };
-  } catch {
-    return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
-  }
-}
-var GO_PARSE_SCRIPT, _cachedGoScriptPath;
-var init_go_parser = __esm({
-  "src/codebase-index/go-parser.ts"() {
-    "use strict";
-    init_win32_resolve();
-    init_parser_output();
-    init_spawn_gate();
-    init_languages();
-    GO_PARSE_SCRIPT = `
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"go/ast"
-	"go/parser"
-	"go/token"
-	"io"
-	"os"
-	"strconv"
-	"strings"
-)
-
-type Sym struct {
-	Name      string \`json:"name"\`
-	Kind      string \`json:"kind"\`
-	Line      int    \`json:"line"\`
-	Col       int    \`json:"col"\`
-	Signature string \`json:"signature"\`
-	Scope     string \`json:"scope"\`
-}
-
-// Ref is a cross-reference emitted alongside the symbols, so one \`go run\`
-// yields both. Module is the import path for CallType "import", else empty.
-type Ref struct {
-	ToName   string \`json:"toName"\`
-	CallType string \`json:"callType"\`
-	Line     int    \`json:"line"\`
-	Module   string \`json:"module"\`
-}
-
-type Result struct {
-	Symbols []Sym \`json:"symbols"\`
-	Refs    []Ref \`json:"refs"\`
-}
-
-func emptyResult() string {
-	return "{\\"symbols\\":[],\\"refs\\":[]}"
-}
-
-func main() {
-	src, err := io.ReadAll(os.Stdin)
-	if err != nil {
-		fmt.Print(emptyResult())
-		return
-	}
-	fset := token.NewFileSet()
-	node, err := parser.ParseFile(fset, "src.go", src, 0)
-	if err != nil {
-		fmt.Print(emptyResult())
-		return
-	}
-
-	var syms []Sym
-
-	// Package-level scope
-	pkgScope := node.Name.Name
-
-	// Collect all top-level declarations
-	for _, decl := range node.Decls {
-		switch d := decl.(type) {
-		case *ast.FuncDecl:
-			name := d.Name.Name
-			kind := "function"
-			scope := pkgScope
-			if d.Recv != nil && len(d.Recv.List) > 0 {
-				scope = pkgScope + "." + recvTypeName(d.Recv.List[0].Type) + "." + name
-				kind = "method"
-			} else {
-				scope = pkgScope + "." + name
-			}
-			pos := fset.Position(d.Pos())
-			sig := formatFuncSig(d)
-			syms = append(syms, Sym{Name: name, Kind: kind, Line: pos.Line, Col: pos.Column, Signature: sig, Scope: scope})
-
-		case *ast.GenDecl:
-			for _, spec := range d.Specs {
-				switch s := spec.(type) {
-				case *ast.TypeSpec:
-					name := s.Name.Name
-					pos := fset.Position(s.Pos())
-					sig := "type " + name
-					if s.TypeParams != nil {
-						sig += formatTypeParams(s.TypeParams)
-					}
-					if st, ok := s.Type.(*ast.StructType); ok {
-						sig += " = struct { " + formatFields(st.Fields.List) + " }"
-					} else if it, ok := s.Type.(*ast.InterfaceType); ok {
-						sig += " = interface { " + formatMethods(it.Methods.List) + " }"
-					} else {
-						sig += " = " + formatType(s.Type)
-					}
-					syms = append(syms, Sym{Name: name, Kind: "type", Line: pos.Line, Col: pos.Column, Signature: sig, Scope: pkgScope})
-
-				case *ast.ValueSpec:
-					for _, n := range s.Names {
-						name := n.Name
-						pos := fset.Position(n.Pos())
-						kind := "var"
-						if d.Tok == token.CONST {
-							kind = "const"
-						}
-						sig := kind + " " + name
-						if s.Type != nil {
-							sig += " " + formatType(s.Type)
-						}
-						syms = append(syms, Sym{Name: name, Kind: kind, Line: pos.Line, Col: pos.Column, Signature: sig, Scope: pkgScope})
-					}
-				}
-			}
-		}
-	}
-
-	refs := []Ref{}
-	ast.Inspect(node, func(n ast.Node) bool {
-		switch expr := n.(type) {
-		case *ast.CallExpr:
-			line := fset.Position(expr.Pos()).Line
-			switch fun := expr.Fun.(type) {
-			case *ast.Ident:
-				refs = append(refs, Ref{ToName: fun.Name, CallType: "call", Line: line})
-			case *ast.SelectorExpr:
-				// Record the selected name (\`Join\` of \`filepath.Join\`): it is the
-				// declared symbol name, so it resolves the same way the TypeScript
-				// and Python extractors' call refs do.
-				refs = append(refs, Ref{ToName: fun.Sel.Name, CallType: "call", Line: line})
-			}
-		case *ast.ImportSpec:
-			if expr.Path != nil {
-				if importPath, uerr := strconv.Unquote(expr.Path.Value); uerr == nil {
-					line := fset.Position(expr.Pos()).Line
-					// A Go import names a package, not a symbol; the package's
-					// last path segment is the name it is referenced by.
-					name := importPath
-					if idx := strings.LastIndex(importPath, "/"); idx >= 0 {
-						name = importPath[idx+1:]
-					}
-					refs = append(refs, Ref{ToName: name, CallType: "import", Line: line, Module: importPath})
-				}
-			}
-		}
-		return true
-	})
-
-	if syms == nil {
-		syms = []Sym{}
-	}
-	data, err := json.Marshal(Result{Symbols: syms, Refs: refs})
-	if err != nil {
-		fmt.Print(emptyResult())
-		return
-	}
-	fmt.Print(string(data))
-}
-
-func recvTypeName(t ast.Expr) string {
-	switch v := t.(type) {
-	case *ast.Ident:
-		return v.Name
-	case *ast.StarExpr:
-		return recvTypeName(v.X)
-	default:
-		return "?"
-	}
-}
-
-func formatFuncSig(d *ast.FuncDecl) string {
-	scope := ""
-	if d.Recv != nil && len(d.Recv.List) > 0 {
-		scope = "(" + formatFieldList(d.Recv.List) + ") "
-	}
-	scope += formatFuncType(d.Type)
-	return "func " + scope
-}
-
-func formatFuncType(f *ast.FuncType) string {
-	params := formatFieldList(f.Params.List)
-	results := ""
-	if f.Results != nil {
-		results = " -> " + formatFieldList(f.Results.List)
-	}
-	return params + results
-}
-
-func formatFieldList(fields []*ast.Field) string {
-	if len(fields) == 0 {
-		return "()"
-	}
-	names := make([]string, 0, len(fields))
-	for _, f := range fields {
-		name := ""
-		if len(f.Names) > 0 {
-			name = f.Names[0].Name
-		}
-		t := formatType(f.Type)
-		if name != "" {
-			names = append(names, name+" "+t)
-		} else {
-			names = append(names, t)
-		}
-	}
-	return "(" + strings.Join(names, ", ") + ")"
-}
-
-func formatFields(fields []*ast.Field) string {
-	lines := make([]string, 0)
-	for _, f := range fields {
-		name := ""
-		if len(f.Names) > 0 {
-			name = f.Names[0].Name
-		}
-		t := formatType(f.Type)
-		if name != "" {
-			lines = append(lines, name+" "+t)
-		} else {
-			lines = append(lines, t)
-		}
-	}
-	return strings.Join(lines, "; ")
-}
-
-func formatMethods(fields []*ast.Field) string {
-	return formatFields(fields)
-}
-
-func formatTypeParams(tp *ast.FieldList) string {
-	if tp == nil || len(tp.List) == 0 {
-		return ""
-	}
-	params := make([]string, len(tp.List))
-	for i, p := range tp.List {
-		if len(p.Names) > 0 {
-			params[i] = p.Names[0].Name
-		} else {
-			params[i] = "T"
-		}
-	}
-	return "[" + strings.Join(params, ", ") + "]"
-}
-
-func formatType(t ast.Expr) string {
-	if t == nil {
-		return "?"
-	}
-	switch v := t.(type) {
-	case *ast.Ident:
-		return v.Name
-	case *ast.SelectorExpr:
-		return formatType(v.X) + "." + v.Sel.Name
-	case *ast.StarExpr:
-		return "*" + formatType(v.X)
-	case *ast.ArrayType:
-		if v.Len == nil {
-			return "[]" + formatType(v.Elt)
-		}
-		return "[...]" + formatType(v.Elt)
-	case *ast.MapType:
-		return "map[" + formatType(v.Key) + "]" + formatType(v.Value)
-	case *ast.InterfaceType:
-		return "interface{}"
-	case *ast.StructType:
-		return "struct{}"
-	case *ast.FuncType:
-		return formatFuncType(v)
-	case *ast.ChanType:
-		return "chan " + formatType(v.Value)
-	case *ast.BasicLit:
-		return v.Value
-	case *ast.IndexExpr:
-		// Generic instantiation with one type arg, e.g. Logger[int].
-		return formatType(v.X) + "[" + formatType(v.Index) + "]"
-	case *ast.IndexListExpr:
-		// Generic instantiation with multiple type args, e.g. Map[K, V].
-		args := make([]string, len(v.Indices))
-		for i, idx := range v.Indices {
-			args[i] = formatType(idx)
-		}
-		return formatType(v.X) + "[" + strings.Join(args, ", ") + "]"
-	default:
-		return "?"
-	}
-}
-`;
-    _cachedGoScriptPath = null;
-  }
-});
-
-// src/codebase-index/rs-parser.ts
-var rs_parser_exports = {};
-__export(rs_parser_exports, {
-  detectLang: () => detectLang,
-  parseSymbols: () => parseSymbols5
-});
-import { expectDefined } from "@wrongstack/core/utils";
-async function parseSymbols5(opts) {
-  const { file, content, lang } = opts;
-  return regexParse({ file, content, lang });
-}
-function regexParse(opts) {
-  const { file, content, lang } = opts;
-  const symbols = [];
-  const lines = content.split("\n");
-  const lineOffsets = [0];
-  for (let i = 0; i < lines.length; i++) {
-    lineOffsets.push((lineOffsets[i] ?? 0) + (lines[i]?.length ?? 0) + 1);
-  }
-  function lineFromOffset(offset) {
-    let lo = 0;
-    let hi = lineOffsets.length - 1;
-    while (lo < hi) {
-      const mid = lo + hi + 1 >>> 1;
-      if (expectDefined(lineOffsets[mid]) <= offset) lo = mid;
-      else hi = mid - 1;
-    }
-    return lo + 1;
-  }
-  function extractDeclaration(lineIdx, _match) {
-    const line = lines[lineIdx] ?? "";
-    return line.trim().slice(0, 500);
-  }
-  for (const pattern of RS_PATTERNS) {
-    pattern.regex.lastIndex = 0;
-    for (let match = pattern.regex.exec(content); match !== null; match = pattern.regex.exec(content)) {
-      const name = expectDefined(match[1]);
-      const offset = match.index ?? 0;
-      const line = lineFromOffset(offset);
-      const col = offset - (lineOffsets[line - 1] ?? 0);
-      const lineIdx = line - 1;
-      const signature = extractDeclaration(lineIdx, match);
-      symbols.push({
-        id: 0,
-        lang,
-        kind: pattern.kind,
-        name,
-        file,
-        line,
-        col,
-        signature,
-        docComment: "",
-        scope: "",
-        text: `${name} ${signature}`.trim()
-      });
-    }
-  }
-  const seen = /* @__PURE__ */ new Set();
-  const deduped = symbols.filter((s) => {
-    const key = `${s.name}:${s.line}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-  return { file, lang, symbols: deduped, mtimeMs: Date.now() };
-}
-var RS_PATTERNS;
-var init_rs_parser = __esm({
-  "src/codebase-index/rs-parser.ts"() {
-    "use strict";
-    init_languages();
-    RS_PATTERNS = [
-      { regex: /fn\s+(\w+)\s*\([^)]*\)/g, kind: "function" },
-      { regex: /struct\s+(\w+)/g, kind: "struct" },
-      { regex: /enum\s+(\w+)/g, kind: "enum" },
-      { regex: /trait\s+(\w+)/g, kind: "trait" },
-      { regex: /impl\s+(?:<[^>]+>)?(\w+)/g, kind: "impl" },
-      { regex: /type\s+(\w+)\s*=/g, kind: "type" },
-      { regex: /const\s+(\w+)/g, kind: "const" },
-      { regex: /static\s+(\w+)/g, kind: "static" },
-      { regex: /mod\s+(\w+)/g, kind: "mod" }
-    ];
-  }
-});
-
-// src/codebase-index/json-parser.ts
-var json_parser_exports = {};
-__export(json_parser_exports, {
-  detectLang: () => detectLang,
-  parseSymbols: () => parseSymbols6
-});
-import { expectDefined as expectDefined2 } from "@wrongstack/core/utils";
-import * as path6 from "node:path";
-function parseSymbols6(opts) {
-  const { file, content, lang } = opts;
-  try {
-    return regexParse2({ file, content, lang });
-  } catch {
-    return { file, lang, symbols: [], mtimeMs: Date.now() };
-  }
-}
-function regexParse2(opts) {
-  const { file, content, lang } = opts;
-  const symbols = [];
-  const basename3 = path6.basename(file).toLowerCase();
-  const isPackageJson = basename3 === "package.json";
-  const isTsconfig = basename3 === "tsconfig.json" || basename3 === "tsconfig.build.json";
-  const isJsonSchema = content.includes("$schema") || content.includes("$id") || content.includes("$ref");
-  const isOpenApi = content.includes("openapi") || content.includes("swagger");
-  const lines = content.split("\n");
-  const lineOffsets = [0];
-  for (let i = 0; i < lines.length; i++) {
-    lineOffsets.push((lineOffsets[i] ?? 0) + (lines[i]?.length ?? 0) + 1);
-  }
-  function lineFromOffset(offset) {
-    let lo = 0;
-    let hi = lineOffsets.length - 1;
-    while (lo < hi) {
-      const mid = lo + hi + 1 >>> 1;
-      if (expectDefined2(lineOffsets[mid]) <= offset) lo = mid;
-      else hi = mid - 1;
-    }
-    return lo + 1;
-  }
-  const rootMatch = content.match(/^\s*\{/m);
-  if (rootMatch) {
-    const offset = expectDefined2(rootMatch.index);
-    const line = lineFromOffset(offset);
-    symbols.push(
-      makeSymbol({
-        name: path6.basename(file),
-        kind: "object",
-        line,
-        col: 0,
-        signature: `"${path6.basename(file)}" = { ... }`,
-        file,
-        lang
-      })
-    );
-  }
-  const topLevelKeyRegex = /^\s*"([^"]+)"\s*:/gm;
-  for (let match = topLevelKeyRegex.exec(content); match !== null; match = topLevelKeyRegex.exec(content)) {
-    const key = expectDefined2(match[1]);
-    const offset = match.index ?? 0;
-    const line = lineFromOffset(offset);
-    const col = offset - (lineOffsets[line - 1] ?? 0);
-    let kind = "property";
-    let signature = `"${key}": ..."`;
-    if (isPackageJson) {
-      if (key === "scripts" || key === "dependencies" || key === "devDependencies" || key === "peerDependencies" || key === "optionalDependencies") {
-        kind = "const";
-        signature = `"${key}": { ... }`;
-      }
-    } else if (isTsconfig) {
-      if (key === "compilerOptions") {
-        kind = "property";
-        signature = `"compilerOptions": { ... }`;
-      }
-    }
-    if (isJsonSchema || isOpenApi) {
-      if (key === "$schema" || key === "$id") {
-        kind = "schema";
-        signature = `"${key}": "..."`;
-      } else if (key === "$ref") {
-        kind = "schema";
-        signature = `"$ref": "..."`;
-      }
-    }
-    symbols.push(
-      makeSymbol({
-        name: key,
-        kind,
-        line,
-        col,
-        signature,
-        file,
-        lang
-      })
-    );
-    if (isPackageJson && key === "scripts") {
-      extractPackageScripts(content, symbols, file, lang, lineOffsets, lineFromOffset);
-    }
-    if (isTsconfig && key === "compilerOptions") {
-      extractCompilerOptions(content, symbols, file, lang, lineOffsets, line, lineFromOffset);
-    }
-  }
-  const defsRegex = /"\$defs"\s*:|"\$defs"\s*:/g;
-  const defsMatch = defsRegex.exec(content);
-  if (defsMatch !== null) {
-    const offset = expectDefined2(defsMatch.index);
-    const line = lineFromOffset(offset);
-    symbols.push(
-      makeSymbol({
-        name: "$defs",
-        kind: "property",
-        line,
-        col: offset - (lineOffsets[line - 1] ?? 0),
-        signature: '"$defs": { ... }',
-        file,
-        lang
-      })
-    );
-  }
-  const defsPatterns = [
-    /"\$defs"\s*:/g,
-    /"definitions"\s*:/g,
-    /"components"\s*:/g,
-    /"schemas"\s*:/g
-  ];
-  for (const pat of defsPatterns) {
-    pat.lastIndex = 0;
-    for (let match = pat.exec(content); match !== null; match = pat.exec(content)) {
-      const offset = match.index ?? 0;
-      const line = lineFromOffset(offset);
-      const key = match[0]?.match(/"([^"]+)"/)?.[1] ?? expectDefined2(match[0]);
-      symbols.push(
-        makeSymbol({
-          name: key,
-          kind: "property",
-          line,
-          col: offset - (lineOffsets[line - 1] ?? 0),
-          signature: `"${key}": { ... }`,
-          file,
-          lang
-        })
-      );
-    }
-  }
-  return { file, lang, symbols, mtimeMs: Date.now() };
-}
-function extractPackageScripts(content, symbols, file, lang, lineOffsets, lineFromOffset) {
-  const scriptsBlockRegex = /"scripts"\s*:\s*\{([^}]+)\}/g;
-  for (let match = scriptsBlockRegex.exec(content); match !== null; match = scriptsBlockRegex.exec(content)) {
-    const blockContent = expectDefined2(match[0]);
-    const blockOffset = match.index ?? 0;
-    const scriptKeyRegex = /"(\w[\w-]*)"\s*:/g;
-    for (let scriptMatch = scriptKeyRegex.exec(blockContent); scriptMatch !== null; scriptMatch = scriptKeyRegex.exec(blockContent)) {
-      const key = expectDefined2(scriptMatch[1]);
-      const keyOffset = blockOffset + expectDefined2(scriptMatch.index);
-      const line = lineFromOffset(keyOffset);
-      symbols.push(
-        makeSymbol({
-          name: key,
-          kind: "function",
-          line,
-          col: keyOffset - (lineOffsets[line - 1] ?? 0),
-          signature: `"${key}": "..."`,
-          file,
-          lang
-        })
-      );
-    }
-  }
-}
-function extractCompilerOptions(content, symbols, file, lang, lineOffsets, parentLine, lineFromOffset) {
-  const optsBlockRegex = /"compilerOptions"\s*:\s*\{([^}]+)\}/g;
-  for (let match = optsBlockRegex.exec(content); match !== null; match = optsBlockRegex.exec(content)) {
-    const blockContent = expectDefined2(match[0]);
-    const blockOffset = match.index ?? 0;
-    const optKeyRegex = /"(\w[\w]*)"\s*:/g;
-    for (let optMatch = optKeyRegex.exec(blockContent); optMatch !== null; optMatch = optKeyRegex.exec(blockContent)) {
-      const key = expectDefined2(optMatch[1]);
-      const keyOffset = blockOffset + expectDefined2(optMatch.index);
-      const line = lineFromOffset(keyOffset);
-      if (line <= parentLine) continue;
-      symbols.push(
-        makeSymbol({
-          name: key,
-          kind: "property",
-          line,
-          col: keyOffset - (lineOffsets[line - 1] ?? 0),
-          signature: `"${key}": ...`,
-          file,
-          lang
-        })
-      );
-    }
-  }
-}
-function makeSymbol(opts) {
-  return {
-    id: 0,
-    lang: opts.lang,
-    kind: opts.kind,
-    name: opts.name,
-    file: opts.file,
-    line: opts.line,
-    col: opts.col,
-    signature: opts.signature,
-    docComment: "",
-    scope: "",
-    text: `${opts.name} ${opts.signature}`.trim()
-  };
-}
-var init_json_parser = __esm({
-  "src/codebase-index/json-parser.ts"() {
-    "use strict";
-    init_languages();
-  }
-});
-
-// src/codebase-index/yaml-parser.ts
-var yaml_parser_exports = {};
-__export(yaml_parser_exports, {
-  detectLang: () => detectLang,
-  parseSymbols: () => parseSymbols7
-});
-import { expectDefined as expectDefined3, truncate } from "@wrongstack/core/utils";
-function parseSymbols7(opts) {
-  const { file, content, lang } = opts;
-  try {
-    return regexParse3({ file, content, lang });
-  } catch {
-    return { file, lang, symbols: [], mtimeMs: Date.now() };
-  }
-}
-function regexParse3(opts) {
-  const { file, content, lang } = opts;
-  const symbols = [];
-  const lines = content.split("\n");
-  const lineOffsets = [0];
-  for (let i = 0; i < lines.length; i++) {
-    lineOffsets.push((lineOffsets[i] ?? 0) + (lines[i]?.length ?? 0) + 1);
-  }
-  function lineFromOffset(offset) {
-    let lo = 0;
-    let hi = lineOffsets.length - 1;
-    while (lo < hi) {
-      const mid = lo + hi + 1 >>> 1;
-      if (expectDefined3(lineOffsets[mid]) <= offset) lo = mid;
-      else hi = mid - 1;
-    }
-    return lo + 1;
-  }
-  const anchorRegex = /&(\w[\w-]*)/g;
-  for (let match = anchorRegex.exec(content); match !== null; match = anchorRegex.exec(content)) {
-    const name = expectDefined3(match[1]);
-    const offset = match.index ?? 0;
-    const line = lineFromOffset(offset);
-    const col = offset - (lineOffsets[line - 1] ?? 0);
-    symbols.push(
-      makeSymbol2({
-        name,
-        kind: "const",
-        line,
-        col,
-        signature: `&${name}`,
-        file,
-        lang
-      })
-    );
-  }
-  const aliasRegex = /\*(\w[\w-]*)/g;
-  for (let match = aliasRegex.exec(content); match !== null; match = aliasRegex.exec(content)) {
-    const name = expectDefined3(match[1]);
-    const offset = match.index ?? 0;
-    const line = lineFromOffset(offset);
-    const col = offset - (lineOffsets[line - 1] ?? 0);
-    symbols.push(
-      makeSymbol2({
-        name,
-        kind: "const",
-        line,
-        col,
-        signature: `*${name}`,
-        file,
-        lang
-      })
-    );
-  }
-  const kvRegex = /^(\s*)([^:#\s][^:#\s]*)\s*:/gm;
-  for (let match = kvRegex.exec(content); match !== null; match = kvRegex.exec(content)) {
-    const indent = match[1]?.length ?? 0;
-    const key = match[2];
-    if (!key) continue;
-    const offset = match.index ?? 0;
-    const line = lineFromOffset(offset);
-    const col = offset - (lineOffsets[line - 1] ?? 0);
-    const lineContent = lines[line - 1] ?? "";
-    if (/^[|&>]/.test(lineContent.trim())) continue;
-    if (key === "---" || key === "...") continue;
-    if (indent > 12) continue;
-    const value = extractValue(content, match.index ?? 0);
-    const kind = isScalar(value) ? "literal" : "property";
-    const signature = `${key}: ${truncate(value, 60)}`;
-    symbols.push(makeSymbol2({ name: key, kind, line, col, signature, file, lang }));
-  }
-  const listItemRegex = /^-(\s+)([^:#\s][^:#\s]*)\s*:/gm;
-  for (let match = listItemRegex.exec(content); match !== null; match = listItemRegex.exec(content)) {
-    const key = expectDefined3(match[2]);
-    const offset = match.index ?? 0;
-    const line = lineFromOffset(offset);
-    const col = offset - (lineOffsets[line - 1] ?? 0);
-    const value = extractValue(content, offset + match[0]?.length);
-    const kind = isScalar(value) ? "literal" : "property";
-    symbols.push(
-      makeSymbol2({
-        name: key,
-        kind,
-        line,
-        col,
-        signature: `- ${key}: ${truncate(value, 60)}`,
-        file,
-        lang
-      })
-    );
-  }
-  const blockScalarRegex = /^(\s*)([^:#\s][^:#\s]*)\s*:\s*[|>](\s|$)/gm;
-  for (let match = blockScalarRegex.exec(content); match !== null; match = blockScalarRegex.exec(content)) {
-    const key = expectDefined3(match[2]);
-    const offset = match.index ?? 0;
-    const line = lineFromOffset(offset);
-    const col = offset - (lineOffsets[line - 1] ?? 0);
-    symbols.push(
-      makeSymbol2({
-        name: key,
-        kind: "property",
-        line,
-        col,
-        signature: `${key}: | ...`,
-        file,
-        lang
-      })
-    );
-  }
-  return { file, lang, symbols, mtimeMs: Date.now() };
-}
-function extractValue(content, afterColonOffset) {
-  const lineEnd = content.indexOf("\n", afterColonOffset);
-  const rest = content.slice(afterColonOffset, lineEnd < 0 ? void 0 : lineEnd);
-  return rest.trim();
-}
-function isScalar(value) {
-  if (!value) return false;
-  if (/^-?\d+(\.\d+)?([eE][+-]?\d+)?$/.test(value)) return true;
-  if (/^(true|false|null|undefined)$/i.test(value)) return true;
-  if (/^'[^']*'$/.test(value) || /^"[^"]*"$/.test(value)) return true;
-  return false;
-}
-function makeSymbol2(opts) {
-  return {
-    id: 0,
-    lang: opts.lang,
-    kind: opts.kind,
-    name: opts.name,
-    file: opts.file,
-    line: opts.line,
-    col: opts.col,
-    signature: opts.signature,
-    docComment: "",
-    scope: "",
-    text: `${opts.name} ${opts.signature}`.trim()
-  };
-}
-var init_yaml_parser = __esm({
-  "src/codebase-index/yaml-parser.ts"() {
-    "use strict";
-    init_languages();
-  }
-});
-
-// src/codebase-index/tree-sitter/queries.ts
-function parseGroupedUse(text) {
-  const open = text.indexOf("{");
-  const close = text.lastIndexOf("}");
-  if (open < 0 || close <= open) return null;
-  const prefix = text.slice(0, open).replace(/[\\/]+$/, "");
-  const out = [];
-  for (const rawMember of text.slice(open + 1, close).split(",")) {
-    let member = rawMember.trim();
-    if (!member) continue;
-    member = member.replace(
-      /^(static|final|type|class|struct|enum|protocol|var|func|let|typealias|function|const)\s+/i,
-      ""
-    ).trim();
-    if (!member) continue;
-    const aliasMatch = /\s+as\s+([A-Za-z_]\w*)\s*$/i.exec(member);
-    if (aliasMatch) member = member.slice(0, aliasMatch.index).trim();
-    if (!member) continue;
-    const module = prefix ? `${prefix}\\${member}` : member;
-    const toName = member.split(/[\\/]/).filter(Boolean).pop();
-    if (toName) out.push({ toName, callType: "import", module });
-  }
-  return out.length ? out : null;
-}
-function importFromText(prefixes) {
-  return (node) => {
-    let text = node.text.replace(/\s+/g, " ").trim();
-    for (const prefix of prefixes) {
-      if (text.startsWith(prefix)) text = text.slice(prefix.length).trim();
-    }
-    text = text.replace(
-      /^(static|final|type|class|struct|enum|protocol|var|func|let|typealias|function|const)\s+/i,
-      ""
-    ).trim();
-    if (text.includes("{")) return parseGroupedUse(text);
-    if (text.includes(",") && !text.includes("<") && !text.includes("=")) {
-      const out = [];
-      for (const clause of text.split(",")) {
-        const one = oneImportClause(clause.trim());
-        if (one) out.push(one);
-      }
-      return out.length ? out : null;
-    }
-    const single = oneImportClause(text);
-    return single ? [single] : null;
-  };
-}
-function oneImportClause(rawClause) {
-  let text = rawClause;
-  text = text.replace(
-    /^(static|final|type|class|struct|enum|protocol|var|func|let|typealias|function|const)\s+/i,
-    ""
-  ).trim();
-  text = text.replace(/[;}]+$/g, "").trim();
-  const aliasMatch = /\s+as\s+([A-Za-z_]\w*)\s*$/i.exec(text);
-  if (aliasMatch) text = text.slice(0, aliasMatch.index).trim();
-  const eqMatch = /^([A-Za-z_]\w*)\s*=\s*(.+)$/.exec(text);
-  if (eqMatch) text = eqMatch[2].trim();
-  if (!text) return null;
-  if (text.endsWith("*")) text = text.slice(0, -1).replace(/[.]$/, "");
-  if (!text) return null;
-  const module = text;
-  const toName = module.split(/[.\\/]/).filter(Boolean).pop()?.replace(/<.*>$/s, "");
-  if (!toName) return null;
-  return { toName, callType: "import", module };
-}
-function heritageLeaf(node, depth) {
-  if (depth > 6) return null;
-  const named = node.childForFieldName("name");
-  if (named) {
-    if (named.type === "scoped_type_identifier" || named.type === "qualified_name" || named.type === "scope_resolution" || named.type === "user_type") {
-      return heritageLeaf(named, depth + 1);
-    }
-    return named.text;
-  }
-  const children = [];
-  for (let i = 0; i < node.namedChildCount; i++) {
-    const c = node.namedChild(i);
-    if (c) children.push(c);
-  }
-  for (let i = children.length - 1; i >= 0; i--) {
-    const c = children[i];
-    if (c.type === "type_arguments" || c.type === "type_argument_list" || // cpp: (template_type arguments: (template_argument_list …)) — the
-    // descriptor's type_identifier inside it is never the declared base.
-    c.type === "template_argument_list" || c.type === "type_parameter_list" || c.type === "type_projection" || c.type === "value_arguments") {
-      continue;
-    }
-    if (c.type === "type_identifier" || c.type === "identifier" || c.type === "constant" || c.type === "name") {
-      return c.text;
-    }
-    if (c.type === "scoped_type_identifier" || c.type === "qualified_name" || c.type === "scope_resolution" || c.type === "user_type") {
-      return heritageLeaf(c, depth + 1);
-    }
-  }
-  return leafSegment(
-    node.text.replace(/\\/g, ".").replace(/::/g, ".").replace(/<[^<>]*>$/, "")
-  );
-}
-function leafSegment(text) {
-  return text.split(".").filter(Boolean).pop() ?? text;
-}
-function getQueries(lang) {
-  return LANG_QUERIES[lang] ?? DEFAULT_QUERIES;
-}
-function readFirstString(node) {
-  if (!node) return null;
-  if (node.type === "string_literal" || node.type === "alias") {
-    return node.text.replace(/^"|"$/g, "");
-  }
-  const child = node.namedChild(0);
-  return child ? readFirstString(child) : null;
-}
-var heritageExtractor, cCallExtractor, rubyCallExtractor, firstIdentifierCallExtractor, cIncludeExtractor, phpConstructorExtractor, DEFAULT_QUERIES, LANG_QUERIES;
-var init_queries = __esm({
-  "src/codebase-index/tree-sitter/queries.ts"() {
-    "use strict";
-    heritageExtractor = (node) => {
-      const out = [];
-      const SKIP_SUBTREES = /* @__PURE__ */ new Set([
-        "type_arguments",
-        "type_argument_list",
-        // tree-sitter-cpp names its argument subtree template_argument_list —
-        // verified AST: (base_class_clause (template_type name:
-        // (type_identifier) arguments: (template_argument_list
-        // (type_descriptor type: (type_identifier))))). Without this entry
-        // `class D : Base<Foo>` recurses into the descriptor and emits Foo as a
-        // phantom inherit ref.
-        "template_argument_list",
-        "type_parameter_list",
-        "type_projection",
-        "value_arguments"
-      ]);
-      const collect = (current, depth) => {
-        if (depth > 4) return;
-        for (let i = 0; i < current.namedChildCount; i++) {
-          const child = current.namedChild(i);
-          if (!child) continue;
-          if (SKIP_SUBTREES.has(child.type)) continue;
-          if (child.type === "type_identifier" || child.type === "identifier" || child.type === "named_type" || child.type === "type" || // PHP heritage carries `name`; Ruby a `constant`.
-          child.type === "constant" || child.type === "name") {
-            const name = child.type === "named_type" ? leafSegment(child.text) : child.text;
-            if (name) out.push({ toName: name });
-            continue;
-          }
-          if (child.type === "generic_type" || child.type === "generic_name") {
-            for (let j = 0; j < child.namedChildCount; j++) {
-              const inner = child.namedChild(j);
-              if (inner && !SKIP_SUBTREES.has(inner.type) && (inner.type === "type_identifier" || inner.type === "identifier" || inner.type === "name")) {
-                out.push({ toName: inner.text });
-                break;
-              }
-            }
-            continue;
-          }
-          if (child.type === "qualified_name" || child.type === "scoped_type_identifier" || child.type === "user_type" || child.type === "scope_resolution") {
-            const leaf = heritageLeaf(child, 0);
-            if (leaf) out.push({ toName: leaf });
-            continue;
-          }
-          collect(child, depth + 1);
-        }
-      };
-      collect(node, 0);
-      return out;
-    };
-    cCallExtractor = (node) => {
-      const fn = node.childForFieldName("function");
-      if (!fn) return null;
-      if (fn.type === "field_expression") {
-        const field = fn.childForFieldName("field");
-        if (field) return [{ toName: field.text, callType: "call" }];
-        const seg = fn.text.split("->").filter(Boolean).pop();
-        if (seg) return [{ toName: leafSegment(seg.split(".")[0] ?? seg), callType: "call" }];
-        return null;
-      }
-      if (fn.type === "qualified_identifier") {
-        const name = fn.childForFieldName("name");
-        if (name) return [{ toName: name.text, callType: "call" }];
-        const seg = fn.text.split("::").filter(Boolean).pop();
-        if (seg) return [{ toName: seg.split(/[<(]/)[0].trim(), callType: "call" }];
-        return null;
-      }
-      return [{ toName: fn.text.split(/[<(]/)[0].trim(), callType: "call" }];
-    };
-    rubyCallExtractor = (node) => {
-      const emissions = [];
-      const method = node.childForFieldName("method");
-      if (method) {
-        const name = method.text;
-        if (name && !name.includes(" ")) emissions.push({ toName: name, callType: "call" });
-        if (name === "require" || name === "require_relative") {
-          const args = node.childForFieldName("arguments");
-          const first = args?.namedChild(0);
-          if (first) {
-            const raw = first.text.replace(/^['"]|['"]$/g, "");
-            const toName = raw.split("/").filter(Boolean).pop();
-            if (toName) emissions.push({ toName, callType: "import", module: raw });
-          }
-        }
-      }
-      return emissions;
-    };
-    firstIdentifierCallExtractor = (node) => {
-      for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (child && (child.type === "simple_identifier" || child.type === "identifier")) {
-          return [{ toName: child.text, callType: "call" }];
-        }
-      }
-      const first = node.namedChild(0);
-      if (!first) return null;
-      const leaf = leafSegment(first.text.split(/[<(]/)[0] ?? first.text);
-      if (!leaf) return null;
-      return [{ toName: leaf, callType: "call" }];
-    };
-    cIncludeExtractor = (node) => {
-      const raw = node.text.replace(/^#\s*include\s*/i, "").trim();
-      const module = raw.replace(/^["'<]|["'>]$/g, "");
-      if (!module) return null;
-      const toName = module.split("/").pop()?.replace(/\.h$/, "");
-      if (!toName) return null;
-      return [{ toName, callType: "import", module }];
-    };
-    phpConstructorExtractor = (node) => {
-      for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (child && (child.type === "qualified_name" || child.type === "name")) {
-          const leaf = child.text.split(/[\\]/).filter(Boolean).pop();
-          if (leaf) return [{ toName: leaf, callType: "call" }];
-        }
-      }
-      return null;
-    };
-    DEFAULT_QUERIES = {
-      declKinds: {}
-    };
-    LANG_QUERIES = {
-      // ─── C family ──────────────────────────────────────────────────────────────
-      c: {
-        declKinds: {
-          function_definition: "function",
-          declaration: "function",
-          // K&R-style `int foo(...)` ambiguous w/ local var; the visitor prefers the function branch when the declarator field is present
-          struct_specifier: "struct",
-          union_specifier: "struct",
-          enum_specifier: "enum",
-          type_definition: "type",
-          // `typedef … X;`
-          preproc_def: "const"
-          // `#define NAME …`
-        },
-        nameField: {
-          function_definition: "declarator",
-          declaration: "declarator",
-          struct_specifier: "name",
-          enum_specifier: "name",
-          type_definition: "declarator",
-          preproc_def: "name"
-        },
-        scopeNodes: /* @__PURE__ */ new Set([
-          "translation_unit",
-          "function_definition",
-          "struct_specifier",
-          "union_specifier",
-          "enum_specifier"
-        ]),
-        refRules: {
-          // `obj->run()` and `Cls::stat()` carry structured function fields —
-          // cCallExtractor handles all three AST shapes.
-          call_expression: { callType: "call", nameExtractor: cCallExtractor },
-          preproc_include: { callType: "import", nameExtractor: cIncludeExtractor }
-        }
-      },
-      cpp: {
-        declKinds: {
-          function_definition: "function",
-          template_declaration: "function",
-          // `template<typename T> …`
-          class_specifier: "class",
-          struct_specifier: "struct",
-          union_specifier: "struct",
-          enum_specifier: "enum",
-          namespace_definition: "namespace",
-          type_definition: "type"
-        },
-        nameField: {
-          function_definition: "declarator",
-          template_declaration: "name",
-          class_specifier: "name",
-          struct_specifier: "name",
-          enum_specifier: "name",
-          namespace_definition: "name",
-          type_definition: "declarator"
-        },
-        scopeNodes: /* @__PURE__ */ new Set([
-          "translation_unit",
-          "function_definition",
-          "class_specifier",
-          "struct_specifier",
-          "union_specifier",
-          "enum_specifier",
-          "namespace_definition"
-        ]),
-        refRules: {
-          call_expression: { callType: "call", nameExtractor: cCallExtractor },
-          preproc_include: { callType: "import", nameExtractor: cIncludeExtractor },
-          // `class Foo : public Bar, private Baz` — the base-class clause.
-          base_class_clause: { callType: "inherit", nameExtractor: heritageExtractor }
-        }
-      },
-      java: {
-        declKinds: {
-          class_declaration: "class",
-          interface_declaration: "interface",
-          enum_declaration: "enum",
-          record_declaration: "class",
-          annotation_type_declaration: "interface",
-          method_declaration: "method",
-          constructor_declaration: "method",
-          field_declaration: "property"
-        },
-        nameField: {
-          class_declaration: "name",
-          interface_declaration: "name",
-          enum_declaration: "name",
-          record_declaration: "name",
-          annotation_type_declaration: "name",
-          method_declaration: "name",
-          constructor_declaration: "name"
-        },
-        // `field_declaration` has no single `name` field — it carries a list of
-        // variable declarators. We emit one Symbol per node using the first
-        // identifier-shaped named child (see `extractName` fallback in
-        // `visitor.ts`). `int a, b, c;` therefore indexes only `a` — splitting
-        // multi-declarator fields into separate Symbols is a separate refactor
-        // that needs the visitor to know it has multiple names per node, and no
-        // current test relies on it.
-        scopeNodes: /* @__PURE__ */ new Set([
-          "program",
-          "class_declaration",
-          "interface_declaration",
-          "enum_declaration",
-          "record_declaration"
-        ]),
-        refRules: {
-          method_invocation: { callType: "call", field: "name" },
-          object_creation_expression: { callType: "call", field: "type" },
-          // Verified AST: `superclass: (superclass (type_identifier))` and
-          // `interfaces: (super_interfaces (type_list ...))` — no underscores.
-          superclass: { callType: "inherit", nameExtractor: heritageExtractor },
-          super_interfaces: {
-            callType: "implement",
-            nameExtractor: heritageExtractor
-          },
-          import_declaration: {
-            callType: "import",
-            nameExtractor: importFromText(["import "])
-          }
-        }
-      },
-      csharp: {
-        // C# 10+ `namespace Foo.Bar;` produces this node type. The legacy block
-        // form `namespace Foo.Bar { ... }` produces `namespace_declaration`. Both
-        // carry a `qualified_name` child whose text already includes the dots.
-        // `using_directive` is intentionally not a declaration. Imports are
-        // extracted separately; indexing a using directive as a namespace makes
-        // the resolver bind it to its own source file before the real declaration.
-        declKinds: {
-          file_scoped_namespace_declaration: "namespace",
-          class_declaration: "class",
-          interface_declaration: "interface",
-          struct_declaration: "struct",
-          enum_declaration: "enum",
-          record_declaration: "class",
-          method_declaration: "method",
-          constructor_declaration: "method",
-          property_declaration: "property",
-          field_declaration: "property",
-          namespace_declaration: "namespace"
-        },
-        // Custom name extractor: take the full dotted name verbatim.
-        nameExtractor: (node) => {
-          const inner = node.namedChild(0);
-          if (inner && (inner.type === "qualified_name" || inner.type === "name")) {
-            return inner.text;
-          }
-          return null;
-        },
-        scopeNodes: /* @__PURE__ */ new Set([
-          "compilation_unit",
-          "namespace_declaration",
-          "class_declaration",
-          "interface_declaration",
-          "struct_declaration",
-          "enum_declaration",
-          "record_declaration"
-        ]),
-        refRules: {
-          // Verified AST: `invocation_expression function: (identifier)` — the
-          // callee field is `function` (C-style), not `name`.
-          invocation_expression: { callType: "call", field: "function" },
-          object_creation_expression: { callType: "call", field: "type" },
-          base_list: { callType: "inherit", nameExtractor: heritageExtractor },
-          using_directive: {
-            callType: "import",
-            nameExtractor: importFromText(["using "])
-          }
-        }
-      },
-      php: {
-        declKinds: {
-          function_definition: "function",
-          method_declaration: "method",
-          class_declaration: "class",
-          interface_declaration: "interface",
-          trait_declaration: "class",
-          enum_declaration: "enum",
-          namespace_definition: "namespace"
-        },
-        nameField: {
-          function_definition: "name",
-          method_declaration: "name",
-          class_declaration: "name",
-          interface_declaration: "name",
-          trait_declaration: "name",
-          enum_declaration: "name",
-          namespace_definition: "name"
-        },
-        scopeNodes: /* @__PURE__ */ new Set([
-          "program",
-          "namespace_definition",
-          "class_declaration",
-          "interface_declaration",
-          "trait_declaration",
-          "enum_declaration"
-        ]),
-        refRules: {
-          function_call_expression: { callType: "call", field: "function" },
-          // Verified AST: `new App\Model\User()` carries a BARE qualified_name
-          // child (no `name:` field), so the field default never fires.
-          object_creation_expression: { callType: "call", nameExtractor: phpConstructorExtractor },
-          base_clause: { callType: "inherit", nameExtractor: heritageExtractor },
-          class_interface_clause: {
-            callType: "implement",
-            nameExtractor: heritageExtractor
-          },
-          // Verified AST: `namespace_use_declaration (namespace_use_clause
-          // (qualified_name ...))` — not `use_declaration`.
-          namespace_use_declaration: {
-            callType: "import",
-            nameExtractor: importFromText(["use "])
-          }
-        }
-      },
-      // ─── Scripting / mobile ────────────────────────────────────────────────────
-      ruby: {
-        declKinds: {
-          method: "function",
-          singleton_method: "method",
-          class: "class",
-          module: "namespace",
-          constant: "const"
-        },
-        nameField: {
-          method: "name",
-          singleton_method: "name",
-          class: "name",
-          module: "name",
-          constant: "name"
-        },
-        scopeNodes: /* @__PURE__ */ new Set(["program", "class", "module", "singleton_method", "method"]),
-        refRules: {
-          // `call` covers both `foo(...)` and `obj.foo(...)` — the extractor
-          // records the method leaf, plus `require`/`require_relative` imports.
-          call: { callType: "call", nameExtractor: rubyCallExtractor },
-          superclass: { callType: "inherit", nameExtractor: heritageExtractor }
-        }
-      },
-      swift: {
-        declKinds: {
-          function_declaration: "function",
-          class_declaration: "class",
-          struct_declaration: "struct",
-          enum_declaration: "enum",
-          protocol_declaration: "interface",
-          actor_declaration: "class",
-          extension_declaration: "class",
-          initializer: "method",
-          property_declaration: "property"
-        },
-        nameField: {
-          function_declaration: "name",
-          class_declaration: "name",
-          struct_declaration: "name",
-          enum_declaration: "name",
-          protocol_declaration: "name",
-          actor_declaration: "name",
-          extension_declaration: "name",
-          initializer: "name",
-          property_declaration: "name"
-        },
-        scopeNodes: /* @__PURE__ */ new Set([
-          "source_file",
-          "class_declaration",
-          "struct_declaration",
-          "enum_declaration",
-          "protocol_declaration",
-          "actor_declaration",
-          "extension_declaration"
-        ]),
-        refRules: {
-          // Verified AST: `call_expression (simple_identifier) (call_suffix …)` —
-          // the callee is a bare first child, no field name.
-          call_expression: { callType: "call", nameExtractor: firstIdentifierCallExtractor },
-          // Verified AST: `inheritance_specifier inherits_from: (user_type …)`.
-          inheritance_specifier: { callType: "inherit", nameExtractor: heritageExtractor },
-          import_declaration: {
-            callType: "import",
-            nameExtractor: importFromText(["import ", "import type ", "@testable import "])
-          }
-        }
-      },
-      kotlin: {
-        declKinds: {
-          class_declaration: "class",
-          object_declaration: "class",
-          interface_declaration: "interface",
-          function_declaration: "function",
-          property_declaration: "property",
-          type_alias: "type"
-        },
-        nameField: {
-          class_declaration: "name",
-          object_declaration: "name",
-          interface_declaration: "name",
-          function_declaration: "name",
-          property_declaration: "name",
-          type_alias: "name"
-        },
-        scopeNodes: /* @__PURE__ */ new Set([
-          "source_file",
-          "class_declaration",
-          "object_declaration",
-          "interface_declaration",
-          "function_declaration"
-        ]),
-        refRules: {
-          call_expression: { callType: "call", nameExtractor: firstIdentifierCallExtractor },
-          // Verified AST: `delegation_specifier (user_type (type_identifier))` —
-          // the `: Handler` / `: Base()` clause.
-          delegation_specifier: { callType: "inherit", nameExtractor: heritageExtractor },
-          import_header: {
-            callType: "import",
-            nameExtractor: importFromText(["import "])
-          }
-        }
-      },
-      elixir: {
-        declKinds: {
-          // `def foo`, `defp foo`, `defmacro foo`, `macrop foo` all surface as
-          // `call` nodes in the tree-sitter grammar — there is no
-          // `function_definition`. The `nameExtractor` walks the call's
-          // children to pick the right sibling identifier.
-          call: "function",
-          module: "namespace"
-        },
-        nameExtractor: (node) => {
-          if (node.type === "module") {
-            const aliasNode = node.childForFieldName("alias");
-            return readFirstString(aliasNode) ?? null;
-          }
-          if (node.type !== "call") return null;
-          const first = node.namedChild(0);
-          if (!first) return null;
-          const target = first.text;
-          if (target !== "def" && target !== "defp" && target !== "defmacro" && target !== "defp_macro" && target !== "macrop" && target !== "defprotocol" && target !== "defguard" && target !== "defguardp") {
-            return null;
-          }
-          const nameNode = node.namedChild(1);
-          return nameNode?.text ?? null;
-        },
-        scopeNodes: /* @__PURE__ */ new Set(["source", "module"])
-      },
-      shell: {
-        declKinds: {
-          function_definition: "function"
-        },
-        nameField: { function_definition: "name" },
-        scopeNodes: /* @__PURE__ */ new Set(["program", "function_definition"])
-      }
-    };
-  }
-});
-
-// src/codebase-index/tree-sitter/util.ts
-function lineColAt2(offsets, index) {
-  let low = 0;
-  let high = offsets.length;
-  while (low < high) {
-    const mid = low + high >>> 1;
-    if ((offsets[mid] ?? 0) < index) low = mid + 1;
-    else high = mid;
-  }
-  const lastNl = low > 0 ? offsets[low - 1] ?? -1 : -1;
-  return { line: low + 1, col: index - lastNl };
-}
-function newlineOffsets3(content) {
-  const offsets = [];
-  for (let i = 0; i < content.length; i++) {
-    if (content.charCodeAt(i) === 10) offsets.push(i);
-  }
-  return offsets;
-}
-var TREE_SITTER_MAX_FILE_CHARS, TREE_SITTER_MAX_SYMBOLS;
-var init_util = __esm({
-  "src/codebase-index/tree-sitter/util.ts"() {
-    "use strict";
-    TREE_SITTER_MAX_FILE_CHARS = 512 * 1024;
-    TREE_SITTER_MAX_SYMBOLS = 500;
-  }
-});
-
-// src/codebase-index/tree-sitter/visitor.ts
-function visitTree(tree, content, file, lang, queries) {
-  const boundedContent = content.length > TREE_SITTER_MAX_FILE_CHARS ? content.slice(0, TREE_SITTER_MAX_FILE_CHARS) : content;
-  const nlOffsets = newlineOffsets3(boundedContent);
-  const symbols = [];
-  const refs = [];
-  const seenRefs = /* @__PURE__ */ new Set();
-  const scopeStack = [];
-  function emitRefsForNode(node, rule) {
-    const emissions = rule.nameExtractor?.(node) ?? defaultRefTarget(node, rule);
-    if (!emissions) return;
-    const { line } = lineColAt2(nlOffsets, node.startIndex);
-    for (const emission of emissions) {
-      if (!emission.toName) continue;
-      const callType = emission.callType ?? rule.callType;
-      const key = `${emission.toName}:${callType}:${line}:${emission.module ?? ""}:${node.startIndex}`;
-      if (seenRefs.has(key)) continue;
-      seenRefs.add(key);
-      refs.push({
-        fromId: 0,
-        // assignRefsToSymbols attaches owners after insertion
-        toName: emission.toName.slice(0, 200),
-        callType,
-        line,
-        lang,
-        module: emission.module
-      });
-    }
-  }
-  function defaultRefTarget(node, rule) {
-    if (!rule.field) return null;
-    const field = node.childForFieldName(rule.field);
-    if (!field) return null;
-    const leaf = field.text.split(/[.:\\]/).filter(Boolean).pop()?.split(/[<(]/)[0];
-    if (!leaf) return null;
-    return [{ toName: leaf.trim() }];
-  }
-  function visit(node, depth) {
-    if (symbols.length >= TREE_SITTER_MAX_SYMBOLS) return;
-    if (node.isMissing || node.isError) {
-    } else {
-      const kind = queries.declKinds[node.type];
-      if (kind) {
-        const emitted = emitSymbol(
-          node,
-          kind,
-          file,
-          lang,
-          scopeStack,
-          boundedContent,
-          nlOffsets,
-          queries
-        );
-        if (emitted) symbols.push(emitted);
-      }
-      const refRule = queries.refRules?.[node.type];
-      if (refRule) emitRefsForNode(node, refRule);
-    }
-    const pushesScope = queries.scopeNodes?.has(node.type) ?? false;
-    const pushIdx = pushesScope ? pushScope(scopeStack, node, queries) : -1;
-    if (queries.skipNamedChildren) {
-      if (pushIdx !== -1) scopeStack.pop();
-      return;
-    }
-    for (const child of node.namedChildren) {
-      visit(child, depth + 1);
-      if (symbols.length >= TREE_SITTER_MAX_SYMBOLS) {
-        if (pushIdx !== -1) scopeStack.pop();
-        return;
-      }
-    }
-    if (pushIdx !== -1) scopeStack.pop();
-  }
-  visit(tree.rootNode, 0);
-  return { symbols, refs };
-}
-function pushScope(scopeStack, node, queries) {
-  const name = extractName(node, queries);
-  if (!name) return -1;
-  scopeStack.push(name);
-  return scopeStack.length - 1;
-}
-function extractName(node, queries) {
-  if (queries.nameExtractor) {
-    const extracted = queries.nameExtractor(node);
-    if (extracted) return extracted;
-  }
-  const fieldName = queries.nameField?.[node.type] ?? "name";
-  const field = node.childForFieldName(fieldName);
-  if (field) {
-    if (IDENTIFIER_NODE_TYPES.has(field.type)) {
-      return field.text;
-    }
-    const inner = field.childForFieldName("name") ?? field.namedChild(0);
-    if (inner && IDENTIFIER_NODE_TYPES.has(inner.type)) {
-      return inner.text;
-    }
-  }
-  for (let i = 0; i < node.namedChildCount; i++) {
-    const child = node.namedChild(i);
-    if (child && IDENTIFIER_NODE_TYPES.has(child.type)) {
-      return child.text;
-    }
-  }
-  return null;
-}
-function emitSymbol(node, kind, file, lang, scopeStack, content, nlOffsets, queries) {
-  const name = extractName(node, queries);
-  if (!name) return null;
-  const pos = node.startIndex;
-  const { line, col } = lineColAt2(nlOffsets, pos);
-  const end = Math.min(node.endIndex, content.length);
-  const signature = content.slice(pos, end).replace(/\s+/g, " ").trim().slice(0, 500);
-  const scope = scopeStack.join(".");
-  const text = [name, signature].filter(Boolean).join(" | ").trim().slice(0, 1e3);
-  return {
-    id: 0,
-    // caller assigns during bulk insertion
-    lang,
-    kind,
-    name: name.slice(0, 200),
-    file,
-    line,
-    col,
-    signature,
-    docComment: "",
-    // doc-comment extraction lands with ref emission on Day 4
-    scope,
-    text
-  };
-}
-var IDENTIFIER_NODE_TYPES;
-var init_visitor = __esm({
-  "src/codebase-index/tree-sitter/visitor.ts"() {
-    "use strict";
-    init_util();
-    IDENTIFIER_NODE_TYPES = /* @__PURE__ */ new Set([
-      "identifier",
-      "simple_identifier",
-      "type_identifier",
-      "field_identifier",
-      "property_identifier",
-      "name",
-      "word",
-      "variable_name",
-      "constant",
-      "sym"
-    ]);
-  }
-});
-
-// src/codebase-index/tree-sitter-parser.ts
-var tree_sitter_parser_exports = {};
-__export(tree_sitter_parser_exports, {
-  __smokeRootType: () => __smokeRootType,
-  getGrammarWasmPath: () => getGrammarWasmPath,
-  isTreeSitterSupported: () => isTreeSitterSupported,
-  loadTreeSitterLanguage: () => loadTreeSitterLanguage,
-  parseSymbols: () => parseSymbols8,
-  parseTreeSitterAst: () => parseTreeSitterAst
-});
-import * as path7 from "node:path";
-import { fileURLToPath } from "node:url";
-function optInEnabled(env) {
-  return process.env[env] === "1" || process.env[env] === "true";
-}
-function getRuntime() {
-  if (!runtimePromise) {
-    runtimePromise = (async () => {
-      const mod = await import("web-tree-sitter");
-      const init = () => mod.Parser.init({ locateFile: () => RUNTIME_WASM });
-      return { Parser: mod.Parser, Language: mod.Language, init };
-    })();
-  }
-  return runtimePromise;
-}
-async function loadLanguage(lang) {
-  const existing = languageCache.get(lang);
-  if (existing) return existing;
-  const promise = (async () => {
-    const grammarName = resolveGrammarName(lang);
-    if (!grammarName) {
-      throw new Error(`tree-sitter: no grammar registered for lang "${lang}"`);
-    }
-    const wasmPath = path7.join(WASM_DIR, grammarName, `tree-sitter-${grammarName}.wasm`);
-    const { Language, init } = await getRuntime();
-    await init();
-    const languageObj = await Language.load(wasmPath);
-    return { lang, Language: languageObj };
-  })();
-  languageCache.set(lang, promise);
-  return promise;
-}
-function resolveGrammarName(lang) {
-  if (lang === "go" && optInEnabled(GO_OPT_IN)) return "go";
-  if (lang === "py" && optInEnabled(PY_OPT_IN)) return "python";
-  if (lang === "rs" && optInEnabled(RS_OPT_IN)) return "rust";
-  return LANG_TO_GRAMMAR[lang];
-}
-function isTreeSitterSupported(lang) {
-  return resolveGrammarName(lang) !== void 0;
-}
-function getGrammarWasmPath(lang) {
-  const name = resolveGrammarName(lang);
-  if (!name) return void 0;
-  return path7.join(WASM_DIR, name, `tree-sitter-${name}.wasm`);
-}
-async function parseSymbols8(opts) {
-  const { file, content, lang } = opts;
-  if (!isTreeSitterSupported(lang)) {
-    return { file, lang, symbols: [], mtimeMs: Date.now() };
-  }
-  try {
-    const { Parser } = await getRuntime();
-    const cached = await loadLanguage(lang);
-    const parser = new Parser();
-    parser.setLanguage(cached.Language);
-    const tree = parser.parse(content);
-    if (!tree) {
-      return { file, lang, symbols: [], mtimeMs: Date.now() };
-    }
-    const { symbols, refs } = visitTree(tree, content, file, lang, getQueries(lang));
-    parser.delete();
-    tree.delete();
-    return { file, lang, symbols, refs, mtimeMs: Date.now() };
-  } catch {
-    return { file, lang, symbols: [], mtimeMs: Date.now() };
-  }
-}
-async function loadTreeSitterLanguage(lang) {
-  const cached = await loadLanguage(lang);
-  return cached.Language;
-}
-async function __smokeRootType(opts) {
-  if (!isTreeSitterSupported(opts.lang)) {
-    throw new Error(`tree-sitter: no grammar registered for lang "${opts.lang}"`);
-  }
-  const { Parser } = await getRuntime();
-  const cached = await loadLanguage(opts.lang);
-  const parser = new Parser();
-  parser.setLanguage(cached.Language);
-  let tree = null;
-  try {
-    tree = parser.parse(opts.content);
-    if (!tree) throw new Error("tree-sitter: parser.parse returned null");
-    return tree.rootNode.type;
-  } finally {
-    tree?.delete();
-    parser.delete();
-  }
-}
-async function parseTreeSitterAst(opts) {
-  const grammar = resolveGrammarName(opts.lang) ?? (opts.lang === "go" ? "go" : opts.lang === "py" ? "python" : opts.lang === "rs" ? "rust" : void 0);
-  if (!grammar) return null;
-  try {
-    const { Parser, Language, init } = await getRuntime();
-    await init();
-    const wasmPath = path7.join(WASM_DIR, grammar, `tree-sitter-${grammar}.wasm`);
-    const languageObj = await Language.load(wasmPath);
-    const parser = new Parser();
-    parser.setLanguage(languageObj);
-    const tree = parser.parse(opts.content);
-    if (!tree) {
-      parser.delete();
-      return null;
-    }
-    return { tree, parser };
-  } catch {
-    return null;
-  }
-}
-var WASM_DIR, RUNTIME_WASM, LANG_TO_GRAMMAR, GO_OPT_IN, PY_OPT_IN, RS_OPT_IN, runtimePromise, languageCache;
-var init_tree_sitter_parser = __esm({
-  "src/codebase-index/tree-sitter-parser.ts"() {
-    "use strict";
-    init_queries();
-    init_visitor();
-    WASM_DIR = fileURLToPath(new URL("./wasm/", import.meta.url));
-    RUNTIME_WASM = path7.join(WASM_DIR, "tree-sitter-runtime.wasm");
-    LANG_TO_GRAMMAR = {
-      c: "c",
-      cpp: "cpp",
-      java: "java",
-      csharp: "c_sharp",
-      // tree-sitter directory uses underscore
-      php: "php",
-      ruby: "ruby",
-      swift: "swift",
-      kotlin: "kotlin",
-      shell: "bash",
-      // we treat `.sh` / `.bash` / `.zsh` via the bash grammar
-      // Go/Python/Rust are opt-in only (see goOptIn / pyOptIn / rsOptIn below)
-      elixir: "elixir"
-    };
-    GO_OPT_IN = "WRONGSTACK_USE_TS_GO";
-    PY_OPT_IN = "WRONGSTACK_USE_TS_PY";
-    RS_OPT_IN = "WRONGSTACK_USE_TS_RS";
-    runtimePromise = null;
-    languageCache = /* @__PURE__ */ new Map();
-  }
-});
+import {
+  parseFilesContent
+} from "../chunk-IYK7XGDZ.js";
+import "../chunk-ZLTFLC25.js";
+import "../chunk-A6BRWIXN.js";
+import "../chunk-UCYQTZ7F.js";
+import "../chunk-TEBQ4VPZ.js";
+import "../chunk-V43EQ6VR.js";
 
 // src/codebase-index/parser-worker-script.ts
 import { parentPort, threadId } from "node:worker_threads";
-
-// src/codebase-index/import-extractor.ts
-var IMPORT_MAX_FILE_CHARS = 512 * 1024;
-var IMPORT_MAX_PER_FILE = 400;
-var DOTTED_IMPORT = [
-  { re: /^[ \t]*import\s+(?:static\s+)?([\w.]+(?:\.\*)?)\s*;?\s*$/gm }
-];
-var LANG_IMPORTS = {
-  // Go and Python have real AST extractors; these patterns are the fallback for
-  // machines with no Go toolchain or Python interpreter installed, where the
-  // parser degrades to regex symbols and would otherwise contribute no edges.
-  go: [
-    { re: /^[ \t]*import\s+(?:[\w.]+\s+)?"([^"]+)"/gm },
-    // Grouped form: inside `import ( … )` each line is an optional alias plus a
-    // quoted path. A stray match elsewhere resolves to no file and is dropped.
-    { re: /^[ \t]*(?:[A-Za-z_.]\w*\s+)?"([^"]+)"\s*$/gm }
-  ],
-  py: [{ re: /^[ \t]*import\s+([\w.]+)/gm }, { re: /^[ \t]*from\s+([.\w]+)\s+import\b/gm }],
-  rs: [
-    // use a::b::C;  |  use a::b::{C, D};  → the path before any brace
-    { re: /^[ \t]*(?:pub\s+)?use\s+([\w:]+?)(?:::\{|\s*;|\s+as\b)/gm },
-    // mod foo;  (a declaration *and* a dependency on foo.rs / foo/mod.rs)
-    { re: /^[ \t]*(?:pub\s+)?mod\s+(\w+)\s*;/gm }
-  ],
-  java: DOTTED_IMPORT,
-  kotlin: DOTTED_IMPORT,
-  scala: [{ re: /^[ \t]*import\s+([\w.]+(?:\.[_*])?)\s*$/gm }],
-  csharp: [
-    // using Foo.Bar;  |  using static Foo.Bar;  |  using Alias = Foo.Bar;
-    { re: /^[ \t]*global\s+using\s+(?:static\s+)?([\w.]+)\s*;/gm, name: "full" },
-    { re: /^[ \t]*using\s+(?:static\s+)?(?:\w+\s*=\s*)?([\w.]+)\s*;/gm, name: "full" }
-  ],
-  // Quoted includes only: <stdio.h> is a system header with no indexed file.
-  c: [{ re: /^[ \t]*#\s*include\s+"([^"]+)"/gm }],
-  cpp: [{ re: /^[ \t]*#\s*include\s+"([^"]+)"/gm }],
-  ruby: [{ re: /^[ \t]*(?:require|require_relative|load)\s*\(?\s*['"]([^'"]+)['"]/gm }],
-  php: [
-    // `use A\B\C` imports the class C, which is what the index has a symbol
-    // for — the namespace symbol only covers the `A\B` prefix.
-    { re: /^[ \t]*use\s+(?:function\s+|const\s+)?([\w\\]+)/gm },
-    { re: /^[ \t]*(?:require|require_once|include|include_once)\s*\(?\s*['"]([^'"]+)['"]/gm }
-  ],
-  swift: [{ re: /^[ \t]*import\s+(?:struct\s+|class\s+|func\s+)?([\w.]+)\s*$/gm }],
-  dart: [{ re: /^[ \t]*(?:import|export|part)\s+['"]([^'"]+)['"]/gm }],
-  lua: [{ re: /\brequire\s*\(?\s*['"]([^'"]+)['"]/g }],
-  elixir: [{ re: /^[ \t]*(?:alias|import|require|use)\s+([A-Z][\w.]*)/gm, name: "full" }],
-  haskell: [{ re: /^[ \t]*import\s+(?:qualified\s+)?([\w.]+)/gm, name: "full" }],
-  zig: [{ re: /@import\s*\(\s*"([^"]+)"\s*\)/g }],
-  proto: [{ re: /^[ \t]*import\s+(?:public\s+|weak\s+)?"([^"]+)"\s*;/gm }],
-  // `@import "x"`, `@use "x"`, `@forward "x"` — Sass and plain CSS alike.
-  css: [{ re: /^[ \t]*@(?:import|use|forward)\s+(?:url\()?\s*['"]([^'"]+)['"]/gm }],
-  // A .vue/.svelte file's <script> block is JS; the same ESM syntax applies.
-  vue: [{ re: /^[ \t]*import\s[^'"]*from\s*['"]([^'"]+)['"]/gm }],
-  svelte: [{ re: /^[ \t]*import\s[^'"]*from\s*['"]([^'"]+)['"]/gm }],
-  html: [
-    { re: /<script[^>]+src\s*=\s*['"]([^'"]+)['"]/g },
-    { re: /<link[^>]+href\s*=\s*['"]([^'"]+)['"]/g }
-  ],
-  shell: [{ re: /^[ \t]*(?:source|\.)\s+(\S+)/gm }],
-  r: [{ re: /\b(?:source|library|require)\s*\(\s*['"]?([\w./-]+)['"]?\s*\)/g }]
-};
-function lastSegment(specifier) {
-  const pathLike = /[/\\]|::/.test(specifier);
-  const segments = specifier.split(/[/\\]|::/).filter(Boolean);
-  let last = segments[segments.length - 1] ?? specifier;
-  if (last === "*" || last === "_") {
-    last = segments[segments.length - 2] ?? specifier;
-  }
-  if (pathLike) return last.replace(/\.[A-Za-z0-9]{1,8}$/, "") || last;
-  const dotted = last.split(".").filter((part) => part && part !== "*" && part !== "_");
-  return dotted[dotted.length - 1] ?? last;
-}
-function newlineOffsets(content) {
-  const offsets = [];
-  for (let i = 0; i < content.length; i++) {
-    if (content.charCodeAt(i) === 10) offsets.push(i);
-  }
-  return offsets;
-}
-function lineAt(offsets, index) {
-  let low = 0;
-  let high = offsets.length;
-  while (low < high) {
-    const mid = low + high >>> 1;
-    if ((offsets[mid] ?? 0) < index) low = mid + 1;
-    else high = mid;
-  }
-  return low + 1;
-}
-function hasImportPatterns(lang) {
-  return LANG_IMPORTS[lang] !== void 0;
-}
-function extractImports(opts) {
-  const patterns = LANG_IMPORTS[opts.lang];
-  if (!patterns || !opts.content) return [];
-  const limit = opts.maxImports ?? IMPORT_MAX_PER_FILE;
-  const content = opts.content.length > IMPORT_MAX_FILE_CHARS ? opts.content.slice(0, IMPORT_MAX_FILE_CHARS) : opts.content;
-  const refs = [];
-  const seen = /* @__PURE__ */ new Set();
-  const offsets = newlineOffsets(content);
-  for (const pattern of patterns) {
-    const re = new RegExp(pattern.re.source, pattern.re.flags);
-    for (const match of content.matchAll(re)) {
-      if (refs.length >= limit) return refs;
-      const specifier = match[1]?.trim();
-      if (!specifier) continue;
-      const module = specifier;
-      const toName = pattern.name === "full" ? module : lastSegment(module);
-      if (!toName) continue;
-      const key = `${module}\0${toName}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      refs.push({
-        fromId: 0,
-        toName,
-        callType: "import",
-        line: lineAt(offsets, match.index ?? 0),
-        lang: opts.lang,
-        module
-      });
-    }
-  }
-  return refs;
-}
-
-// src/codebase-index/parser-batch.ts
-init_win32_resolve();
-init_parser_output();
-init_spawn_gate();
-import { spawn } from "node:child_process";
-import * as fsSync from "node:fs";
-import * as fs2 from "node:fs/promises";
-import * as os from "node:os";
-import * as path2 from "node:path";
-var MAX_BATCH_FILES = 100;
-var MAX_BATCH_BYTES = 8 * 1024 * 1024;
-function chunkBatchFiles(files) {
-  const chunks = [];
-  let current = [];
-  let bytes = 0;
-  for (const file of files) {
-    const size = Buffer.byteLength(file.content, "utf8");
-    if (current.length > 0 && (current.length >= MAX_BATCH_FILES || bytes + size > MAX_BATCH_BYTES)) {
-      chunks.push(current);
-      current = [];
-      bytes = 0;
-    }
-    current.push(file);
-    bytes += size;
-  }
-  if (current.length > 0) chunks.push(current);
-  return chunks;
-}
-function batchTimeoutMs(fileCount) {
-  return Math.min(12e4, 15e3 + fileCount * 1500);
-}
-var GO_BATCH_SCRIPT = `
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"go/ast"
-	"go/parser"
-	"go/token"
-	"io"
-	"os"
-	"strconv"
-	"strings"
-)
-
-type Sym struct {
-	Name      string \`json:"name"\`
-	Kind      string \`json:"kind"\`
-	Line      int    \`json:"line"\`
-	Col       int    \`json:"col"\`
-	Signature string \`json:"signature"\`
-	Scope     string \`json:"scope"\`
-}
-
-type Ref struct {
-	ToName   string \`json:"toName"\`
-	CallType string \`json:"callType"\`
-	Line     int    \`json:"line"\`
-	Module   string \`json:"module"\`
-}
-
-type FileResult struct {
-	File    string \`json:"file"\`
-	Error   string \`json:"error,omitempty"\`
-	Symbols []Sym  \`json:"symbols"\`
-	Refs    []Ref  \`json:"refs"\`
-}
-
-type BatchResult struct {
-	Version int          \`json:"version"\`
-	Results []FileResult \`json:"results"\`
-}
-
-type inputFile struct {
-	File    string \`json:"file"\`
-	Content string \`json:"content"\`
-}
-
-func parseOne(name string, src []byte) FileResult {
-	res := FileResult{File: name, Symbols: []Sym{}, Refs: []Ref{}}
-	fset := token.NewFileSet()
-	node, err := parser.ParseFile(fset, "src.go", src, 0)
-	if err != nil {
-		res.Error = err.Error()
-		return res
-	}
-	pkgScope := node.Name.Name
-	for _, decl := range node.Decls {
-		switch d := decl.(type) {
-		case *ast.FuncDecl:
-			symName := d.Name.Name
-			kind := "function"
-			scope := pkgScope
-			if d.Recv != nil && len(d.Recv.List) > 0 {
-				scope = pkgScope + "." + recvTypeName(d.Recv.List[0].Type) + "." + symName
-				kind = "method"
-			} else {
-				scope = pkgScope + "." + symName
-			}
-			pos := fset.Position(d.Pos())
-			res.Symbols = append(res.Symbols, Sym{Name: symName, Kind: kind, Line: pos.Line, Col: pos.Column, Signature: formatFuncSig(d), Scope: scope})
-		case *ast.GenDecl:
-			for _, spec := range d.Specs {
-				switch s := spec.(type) {
-				case *ast.TypeSpec:
-					typeName := s.Name.Name
-					pos := fset.Position(s.Pos())
-					sig := "type " + typeName
-					if s.TypeParams != nil {
-						sig += formatTypeParams(s.TypeParams)
-					}
-					if st, ok := s.Type.(*ast.StructType); ok {
-						sig += " = struct { " + formatFields(st.Fields.List) + " }"
-					} else if it, ok := s.Type.(*ast.InterfaceType); ok {
-						sig += " = interface { " + formatMethods(it.Methods.List) + " }"
-					} else {
-						sig += " = " + formatType(s.Type)
-					}
-					res.Symbols = append(res.Symbols, Sym{Name: typeName, Kind: "type", Line: pos.Line, Col: pos.Column, Signature: sig, Scope: pkgScope})
-				case *ast.ValueSpec:
-					for _, n := range s.Names {
-						valueName := n.Name
-						pos := fset.Position(n.Pos())
-						kind := "var"
-						if d.Tok == token.CONST {
-							kind = "const"
-						}
-						sig := kind + " " + valueName
-						if s.Type != nil {
-							sig += " " + formatType(s.Type)
-						}
-						res.Symbols = append(res.Symbols, Sym{Name: valueName, Kind: kind, Line: pos.Line, Col: pos.Column, Signature: sig, Scope: pkgScope})
-					}
-				}
-			}
-		}
-	}
-	ast.Inspect(node, func(n ast.Node) bool {
-		switch expr := n.(type) {
-		case *ast.CallExpr:
-			line := fset.Position(expr.Pos()).Line
-			switch fun := expr.Fun.(type) {
-			case *ast.Ident:
-				res.Refs = append(res.Refs, Ref{ToName: fun.Name, CallType: "call", Line: line})
-			case *ast.SelectorExpr:
-				res.Refs = append(res.Refs, Ref{ToName: fun.Sel.Name, CallType: "call", Line: line})
-			}
-		case *ast.ImportSpec:
-			if expr.Path != nil {
-				if importPath, uerr := strconv.Unquote(expr.Path.Value); uerr == nil {
-					line := fset.Position(expr.Pos()).Line
-					name := importPath
-					if idx := strings.LastIndex(importPath, "/"); idx >= 0 {
-						name = importPath[idx+1:]
-					}
-					res.Refs = append(res.Refs, Ref{ToName: name, CallType: "import", Line: line, Module: importPath})
-				}
-			}
-		}
-		return true
-	})
-	return res
-}
-
-func main() {
-	raw, err := io.ReadAll(os.Stdin)
-	if err != nil {
-		out, _ := json.Marshal(BatchResult{Version: 1, Results: []FileResult{}})
-		fmt.Print(string(out))
-		return
-	}
-	var inputs []inputFile
-	if err := json.Unmarshal(raw, &inputs); err != nil {
-		out, _ := json.Marshal(BatchResult{Version: 1, Results: []FileResult{}})
-		fmt.Print(string(out))
-		return
-	}
-	results := make([]FileResult, 0, len(inputs))
-	for _, in := range inputs {
-		results = append(results, parseOne(in.File, []byte(in.Content)))
-	}
-	data, err := json.Marshal(BatchResult{Version: 1, Results: results})
-	if err != nil {
-		fmt.Print("{\\"version\\":1,\\"results\\":[]}")
-		return
-	}
-	fmt.Print(string(data))
-}
-
-func recvTypeName(t ast.Expr) string {
-	switch v := t.(type) {
-	case *ast.Ident:
-		return v.Name
-	case *ast.StarExpr:
-		return recvTypeName(v.X)
-	default:
-		return "?"
-	}
-}
-
-func formatFuncSig(d *ast.FuncDecl) string {
-	scope := ""
-	if d.Recv != nil && len(d.Recv.List) > 0 {
-		scope = "(" + formatFieldList(d.Recv.List) + ") "
-	}
-	scope += formatFuncType(d.Type)
-	return "func " + scope
-}
-
-func formatFuncType(f *ast.FuncType) string {
-	params := formatFieldList(f.Params.List)
-	results := ""
-	if f.Results != nil {
-		results = " -> " + formatFieldList(f.Results.List)
-	}
-	return params + results
-}
-
-func formatFieldList(fields []*ast.Field) string {
-	if len(fields) == 0 {
-		return "()"
-	}
-	names := make([]string, 0, len(fields))
-	for _, f := range fields {
-		name := ""
-		if len(f.Names) > 0 {
-			name = f.Names[0].Name
-		}
-		t := formatType(f.Type)
-		if name != "" {
-			names = append(names, name+" "+t)
-		} else {
-			names = append(names, t)
-		}
-	}
-	return "(" + strings.Join(names, ", ") + ")"
-}
-
-func formatFields(fields []*ast.Field) string {
-	lines := make([]string, 0)
-	for _, f := range fields {
-		name := ""
-		if len(f.Names) > 0 {
-			name = f.Names[0].Name
-		}
-		t := formatType(f.Type)
-		if name != "" {
-			lines = append(lines, name+" "+t)
-		} else {
-			lines = append(lines, t)
-		}
-	}
-	return strings.Join(lines, "; ")
-}
-
-func formatMethods(fields []*ast.Field) string {
-	return formatFields(fields)
-}
-
-func formatTypeParams(tp *ast.FieldList) string {
-	if tp == nil || len(tp.List) == 0 {
-		return ""
-	}
-	params := make([]string, len(tp.List))
-	for i, p := range tp.List {
-		if len(p.Names) > 0 {
-			params[i] = p.Names[0].Name
-		} else {
-			params[i] = "T"
-		}
-	}
-	return "[" + strings.Join(params, ", ") + "]"
-}
-
-func formatType(t ast.Expr) string {
-	if t == nil {
-		return "?"
-	}
-	switch v := t.(type) {
-	case *ast.Ident:
-		return v.Name
-	case *ast.SelectorExpr:
-		return formatType(v.X) + "." + v.Sel.Name
-	case *ast.StarExpr:
-		return "*" + formatType(v.X)
-	case *ast.ArrayType:
-		if v.Len == nil {
-			return "[]" + formatType(v.Elt)
-		}
-		return "[...]" + formatType(v.Elt)
-	case *ast.MapType:
-		return "map[" + formatType(v.Key) + "]" + formatType(v.Value)
-	case *ast.InterfaceType:
-		return "interface{}"
-	case *ast.StructType:
-		return "struct{}"
-	case *ast.FuncType:
-		return formatFuncType(v)
-	case *ast.ChanType:
-		return "chan " + formatType(v.Value)
-	case *ast.BasicLit:
-		return v.Value
-	case *ast.IndexExpr:
-		return formatType(v.X) + "[" + formatType(v.Index) + "]"
-	case *ast.IndexListExpr:
-		args := make([]string, len(v.Indices))
-		for i, idx := range v.Indices {
-			args[i] = formatType(idx)
-		}
-		return formatType(v.X) + "[" + strings.Join(args, ", ") + "]"
-	default:
-		return "?"
-	}
-}
-`;
-var PY_BATCH_SCRIPT = `import ast, json, sys
-
-def get_name(node):
-    if isinstance(node, ast.Name):
-        return node.id
-    elif isinstance(node, ast.Attribute):
-        return get_name(node.value) + "." + node.attr
-    elif isinstance(node, ast.Subscript):
-        return get_name(node.value)
-    elif isinstance(node, ast.Call):
-        return get_name(node.func)
-    elif isinstance(node, ast.Constant):
-        return str(node.value)
-    return ""
-
-def leaf_name(node):
-    if isinstance(node, ast.Attribute):
-        return node.attr
-    if isinstance(node, ast.Name):
-        return node.id
-    return get_name(node).split(".")[-1]
-
-def is_private(name):
-    return name.startswith("__") and not name.endswith("__")
-
-def parse_one(name, source, module_name):
-    result = {"file": name, "symbols": [], "refs": []}
-    try:
-        tree = ast.parse(source, filename=name)
-    except Exception as e:
-        result["error"] = str(e)
-        return result
-    syms = []
-    refs = []
-    scope_stack = [module_name]
-
-    def sym(d):
-        return {
-            "name": d["name"], "kind": d["kind"], "line": d["line"], "col": d["col"],
-            "signature": d["signature"], "scope": d["scope"],
-        }
-
-    class Visitor(ast.NodeVisitor):
-        def visit_ClassDef(self, node):
-            bases = [get_name(b) for b in node.bases]
-            sig = "class " + node.name
-            if bases:
-                sig += "(" + ", ".join(bases) + ")"
-            sig += ": ..."
-            syms.append(sym({
-                "name": node.name, "kind": "class", "line": node.lineno,
-                "col": node.col_offset, "signature": sig,
-                "scope": ".".join(scope_stack) + "." + node.name,
-            }))
-            scope_stack.append(node.name)
-            self.generic_visit(node)
-            scope_stack.pop()
-
-        def visit_FunctionDef(self, node):
-            args = ", ".join(a.arg for a in node.args.args)
-            returns = get_name(node.returns) if node.returns is not None else ""
-            is_async = isinstance(node, ast.AsyncFunctionDef)
-            kind = "function"
-            prefix = "def "
-            for dec in node.decorator_list:
-                d = get_name(dec)
-                if d.endswith(".staticmethod"):
-                    kind = "staticmethod"
-                elif d.endswith(".classmethod"):
-                    kind = "classmethod"
-                elif d == "property":
-                    kind = "property"
-            if is_async:
-                kind = "async_" + kind
-            sig = f"{prefix}{node.name}({args})"
-            if returns:
-                sig += f" -> {returns}"
-            syms.append(sym({
-                "name": node.name, "kind": kind, "line": node.lineno,
-                "col": node.col_offset, "signature": sig,
-                "scope": ".".join(scope_stack) + "." + node.name,
-            }))
-
-        def visit_AsyncFunctionDef(self, node):
-            self.visit_FunctionDef(node)
-
-        def visit_Assign(self, node):
-            for target in node.targets:
-                if isinstance(target, ast.Name):
-                    tname = target.id
-                    if is_private(tname):
-                        continue
-                    kind = "const" if tname.isupper() else "var"
-                    col = target.col_offset if hasattr(target, "col_offset") else 0
-                    syms.append(sym({
-                        "name": tname, "kind": kind, "line": node.lineno, "col": col,
-                        "signature": f"{tname} = ...", "scope": ".".join(scope_stack),
-                    }))
-
-        def visit_AnnAssign(self, node):
-            if isinstance(node.target, ast.Name):
-                tname = node.target.id
-                if is_private(tname):
-                    return
-                kind = "const" if tname.isupper() else "var"
-                col = node.target.col_offset if hasattr(node.target, "col_offset") else 0
-                sig = f"{tname}: {get_name(node.annotation)}"
-                if node.value:
-                    sig += " = ..."
-                syms.append(sym({
-                    "name": tname, "kind": kind, "line": node.lineno, "col": col,
-                    "signature": sig, "scope": ".".join(scope_stack),
-                }))
-
-        def visit_Import(self, node):
-            # Parity with the single-file parser: imports are symbols too.
-            for alias in node.names:
-                name = alias.asname or alias.name
-                syms.append(sym({
-                    "name": name, "kind": "import", "line": node.lineno,
-                    "col": node.col_offset, "signature": f"import {alias.name}",
-                    "scope": ".".join(scope_stack),
-                }))
-
-        def visit_ImportFrom(self, node):
-            module = node.module or ""
-            for alias in node.names:
-                name = alias.asname or alias.name
-                syms.append(sym({
-                    "name": name, "kind": "import", "line": node.lineno,
-                    "col": node.col_offset, "signature": f"from {module} import {alias.name}",
-                    "scope": ".".join(scope_stack),
-                }))
-
-    Visitor().visit(tree)
-
-    for node in ast.walk(tree):
-        if isinstance(node, ast.Call):
-            cname = leaf_name(node.func)
-            if cname:
-                refs.append({"toName": cname, "callType": "call", "line": node.lineno})
-        elif isinstance(node, ast.Import):
-            for alias in node.names:
-                refs.append({
-                    "toName": alias.name.split(".")[-1], "callType": "import",
-                    "line": node.lineno, "module": alias.name,
-                })
-        elif isinstance(node, ast.ImportFrom):
-            module = ("." * (node.level or 0)) + (node.module or "")
-            for alias in node.names:
-                refs.append({
-                    "toName": alias.name, "callType": "import",
-                    "line": node.lineno, "module": module,
-                })
-        elif isinstance(node, ast.ClassDef):
-            for base in node.bases:
-                bname = leaf_name(base)
-                if bname:
-                    refs.append({"toName": bname, "callType": "inherit", "line": node.lineno})
-
-    result["symbols"] = syms
-    result["refs"] = refs
-    return result
-
-def main():
-    try:
-        inputs = json.loads(sys.stdin.read())
-    except Exception:
-        print(json.dumps({"version": 1, "results": []}))
-        return
-    results = []
-    for entry in inputs:
-        name = entry.get("file", "")
-        module_name = name.rsplit("/", 1)[-1].rsplit("\\\\", 1)[-1][:-3]
-        results.append(parse_one(name, entry.get("content", ""), module_name))
-    print(json.dumps({"version": 1, "results": results}))
-
-main()
-`;
-var _goBatchScriptPath = null;
-var _pyBatchScriptPath = null;
-async function ensureScriptPath(cached, prefix, fileName, script) {
-  if (cached) return { path: cached, wrote: false };
-  const dir = await fs2.mkdtemp(path2.join(os.tmpdir(), prefix));
-  const scriptPath = path2.join(dir, fileName);
-  await fs2.writeFile(scriptPath, script, { encoding: "utf8", flag: "wx" });
-  process.once("exit", () => {
-    try {
-      fsSync.rmSync(dir, { recursive: true, force: true });
-    } catch {
-    }
-  });
-  return { path: scriptPath, wrote: true };
-}
-function runToolchainChild(binary, args, stdinPayload, timeoutMs) {
-  return new Promise((resolve) => {
-    let settled = false;
-    let stdout = "";
-    let proc;
-    try {
-      proc = spawn(binary, args, { stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
-    } catch {
-      resolve(null);
-      return;
-    }
-    const finish = (value) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolve(value);
-    };
-    const timer = setTimeout(() => {
-      proc.kill("SIGKILL");
-      finish(null);
-    }, timeoutMs);
-    timer.unref?.();
-    proc.on("error", () => finish(null));
-    proc.stdout?.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    proc.stderr?.resume();
-    proc.stdin?.on("error", () => {
-    });
-    proc.stdin?.write(stdinPayload);
-    proc.stdin?.end();
-    proc.on("close", (code) => finish({ code, stdout }));
-  });
-}
-async function runGoBatch(files, goBinary) {
-  const out = /* @__PURE__ */ new Map();
-  if (files.length === 0) return out;
-  const { path: scriptPath } = await ensureScriptPath(
-    _goBatchScriptPath,
-    "ws-go-parse",
-    "batch.go",
-    GO_BATCH_SCRIPT
-  );
-  _goBatchScriptPath = scriptPath;
-  const payload = JSON.stringify(files.map((f) => ({ file: f.file, content: f.content })));
-  const result = await withSpawnGate(
-    () => runToolchainChild(
-      goBinary ?? resolveWin32Command("go"),
-      ["run", scriptPath],
-      payload,
-      batchTimeoutMs(files.length)
-    )
-  );
-  if (result?.code !== 0 || !result.stdout.trim()) return out;
-  for (const entry of parseParserBatchOutput(result.stdout, "go")) {
-    if (entry.error !== void 0) continue;
-    out.set(entry.file, {
-      file: entry.file,
-      lang: "go",
-      symbols: entry.symbols.map((s) => ({
-        id: 0,
-        lang: "go",
-        kind: s.kind,
-        name: s.name,
-        file: entry.file,
-        line: s.line,
-        col: s.col,
-        signature: s.signature ?? "",
-        docComment: "",
-        scope: s.scope ?? "",
-        text: `${s.name} ${s.signature ?? ""}`.trim()
-      })),
-      refs: entry.refs,
-      mtimeMs: Date.now()
-    });
-  }
-  return out;
-}
-async function runPyBatch(files, pythonBinary) {
-  const out = /* @__PURE__ */ new Map();
-  if (files.length === 0) return out;
-  const { path: scriptPath } = await ensureScriptPath(
-    _pyBatchScriptPath,
-    "ws-py-parse",
-    "batch.py",
-    PY_BATCH_SCRIPT
-  );
-  _pyBatchScriptPath = scriptPath;
-  const payload = JSON.stringify(files.map((f) => ({ file: f.file, content: f.content })));
-  const result = await withSpawnGate(
-    () => runToolchainChild(pythonBinary, [scriptPath], payload, batchTimeoutMs(files.length))
-  );
-  if (result?.code !== 0 || !result.stdout.trim()) return out;
-  for (const entry of parseParserBatchOutput(result.stdout, "py")) {
-    if (entry.error !== void 0) continue;
-    out.set(entry.file, {
-      file: entry.file,
-      lang: "py",
-      symbols: entry.symbols.map((s) => ({
-        id: 0,
-        lang: "py",
-        kind: s.kind,
-        name: s.name,
-        file: entry.file,
-        line: s.line,
-        col: s.col,
-        signature: s.signature ?? "",
-        docComment: "",
-        scope: s.scope ?? "",
-        text: `${s.name} ${s.signature ?? ""}`.trim()
-      })),
-      refs: entry.refs,
-      mtimeMs: Date.now()
-    });
-  }
-  return out;
-}
-
-// src/codebase-index/parser-dispatch.ts
-init_py_parser();
-async function parseFileContent(file, content, lang) {
-  const parsed = await dispatch(file, content, lang);
-  return withRelations(parsed, content, lang);
-}
-async function parseFilesContent(files) {
-  if (files.length === 0) return [];
-  const slots = files.map(() => ({ result: null }));
-  const batchingEnabled = process.env["WRONGSTACK_TOOLCHAIN_BATCH"] !== "0";
-  if (batchingEnabled) {
-    const goFiles = [];
-    const pyFiles = [];
-    files.forEach((f, index) => {
-      if (f.lang === "go") goFiles.push({ ...f, index });
-      else if (f.lang === "py") pyFiles.push({ ...f, index });
-    });
-    if (goFiles.length > 0) {
-      await applyBatchResults(slots, goFiles, (chunks) => runGoBatch(chunks), "go");
-    }
-    if (pyFiles.length > 0) {
-      const pyBinary = await resolvePythonBinary();
-      if (pyBinary) {
-        await applyBatchResults(slots, pyFiles, (chunks) => runPyBatch(chunks, pyBinary), "py");
-      }
-    }
-  }
-  const jobs = [];
-  for (let i = 0; i < files.length; i++) {
-    if (slots[i].result !== null) continue;
-    const { file, content, lang } = files[i];
-    const slot = slots[i];
-    jobs.push(
-      (async () => {
-        try {
-          slot.result = await parseFileContent(file, content, lang);
-        } catch (err) {
-          slot.error = err instanceof Error ? err.message : String(err);
-        }
-      })()
-    );
-  }
-  await Promise.all(jobs);
-  return slots;
-}
-async function applyBatchResults(slots, batchFiles, runBatch, lang) {
-  for (const chunk of chunkBatchFiles(batchFiles)) {
-    let byFile = null;
-    try {
-      byFile = await runBatch(chunk);
-    } catch {
-      byFile = null;
-    }
-    if (!byFile) continue;
-    for (const item of chunk) {
-      const parsed = byFile.get(item.file);
-      if (!parsed) continue;
-      slots[item.index] = { result: withRelations(parsed, item.content, lang) };
-    }
-  }
-}
-async function dispatch(file, content, lang) {
-  switch (lang) {
-    case "ts":
-    case "tsx":
-    case "js":
-    case "jsx": {
-      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_ts_parser(), ts_parser_exports));
-      return parseSymbols9({ file, content, lang });
-    }
-    case "go": {
-      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_go_parser(), go_parser_exports));
-      return parseSymbols9({ file, content, lang: "go" });
-    }
-    case "py": {
-      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_py_parser(), py_parser_exports));
-      return parseSymbols9({ file, content, lang: "py" });
-    }
-    case "rs": {
-      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_rs_parser(), rs_parser_exports));
-      return parseSymbols9({ file, content, lang: "rs" });
-    }
-    case "json": {
-      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_json_parser(), json_parser_exports));
-      return parseSymbols9({ file, content, lang: "json" });
-    }
-    case "yaml": {
-      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_yaml_parser(), yaml_parser_exports));
-      return parseSymbols9({ file, content, lang: "yaml" });
-    }
-    // Phase 1: ten languages now route through the Tree-Sitter WASM
-    // universal parser (`tree-sitter-parser.ts`). The dispatch falls back to
-    // the regex extractor in `generic-parser.ts` whenever WASM loading fails
-    // or the parser returns zero symbols — preserving the indexable-file
-    // contract that "missing a parser must never mean skipping the file".
-    case "c":
-    case "cpp":
-    case "java":
-    case "csharp":
-    case "php":
-    case "ruby":
-    case "swift":
-    case "kotlin":
-    case "shell":
-    case "elixir": {
-      try {
-        const { parseSymbols: parseSymbols10 } = await Promise.resolve().then(() => (init_tree_sitter_parser(), tree_sitter_parser_exports));
-        const parsed = await parseSymbols10({ file, content, lang });
-        if (parsed.symbols.length > 0) return parsed;
-      } catch {
-      }
-      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_generic_parser(), generic_parser_exports));
-      return parseSymbols9({ file, content, lang });
-    }
-    default: {
-      const { parseSymbols: parseSymbols9 } = await Promise.resolve().then(() => (init_generic_parser(), generic_parser_exports));
-      return parseSymbols9({ file, content, lang });
-    }
-  }
-}
-function withRelations(parsed, content, lang) {
-  let refs = parsed.refs ?? [];
-  if (refs.length === 0 && hasImportPatterns(lang)) {
-    refs = extractImports({ content, lang });
-  }
-  return { ...parsed, refs: refs.map((ref) => ref.lang ? ref : { ...ref, lang }) };
-}
-
-// src/codebase-index/parser-worker-script.ts
 if (!parentPort) {
   throw new Error("parser-worker-script must be started as a worker thread");
 }