@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/chunk-3ZTOHHSW.js

@@ -0,0 +1,2104 @@
+import {
+  create
+} from "./chunk-BQ3OVQ3P.js";
+import {
+  ensureWasmRegistry,
+  hasWasmInRegistry,
+  isWasmRegistryLoaded,
+  loadWebTreeSitter,
+  resolveWasmAsset
+} from "./chunk-SK6YVHFZ.js";
+import {
+  RelationshipType,
+  decodeSourceText
+} from "./chunk-KAET47ZL.js";
+import {
+  detectLanguageFromPath
+} from "./chunk-KCDECRJY.js";
+
+// src/util/lazy.ts
+function lazy(fn) {
+  let value;
+  let loaded = false;
+  const result = () => {
+    if (loaded) return value;
+    value = fn();
+    loaded = true;
+    return value;
+  };
+  result.reset = () => {
+    loaded = false;
+    value = void 0;
+  };
+  result.loaded = () => loaded;
+  return result;
+}
+
+// src/ast/engine.ts
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+var __dirname = fileURLToPath(new URL(".", import.meta.url)).replace(/[\\/]+$/, "");
+var require2 = createRequire(import.meta.url);
+var log = create({ service: "ast-engine" });
+var wasmTemps = /* @__PURE__ */ new Set();
+var wasmCleanupHooked = false;
+function trackWasmTemp(p) {
+  wasmTemps.add(p);
+  if (wasmCleanupHooked) return;
+  wasmCleanupHooked = true;
+  const sweep = () => {
+    for (const f of wasmTemps) {
+      try {
+        require2("fs").unlinkSync(f);
+      } catch {
+      }
+    }
+    wasmTemps.clear();
+  };
+  process.on("exit", sweep);
+  for (const sig of ["SIGINT", "SIGTERM"]) {
+    process.on(sig, () => {
+      sweep();
+      process.exit(0);
+    });
+  }
+}
+var ASTEngine;
+((ASTEngine2) => {
+  const languages = /* @__PURE__ */ new Map();
+  const parsers = /* @__PURE__ */ new Map();
+  const MAX_CONCURRENT_PARSERS = 20;
+  const MAX_PARSER_CACHE_SIZE = 30;
+  const MAX_PARSE_BYTES = 16 * 1024 * 1024;
+  ASTEngine2.parseTruncation = {
+    /** how many files were truncated */
+    files: 0,
+    /** total bytes dropped before parsing */
+    bytesDropped: 0,
+    /** worst offenders, largest loss first, for a report that names names */
+    worst: []
+  };
+  function recordTruncation(filePath, originalBytes, parsedBytes) {
+    const dropped = originalBytes - parsedBytes;
+    ASTEngine2.parseTruncation.files++;
+    ASTEngine2.parseTruncation.bytesDropped += dropped;
+    ASTEngine2.parseTruncation.worst.push({ filePath, bytesDropped: dropped });
+    ASTEngine2.parseTruncation.worst.sort((a, b) => b.bytesDropped - a.bytesDropped);
+    if (ASTEngine2.parseTruncation.worst.length > 20) ASTEngine2.parseTruncation.worst.length = 20;
+  }
+  let totalFilesParsed = 0;
+  let lastMemoryReport = 0;
+  const parserUsage = /* @__PURE__ */ new Map();
+  const parseCount = /* @__PURE__ */ new Map();
+  const grammarLoads = /* @__PURE__ */ new Map();
+  const treeSitterCore = lazy(async () => {
+    const WebTreeSitter = await loadWebTreeSitter();
+    const Parser = WebTreeSitter.Parser ?? WebTreeSitter.default ?? WebTreeSitter;
+    const Language = WebTreeSitter.Language ?? WebTreeSitter.default?.Language;
+    const treePath = resolveWasmCore("tree-sitter.wasm");
+    const coreWasm = hasWasmInRegistry("tree-sitter.wasm");
+    let wasmFile = treePath;
+    if (coreWasm) {
+      const os = require2("os");
+      const p = require2("path");
+      const fsModule = require2("fs");
+      for (const tmpDir of [os.tmpdir(), "/tmp", process.cwd()]) {
+        try {
+          const tmp = p.join(tmpDir, "bb-ts-core.wasm");
+          fsModule.writeFileSync(tmp, coreWasm);
+          wasmFile = tmp;
+          break;
+        } catch (e) {
+          log.debug("resolveWasm: temp file fallback failed", { error: e?.message });
+        }
+      }
+    }
+    const initFn = WebTreeSitter.init ?? Parser.init ?? Parser.init;
+    if (initFn) {
+      try {
+        await initFn({ locateFile() {
+          return wasmFile;
+        } });
+        log.info("tree-sitter core initialized", { wasmFile });
+      } catch (e1) {
+        log.warn("core init via locateFile failed, trying default", { wasmFile, error: e1 });
+        try {
+          if (wasmFile !== treePath) await initFn({ locateFile() {
+            return treePath;
+          } });
+          else await initFn();
+          log.info("tree-sitter core initialized via fallback");
+        } catch (e2) {
+          log.error("tree-sitter core init failed", { error: e2 });
+        }
+      }
+    }
+    const lang = Language ?? WebTreeSitter.default?.Language ?? Parser.Language;
+    return { Parser, Language: lang };
+  });
+  function cleanupParsers() {
+    while (parsers.size >= MAX_PARSER_CACHE_SIZE) {
+      let oldestLang = null;
+      let oldestTime = Infinity;
+      parserUsage.forEach((time, language) => {
+        if (time < oldestTime) {
+          oldestTime = time;
+          oldestLang = language;
+        }
+      });
+      if (!oldestLang) break;
+      const parser = parsers.get(oldestLang);
+      if (parser && typeof parser.delete === "function") {
+        parser.delete();
+      }
+      parsers.delete(oldestLang);
+      languages.delete(oldestLang);
+      parserUsage.delete(oldestLang);
+      log.debug("evicted parser from cache, freed WASM memory", {
+        language: oldestLang,
+        remainingParsers: parsers.size,
+        totalFilesParsed
+      });
+    }
+  }
+  function resolveWasmCore(asset) {
+    return resolveWasmAsset(asset);
+  }
+  const SUPPORTED_LANGUAGES = {
+    // === CORE WEB TECHNOLOGIES ===
+    typescript: "tree-sitter-typescript/typescript",
+    tsx: "tree-sitter-typescript/tsx",
+    javascript: "tree-sitter-javascript",
+    html: "tree-sitter-html",
+    css: "tree-sitter-css",
+    scss: "tree-sitter-css",
+    sass: "tree-sitter-css",
+    svelte: "tree-sitter-svelte",
+    json: "tree-sitter-json",
+    perl: "tree-sitter-perl",
+    yaml: "tree-sitter-yaml",
+    // === SYSTEMS PROGRAMMING ===
+    c: "tree-sitter-c",
+    cpp: "tree-sitter-cpp",
+    rust: "tree-sitter-rust",
+    go: "tree-sitter-go",
+    // === ENTERPRISE & JVM ===
+    java: "tree-sitter-java",
+    kotlin: "tree-sitter-kotlin",
+    scala: "tree-sitter-scala",
+    // === SCRIPTING & DYNAMIC ===
+    python: "tree-sitter-python",
+    ruby: "tree-sitter-ruby",
+    php: "tree-sitter-php",
+    lua: "tree-sitter-lua",
+    elixir: "tree-sitter-elixir",
+    // === FUNCTIONAL PROGRAMMING ===
+    erlang: "tree-sitter-erlang",
+    haskell: "tree-sitter-haskell",
+    clean: "tree-sitter-clean",
+    clojure: "tree-sitter-clojure",
+    // === MOBILE & MODERN ===
+    swift: "tree-sitter-swift",
+    dart: "tree-sitter-dart",
+    // === SCIENTIFIC / DYNAMIC ===
+    julia: "tree-sitter-julia",
+    // === MICROSOFT ECOSYSTEM ===
+    csharp: "tree-sitter-c-sharp",
+    // === DATA SCIENCE & STATS ===
+    r: "tree-sitter-r",
+    sql: "tree-sitter-sql",
+    // === SHELL & SYSTEM ===
+    bash: "tree-sitter-bash",
+    powershell: "tree-sitter-powershell",
+    "objective-c": "tree-sitter-objc",
+    groovy: "tree-sitter-groovy",
+    vue: "tree-sitter-vue",
+    hcl: "tree-sitter-hcl",
+    terraform: "tree-sitter-hcl",
+    graphql: "tree-sitter-graphql",
+    zig: "tree-sitter-zig",
+    fsharp: "tree-sitter-fsharp",
+    markdown: "tree-sitter-markdown",
+    toml: "tree-sitter-toml",
+    xml: "tree-sitter-xml",
+    make: "tree-sitter-make",
+    // === SYSTEMS & COMPILING LANGUAGES (a real parser each) ===
+    //
+    // `nim` appeared TWICE in this object: here as the real grammar, and again
+    // under "LANGUAGES WITHOUT DEDICATED PARSER" as `"__generic__"`. The later
+    // key won, so the map claimed nim had no parser while the wasm switch below,
+    // the vendored `grammars/tree-sitter-nim/`, the 5.8 MB
+    // `wasm/tree-sitter-nim.wasm` and a pinned fixture set all said otherwise.
+    //
+    // Two reasons it cost nothing measurable, which is why it survived until the
+    // type checker objected: this map's VALUES are never read (only its keys are
+    // — see the solidity note below), and the wasm switch is keyed off the
+    // language NAME, so .nim files loaded the real grammar either way. Measured
+    // before the fix, a .nim file declaring a type and a proc produced 3 real
+    // symbols (struct:Person, property:name, function:greet) — already correct.
+    //
+    // So removing the later entry is behaviour-NEUTRAL, and that is the point: the
+    // object no longer contradicts the grammar it points at. The M60 VB note
+    // below describes the same hazard for `vb`, where the outcome really was a
+    // silent regex pass. nim got lucky.
+    nim: "tree-sitter-nim",
+    // M60 VB wave. `vb` was `__generic__` until 2026-09-27: `.vb` was a routed
+    // extension and `vb` a declared DetectedLanguage, but there was no VB.NET
+    // grammar on npm at all (`tree-sitter-vb` and `tree-sitter-visual-basic` are
+    // both 404, and the `tree-sitter-wasms` bundle that supplies 39 of this
+    // repo's grammars ships no VB), so the file was "analysed" by a regex generic
+    // pass that cannot see a Class, a Function, an Implements clause or a call
+    // site -- and reported as covered rather than refused.
+    //
+    // The grammar is a vendored and repaired tree-sitter-vbnet; its pin, its 18
+    // patches, its source<->wasm proof and its measured parse success are in
+    // grammars/tree-sitter-vbnet/PIN.md and validation/m14/grammar-pins.json.
+    // Measured: 90.89 % clean over 1185 files on four independent corpora with
+    // 0 crash files, up from 38.67 % on Microsoft's own VisualBasic.Core when
+    // the upstream grammar was first wired.
+    vb: "tree-sitter-vbnet",
+    vba: "tree-sitter-vba",
+    matlab: "tree-sitter-matlab",
+    // === LANGUAGES WITHOUT DEDICATED PARSER (fallback to GenericAnalyzer) ===
+    // (the `nim: "__generic__"` line that used to sit here is gone — see below)
+    // Protobuf: the vendored, patched tree-sitter-proto. See
+    // grammars/tree-sitter-proto/README.md — the node surface is snake_case and
+    // is a contract, and this is the ONE routed language whose grammar had to be
+    // cloned and patched because no protobuf grammar is published on npm.
+    protobuf: "tree-sitter-protobuf",
+    // Solidity (SOL-21). ABSENT until now, and that was a real defect rather than
+    // a missing feature: the engine had a `case "solidity"` in the wasm switch
+    // below, a `case "solidity"` in getAnalyzer, a pinned grammar
+    // (validation/m14/grammar-pins.json), a real analyzer, and `DetectedLanguage`
+    // admitting "solidity" — but no key here, and this map is what
+    // `isSupportedLanguage` reads. Measured through the CLI, on an index holding
+    // the five symbols bb extracted from a Vault.sol:
+    //
+    //   $ bb search --dir <proj> --language solidity Vault
+    //   ✗ unknown language "solidity". Run `bb index --help` for supported
+    //     languages, or `bb projects` to see which are in this index.
+    //
+    // byte-identical to the answer for a genuine typo, from a filter whose whole
+    // purpose (see isSupportedLanguage) is to tell "not a language bb knows"
+    // apart from "this project has none of that language". The data was in the
+    // index and the filter refused the name.
+    //
+    // Parsing was never affected — the wasm switch and getAnalyzer key off the
+    // language name, not this map — which is exactly why it survived: the index
+    // looked correct, and the only symptom was a rejected flag.
+    //
+    // The value is the grammar package name, matching every other entry. Only the
+    // KEYS are read at runtime: isSupportedLanguage, supportedLanguageNames, and
+    // `language in SUPPORTED_LANGUAGES`.
+    solidity: "tree-sitter-solidity"
+  };
+  function isSupportedLanguage(name) {
+    if (typeof name !== "string") return false;
+    const n = name.trim().toLowerCase();
+    if (!n) return false;
+    if (Object.prototype.hasOwnProperty.call(SUPPORTED_LANGUAGES, n)) return true;
+    const aliases = {
+      ts: "typescript",
+      tsx: "tsx",
+      js: "javascript",
+      jsx: "javascript",
+      py: "python",
+      rb: "ruby",
+      rs: "rust",
+      csharp: "csharp",
+      "c#": "csharp",
+      golang: "go",
+      kt: "kotlin",
+      sh: "bash",
+      shell: "bash",
+      yml: "yaml",
+      md: "markdown"
+    };
+    const target = aliases[n];
+    return !!target && Object.prototype.hasOwnProperty.call(SUPPORTED_LANGUAGES, target);
+  }
+  ASTEngine2.isSupportedLanguage = isSupportedLanguage;
+  function supportedLanguageNames() {
+    return Object.keys(SUPPORTED_LANGUAGES).sort();
+  }
+  ASTEngine2.supportedLanguageNames = supportedLanguageNames;
+  let SymbolKind;
+  ((SymbolKind2) => {
+    SymbolKind2["Function"] = "function";
+    SymbolKind2["Class"] = "class";
+    SymbolKind2["Variable"] = "variable";
+    SymbolKind2["Constant"] = "constant";
+    SymbolKind2["Interface"] = "interface";
+    SymbolKind2["Enum"] = "enum";
+    SymbolKind2["EnumMember"] = "enum_member";
+    SymbolKind2["Type"] = "type";
+    SymbolKind2["Import"] = "import";
+    SymbolKind2["Export"] = "export";
+    SymbolKind2["Method"] = "method";
+    SymbolKind2["Property"] = "property";
+    SymbolKind2["Constructor"] = "constructor";
+    SymbolKind2["Namespace"] = "namespace";
+    SymbolKind2["Module"] = "module";
+    SymbolKind2["Table"] = "class";
+    SymbolKind2["Service"] = "class";
+    SymbolKind2["Resource"] = "class";
+    SymbolKind2["TypeAlias"] = "type";
+    SymbolKind2["Event"] = "event";
+    SymbolKind2["Delegate"] = "delegate";
+    SymbolKind2["Object"] = "class";
+    SymbolKind2["Record"] = "type";
+    SymbolKind2["Macro"] = "macro";
+    SymbolKind2["Trait"] = "trait";
+    SymbolKind2["Struct"] = "struct";
+    SymbolKind2["Impl"] = "impl";
+    SymbolKind2["Actor"] = "actor";
+    SymbolKind2["Union"] = "union";
+    SymbolKind2["Mixin"] = "mixin";
+    SymbolKind2["Extension"] = "extension";
+    SymbolKind2["Instance"] = "instance";
+  })(SymbolKind = ASTEngine2.SymbolKind || (ASTEngine2.SymbolKind = {}));
+  ASTEngine2.RelationshipType = RelationshipType;
+  const PATCHED_GRAMMAR_SHA256 = {
+    "tree-sitter-typescript.wasm": "b75fa34cfde954d15429b39062d217e6fa99b425a0c3f1aaedd082116dd20335",
+    // P3 `.RECIPEPREFIX`: the wired build is regenerated from `grammars/tree-sitter-make/recipeprefix/`
+    // (external scanner + grammar). Without this entry the resolver served the DEPENDENCY build, whose
+    // `_recipeprefix` is the hardcoded tab — so the fixture's `>` recipes parsed as ERROR nodes and the
+    // rule after them (`clean:`) was never published. Measured: `tree-sitter` CLI build, 192,211 bytes.
+    "tree-sitter-make.wasm": "af93a7597fd11dda62f5c4496fff828956c0a78656323785975ab96e3ae900ab",
+    // The two dedicated-root lanes (matlab, vba). Both are WIRED FROM THE REPO'S OWN wasm/ DIRECTORY — no
+    // npm package publishes a wasm for either grammar (matlab is an in-tree patch of acristoffers/
+    // tree-sitter-matlab 1.3.1; vba is the vendored tree-sitter-vba 0.14.5 under grammars/tree-sitter-vba/) —
+    // and both files were left UNTRACKED by the one-branch consolidation, so a fresh clone silently had no
+    // grammar for two of the 50 lanes. Pinning the bytes here is what makes the resolver serve them AT ALL
+    // (resolveWasm serves repo wasm only through this digest table), so the pin and the tracking are the
+    // same fix. The digests are the ones the lanes' own pin records verified: validation/m14/
+    // {matlab,vba}-grammar-pin.json.
+    "tree-sitter-matlab.wasm": "0f2f381f010d81af18a9f132e77606dceb02ae705c5b2e3cb0eabff3f42083c3",
+    "tree-sitter-vba.wasm": "9e0615ad1a4fdf3abff07265fe84d95ba1f392df6f4bbecd0f3ddea92aee00de"
+  };
+  function resolveWasm(relativePath) {
+    const fs = require2("fs");
+    const path = require2("path");
+    const isCompiled = typeof BB_POOL_WORKER_PATH !== "undefined";
+    if (isCompiled) {
+      const data = hasWasmInRegistry(relativePath);
+      if (data) {
+        return relativePath;
+      }
+      throw new Error(`WASM not in compiled registry: ${relativePath}`);
+    }
+    const argv0 = process.argv?.[0];
+    let execDir = argv0 && fs.existsSync(argv0) ? path.dirname(argv0) : path.dirname(process.execPath);
+    try {
+      const metaDir = path.dirname(require2("url").fileURLToPath(import.meta.url));
+      const metaCheck = path.join(metaDir, "tree-sitter.wasm");
+      if (fs.existsSync(metaCheck)) {
+        execDir = metaDir;
+      }
+    } catch (e) {
+      log.debug("resolveWasm: temp file fallback failed", { error: e?.message });
+    }
+    const flatWasmName = relativePath.split("/").pop() || "";
+    const siblingPath = `${execDir}/${flatWasmName}`;
+    if (fs.existsSync(siblingPath)) {
+      return siblingPath;
+    }
+    {
+      const pinned = PATCHED_GRAMMAR_SHA256[flatWasmName];
+      if (pinned) {
+        try {
+          const repoWasm = path.resolve(
+            path.dirname(require2("url").fileURLToPath(import.meta.url)),
+            "..",
+            "..",
+            "wasm",
+            flatWasmName
+          );
+          if (fs.existsSync(repoWasm)) {
+            const crypto = require2("crypto");
+            const actual = crypto.createHash("sha256").update(fs.readFileSync(repoWasm)).digest("hex");
+            if (actual === pinned) return repoWasm;
+            log.warn(
+              `resolveWasm: REFUSING the pinned patched grammar ${flatWasmName} \u2014 its bytes are ${actual.slice(0, 16)}\u2026 but the table pins ${pinned.slice(0, 16)}\u2026. Falling through to the dependency tree.`
+            );
+          }
+        } catch (e) {
+          log.debug("resolveWasm: patched-grammar probe failed", { error: e?.message });
+        }
+      }
+    }
+    try {
+      const resolved = require2.resolve(relativePath);
+      return resolved;
+    } catch {
+      const packageName = relativePath.split("/")[0];
+      const wasmFile = relativePath.split("/")[1] || relativePath.split("/").pop();
+      const _dirname = typeof __dirname !== "undefined" ? __dirname : fileURLToPath(import.meta.url) ? require2("path").dirname(fileURLToPath(import.meta.url)) : process.cwd();
+      const possiblePaths = [
+        `${process.cwd()}/node_modules/${packageName}/${wasmFile}`,
+        `${process.cwd()}/node_modules/.bun/${packageName}@*/node_modules/${packageName}/${wasmFile}`,
+        `${_dirname}/../../../../node_modules/${packageName}/${wasmFile}`
+      ];
+      for (const path2 of possiblePaths) {
+        try {
+          if (path2.includes("*")) {
+            const globPart = path2.substring(0, path2.indexOf("*"));
+            const afterGlob = path2.substring(path2.indexOf("*") + 1);
+            try {
+              const dirs = fs.readdirSync(globPart.substring(0, globPart.lastIndexOf("/")));
+              for (const dir of dirs) {
+                const fullPath = `${globPart}${dir}${afterGlob}`;
+                if (fs.existsSync(fullPath)) {
+                  return fullPath;
+                }
+              }
+            } catch (e) {
+              continue;
+            }
+          } else {
+            if (fs.existsSync(path2)) {
+              return path2;
+            }
+          }
+        } catch (e) {
+          continue;
+        }
+      }
+      const fallback = {
+        "tree-sitter-clean/tree-sitter-clean.wasm": [
+          "tree-sitter-clean/tree-sitter-clean.wasm"
+        ],
+        "tree-sitter-kotlin/tree-sitter-kotlin.wasm": ["tree-sitter-wasms/out/tree-sitter-kotlin.wasm"],
+        "tree-sitter-swift/tree-sitter-swift.wasm": ["tree-sitter-wasms/out/tree-sitter-swift.wasm"],
+        "tree-sitter-r/tree-sitter-r.wasm": ["@eagleoutice/tree-sitter-r/tree-sitter-r.wasm"],
+        "tree-sitter-dart/tree-sitter-dart.wasm": [
+          "tree-sitter-dart/tree-sitter-dart.wasm"
+        ],
+        "tree-sitter-yaml/tree-sitter-yaml.wasm": [
+          "@tree-sitter-grammars/tree-sitter-yaml/tree-sitter-yaml.wasm",
+          "tree-sitter-wasms/out/tree-sitter-yaml.wasm",
+          "tree-sitter-wasm-prebuilt/lib/tree-sitter-yaml.wasm"
+        ],
+        "tree-sitter-sql/tree-sitter-sql.wasm": ["@derekstride/tree-sitter-sql/src/parser"],
+        "tree-sitter-zig/tree-sitter-zig.wasm": [
+          "tree-sitter-wasms/out/tree-sitter-zig.wasm",
+          "@opentui/core/assets/zig/tree-sitter-zig.wasm"
+        ],
+        "tree-sitter-hcl/tree-sitter-hcl.wasm": [
+          "@tree-sitter-grammars/tree-sitter-hcl/tree-sitter-hcl.wasm",
+          "tree-sitter-hcl/tree-sitter-hcl.wasm"
+        ],
+        "tree-sitter-lua/tree-sitter-lua.wasm": ["tree-sitter-lua/tree-sitter-lua.wasm", "tree-sitter-wasms/out/tree-sitter-lua.wasm"],
+        // The nim grammar has no published npm tarball wasm (see
+        // grammars/tree-sitter-nim/PIN.md), so the only alternative that can
+        // resolve is a sibling checkout of the vendored source.
+        "tree-sitter-nim/tree-sitter-nim.wasm": ["tree-sitter-nim/tree-sitter-nim.wasm"],
+        "tree-sitter-erlang/tree-sitter-erlang.wasm": ["tree-sitter-erlang/tree-sitter-erlang.wasm"],
+        "tree-sitter-clojure/tree-sitter-clojure.wasm": ["tree-sitter-clojure/tree-sitter-clojure.wasm"],
+        "tree-sitter-groovy/tree-sitter-groovy.wasm": ["tree-sitter-groovy/tree-sitter-groovy.wasm"],
+        "tree-sitter-perl/tree-sitter-perl.wasm": ["tree-sitter-perl/tree-sitter-perl.wasm"],
+        "tree-sitter-scala/tree-sitter-scala.wasm": ["tree-sitter-scala/tree-sitter-scala.wasm"],
+        "tree-sitter-elixir/tree-sitter-elixir.wasm": ["tree-sitter-elixir/tree-sitter-elixir.wasm"],
+        "tree-sitter-haskell/tree-sitter-haskell.wasm": ["tree-sitter-haskell/tree-sitter-haskell.wasm"],
+        "tree-sitter-fsharp/tree-sitter-fsharp.wasm": ["tree-sitter-fsharp/tree-sitter-fsharp.wasm"]
+      };
+      const extra = fallback[relativePath] ?? [];
+      for (const item of extra) {
+        try {
+          const resolved = require2.resolve(item);
+          if (fs.existsSync(resolved)) return resolved;
+        } catch (e) {
+          continue;
+        }
+      }
+      const data = hasWasmInRegistry(relativePath);
+      if (data) {
+        try {
+          const os = require2("os");
+          const procTag = `${process.pid}_${(process.hrtime?.bigint?.() ?? BigInt(0)).toString(36)}`;
+          const base = "bb-wasm_" + relativePath.replace(/\//g, "_").replace(/\\/g, "_");
+          const tmp = path.join(os.tmpdir(), `${base}_${procTag}.partial`);
+          const final = path.join(os.tmpdir(), `${base}_${procTag}`);
+          fs.writeFileSync(tmp, data);
+          fs.renameSync(tmp, final);
+          trackWasmTemp(final);
+          return final;
+        } catch (e) {
+          log.debug("resolveWasm: temp file fallback failed", { error: e?.message });
+        }
+      }
+      return relativePath;
+    }
+  }
+  function getCachedParser2(language) {
+    return parsers.get(language);
+  }
+  ASTEngine2.getCachedParser = getCachedParser2;
+  async function getParser2(language) {
+    await ensureWasmRegistry();
+    totalFilesParsed++;
+    const MEMORY_REPORT_INTERVAL = 100;
+    if (totalFilesParsed - lastMemoryReport >= MEMORY_REPORT_INTERVAL) {
+      log.debug("parser memory report", {
+        totalFilesParsed,
+        cachedParsers: parsers.size,
+        maxParsers: MAX_PARSER_CACHE_SIZE
+      });
+      lastMemoryReport = totalFilesParsed;
+    }
+    if (parsers.size >= MAX_CONCURRENT_PARSERS) {
+      cleanupParsers();
+    }
+    const currentCount = parseCount.get(language) || 0;
+    if (currentCount >= 500 && parsers.has(language)) {
+      const p = parsers.get(language);
+      try {
+        if (typeof p.delete === "function") p.delete();
+      } catch {
+      }
+      parsers.delete(language);
+      parserUsage.delete(language);
+      parseCount.set(language, 0);
+    }
+    if (parsers.has(language)) {
+      parserUsage.set(language, Date.now());
+      parseCount.set(language, currentCount + 1);
+      return parsers.get(language);
+    }
+    const { Parser, Language } = await treeSitterCore();
+    let languageWasmPath;
+    try {
+      switch (language) {
+        // === WEB TECHNOLOGIES ===
+        case "typescript": {
+          languageWasmPath = resolveWasm("tree-sitter-typescript/tree-sitter-typescript.wasm");
+          break;
+        }
+        case "tsx": {
+          languageWasmPath = resolveWasm("tree-sitter-typescript/tree-sitter-tsx.wasm");
+          break;
+        }
+        case "javascript": {
+          languageWasmPath = resolveWasm("tree-sitter-javascript/tree-sitter-javascript.wasm");
+          break;
+        }
+        case "html": {
+          languageWasmPath = resolveWasm("tree-sitter-html/tree-sitter-html.wasm");
+          break;
+        }
+        case "css": {
+          languageWasmPath = resolveWasm("tree-sitter-css/tree-sitter-css.wasm");
+          break;
+        }
+        // scss is its OWN grammar and its own lane, not a dialect flag on the CSS one.
+        // The two were conflated until this change and the conflation was measurable:
+        // 254 `.scss` files were routed to a grammar with no `$variables`, no
+        // `@mixin`/`@include` and no interpolation, and 43 of the 244 non-empty ones
+        // parsed clean. `.sass` (indented syntax, a genuinely different grammar) and
+        // `.less` stay on the CSS wasm and stay DECLARED — measured 0 files of each in
+        // 13 corpora, so neither is a claim this repo can support or refute.
+        case "scss": {
+          languageWasmPath = resolveWasm("tree-sitter-scss.wasm");
+          break;
+        }
+        case "sass": {
+          languageWasmPath = resolveWasm("tree-sitter-css/tree-sitter-css.wasm");
+          break;
+        }
+        case "json": {
+          languageWasmPath = resolveWasm("tree-sitter-json/tree-sitter-json.wasm");
+          break;
+        }
+        case "perl": {
+          languageWasmPath = resolveWasm("tree-sitter-perl/tree-sitter-perl.wasm");
+          break;
+        }
+        case "yaml": {
+          languageWasmPath = resolveWasm("tree-sitter-yaml/tree-sitter-yaml.wasm");
+          break;
+        }
+        // === SYSTEMS PROGRAMMING ===
+        case "c": {
+          languageWasmPath = resolveWasm("tree-sitter-c/tree-sitter-c.wasm");
+          break;
+        }
+        case "cpp": {
+          languageWasmPath = resolveWasm("tree-sitter-cpp/tree-sitter-cpp.wasm");
+          break;
+        }
+        case "rust": {
+          languageWasmPath = resolveWasm("tree-sitter-rust/tree-sitter-rust.wasm");
+          break;
+        }
+        case "go": {
+          languageWasmPath = resolveWasm("tree-sitter-go/tree-sitter-go.wasm");
+          break;
+        }
+        // === ENTERPRISE & JVM ===
+        case "java": {
+          languageWasmPath = resolveWasm("tree-sitter-java/tree-sitter-java.wasm");
+          break;
+        }
+        case "kotlin": {
+          languageWasmPath = resolveWasm("tree-sitter-kotlin/tree-sitter-kotlin.wasm");
+          break;
+        }
+        case "scala": {
+          languageWasmPath = resolveWasm("tree-sitter-scala/tree-sitter-scala.wasm");
+          break;
+        }
+        // === SCRIPTING & DYNAMIC ===
+        case "python": {
+          languageWasmPath = resolveWasm("tree-sitter-python/tree-sitter-python.wasm");
+          break;
+        }
+        case "ruby": {
+          languageWasmPath = resolveWasm("tree-sitter-ruby/tree-sitter-ruby.wasm");
+          break;
+        }
+        case "php": {
+          languageWasmPath = resolveWasm("tree-sitter-php/tree-sitter-php.wasm");
+          break;
+        }
+        case "lua": {
+          try {
+            languageWasmPath = resolveWasm("tree-sitter-lua/tree-sitter-lua.wasm");
+          } catch {
+            languageWasmPath = resolveWasm("@tree-sitter-grammars/tree-sitter-lua/tree-sitter-lua.wasm");
+          }
+          break;
+        }
+        case "elixir": {
+          languageWasmPath = resolveWasm("tree-sitter-elixir/tree-sitter-elixir.wasm");
+          break;
+        }
+        case "erlang": {
+          try {
+            languageWasmPath = resolveWasm("tree-sitter-erlang/tree-sitter-erlang.wasm");
+          } catch {
+            languageWasmPath = resolveWasm("@lumis-sh/wasm-erlang/tree-sitter-erlang.wasm");
+          }
+          break;
+        }
+        // === FUNCTIONAL PROGRAMMING ===
+        case "haskell": {
+          try {
+            languageWasmPath = resolveWasm("tree-sitter-haskell/tree-sitter-haskell.wasm");
+          } catch {
+            languageWasmPath = resolveWasm("@tree-sitter-grammars/tree-sitter-haskell/tree-sitter-haskell.wasm");
+          }
+          break;
+        }
+        case "julia": {
+          languageWasmPath = resolveWasm("tree-sitter-julia/tree-sitter-julia.wasm");
+          break;
+        }
+        case "clean": {
+          languageWasmPath = resolveWasm("tree-sitter-clean/tree-sitter-clean.wasm");
+          break;
+        }
+        case "clojure": {
+          languageWasmPath = resolveWasm("tree-sitter-clojure/tree-sitter-clojure.wasm");
+          break;
+        }
+        // === MOBILE & MODERN ===
+        case "swift": {
+          languageWasmPath = resolveWasm("tree-sitter-swift/tree-sitter-swift.wasm");
+          break;
+        }
+        case "dart": {
+          languageWasmPath = resolveWasm("tree-sitter-dart/tree-sitter-dart.wasm");
+          break;
+        }
+        // === MICROSOFT ECOSYSTEM ===
+        case "csharp": {
+          languageWasmPath = resolveWasm("tree-sitter-c-sharp/tree-sitter-c_sharp.wasm");
+          break;
+        }
+        // === DATA SCIENCE & STATS ===
+        case "r": {
+          languageWasmPath = resolveWasm("tree-sitter-r/tree-sitter-r.wasm");
+          break;
+        }
+        case "sql": {
+          languageWasmPath = resolveWasm("tree-sitter-sql/tree-sitter-sql.wasm");
+          break;
+        }
+        // === SHELL & SYSTEM ===
+        case "bash": {
+          languageWasmPath = resolveWasm("tree-sitter-bash/tree-sitter-bash.wasm");
+          break;
+        }
+        case "objective-c": {
+          languageWasmPath = resolveWasm("tree-sitter-objc/tree-sitter-objc.wasm");
+          break;
+        }
+        case "groovy": {
+          languageWasmPath = resolveWasm("tree-sitter-groovy/tree-sitter-groovy.wasm");
+          break;
+        }
+        case "vue": {
+          languageWasmPath = resolveWasm("tree-sitter-vue/tree-sitter-vue.wasm");
+          break;
+        }
+        case "svelte": {
+          languageWasmPath = resolveWasm("tree-sitter-svelte/tree-sitter-svelte.wasm");
+          break;
+        }
+        case "hcl":
+        case "terraform": {
+          languageWasmPath = resolveWasm("tree-sitter-hcl/tree-sitter-hcl.wasm");
+          break;
+        }
+        case "graphql": {
+          languageWasmPath = resolveWasm("tree-sitter-graphql/tree-sitter-graphql.wasm");
+          break;
+        }
+        case "zig": {
+          languageWasmPath = resolveWasm("tree-sitter-zig/tree-sitter-zig.wasm");
+          break;
+        }
+        case "nim": {
+          languageWasmPath = resolveWasm("tree-sitter-nim/tree-sitter-nim.wasm");
+          break;
+        }
+        case "fsharp": {
+          languageWasmPath = resolveWasm("tree-sitter-fsharp/tree-sitter-fsharp.wasm");
+          break;
+        }
+        case "powershell": {
+          languageWasmPath = resolveWasm("tree-sitter-powershell/tree-sitter-powershell.wasm");
+          break;
+        }
+        // The Solidity pin names the wired bytes at `wasm/tree-sitter-solidity.wasm`
+        // (script/m14/verify-grammar-pins.ts, LANES.solidity), byte-identical to the
+        // npm tarball tree-sitter-solidity@1.2.13. The resolver keys on the basename,
+        // so this spelling and the pin's `wired` field name the same file — a swap
+        // here is a swap the pin gate catches.
+        case "solidity": {
+          languageWasmPath = resolveWasm("tree-sitter-solidity.wasm");
+          break;
+        }
+        // M60 VB wave. The wasm name is the GRAMMAR's name, not the language's:
+        // the lane reads `tree-sitter-vbnet`, and the pin's `wired` field names
+        // the same file, so a swap of the wasm here is a swap the pin catches.
+        // See grammars/tree-sitter-vbnet/PIN.md.
+        case "vb": {
+          languageWasmPath = resolveWasm("tree-sitter-vbnet/tree-sitter-vbnet.wasm");
+          break;
+        }
+        case "vba": {
+          languageWasmPath = resolveWasm("tree-sitter-vba.wasm");
+          break;
+        }
+        case "matlab": {
+          languageWasmPath = resolveWasm("tree-sitter-matlab.wasm");
+          break;
+        }
+        // === MARKUP & DATA ===
+        case "markdown": {
+          languageWasmPath = resolveWasm("tree-sitter-markdown/tree-sitter-markdown.wasm");
+          break;
+        }
+        case "toml": {
+          languageWasmPath = resolveWasm("tree-sitter-toml/tree-sitter-toml.wasm");
+          break;
+        }
+        case "xml": {
+          languageWasmPath = resolveWasm("tree-sitter-xml/tree-sitter-xml.wasm");
+          break;
+        }
+        case "make": {
+          languageWasmPath = resolveWasm("tree-sitter-make/tree-sitter-make.wasm");
+          break;
+        }
+        case "protobuf": {
+          languageWasmPath = resolveWasm("tree-sitter-protobuf/tree-sitter-protobuf.wasm");
+          break;
+        }
+        default:
+          throw new Error(`Language ${language} parser not yet implemented. Add the WASM loading case.`);
+      }
+    } catch (error) {
+      throw new Error(
+        `Failed to determine WASM path for ${language}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    let wasmBuffer;
+    const registryData = hasWasmInRegistry(languageWasmPath);
+    if (registryData) {
+      wasmBuffer = registryData;
+    } else if (isWasmRegistryLoaded()) {
+      throw new Error(`WASM not found in registry for ${language} (${languageWasmPath})`);
+    } else {
+      const fs = require2("fs");
+      wasmBuffer = new Uint8Array(fs.readFileSync(languageWasmPath));
+    }
+    let languageGrammar = languages.get(language);
+    if (!languageGrammar) {
+      try {
+        if (!wasmBuffer) throw new Error(`WASM buffer is undefined for ${language}`);
+        let inflight = grammarLoads.get(language);
+        if (!inflight) {
+          inflight = (async () => {
+            const g = await Promise.race([
+              new Promise((resolve, reject) => {
+                try {
+                  resolve(Language.load(wasmBuffer));
+                } catch (e) {
+                  reject(e);
+                }
+              }),
+              new Promise((_, r) => setTimeout(() => r(new Error("load timeout")), 1e4))
+            ]);
+            languages.set(language, g);
+            log.info("language grammar allocated", { language });
+            return g;
+          })();
+          grammarLoads.set(language, inflight);
+          inflight.catch(() => {
+          }).finally(() => grammarLoads.delete(language));
+        }
+        languageGrammar = await inflight;
+      } catch (e) {
+        throw new Error(`Language.load failed for ${language}: ${e?.message || String(e)}`);
+      }
+    }
+    const parser = new Parser();
+    parser.setLanguage(languageGrammar);
+    const existing = parsers.get(language);
+    if (existing && existing !== parser) {
+      try {
+        if (typeof parser.delete === "function") parser.delete();
+      } catch {
+      }
+      parserUsage.set(language, Date.now());
+      return existing;
+    }
+    languages.set(language, languageGrammar);
+    parsers.set(language, parser);
+    parserUsage.set(language, Date.now());
+    parseCount.set(language, 1);
+    log.info("language parser loaded", { language, wasmPath: languageWasmPath });
+    return parser;
+  }
+  ASTEngine2.getParser = getParser2;
+  function detectLanguage(filePath, content) {
+    return detectLanguageFromPath(filePath, content);
+  }
+  ASTEngine2.detectLanguage = detectLanguage;
+  function extractHtmlEmbeddedBlocks(rootNode, content) {
+    const out = [];
+    const stack = [rootNode];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "script_element" || n.type === "style_element") {
+        const isStyle = n.type === "style_element";
+        let rawText = null;
+        let lang = isStyle ? "css" : "js";
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (!c) continue;
+          if (c.type === "raw_text") rawText = c;
+          if (c.type === "start_tag") {
+            for (let j = 0; j < c.namedChildCount; j++) {
+              const a = c.namedChild(j);
+              if (a && a.type === "attribute") {
+                const attrName = findAttributeName(a);
+                if (isStyle) {
+                  if (attrName === "lang") {
+                    const v = findAttributeValue(a);
+                    if (v === "css" || v === "text/css") lang = "css";
+                    else lang = "js";
+                  }
+                } else if (attrName === "lang") {
+                  const v = findAttributeValue(a);
+                  if (v === "ts" || v === "typescript") lang = "ts";
+                  else if (v === "tsx") lang = "tsx";
+                } else if (attrName === "type") {
+                  const v = findAttributeValue(a);
+                  const lowered = v.toLowerCase();
+                  if (lowered === "module" || lowered === "text/javascript" || lowered === "application/javascript" || lowered === "text/ecmascript" || lowered === "module/javascript") lang = "js";
+                  else if (lowered === "text/typescript" || lowered === "application/typescript" || lowered === "ts") lang = "ts";
+                  else if (lowered === "text/tsx" || lowered === "tsx") lang = "tsx";
+                }
+              }
+            }
+          }
+        }
+        if (rawText) {
+          const body = content.substring(rawText.startIndex, rawText.endIndex);
+          if (body.trim().length > 0) {
+            out.push({
+              body,
+              lang,
+              startLine: rawText.startPosition.row + 1,
+              startColumn: rawText.startPosition.column,
+              startIndex: rawText.startIndex
+            });
+          }
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return out;
+  }
+  ASTEngine2.extractHtmlEmbeddedBlocks = extractHtmlEmbeddedBlocks;
+  function extractSfcScriptBlocks(rootNode, content) {
+    const out = [];
+    const stack = [rootNode];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "script_element") {
+        let rawText = null;
+        let lang = "js";
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (!c) continue;
+          if (c.type === "raw_text") rawText = c;
+          if (c.type === "start_tag") {
+            for (let j = 0; j < c.namedChildCount; j++) {
+              const a = c.namedChild(j);
+              if (a && a.type === "attribute") {
+                const attrName = findAttributeName(a);
+                if (attrName === "lang") {
+                  let v = findAttributeValue(a);
+                  if (v === "ts") lang = "ts";
+                  else if (v === "tsx") lang = "tsx";
+                }
+              }
+            }
+          }
+        }
+        if (rawText) {
+          const body = content.substring(rawText.startIndex, rawText.endIndex);
+          if (body.trim().length > 0) {
+            out.push({
+              body,
+              lang,
+              startLine: rawText.startPosition.row + 1,
+              startColumn: rawText.startPosition.column,
+              // H3 (vue review wave): script-relative symbol indices need
+              // this SFC base to become file-coherent (lines/cols alone
+              // leave index-based consumers misaligned).
+              startIndex: rawText.startIndex
+            });
+          }
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return out;
+  }
+  ASTEngine2.extractSfcScriptBlocks = extractSfcScriptBlocks;
+  function extractMarkdownInlineBlocks(rootNode) {
+    const out = [];
+    const stack = [rootNode];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "inline") {
+        out.push({
+          startIndex: n.startIndex,
+          endIndex: n.endIndex,
+          startPosition: { row: n.startPosition.row, column: n.startPosition.column }
+        });
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return out.sort((a, b) => a.startIndex - b.startIndex);
+  }
+  async function getMarkdownInlineParser() {
+    const key = "__markdown_inline__";
+    await ensureWasmRegistry();
+    if (parsers.has(key)) {
+      parserUsage.set(key, Date.now());
+      return parsers.get(key);
+    }
+    const { Parser, Language } = await treeSitterCore();
+    const wasmPath = resolveWasm("tree-sitter-markdown_inline/tree-sitter-markdown_inline.wasm");
+    let wasmBuffer;
+    const registryData = hasWasmInRegistry(wasmPath);
+    if (registryData) {
+      wasmBuffer = registryData;
+    } else if (isWasmRegistryLoaded()) {
+      throw new Error(`WASM not found in registry for markdown_inline (${wasmPath})`);
+    } else {
+      const fs = require2("fs");
+      wasmBuffer = new Uint8Array(fs.readFileSync(wasmPath));
+    }
+    const languageGrammar = await Language.load(wasmBuffer);
+    const parser = new Parser();
+    parser.setLanguage(languageGrammar);
+    languages.set(key, languageGrammar);
+    parsers.set(key, parser);
+    parserUsage.set(key, Date.now());
+    parseCount.set(key, 1);
+    log.debug("language parser loaded", { language: "markdown_inline", wasmPath });
+    return parser;
+  }
+  function findAttributeName(attr) {
+    for (let i = 0; i < attr.namedChildCount; i++) {
+      const c = attr.namedChild(i);
+      if (c && c.type === "attribute_name") return c.text;
+    }
+    return "";
+  }
+  function findAttributeValue(attr) {
+    const stack = [];
+    for (let i = 0; i < attr.namedChildCount; i++) {
+      const c = attr.namedChild(i);
+      if (c) stack.push(c);
+    }
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "attribute_value") return n.text;
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return "";
+  }
+  async function parseRaw(filePath, content, language) {
+    let parser;
+    let transientLuaGrammar = null;
+    if (language === "lua") {
+      const fs = require2("fs");
+      const WebTreeSitter = await loadWebTreeSitter();
+      const ParserCtor = WebTreeSitter.Parser ?? WebTreeSitter.default ?? WebTreeSitter;
+      const LanguageCtor = WebTreeSitter.Language ?? WebTreeSitter.default?.Language;
+      const initFn = WebTreeSitter.init ?? ParserCtor.init ?? ParserCtor.init;
+      if (initFn) await initFn({ locateFile: () => resolveWasmAsset("tree-sitter.wasm") });
+      transientLuaGrammar = await LanguageCtor.load(
+        new Uint8Array(fs.readFileSync(resolveWasmAsset("tree-sitter-lua.wasm")))
+      );
+      parser = new ParserCtor();
+      parser.setLanguage(transientLuaGrammar);
+    } else {
+      parser = await getParser2(language);
+    }
+    let truncated = null;
+    if (content.length > MAX_PARSE_BYTES) {
+      log.warn("large file detected, using truncated content", {
+        filePath,
+        originalSize: content.length,
+        truncatedSize: MAX_PARSE_BYTES
+      });
+      recordTruncation(filePath, content.length, MAX_PARSE_BYTES);
+      truncated = { originalSize: content.length, parsedSize: MAX_PARSE_BYTES };
+      content = content.substring(0, MAX_PARSE_BYTES);
+    }
+    const blankKeepingNewlines = (match) => match.replace(/[^\n]/g, " ");
+    if (language === "c" || language === "cpp") {
+      content = content.replace(/__attribute__\s*\(\([\s\S]*?\)\)/g, blankKeepingNewlines).replace(/__declspec\s*\([\s\S]*?\)/g, blankKeepingNewlines).replace(/__restrict__/g, "            ").replace(/__restrict/g, "          ").replace(/__volatile__/g, "            ").replace(/__inline__/g, "          ").replace(/__forceinline/g, "             ").replace(/__cdecl/g, "       ").replace(/__stdcall/g, "         ").replace(/__fastcall/g, "          ").replace(/__stored_key/g, "            ");
+    }
+    const parseBomb = setTimeout(() => {
+      process.stderr.write(`[BB-HANG] parser stuck 120s on ${filePath} \u2014 exiting
+`);
+      process.exit(1);
+    }, 12e4);
+    let tree;
+    try {
+      tree = parser.parse(content);
+    } finally {
+      clearTimeout(parseBomb);
+    }
+    if (!tree) {
+      throw new Error(`Failed to parse file: ${filePath}`);
+    }
+    if (language === "sql") {
+      try {
+        const mod = await import("./real-sql-analyzer-F77ZMQXR.js");
+        const grammar = parser.language;
+        if (grammar) mod.RealSqlAnalyzer.setGrammar?.(grammar, parser.constructor);
+      } catch {
+      }
+    }
+    return { parser, tree, transientLuaGrammar, truncated };
+  }
+  async function parseWithTimeout(filePath, content, language) {
+    const parsePromise = parseRaw(filePath, content, language);
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        log.error("parser timeout - forcefully aborting", { filePath });
+        reject(new Error(`Parser timeout for ${filePath}`));
+      }, 12e4);
+    });
+    try {
+      const result = await Promise.race([parsePromise, timeoutPromise]);
+      clearTimeout(timeoutId);
+      return result;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  async function parseTree(filePath, content) {
+    const language = detectLanguage(filePath, content);
+    if (!language) {
+      throw new Error(`Unsupported file type: ${filePath}`);
+    }
+    const { parser, tree, transientLuaGrammar } = await parseWithTimeout(filePath, content, language);
+    return { language, tree, parser, transientLuaGrammar };
+  }
+  ASTEngine2.parseTree = parseTree;
+  async function parseFile2(filePath, content, context) {
+    const language = detectLanguage(filePath, content);
+    if (!language) {
+      throw new Error(`Unsupported file type: ${filePath}`);
+    }
+    const { parser, tree, transientLuaGrammar, truncated } = await parseWithTimeout(filePath, content, language);
+    const treeErrors = [];
+    if (tree.rootNode.hasError) {
+      const traverse = (node) => {
+        if (node.type === "ERROR" || node.isMissing) {
+          treeErrors.push({
+            message: `Syntax error (${node.isMissing ? "missing" : "unexpected"} node)`,
+            range: {
+              startLine: node.startPosition.row + 1,
+              startColumn: node.startPosition.column + 1,
+              endLine: node.endPosition.row + 1,
+              endColumn: node.endPosition.column + 1
+            },
+            severity: `warning`
+          });
+        }
+        const children = node.children;
+        for (let i = 0; i < children.length; i++) {
+          if (treeErrors.length < 50) traverse(children[i]);
+        }
+      };
+      traverse(tree.rootNode);
+      if (treeErrors.length === 0) {
+        treeErrors.push({
+          message: `Syntax error present in file (hidden MISSING node)`,
+          range: {
+            startLine: tree.rootNode.startPosition.row + 1,
+            startColumn: tree.rootNode.startPosition.column + 1,
+            endLine: tree.rootNode.endPosition.row + 1,
+            endColumn: tree.rootNode.endPosition.column + 1
+          },
+          severity: `warning`
+        });
+      }
+    }
+    log.debug("parsed file", {
+      filePath,
+      language,
+      nodeCount: tree.rootNode.namedChildCount
+    });
+    const analyzePromise = (async () => {
+      const analyzer = await getAnalyzer(language);
+      let analysisResult;
+      if ((language === "vue" || language === "svelte") && tree?.rootNode) {
+        try {
+          const scriptBlocks = extractSfcScriptBlocks(tree.rootNode, content);
+          if (scriptBlocks.length > 0) {
+            const sfcScriptTrees = [];
+            const sfcScriptLines = [];
+            const sfcScriptCols = [];
+            const sfcScriptStartIndex = [];
+            for (const block of scriptBlocks) {
+              const subLang = block.lang === "ts" ? "typescript" : block.lang === "tsx" ? "tsx" : "javascript";
+              const subParser = await getParser2(subLang);
+              const subTree = subParser.parse(block.body);
+              sfcScriptTrees.push(subTree);
+              sfcScriptLines.push(block.startLine);
+              sfcScriptCols.push(block.startColumn);
+              sfcScriptStartIndex.push(block.startIndex);
+            }
+            context = {
+              ...context,
+              sfcScriptTrees,
+              sfcScriptLines,
+              sfcScriptCols,
+              sfcScriptStartIndex,
+              sfcScriptLangs: scriptBlocks.map((b) => b.lang)
+            };
+          }
+        } catch (e) {
+          log.debug("sfc script sub-parse failed", { error: e?.message });
+        }
+      }
+      if (language === "html" && tree?.rootNode) {
+        try {
+          const blocks = extractHtmlEmbeddedBlocks(tree.rootNode, content);
+          if (blocks.length > 0) {
+            const trees = [];
+            for (const block of blocks) {
+              const subParser = await getParser2(block.lang === "ts" ? "typescript" : block.lang === "tsx" ? "tsx" : block.lang === "css" ? "css" : "javascript");
+              trees.push(subParser.parse(block.body));
+            }
+            context = {
+              ...context,
+              htmlEmbeddedTrees: trees,
+              htmlEmbeddedLangs: blocks.map((b) => b.lang),
+              htmlEmbeddedStartLines: blocks.map((b) => b.startLine),
+              htmlEmbeddedStartColumns: blocks.map((b) => b.startColumn),
+              htmlEmbeddedStartIndices: blocks.map((b) => b.startIndex)
+            };
+          }
+        } catch (e) {
+          log.debug("html embedded sub-parse failed", { error: e?.message });
+        }
+      }
+      if (language === "markdown" && tree?.rootNode) {
+        try {
+          const inlineBlocks = extractMarkdownInlineBlocks(tree.rootNode);
+          if (inlineBlocks.length > 0) {
+            const inlineParser = await getMarkdownInlineParser();
+            const mdInlineTrees = [];
+            const mdInlineStarts = [];
+            const mdInlineLines = [];
+            for (const block of inlineBlocks) {
+              const inlineText = content.substring(block.startIndex, block.endIndex);
+              if (inlineText.trim().length === 0) continue;
+              const subTree = inlineParser.parse(inlineText);
+              mdInlineTrees.push(subTree);
+              mdInlineStarts.push(block.startIndex);
+              mdInlineLines.push(block.startPosition.row + 1);
+            }
+            context = {
+              ...context,
+              mdInlineTrees,
+              mdInlineStarts,
+              mdInlineLines
+            };
+          }
+        } catch (e) {
+          log.debug("markdown inline sub-parse failed", { error: e?.message });
+        }
+      }
+      const TypeInference = (await import("./type-inference-QMT2RMLV.js")).TypeInference;
+      const enhancedAnalyzer = TypeInference.enhanceAnalyzerWithTypeInference(analyzer, language);
+      analysisResult = enhancedAnalyzer.analyze(tree.rootNode, content, filePath, context);
+      const FrameworkIntelligence = (await import("./framework-intelligence-3LORTPOX.js")).FrameworkIntelligence;
+      analysisResult = FrameworkIntelligence.enhanceWithFrameworkIntelligence(analysisResult, content, language);
+      return analysisResult;
+    })();
+    let timeoutId2;
+    const analyzeTimeoutPromise = new Promise((_, reject) => {
+      timeoutId2 = setTimeout(() => {
+        log.error("analyzer timeout - forcefully aborting", { filePath });
+        reject(new Error(`Analyzer timeout for ${filePath}`));
+      }, 12e4);
+    });
+    let result;
+    try {
+      try {
+        result = await Promise.race([analyzePromise, analyzeTimeoutPromise]);
+        clearTimeout(timeoutId2);
+      } catch (error) {
+        clearTimeout(timeoutId2);
+        log.warn("analyzer timeout, returning basic parse result", {
+          filePath,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        return {
+          language,
+          symbols: [],
+          relationships: [],
+          imports: [],
+          exports: [],
+          errors: [
+            {
+              message: error instanceof Error ? error.message : String(error),
+              range: { startLine: 1, startColumn: 1, endLine: 1, endColumn: 1 },
+              severity: "error"
+            }
+          ],
+          rawContent: content,
+          metadata: {
+            complexity: 0,
+            linesOfCode: content.split("\n").length,
+            cyclomaticComplexity: 0,
+            framework: "unknown",
+            architecture: "unknown",
+            patterns: [],
+            detectedFrameworks: [],
+            frameworkPatterns: [],
+            architecturalInsights: [],
+            architecturalScore: 0,
+            codeQuality: "unknown",
+            hasTypeInference: false,
+            hasFrameworkIntelligence: false,
+            analysisVersion: "2.0-basic-fallback"
+          }
+        };
+      }
+      const meta = result.metadata || {};
+      if (language === "html" || language === "vue" || language === "svelte") {
+        const polyglotSymbols = [];
+        const polyglotRels = [];
+        const polyglotImports = [];
+        for (const sym of result.symbols) {
+          if (sym.metadata?.embeddedScriptContent || sym.metadata?.embeddedStyleContent) {
+            const langName = sym.metadata?.embeddedScriptContent ? "inline.js" : "inline.css";
+            const snip = content.substring(sym.range.startIndex, sym.range.endIndex);
+            let match = null;
+            if (langName === "inline.js") match = snip.match(/<script[^>]*>([\s\S]*?)<\/script>/i);
+            else match = snip.match(/<style[^>]*>([\s\S]*?)<\/style>/i);
+            if (match && match[1] && match[1].trim().length > 0) {
+              const innerCode = match[1];
+              const offsetIndex = sym.range.startIndex + match.index + match[0].indexOf(innerCode);
+              const preCode = content.substring(0, offsetIndex);
+              const offsetLine = preCode.split("\n").length - 1;
+              const offsetCol = preCode.length - preCode.lastIndexOf("\n") - 1;
+              try {
+                if (filePath.includes("UltimateSvelteTest.svelte")) {
+                  require2("fs").writeFileSync("/tmp/svelte_inner_" + langName + ".txt", innerCode);
+                }
+                const subParse = await ASTEngine2.parseFile(filePath + "." + langName, innerCode);
+                for (const jsSym of subParse.symbols) {
+                  jsSym.range.startIndex += offsetIndex;
+                  jsSym.range.endIndex += offsetIndex;
+                  jsSym.range.startLine += offsetLine;
+                  jsSym.range.endLine += offsetLine;
+                  jsSym.ownerName = jsSym.ownerName || sym.name;
+                  jsSym.metadata = { ...jsSym.metadata, polyglotHost: sym.name, embeddedIn: filePath };
+                  polyglotSymbols.push(jsSym);
+                }
+                for (const jsRel of subParse.relationships) {
+                  polyglotRels.push(jsRel);
+                }
+                for (const jsImp of subParse.imports) {
+                  if (jsImp.range) {
+                    if (jsImp.range.startIndex !== void 0) jsImp.range.startIndex += offsetIndex;
+                    if (jsImp.range.endIndex !== void 0) jsImp.range.endIndex += offsetIndex;
+                    jsImp.range.startLine += offsetLine;
+                    jsImp.range.endLine += offsetLine;
+                  }
+                  polyglotImports.push(jsImp);
+                }
+              } catch (e) {
+              }
+            }
+          }
+        }
+        result.symbols.push(...polyglotSymbols);
+        result.relationships.push(...polyglotRels);
+        result.imports.push(...polyglotImports);
+      }
+      return {
+        language,
+        symbols: result.symbols || [],
+        relationships: result.relationships || [],
+        imports: result.imports || [],
+        exports: result.exports || [],
+        errors: [
+          ...result.errors || [],
+          ...treeErrors,
+          // PY-19: see the truncation branch above. Declared as an error because a partial parse is
+          // exactly what a caller reading `errors` needs to know, and `severity: "warning"` because
+          // the analysis that WAS produced is sound — it is incomplete, not wrong. The percentage is
+          // in the message on purpose: "1 file was truncated" is not actionable, "75% of this file
+          // was never parsed" is.
+          ...truncated ? [
+            {
+              message: `input truncated at the 1 MiB parse limit: ${truncated.parsedSize} of ${truncated.originalSize} bytes parsed (${Math.round(100 * truncated.parsedSize / truncated.originalSize)}%), so symbols, relationships and imports below may be incomplete`,
+              range: { startLine: 1, startColumn: 1, endLine: 1, endColumn: 1 },
+              severity: `warning`
+            }
+          ] : []
+        ],
+        rawContent: result.rawContent,
+        metadata: {
+          // The analyzer's OWN metadata is spread FIRST, so a lane's own keys
+          // survive the trip to the production entry. This object used to be a
+          // fixed allowlist of thirteen fields, and every key outside that list
+          // was silently dropped — which is how the VB lane's `vbGaps` (its
+          // disclosed gaps, the thing the lane exists to report) never reached
+          // `parseFile`, and how `analysisVersion` read `m10.06-cut` for a lane
+          // whose analyzer stamps `m60-vb-1`. A disclosure that is computed and
+          // then thrown away is not a disclosure.
+          ...meta,
+          // PY-19: the same disclosure as the `errors` entry, but STRUCTURED. The message is for
+          // a human reading a result; this is for a caller that has to reproduce the parse
+          // exactly — the M14 oracle mirrors the engine's byte-for-byte, and it used to do that
+          // by copying the 1 MiB constant out of this file. A copied constant drifts silently:
+          // move the limit and the oracle keeps cutting at the old value, the two sides parse
+          // different byte ranges, and every relationship past the cut reports as a phantom
+          // analyzer defect. Reading the limit back from here means there is nothing to drift.
+          //
+          // Spread CONDITIONALLY. A `truncated: null` on every file in the corpus would be true
+          // and useless, and it would put a new key into the FILE-level metadata of every lane's
+          // results in order to say nothing. Only a truncated file learns that it was truncated,
+          // which also means no other lane's metadata shape changes at all.
+          ...truncated ? { truncated } : {},
+          complexity: meta.complexity || 0,
+          linesOfCode: content.split("\n").length,
+          // These two publish `undefined` as a PRESENT key when the analyzer did
+          // not set them, which is the same defect as the eight scored keys below —
+          // found by the corrected `verify-lua-published-claims` check, which
+          // compares the pipeline's keys against the analyzer's own and named
+          // `architecture` as the one a Lua file receives without producing.
+          //
+          // `framework` is DELIBERATELY left as a plain assignment, and the reason
+          // is a consumer: `script/m60/framework-surface-probe.ts` reports a lane as
+          // missing if `"framework" in meta` is false, so omitting the key would turn
+          // a language that never set it into a reported defect. That is the one
+          // place in the tree where presence is the contract, so presence is kept
+          // there and nowhere else. Making these two conditional is safe for the same
+          // reason the eight are: nothing tests them for presence (0 call sites).
+          ...meta.cyclomaticComplexity !== void 0 && { cyclomaticComplexity: meta.cyclomaticComplexity },
+          framework: meta.framework,
+          ...meta.architecture !== void 0 && { architecture: meta.architecture },
+          patterns: meta.patterns || [],
+          // NEW: Enhanced intelligence metadata
+          detectedFrameworks: meta.detectedFrameworks || [],
+          frameworkPatterns: meta.frameworkPatterns || [],
+          architecturalInsights: meta.architecturalInsights || [],
+          architecturalScore: meta.architecturalScore || 0,
+          codeQuality: meta.codeQuality || "unknown",
+          // NOT hardcoded `true`. These two are CLAIMS a lane makes about
+          // itself, and lanes make them honestly in both directions: the VB
+          // analyzer reports `false` for both, because it does no type inference
+          // and has no framework intelligence, and the hardcode overwrote that
+          // with `true` on the way out — the product asserting a capability the
+          // lane has explicitly said it lacks. The `?? true` default keeps every
+          // lane that says nothing behaving exactly as it did before, so the only
+          // behaviour that changes is a lane that made the claim and was
+          // overwritten. (kotlin's spec already records this field as real:
+          // "metadata.hasTypeInference stays — declared-type extraction IS real
+          // inference input.")
+          hasTypeInference: meta.hasTypeInference ?? true,
+          hasFrameworkIntelligence: meta.hasFrameworkIntelligence ?? true,
+          // M14 (#888): FORWARD the analyzer's own scored metrics, and do it
+          // WITHOUT materialising the key for a language that did not produce it.
+          //
+          // This object is a fresh literal, so anything an analyzer computes and
+          // this list omits is computed and DISCARDED — silently, because
+          // `FileMetadata` carries an index signature and the extra key
+          // typechecks. The html analyzer measured exactly that: it computed
+          // accessibility / semantic / performance scores, a `score` breakdown and
+          // a `documentMetrics` census, none of which appeared in the parse result
+          // (`"accessibilityScore" in metadata === false`).
+          //
+          // The first version of this fix added the keys as plain assignments:
+          //
+          //     accessibilityScore: (meta as any).accessibilityScore,
+          //
+          // and justified it with "each key reads `undefined` for every other
+          // language, which is identical to the key being absent — so this is
+          // additive by construction, not a change to any other lane's payload."
+          //
+          // THAT IS FALSE, and it is worth being precise about why, because the
+          // comment three lines above it is the evidence:
+          //
+          //     { x: 1, y: undefined }  ->  "y" in obj === true,  Object.keys === ["x","y"]
+          //     { x: 1 }                ->  "y" in obj === false, Object.keys === ["x"]
+          //
+          // `undefined` is only invisible to `JSON.stringify`, which is the one
+          // operation that drops such keys. `"k" in metadata` and `Object.keys()`
+          // both see them, and a key's PRESENCE is a claim: a consumer testing
+          // `if (metadata.elementCount)` behaves identically, but one testing
+          // `"elementCount" in metadata` — the exact form this file used to prove
+          // the html lane's key was missing — now reads TRUE for every language on
+          // earth. Eight keys were added to all 44 lanes' metadata.
+          //
+          // Found by the LUA lane's `verify-lua-published-claims`, whose eleventh
+          // check asserts the pipeline does not synthesise a metadata block that was
+          // never mapped, because that is precisely the class of defect it exists to
+          // catch: a value that reaches a consumer shaped like a measurement and is
+          // not one. Before this, a Lua file's metadata reported
+          // `documentMetrics`, `elementCount`, `accessibilityScore`, `score` and four
+          // more — all undefined, all belonging to html and toml.
+          //
+          // So a key is added only when the analyzer actually produced it. html and
+          // toml keep theirs; every other language gets the object it had before
+          // #888, which is the "not a change to any other lane's payload" claim
+          // this comment originally intended to make.
+          ...meta.accessibilityScore !== void 0 && { accessibilityScore: meta.accessibilityScore },
+          ...meta.semanticScore !== void 0 && { semanticScore: meta.semanticScore },
+          ...meta.performanceScore !== void 0 && { performanceScore: meta.performanceScore },
+          ...meta.score !== void 0 && { score: meta.score },
+          ...meta.documentMetrics !== void 0 && { documentMetrics: meta.documentMetrics },
+          ...meta.elementCount !== void 0 && { elementCount: meta.elementCount },
+          ...meta.addressableNodeCount !== void 0 && { addressableNodeCount: meta.addressableNodeCount },
+          ...meta.maxElementDepth !== void 0 && { maxElementDepth: meta.maxElementDepth },
+          analysisVersion: meta.analysisVersion || "m10.06-cut"
+        }
+      };
+    } finally {
+      if (tree && typeof tree.delete === "function") {
+        tree.delete();
+      }
+      if (language === "lua" && transientLuaGrammar) {
+        try {
+          if (parser && typeof parser.delete === "function") parser.delete();
+        } catch {
+        }
+        try {
+          if (typeof transientLuaGrammar.delete === "function") transientLuaGrammar.delete();
+        } catch {
+        }
+      }
+    }
+  }
+  ASTEngine2.parseFile = parseFile2;
+  async function getAnalyzer(language) {
+    switch (language) {
+      case "typescript":
+      case "tsx":
+        return new (await import("./real-typescript-analyzer-6KEMVDWQ.js")).RealTypeScriptAnalyzer();
+      case "javascript":
+        return new (await import("./real-javascript-analyzer-QA4QOJ6W.js")).RealJavaScriptAnalyzer();
+      case "html":
+        return new (await import("./real-html-analyzer-JWNX3C6I.js")).RealHtmlAnalyzer();
+      case "css":
+      case "sass":
+        return new (await import("./real-css-analyzer-6XRQLUN7.js")).RealCssAnalyzer();
+      case "scss":
+        return new (await import("./real-scss-analyzer-AVWYPSOQ.js")).RealScssAnalyzer();
+      case "json":
+        return new (await import("./real-json-analyzer-MPA6PRXL.js")).RealJsonAnalyzer();
+      case "yaml":
+        return new (await import("./real-yaml-analyzer-SUBCBNSI.js")).RealYamlAnalyzer();
+      case "perl":
+        return new (await import("./real-perl-analyzer-WWTRHYDT.js")).RealPerlAnalyzer();
+      case "c":
+        return new (await import("./real-c-analyzer-HBD3FNNH.js")).RealCAnalyzer();
+      case "cpp":
+        return new (await import("./real-cpp-analyzer-IVVOD25R.js")).RealCppAnalyzer();
+      case "rust":
+        return new (await import("./real-rust-analyzer-OFFHPL2A.js")).RealRustAnalyzer();
+      case "go":
+        return new (await import("./real-go-analyzer-UKGI43YS.js")).RealGoAnalyzer();
+      case "java":
+        return new (await import("./real-java-analyzer-GU42VBGQ.js")).RealJavaAnalyzer();
+      case "kotlin":
+        return new (await import("./real-kotlin-analyzer-QDZJLXXU.js")).RealKotlinAnalyzer();
+      case "scala":
+        return new (await import("./real-scala-analyzer-TSTW27J6.js")).RealScalaAnalyzer();
+      case "python":
+        return new (await import("./real-python-analyzer-VXAFWI72.js")).RealPythonAnalyzer();
+      case "ruby":
+        return new (await import("./real-ruby-analyzer-X2KTLVBH.js")).RealRubyAnalyzer();
+      case "php":
+        return new (await import("./real-php-analyzer-JNKJHTCL.js")).RealPhpAnalyzer();
+      case "lua":
+        return new (await import("./real-lua-analyzer-G7NHLYKS.js")).RealLuaAnalyzer();
+      case "elixir":
+        return new (await import("./real-elixir-analyzer-MQWGAH2I.js")).RealElixirAnalyzer();
+      case "erlang":
+        return new (await import("./real-erlang-analyzer-7BVPQEHO.js")).RealErlangAnalyzer();
+      case "haskell":
+        return new (await import("./real-haskell-analyzer-5CVVAJRX.js")).RealHaskellAnalyzer();
+      case "clean":
+        return new (await import("./real-clean-analyzer-4EEZLPV5.js")).RealCleanAnalyzer();
+      case "clojure":
+        return new (await import("./real-clojure-analyzer-Q55EBOO2.js")).RealClojureAnalyzer();
+      case "swift":
+        return new (await import("./real-swift-analyzer-MN5QT3QN.js")).RealSwiftAnalyzer();
+      case "julia":
+        return new (await import("./real-julia-analyzer-22CWYQMN.js")).RealJuliaAnalyzer();
+      case "dart":
+        return new (await import("./real-dart-analyzer-OLR72EFW.js")).RealDartAnalyzer();
+      case "csharp":
+        return new (await import("./real-csharp-analyzer-ZBNLNJZJ.js")).RealCSharpAnalyzer();
+      case "r":
+        return new (await import("./real-r-analyzer-ZGAIDVI4.js")).RealRAnalyzer();
+      case "sql":
+        return new (await import("./real-sql-analyzer-F77ZMQXR.js")).RealSqlAnalyzer();
+      case "bash":
+        return new (await import("./real-bash-analyzer-EJAU5LW5.js")).RealBashAnalyzer();
+      case "objective-c":
+        return new (await import("./real-objective-c-analyzer-D23ACC2R.js")).RealObjectiveCAnalyzer();
+      case "groovy":
+        return new (await import("./real-groovy-analyzer-W26VACFW.js")).RealGroovyAnalyzer();
+      case "vue":
+        return new (await import("./real-vue-analyzer-QXR56CFV.js")).RealVueAnalyzer();
+      case "svelte":
+        return new (await import("./real-svelte-analyzer-SF7NRUO5.js")).RealSvelteAnalyzer();
+      case "hcl":
+      case "terraform":
+        return new (await import("./real-hcl-analyzer-5ZT4U43N.js")).RealHclAnalyzer();
+      case "graphql":
+        return new (await import("./real-graphql-analyzer-VE2EEFII.js")).RealGraphqlAnalyzer();
+      // Protobuf: the vendored, patched tree-sitter-proto (see the name map
+      // above and grammars/tree-sitter-proto/README.md).
+      case "protobuf":
+        return new (await import("./real-protobuf-analyzer-3OKUCZ7T.js")).RealProtobufAnalyzer();
+      case "zig":
+        return new (await import("./real-zig-analyzer-HIQLZMGY.js")).RealZigAnalyzer();
+      case "nim":
+        return new (await import("./real-nim-analyzer-YLXSK563.js")).RealNimAnalyzer();
+      case "fsharp":
+        return new (await import("./real-fsharp-analyzer-C2UPFNOA.js")).RealFsharpAnalyzer();
+      case "powershell":
+        return new (await import("./real-powershell-analyzer-XRSNQERV.js")).RealPowershellAnalyzer();
+      case "solidity":
+        return new (await import("./real-solidity-analyzer-UCI2KWUB.js")).RealSolidityAnalyzer();
+      case "make":
+        return new (await import("./real-makefile-analyzer-OCY3GT5N.js")).RealMakefileAnalyzer();
+      case "xml":
+        return new (await import("./real-xml-analyzer-YL465ZJW.js")).RealXmlAnalyzer();
+      case "markdown":
+        return new (await import("./real-markdown-analyzer-TEJK2JXJ.js")).RealMarkdownAnalyzer();
+      case "vb":
+        return new (await import("./real-vb-analyzer-VICVPOP7.js")).RealVbAnalyzer();
+      case "vba":
+        return new (await import("./real-vba-analyzer-HXLTTHKM.js")).RealVbaAnalyzer();
+      case "matlab":
+        return new (await import("./real-matlab-analyzer-Q5SWLN7Z.js")).RealMatlabAnalyzer();
+      case "toml":
+        return new (await import("./real-toml-analyzer-66L7BDCQ.js")).RealTomlAnalyzer();
+      default:
+        return new GenericAnalyzer();
+    }
+  }
+  const JAVA_STDLIB_TYPES = /* @__PURE__ */ new Set([
+    "String",
+    "Integer",
+    "Boolean",
+    "Long",
+    "Double",
+    "Float",
+    "Byte",
+    "Short",
+    "Character",
+    "Object",
+    "Class",
+    "Number",
+    "Void",
+    "BigDecimal",
+    "BigInteger",
+    "List",
+    "Map",
+    "Set",
+    "Collection",
+    "ArrayList",
+    "HashMap",
+    "HashSet",
+    "Optional",
+    "Stream",
+    "File",
+    "Path",
+    "IOException",
+    "Exception",
+    "RuntimeException",
+    "Thread",
+    "Runnable",
+    "Callable",
+    "Future",
+    "CompletableFuture",
+    "StringBuilder",
+    "StringBuffer",
+    "Pattern",
+    "Matcher"
+  ]);
+  const PYTHON_STDLIB_TYPES = /* @__PURE__ */ new Set([
+    "str",
+    "int",
+    "float",
+    "bool",
+    "list",
+    "dict",
+    "set",
+    "tuple",
+    "bytes",
+    "bytearray",
+    "memoryview",
+    "complex",
+    "frozenset",
+    "range",
+    "slice",
+    "type",
+    "object",
+    "Exception",
+    "ValueError",
+    "TypeError",
+    "KeyError",
+    "os",
+    "sys",
+    "json",
+    "re",
+    "datetime",
+    "collections",
+    "itertools",
+    "functools",
+    "pathlib",
+    "Path",
+    "IO",
+    "TextIO"
+  ]);
+  const JS_BUILTIN_TYPES = /* @__PURE__ */ new Set([
+    "String",
+    "Number",
+    "Boolean",
+    "Array",
+    "Object",
+    "Function",
+    "Symbol",
+    "Map",
+    "Set",
+    "WeakMap",
+    "WeakSet",
+    "Promise",
+    "RegExp",
+    "Date",
+    "Error",
+    "JSON",
+    "Math",
+    "Intl",
+    "console",
+    "Buffer",
+    "process",
+    "BigInt",
+    "ArrayBuffer",
+    "DataView",
+    "Float32Array",
+    "Float64Array",
+    "Int8Array",
+    "Int16Array",
+    "Int32Array",
+    "Uint8Array",
+    "Uint16Array",
+    "Uint32Array"
+  ]);
+  const GO_STDLIB_TYPES = /* @__PURE__ */ new Set([
+    "string",
+    "int",
+    "int8",
+    "int16",
+    "int32",
+    "int64",
+    "uint",
+    "uint8",
+    "uint16",
+    "uint32",
+    "uint64",
+    "uintptr",
+    "float32",
+    "float64",
+    "complex64",
+    "complex128",
+    "bool",
+    "byte",
+    "rune",
+    "error",
+    "Context",
+    "Reader",
+    "Writer",
+    "Closer",
+    "Seeker",
+    "Scanner",
+    "Builder",
+    "File",
+    "ResponseWriter",
+    "Request",
+    "http",
+    "os",
+    "io",
+    "fmt",
+    "strings",
+    "strconv",
+    "time",
+    "sync",
+    "json",
+    "net",
+    "url",
+    "crypto",
+    "encoding"
+  ]);
+  const RUST_STDLIB_TYPES = /* @__PURE__ */ new Set([
+    "String",
+    "str",
+    "Vec",
+    "Option",
+    "Result",
+    "Box",
+    "Rc",
+    "Arc",
+    "HashMap",
+    "HashSet",
+    "BTreeMap",
+    "BTreeSet",
+    "LinkedList",
+    "VecDeque",
+    "i8",
+    "i16",
+    "i32",
+    "i64",
+    "i128",
+    "isize",
+    "u8",
+    "u16",
+    "u32",
+    "u64",
+    "u128",
+    "usize",
+    "f32",
+    "f64",
+    "bool",
+    "char",
+    "Path",
+    "PathBuf",
+    "File",
+    "Error",
+    "Iterator",
+    "Clone",
+    "Copy",
+    "Debug",
+    "Display",
+    "std",
+    "core",
+    "alloc",
+    "collections"
+  ]);
+  const SWIFT_STDLIB_TYPES = /* @__PURE__ */ new Set([
+    "String",
+    "Int",
+    "Double",
+    "Float",
+    "Bool",
+    "Character",
+    "Array",
+    "Dictionary",
+    "Set",
+    "Optional",
+    "Result",
+    "Data",
+    "URL",
+    "Date",
+    "UUID",
+    "Error",
+    "AnyObject",
+    "AnyClass",
+    "UIView",
+    "UIViewController"
+  ]);
+  const ALL_STDLIB_TYPES = /* @__PURE__ */ new Set([
+    ...JAVA_STDLIB_TYPES,
+    ...PYTHON_STDLIB_TYPES,
+    ...JS_BUILTIN_TYPES,
+    ...GO_STDLIB_TYPES,
+    ...RUST_STDLIB_TYPES,
+    ...SWIFT_STDLIB_TYPES
+  ]);
+  class GenericAnalyzer {
+    analyze(rootNode, content, filePath, _context) {
+      const symbols = [];
+      const relationships = [];
+      const imports = [];
+      const exports = [];
+      const errors = [];
+      this.traverseNode(rootNode, symbols, content);
+      return {
+        symbols,
+        relationships,
+        imports,
+        exports,
+        errors,
+        metadata: {
+          complexity: this.calculateComplexity(rootNode),
+          patterns: []
+        }
+      };
+    }
+    traverseNode(rootNode, symbols, content) {
+      const walkStack = [rootNode];
+      while (walkStack.length > 0) {
+        const node = walkStack.pop();
+        if (node.isNamed) {
+          const isReasonablySmall = node.endIndex - node.startIndex < 100;
+          if (isReasonablySmall) {
+            const text = node.text;
+            if (text) {
+              let kind = this.mapNodeTypeToSymbolKind(node.type);
+              const upgraded = this.upgradeStdlibKind(text, kind);
+              if (upgraded) kind = upgraded;
+              symbols.push({
+                name: text,
+                kind,
+                range: {
+                  startLine: node.startPosition.row + 1,
+                  startColumn: node.startPosition.column + 1,
+                  endLine: node.endPosition.row + 1,
+                  endColumn: node.endPosition.column + 1,
+                  startIndex: node.startIndex,
+                  endIndex: node.endIndex
+                },
+                metadata: {
+                  nodeType: node.type,
+                  raw: true
+                }
+              });
+            }
+          }
+        }
+        const childCount = node.namedChildCount;
+        for (let i = childCount - 1; i >= 0; i--) {
+          const child = node.namedChild(i);
+          if (child) {
+            walkStack.push(child);
+          }
+        }
+      }
+    }
+    mapNodeTypeToSymbolKind(nodeType) {
+      if (nodeType.includes("function")) return "function" /* Function */;
+      if (nodeType.includes("method")) return "method" /* Method */;
+      if (nodeType.includes("class")) return "class" /* Class */;
+      if (nodeType.includes("interface")) return "interface" /* Interface */;
+      if (nodeType.includes("enum")) return "enum" /* Enum */;
+      if (nodeType.includes("struct")) return "struct" /* Struct */;
+      if (nodeType.includes("trait")) return "trait" /* Trait */;
+      if (nodeType.includes("impl")) return "impl" /* Impl */;
+      if (nodeType.includes("mixin")) return "mixin" /* Mixin */;
+      if (nodeType.includes("extension")) return "extension" /* Extension */;
+      if (nodeType.includes("namespace") || nodeType.includes("module")) return "namespace" /* Namespace */;
+      if (nodeType.includes("constructor")) return "constructor" /* Constructor */;
+      if (nodeType.includes("property") || nodeType.includes("field")) return "property" /* Property */;
+      if (nodeType.includes("variable") || nodeType.includes("identifier") || nodeType.includes("parameter")) return "variable" /* Variable */;
+      if (nodeType.includes("constant")) return "constant" /* Constant */;
+      if (nodeType.includes("import")) return "import" /* Import */;
+      if (nodeType.includes("export")) return "export" /* Export */;
+      if (nodeType.includes("type_alias") || nodeType.includes("type_annotation")) return "type" /* Type */;
+      return "variable" /* Variable */;
+    }
+    // Recognizes common stdlib type names across all 40 languages.
+    // Tree-sitter sees these as plain identifiers (not class_declarations),
+    // so the GenericAnalyzer defaults them to Variable. This upgrades them.
+    // The import-only filter in parallel-indexer catches the rest at storage level.
+    upgradeStdlibKind(name, currentKind) {
+      if (currentKind !== "variable" /* Variable */ && currentKind !== "unknown") return null;
+      if (ALL_STDLIB_TYPES.has(name)) return "class" /* Class */;
+      if (name.length > 1 && name[0] === name[0].toUpperCase() && name[0] !== name[0].toLowerCase()) {
+        return "class" /* Class */;
+      }
+      return null;
+    }
+    calculateComplexity(rootNode) {
+      let complexity = 1;
+      const walkStack = [rootNode];
+      while (walkStack.length > 0) {
+        const node = walkStack.pop();
+        complexity++;
+        const childCount = node.namedChildCount;
+        for (let i = childCount - 1; i >= 0; i--) {
+          const child = node.namedChild(i);
+          if (child) {
+            walkStack.push(child);
+          }
+        }
+      }
+      return Math.min(complexity, 100);
+    }
+  }
+  async function findSymbol(projectId, symbolName, filePath, lineStart) {
+    const { BrainDatabase } = await import("./database-76RP44JG.js");
+    const db = await BrainDatabase.getReadOnlyInstance(projectId);
+    const { BrainSymbolTable, BrainFileTable } = await import("./brain.sql-EIM4WS4D.js");
+    const { eq, and, like } = await import("drizzle-orm");
+    const conditions = [eq(BrainSymbolTable.project_id, projectId), eq(BrainSymbolTable.name, symbolName)];
+    if (filePath) {
+      const fp = filePath.replace(/\\/g, "/");
+      if (fp.includes("/")) {
+        conditions.push(eq(BrainFileTable.path, fp));
+      } else {
+        conditions.push(like(BrainFileTable.path, `%/${fp}`));
+      }
+    }
+    let results = await db.select({
+      id: BrainSymbolTable.id,
+      fileId: BrainFileTable.path,
+      name: BrainSymbolTable.name,
+      symbolType: BrainSymbolTable.symbol_type,
+      lineStart: BrainSymbolTable.line_start,
+      byteStart: BrainSymbolTable.byte_start,
+      byteEnd: BrainSymbolTable.byte_end,
+      // The file row is already joined in, so the language is free here. It was
+      // absent, so `bb search --mode symbol` rendered `alpha0 [function]
+      // (m0.ts:1)` with no language while the DEFAULT mode printed
+      // `(typescript, m0.ts:1)` — the two modes disagreed about the same symbol.
+      language: BrainFileTable.language,
+      relativePath: BrainFileTable.relative_path
+    }).from(BrainSymbolTable).innerJoin(BrainFileTable, eq(BrainSymbolTable.file_id, BrainFileTable.id)).where(and(...conditions)).all();
+    if (results.length === 0 && filePath && filePath.includes("/")) {
+      const fp = filePath.replace(/\\/g, "/");
+      results = await db.select({
+        id: BrainSymbolTable.id,
+        fileId: BrainFileTable.path,
+        name: BrainSymbolTable.name,
+        symbolType: BrainSymbolTable.symbol_type,
+        lineStart: BrainSymbolTable.line_start,
+        byteStart: BrainSymbolTable.byte_start,
+        byteEnd: BrainSymbolTable.byte_end,
+        // This fallback SELECT omitted the file columns entirely, so a match
+        // resolved through a relative `filePath` came back with no language
+        // and could not be noise-classified by its relative path.
+        language: BrainFileTable.language,
+        relativePath: BrainFileTable.relative_path
+      }).from(BrainSymbolTable).innerJoin(BrainFileTable, eq(BrainSymbolTable.file_id, BrainFileTable.id)).where(and(
+        eq(BrainSymbolTable.project_id, projectId),
+        eq(BrainSymbolTable.name, symbolName),
+        like(BrainFileTable.path, `%${fp}`)
+      )).all();
+    }
+    for (const r of results) {
+      if ((r.byteStart == null || r.byteEnd == null || r.byteEnd <= r.byteStart) && r.fileId && r.lineStart != null) {
+        try {
+          const fs = require2("fs");
+          const content = decodeSourceText(fs.readFileSync(r.fileId)).text;
+          const lines = content.split("\n");
+          let offset = 0;
+          for (let i = 0; i < Math.min(r.lineStart, lines.length); i++) {
+            offset += lines[i].length + 1;
+          }
+          r.byteStart = offset;
+          const lineEnd = r.lineEnd ?? null;
+          if (lineEnd != null && lineEnd >= r.lineStart) {
+            let endOffset = offset;
+            for (let i = r.lineStart; i < Math.min(lineEnd + 1, lines.length); i++) {
+              endOffset += lines[i].length + 1;
+            }
+            r.byteEnd = endOffset;
+          } else {
+            r.byteEnd = offset + (lines[Math.min(r.lineStart, lines.length - 1)]?.length || 0);
+          }
+        } catch (e) {
+          log.debug("findSymbol: byte-offset repair failed", { error: e?.message });
+        }
+      }
+    }
+    let matches = results;
+    const { isHardNoisePath } = await import("./analysis-exclusions-7ZJDXOVZ.js");
+    matches = matches.filter((m) => !isHardNoisePath(m.relativePath ?? m.fileId ?? ""));
+    if (matches.length > 1 && filePath) {
+      const classSymbols = matches.filter((m) => m.symbolType === "class" || m.symbolType === "interface");
+      if (classSymbols.length === 1) {
+        matches = classSymbols;
+      }
+    }
+    if (lineStart !== void 0) {
+      matches = matches.filter((m) => m.lineStart === lineStart);
+    }
+    return { matches };
+  }
+  ASTEngine2.findSymbol = findSymbol;
+  function isLanguageSupported(language) {
+    return language in SUPPORTED_LANGUAGES;
+  }
+  ASTEngine2.isLanguageSupported = isLanguageSupported;
+})(ASTEngine || (ASTEngine = {}));
+var parseFile = ASTEngine.parseFile;
+var getParser = ASTEngine.getParser;
+var getCachedParser = ASTEngine.getCachedParser;
+
+export {
+  ASTEngine,
+  parseFile,
+  getParser,
+  getCachedParser
+};