@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/pool-worker.js

@@ -0,0 +1,1153 @@
+#!/usr/bin/env bun
+import {
+  BINDING_SEP,
+  decodeSourceText
+} from "./chunk-KAET47ZL.js";
+import {
+  detectLanguageFromPath
+} from "./chunk-KCDECRJY.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ast/pool-worker.ts
+import { createHash } from "crypto";
+import { createRequire } from "module";
+import path from "path";
+import fs from "fs";
+var require2 = createRequire(import.meta.url);
+if (!process.env.BB_LOG_LEVEL) {
+  process.env.BB_LOG_LEVEL = "error";
+}
+function bbDiagnosticsLogPath(name) {
+  const dataDir = process.env.BB_DATA_DIR || path.join(process.env.HOME || process.env.USERPROFILE || "/tmp", ".bb");
+  const logsDir = path.join(dataDir, "logs");
+  try {
+    fs.mkdirSync(logsDir, { recursive: true });
+  } catch {
+  }
+  return path.join(logsDir, name);
+}
+function log(..._args) {
+}
+var startupDiagnostics = [];
+var reportedStartupProblems = /* @__PURE__ */ new Set();
+function reportStartupProblem(what, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const line = `${what}: ${message}`;
+  if (reportedStartupProblems.has(line)) return;
+  reportedStartupProblems.add(line);
+  process.stderr.write(`[BB-WORKER-STARTUP] ${line}
+`);
+  startupDiagnostics.push(line.slice(0, 300));
+}
+function safeSend(message) {
+  try {
+    if (typeof process.send !== "function") return false;
+    if (process.connected === false) return false;
+    process.send(message);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function extractBasicSymbols(content, language) {
+  const symbols = [];
+  const lines = content.split("\n");
+  const patterns = {
+    typescript: [
+      /^(?:export\s+)?(?:async\s+)?function\s+(\w+)/,
+      /^(?:export\s+)?class\s+(\w+)/,
+      /^(?:export\s+)?interface\s+(\w+)/,
+      /^(?:export\s+)?type\s+(\w+)/,
+      /^(?:export\s+)?(?:const|let|var)\s+(\w+)/,
+      /^\s*(?:public|private|protected)?\s*(?:async\s+)?(\w+)\s*\(/
+    ],
+    javascript: [
+      /^(?:export\s+)?(?:async\s+)?function\s+(\w+)/,
+      /^(?:export\s+)?class\s+(\w+)/,
+      /^(?:export\s+)?(?:const|let|var)\s+(\w+)/
+    ],
+    python: [/^(?:async\s+)?def\s+(\w+)/, /^class\s+(\w+)/],
+    svelte: [
+      /^\s*export\s+let\s+(\w+)/,
+      /^\s*\$:.*?\s*=\s*(.+)/,
+      /^\s*const\s+(\w+)\s*=\s*\$state/,
+      /^\s*const\s+(\w+)\s*=\s*\$derived/,
+      /^\s*\$effect\s*\(/,
+      /^\s*\$props\s*\(/,
+      /^\s*function\s+(\w+)/,
+      /^\s*class\s+(\w+)/
+    ],
+    go: [/^func\s+(?:\([^)]+\)\s+)?(\w+)/, /^type\s+(\w+)\s+struct/, /^type\s+(\w+)\s+interface/],
+    rust: [
+      /^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/,
+      /^(?:pub\s+)?struct\s+(\w+)/,
+      /^(?:pub\s+)?trait\s+(\w+)/,
+      /^(?:pub\s+)?impl(?:\s+\w+)?\s+(?:for\s+)?(\w+)/
+    ],
+    java: [
+      /^(?:public|private|protected)?\s*(?:static\s+)?(?:final\s+)?class\s+(\w+)/,
+      /^(?:public|private|protected)?\s*(?:static\s+)?(?:final\s+)?interface\s+(\w+)/,
+      /^(?:public|private|protected)?\s*(?:static\s+)?(?:\w+\s+)+(\w+)\s*\(/
+    ],
+    kotlin: [
+      /^(?:fun|suspend\s+fun)\s+(\w+)/,
+      /^(?:class|data\s+class|sealed\s+class|object)\s+(\w+)/,
+      /^interface\s+(\w+)/
+    ],
+    swift: [/^(?:func|class\s+func|static\s+func)\s+(\w+)/, /^(?:class|struct|protocol|enum)\s+(\w+)/],
+    ruby: [/^def\s+(\w+)/, /^class\s+(\w+)/, /^module\s+(\w+)/],
+    php: [
+      /^(?:public|private|protected)?\s*function\s+(\w+)/,
+      /^class\s+(\w+)/,
+      /^interface\s+(\w+)/,
+      /^trait\s+(\w+)/
+    ],
+    csharp: [
+      /^(?:public|private|protected|internal)?\s*(?:static\s+)?(?:async\s+)?(?:\w+\s+)+(\w+)\s*\(/,
+      /^(?:public|private|protected|internal)?\s*(?:partial\s+)?class\s+(\w+)/,
+      /^(?:public|private|protected|internal)?\s*interface\s+(\w+)/
+    ]
+  };
+  const langPatterns = patterns[language] || patterns.javascript || [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    for (const pattern of langPatterns) {
+      const match = line.match(pattern);
+      if (match && match[1]) {
+        const name = match[1];
+        if (["if", "for", "while", "switch", "catch", "return", "new", "this", "super"].includes(name)) continue;
+        let type = "function";
+        if (/class\s/.test(line)) type = "class";
+        else if (/interface\s/.test(line)) type = "interface";
+        else if (/struct\s/.test(line)) type = "class";
+        else if (/trait\s/.test(line) || /protocol\s/.test(line)) type = "interface";
+        else if (/type\s/.test(line)) type = "type";
+        else if (/const\s|let\s|var\s/.test(line)) type = "variable";
+        else if (/module\s/.test(line) || /namespace\s/.test(line)) type = "module";
+        else if (language === "svelte") {
+          if (/export\s+let/.test(line)) type = "prop";
+          else if (/^\$:\s/.test(line)) type = "reactive";
+          else if (/\$state/.test(line)) type = "rune";
+          else if (/\$derived/.test(line)) type = "rune";
+          else if (/\$effect\(/.test(line)) type = "rune";
+          else if (/\$props\(/.test(line)) type = "rune";
+        }
+        let byteOffset = 0;
+        for (let j = 0; j < i; j++) byteOffset += lines[j].length + 1;
+        const lineLen = lines[i].length;
+        symbols.push({
+          name,
+          type,
+          startLine: i + 1,
+          endLine: i + 1
+        });
+        break;
+      }
+    }
+  }
+  return symbols;
+}
+function extractBasicImports(content, language) {
+  const imports = [];
+  const lines = content.split("\n");
+  const patterns = {
+    typescript: [
+      /import\s+(?:{([^}]+)}|(\w+))\s+from\s+['"]([^'"]+)['"]/,
+      /import\s+\*\s+as\s+(\w+)\s+from\s+['"]([^'"]+)['"]/
+    ],
+    javascript: [/import\s+(?:{([^}]+)}|(\w+))\s+from\s+['"]([^'"]+)['"]/, /require\s*\(\s*['"]([^'"]+)['"]\s*\)/],
+    python: [/^from\s+([\w.]+)\s+import\s+(.+)$/, /^import\s+([\w.]+)/],
+    go: [/import\s+(?:"([^"]+)"|(\w+)\s+"([^"]+)")/],
+    rust: [/use\s+([\w:]+)(?:::\{([^}]+)\})?/],
+    java: [/import\s+(?:static\s+)?([\w.]+)/]
+  };
+  const GROUP_ROLES = {
+    typescript: { module: 3, items: 1 },
+    javascript: { module: 3, items: 1 },
+    python: { module: 1, items: 2 },
+    go: { module: 3, items: 1 },
+    rust: { module: 1, items: 2 },
+    java: { module: 1, items: 1 }
+  };
+  const langPatterns = patterns[language] || patterns.javascript || [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    for (const pattern of langPatterns) {
+      const match = line.match(pattern);
+      if (match) {
+        const roles = GROUP_ROLES[language] ?? GROUP_ROLES.javascript;
+        const path2 = String(match[roles.module] ?? "");
+        const names = String(match[roles.items] ?? "");
+        if (!path2) continue;
+        const isExternal = !path2.startsWith(".") && !path2.startsWith("/");
+        const items = names.split(",").map((s) => s.trim()).filter(Boolean);
+        if (items.length === 0) items.push(path2.split("/").pop() || path2);
+        for (const name of items) {
+          const asMatch = name.match(/^(\S+)\s+as\s+(\S+)$/);
+          imports.push({
+            name: asMatch ? asMatch[1] : name,
+            alias: asMatch ? asMatch[2] : void 0,
+            path: path2,
+            type: "named",
+            isExternal,
+            line: i + 1
+          });
+        }
+        break;
+      }
+    }
+  }
+  return imports;
+}
+function extractBasicRelationships(content, _language, symbols, imports = []) {
+  const rels = [];
+  const knownNames = new Set(symbols.map((s) => s.name));
+  for (const imp of imports) {
+    knownNames.add(imp.name);
+  }
+  const knownFunctions = new Set(
+    symbols.filter((s) => s.type === "function" || s.type === "method").map((s) => s.name)
+  );
+  const lines = content.split("\n");
+  const callPattern = /(\w+)\s*\(/g;
+  const methodCallPattern = /(\w+)\.(\w+)\s*\(/g;
+  const newPattern = /new\s+(\w+)\s*[\(<]/g;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    let nmatch;
+    while ((nmatch = newPattern.exec(line)) !== null) {
+      const className = nmatch[1];
+      if (className.length < 2) continue;
+      if (className === className.toUpperCase()) continue;
+      if (knownNames.has(className)) {
+        rels.push({
+          source: "this",
+          target: className,
+          type: "instantiates",
+          confidence: 0.6,
+          metadata: { line: i + 1, method: "regex", isNew: true }
+        });
+      }
+    }
+    newPattern.lastIndex = 0;
+    let match;
+    while ((match = methodCallPattern.exec(line)) !== null) {
+      const target = match[2];
+      if (knownFunctions.has(target) || knownNames.has(target)) {
+        rels.push({
+          source: match[1],
+          // object name (approximate)
+          target,
+          type: "calls",
+          confidence: 0.4,
+          // Lower confidence: regex-based, may have false positives
+          metadata: { line: i + 1, method: "regex" }
+        });
+      }
+    }
+    methodCallPattern.lastIndex = 0;
+    while ((match = callPattern.exec(line)) !== null) {
+      const target = match[1];
+      if ([
+        "if",
+        "for",
+        "while",
+        "switch",
+        "catch",
+        "return",
+        "new",
+        "this",
+        "super",
+        "function",
+        "class",
+        "import",
+        "export",
+        "const",
+        "let",
+        "var",
+        "typeof",
+        "instanceof",
+        "throw",
+        "else",
+        "case",
+        "default",
+        "break",
+        "continue",
+        "delete",
+        "void"
+      ].includes(target)) continue;
+      if (target.length < 2) continue;
+      if (target === target.toUpperCase() && target.length > 3) continue;
+      if (target.startsWith("_") && target.length < 3) continue;
+      if (knownFunctions.has(target) || knownNames.has(target)) {
+        rels.push({
+          source: "this",
+          target,
+          type: "calls",
+          confidence: 0.5,
+          metadata: { line: i + 1, method: "regex" }
+        });
+      }
+    }
+    callPattern.lastIndex = 0;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return rels.filter((r) => {
+    const key = `${r.source}:${r.target}:${r.type}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function extractFallback(content, language, hash, sizeBytes, lastModified) {
+  const symbols = extractBasicSymbols(content, language);
+  const imports = extractBasicImports(content, language);
+  const relationships = filterNoiseRelationships(
+    extractBasicRelationships(content, language, symbols, imports),
+    language,
+    new Set(symbols.map((s) => String(s?.name ?? "")).filter(Boolean))
+  );
+  return {
+    success: true,
+    language,
+    framework: null,
+    fileHash: hash,
+    sizeBytes,
+    lastModified,
+    symbols,
+    imports,
+    relationships,
+    errors: [],
+    fallback: true
+  };
+}
+var NOISE_TARGETS = /* @__PURE__ */ new Set([
+  // Tree-sitter AST internals
+  "namedChild",
+  "childForFieldName",
+  "namedChildren",
+  "childCount",
+  "namedChildCount",
+  "type",
+  "text",
+  "startIndex",
+  "endIndex",
+  "startPosition",
+  "endPosition",
+  "nextSibling",
+  "previousSibling",
+  "firstChild",
+  "lastChild",
+  "parent",
+  // CSS properties that leak into relationships (hyphenated names)
+  "font-size",
+  "background-color",
+  "align-items",
+  "justify-content",
+  "flex-direction",
+  "border-radius",
+  "font-weight",
+  "line-height",
+  "margin-bottom",
+  "min-width",
+  // Test-framework boilerplate (NOT valid production targets)
+  "setUp",
+  "tearDown",
+  "setUpBeforeClass",
+  "tearDownAfterClass",
+  "beforeEach",
+  "afterEach"
+]);
+function isDeclarationShaped(s) {
+  const r = s?.range ?? {};
+  const st = Number(r.startIndex ?? s?.startIndex);
+  const en = Number(r.endIndex ?? s?.endIndex);
+  const sl = Number(r.startLine ?? s?.startLine);
+  const el = Number(r.endLine ?? s?.endLine);
+  return Number.isFinite(st) && Number.isFinite(en) && en > st && Number.isFinite(sl) && sl >= 1 && Number.isFinite(el) && el >= sl;
+}
+function keepSymbol(s, lang) {
+  const name = s.name || "";
+  if (s.qualifiedName?.startsWith("__global__")) return false;
+  if (lang === "json" || lang === "yaml" || lang === "xml" || lang === "make" || lang === "markdown") return true;
+  const JS_FAMILY = /* @__PURE__ */ new Set(["javascript", "typescript", "tsx", "vue", "svelte"]);
+  const JS_GLOBALS = /* @__PURE__ */ new Set([
+    "window",
+    "document",
+    "console",
+    "process",
+    "global",
+    "__dirname",
+    "__filename",
+    "module",
+    "exports",
+    "default",
+    "globalThis"
+  ]);
+  if (JS_FAMILY.has(lang) && JS_GLOBALS.has(name)) return isDeclarationShaped(s);
+  const UNIVERSAL = /* @__PURE__ */ new Set([
+    // Reserved in essentially every language parsed here. Kept unconditionally
+    // because no lane produced a legitimate declaration of any of them.
+    "this",
+    "super",
+    // Synthetic artifact names the analyzers themselves mint. These are OURS, not
+    // the language's, so no user program can declare them.
+    "SCSS_FILE_SCOPE",
+    "GlobalScope",
+    "module_declaration",
+    "package_manifest"
+    // REMOVED, each with a lane and a count — see the comment above:
+    //   self, Self   deleted R/Python/Zig `self`; lua declares `local this`
+    //   me, My       legitimate in every language (graphql `me`, lua `me`)
+    //   destructor    a real method name in C++/Rust/Go
+    //   root          lua `local root` at lazy.nvim/lua/lazy/core/loader.lua:497
+    //   program       a legal SQL column name
+    //   source_file   an ordinary R function
+    //   unknown       hcl files declare a variable literally named `unknown`
+    //
+    // `unknown` is the one that cannot simply be deleted: R7 counts it as a
+    // PLACEHOLDER, and 46 registered placeholder sites depend on that. It now moves
+    // to RESERVED below rather than being dropped, so a placeholder is still refused
+    // while a declared `unknown` survives.
+  ]);
+  if (lang === "julia" && name === "this") return true;
+  if (UNIVERSAL.has(name)) return false;
+  const RESERVED = {
+    // `self` is reserved in PHP and Python 2-style declarations but a LEGAL variable
+    // in Lua, Python 3, Rust and Zig, all of which are parsed here.
+    php: /* @__PURE__ */ new Set(["self", "parent"]),
+    // `program` is reserved in Haskell/Elm-ish contexts; it is a SQL column name.
+    sql: /* @__PURE__ */ new Set(["program"])
+  };
+  if (RESERVED[lang]?.has(name)) {
+    const PHP_MEMBER_KINDS = /* @__PURE__ */ new Set(["method", "property", "constant", "enum_member"]);
+    const isPhpMember = lang === "php" && PHP_MEMBER_KINDS.has(String(s.kind)) && Boolean(s.ownerName);
+    if (!isPhpMember) return false;
+  }
+  return true;
+}
+function nameTheSymbolRule(s, lang) {
+  const name = s.name || "";
+  if (s.qualifiedName?.startsWith("__global__")) return "qualifiedName is the __global__ sentinel";
+  if (["json", "yaml", "xml", "make", "markdown"].includes(lang)) return "language-exempt (kept)";
+  if ((/* @__PURE__ */ new Set(["javascript", "typescript", "tsx", "vue", "svelte"])).has(lang) && (/* @__PURE__ */ new Set([
+    "window",
+    "document",
+    "console",
+    "process",
+    "global",
+    "__dirname",
+    "__filename",
+    "module",
+    "exports",
+    "default",
+    "globalThis"
+  ])).has(name)) return "JS-family global name";
+  return "UNIVERSAL denylist (a keyword or a synthetic tree-sitter artifact name)";
+}
+var JS_FAMILY_LANGUAGES = /* @__PURE__ */ new Set(["javascript", "typescript", "tsx", "vue", "svelte"]);
+var CSS_FAMILY_LANGUAGES = /* @__PURE__ */ new Set(["css", "scss", "sass", "less"]);
+var NOISE_TARGET_FAMILIES = {};
+for (const n of [
+  "namedChild",
+  "childForFieldName",
+  "namedChildren",
+  "childCount",
+  "namedChildCount",
+  "type",
+  "text",
+  "startIndex",
+  "endIndex",
+  "startPosition",
+  "endPosition",
+  "nextSibling",
+  "previousSibling",
+  "firstChild",
+  "lastChild",
+  "parent"
+]) {
+  NOISE_TARGET_FAMILIES[n] = JS_FAMILY_LANGUAGES;
+}
+for (const n of [
+  "font-size",
+  "background-color",
+  "align-items",
+  "justify-content",
+  "flex-direction",
+  "border-radius",
+  "font-weight",
+  "line-height",
+  "margin-bottom",
+  "min-width"
+]) {
+  NOISE_TARGET_FAMILIES[n] = CSS_FAMILY_LANGUAGES;
+}
+function importBindingNames(imports) {
+  const names = /* @__PURE__ */ new Set();
+  const add = (raw) => {
+    if (typeof raw !== "string") return;
+    let s = raw.trim();
+    if (!s) return;
+    const colon = s.lastIndexOf(":");
+    if (colon >= 0) s = s.slice(colon + 1).trim();
+    const slash = s.lastIndexOf("/");
+    if (slash >= 0) s = s.slice(slash + 1).trim();
+    if (!s) return;
+    const asAt = s.indexOf(" as ");
+    if (asAt > 0) {
+      const imported = s.slice(0, asAt).trim();
+      const local = s.slice(asAt + 4).trim();
+      if (imported) names.add(imported);
+      if (local) names.add(local);
+      return;
+    }
+    names.add(s);
+  };
+  for (const i of imports ?? []) {
+    if (!i || typeof i !== "object") continue;
+    if (Array.isArray(i.items)) for (const it of i.items) add(it);
+    add(i.localName);
+    add(i.defaultName);
+    add(i.alias);
+    add(i.namespaceName);
+  }
+  return names;
+}
+function filterNoiseRelationships(rels, language, declaredNames, boundNames) {
+  if (!rels || rels.length === 0) return rels;
+  const extractLeaf = (name) => {
+    const afterSep = BINDING_SEP.length > 0 && name.includes(BINDING_SEP) ? name.slice(name.lastIndexOf(BINDING_SEP) + BINDING_SEP.length) : name;
+    const noLine = afterSep.replace(/:\d+$/, "");
+    const segments = noLine.split(":").filter((s) => s.length > 0);
+    const last = segments[segments.length - 1] ?? "";
+    const dotParts = last.split(".");
+    return dotParts[dotParts.length - 1];
+  };
+  return rels.filter((r) => {
+    const target = r.target || r.targetId || r.to || r.toSymbol || "";
+    if (!target) return true;
+    if (language === "json" || language === "yaml" || language === "hcl" || language === "terraform" || language === "graphql" || language === "toml") return true;
+    if ((language === "bash" || language === "toml") && (r.type === "imports" || r.type === "references" || r.relationshipType === "imports" || r.relationshipType === "references")) {
+      if (target.length > 200 || target.includes("\n")) return false;
+      return true;
+    }
+    if (language === "julia" && target.includes('var"') && (r.type === "contains" || r.type === "calls" || r.type === "references" || r.relationshipType === "contains" || r.relationshipType === "calls" || r.relationshipType === "references")) {
+      if (target.includes("\n") || target.includes("	") || target.includes(" ")) return false;
+      return true;
+    }
+    if (language === "julia" && target.trim() === ":" && (r.type === "calls" || r.relationshipType === "calls")) return true;
+    if (target.includes("\n")) return false;
+    const leaf = extractLeaf(target);
+    const lower = leaf.toLowerCase();
+    if (leaf.length < 1) return false;
+    const SETTER_NAME = /^[A-Za-z_$][A-Za-z0-9_$]*=$/;
+    const OPERATOR_NAME = /^[<>=!+\-*/%^&|~\[\]]+$/;
+    const CALLABLE_REF = /^@(?:mixin|function)\s+[A-Za-z_$][\w$-]*$/;
+    const DERIVED_TEMPLATE_ID = /xsl:template\[[^\]]*\](?:#\d+)?$/;
+    const DECLARED_SIGNATURE = /^[A-Za-z_$][A-Za-z0-9_$]*\(\)$/;
+    const isDeclaredSignature = DECLARED_SIGNATURE.test(leaf) && ((declaredNames?.has(leaf) ?? false) || (declaredNames?.has(target) ?? false));
+    const isDeclaredName = (declaredNames?.has(leaf) ?? false) || (declaredNames?.has(target) ?? false);
+    if (/[\s'"(),=]/.test(leaf) && !OPERATOR_NAME.test(leaf) && !SETTER_NAME.test(leaf) && !CALLABLE_REF.test(leaf) && !DERIVED_TEMPLATE_ID.test(target) && !isDeclaredSignature && !isDeclaredName) return false;
+    const isOperatorName = /^[<>=!+\-*/%^&|~\[\]]+$/.test(leaf);
+    if (!isOperatorName && /[{}`<>\n\r\t]/.test(leaf)) return false;
+    if (leaf.startsWith(" ") || leaf.includes("  ")) return false;
+    const declaredTarget = !!declaredNames && (declaredNames.has(String(r.target ?? r.to ?? "")) || declaredNames.has(leaf));
+    if (NOISE_TARGETS.has(leaf) && !declaredTarget && // UNION: main's second hatch — a name the file BINDS without declaring (an imported binding is
+    // not framework noise). Absent here, present there, and the probe taken from main depends on it.
+    !(boundNames && boundNames.has(leaf))) {
+      const family = NOISE_TARGET_FAMILIES[leaf];
+      if (family && !family.has(language)) return true;
+      return false;
+    }
+    return true;
+  });
+}
+var SNIPPET_KINDS = /* @__PURE__ */ new Set(["function", "class", "method", "interface", "impl", "struct"]);
+var engineModule = null;
+async function parseFile(filePath, projectPath, context) {
+  const stat = await import("fs/promises").then((fs2) => fs2.stat(filePath));
+  const sizeBytes = stat.size;
+  const lastModified = stat.mtimeMs;
+  const ext = path.extname(filePath).toLowerCase();
+  const language = detectLanguageFromPath(filePath) ?? "unknown";
+  const STRUCTURAL_LIMIT = 5 * 1024 * 1024;
+  if (sizeBytes > STRUCTURAL_LIMIT) {
+    log(`Skipping file over 5MB: ${filePath} (${sizeBytes} bytes)`);
+    return {
+      success: true,
+      language,
+      fileHash: createHash("sha256").update("").digest("hex").slice(0, 16),
+      sizeBytes,
+      lastModified,
+      symbols: [],
+      imports: [],
+      relationships: [],
+      errors: [],
+      fallback: true
+    };
+  }
+  const FULL_AST_LIMIT = 1 * 1024 * 1024;
+  if (sizeBytes > FULL_AST_LIMIT) {
+    const fsModule = await import("fs/promises");
+    const fd = await fsModule.open(filePath, "r");
+    const buffer = Buffer.alloc(Math.min(sizeBytes, 256 * 1024));
+    await fd.read(buffer, 0, buffer.length, 0);
+    await fd.close();
+    const content2 = decodeSourceText(buffer).text;
+    const hash2 = createHash("sha256").update(content2).digest("hex").slice(0, 16);
+    log(`Using structural extraction for large file: ${filePath} (${sizeBytes} bytes)`);
+    return extractFallback(content2, language, hash2, sizeBytes, lastModified);
+  }
+  const decoded = decodeSourceText(await import("fs/promises").then((fs2) => fs2.readFile(filePath)));
+  const content = decoded.text;
+  const hash = createHash("sha256").update(content).digest("hex").slice(0, 16);
+  if (decoded.encoding !== "utf8" || decoded.inferred) {
+    log(`Decoded ${filePath} as ${decoded.encoding}${decoded.inferred ? " (inferred from a NUL pattern, no BOM)" : decoded.hadBom ? " (BOM)" : ""}`);
+  }
+  try {
+    if (!engineModule) {
+      engineModule = await import("./engine-LO6L4JLQ.js");
+    }
+    const parsed = await engineModule.ASTEngine.parseFile(filePath, content, context);
+    if ((parsed?.symbols?.length || 0) === 0 && (parsed?.errors?.length || 0) > 0) {
+      try {
+        const errSample = parsed.errors.slice(0, 3).map((e) => e.message).join(" | ");
+        fs.appendFileSync(
+          bbDiagnosticsLogPath("parse-errors.log"),
+          `${(/* @__PURE__ */ new Date()).toISOString()} | ${language} | ${sizeBytes}B | ${filePath} | ENGINE_EMPTY: ${errSample.substring(0, 200)}
+`
+        );
+      } catch {
+      }
+    }
+    if (ext === ".dart") {
+      try {
+        fs.appendFileSync(
+          bbDiagnosticsLogPath("worker-debug.log"),
+          `[Worker] ASTEngine.parseFile returned ${parsed?.relationships?.length || 0} relationships for ${filePath}
+`
+        );
+      } catch {
+      }
+    }
+    const TAINT_ELIGIBLE_LANGUAGES = /* @__PURE__ */ new Set([
+      // The languages the engine dispatches to a REAL analyzer AND for which
+      // the taint rules are written against a language API (`db.query`,
+      // `child_process`, `PreparedStatement`, `cursor.execute`, …).
+      "typescript",
+      "tsx",
+      "javascript",
+      "java",
+      "kotlin",
+      "scala",
+      "groovy",
+      "python",
+      "ruby",
+      "php",
+      "go",
+      "rust",
+      "swift",
+      "dart",
+      "c",
+      "cpp",
+      "csharp",
+      "perl",
+      "lua",
+      "r",
+      "elixir",
+      "erlang",
+      "clojure",
+      "haskell",
+      "zig",
+      "nim",
+      "fsharp",
+      "vb",
+      "powershell",
+      "bash",
+      "objective-c"
+      // Explicitly EXCLUDED, and each exclusion is load-bearing:
+      //   markdown json yaml toml xml html css sass scss graphql protobuf
+      //   make clean hcl terraform svelte vue sql
+      // Markdown/JSON/YAML/TOML/XML/HTML/CSS carry prose and data, not code —
+      // measured at 326 of 3,190 bb_security findings (10.2%). The rest are
+      // schema, query, build and markup formats whose tokens ("select", "exec",
+      // "query") collide with the sink rules without ever being a sink.
+    ]);
+    const taintEligible = TAINT_ELIGIBLE_LANGUAGES.has((language || "").toLowerCase());
+    try {
+      if (taintEligible) {
+        const { TaintAnalyzer } = await import("./taint-analyzer-N7YLZU3N.js");
+        TaintAnalyzer.enrichSymbols(parsed.symbols, content, language);
+      }
+    } catch (e) {
+      log("Taint extraction failed:", e);
+    }
+    let snippetLines;
+    const identityOf = (s) => {
+      const out = [];
+      if (s?.name) out.push(String(s.name));
+      if (s?.qualifiedName) out.push(String(s.qualifiedName));
+      if (typeof s?.metadata?.fqn === "string" && s.metadata.fqn) out.push(String(s.metadata.fqn));
+      if (s?.name) {
+        out.push(
+          s.qualifiedName || s.metadata?.fqn || (s.scope ? `${s.scope}.${s.name}` : String(s.name))
+        );
+      }
+      return out;
+    };
+    const keptSymbols = [];
+    const keptNames = /* @__PURE__ */ new Set();
+    const notKept = [];
+    for (const s of parsed.symbols ?? []) {
+      if (keepSymbol(s, parsed.language || language)) {
+        keptSymbols.push(s);
+        for (const id of identityOf(s)) keptNames.add(id);
+      } else {
+        notKept.push(s);
+      }
+    }
+    const droppedNames = /* @__PURE__ */ new Set();
+    for (const s of notKept) {
+      for (const id of identityOf(s)) {
+        if (!keptNames.has(id)) droppedNames.add(id);
+      }
+    }
+    const ret = {
+      success: true,
+      language: parsed.language || language,
+      framework: parsed.metadata?.framework,
+      fileHash: hash,
+      sizeBytes,
+      lastModified,
+      symbols: keptSymbols.map((s) => {
+        let snippet = "";
+        if (SNIPPET_KINDS.has(s.kind)) {
+          const lines = snippetLines ?? (snippetLines = content.split("\n"));
+          snippet = lines.slice(Math.max(0, s.range.startLine - 1), s.range.endLine).join("\n");
+          if (snippet.length > 1e4) snippet = snippet.substring(0, 1e4);
+        }
+        return {
+          name: s.name,
+          type: s.kind,
+          kind: s.kind,
+          qualifiedName: s.qualifiedName || s.metadata?.fqn || (s.scope ? `${s.scope}.${s.name}` : s.name),
+          startLine: s.range.startLine,
+          endLine: s.range.endLine,
+          startIndex: s.range.startIndex,
+          endIndex: s.range.endIndex,
+          visibility: s.visibility || "public",
+          parameters: s.parameters,
+          returnType: s.returnType,
+          qualifiedCalls: s.qualified_calls,
+          complexity: s.complexity || s.metadata?.complexity || 1,
+          ownerName: s.ownerName || s.scope,
+          ownerKind: s.ownerKind || s.metadata?.ownerKind,
+          scope: s.scope,
+          taintSources: s.taintSources,
+          taintSinks: s.taintSinks,
+          decorators: s.decorators,
+          genericParameters: s.genericParameters,
+          isStatic: s.isStatic,
+          isAsync: s.isAsync,
+          isAbstract: s.isAbstract,
+          // M35 pre-work: carry the analyzer-extracted docstring across the
+          // worker boundary. It was dropped here AND never bound in the
+          // brain_symbol INSERT, so brain_symbol.docstring was always NULL.
+          docstring: s.docstring ?? null,
+          // SOL-16. `docstring` alone cannot answer "is this NatSpec, or a stray
+          // `//` remark?" — and Solidity's documentation system has THREE forms
+          // (`///`, the slash-star block, and a plain line comment), so the kind is
+          // the difference between documented code and a comment that happened to sit
+          // above a declaration. `docTags` is the structured half: the tags are inside
+          // `docstring` already, but a consumer that wants `@param` names should not
+          // have to re-parse prose, and `comments` is the per-comment array the
+          // TypeScript lane populates for the same job, so a reader of Solidity
+          // documentation should not have to learn a second shape.
+          //
+          // Purely additive, on the same terms as the CSS forwarding above: nothing
+          // read these before, so no consumer changes behaviour.
+          // SOL-22. A LICENCE is a file-level fact and the module symbol is the only
+          // symbol that can carry it, so without this key a Solidity file's licence was
+          // in the analyzer's payload and in no consumer's hands — the same seam as
+          // `docstring` above, and the same terms: additive, nothing read it before.
+          license: s.license ?? s.metadata?.license ?? null,
+          // SOL-23: the NatSpec-vs-signature findings, per symbol. Additive on the same
+          // terms as the rest of this block.
+          undocumentedParameters: s.undocumentedParameters ?? null,
+          // Data location (`transient` / `storage` / `memory` / `calldata`). Read by the
+          // analyzer from the declaration's `location:` field, and invisible until it is
+          // whitelisted here. The CORPUS cannot exercise it — this grammar reports
+          // `transient` on the state-variable field rather than as a `layout_specifier`
+          // node, and no OpenZeppelin contract at 5.5.0 declares one — so the fixture is
+          // the only place this can be gated, which is worth knowing before anyone reads
+          // a zero here as a broken path.
+          stateLocation: s.stateLocation ?? s.metadata?.stateLocation ?? null,
+          overDocumentedParameters: s.overDocumentedParameters ?? null,
+          returnDocumentedWithoutReturn: s.returnDocumentedWithoutReturn ?? false,
+          docstringKind: s.docstringKind ?? s.metadata?.docstringKind ?? null,
+          docTags: s.docTags ?? s.metadata?.docTags ?? null,
+          comments: s.comments ?? s.metadata?.comments ?? null,
+          // #612 store-phase (same seam class as docstring above and scope_kind
+          // below): the declaration/definition fact. c has published
+          // `metadata.isDeclaration` since the HC1 review, and cpp/rust/zig
+          // publish it as of #612 — but the whole `metadata` object was dropped
+          // HERE, so brain_symbol.annotations was NULL for every analyzer
+          // symbol and the store had nothing but the NAME to resolve with. The
+          // narrow key is carried rather than all of metadata: it is the one
+          // metadata fact the store phase reads (a schema column of its own,
+          // `is_declaration`), and widening `annotations` for every symbol in
+          // every language is a separate, larger change that would need its own
+          // measurement round.
+          isDeclaration: s.metadata?.isDeclaration === true || void 0,
+          // CSS lane (2026-09-26). The same seam as `isDeclaration` above, met
+          // from the other side: the store DOES read `symbol.metadata` and
+          // serialise it into `brain_symbol.annotations`, but the whole
+          // `metadata` object is dropped HERE, so nothing an analyzer puts in it
+          // survives the worker boundary. For CSS that silently deleted a
+          // payload the lane's own ruling depends on — `declaresProperties`,
+          // which replaced 32,654 relationships to CSS property names that are
+          // not graph nodes (measured: `uses` resolved at both ends 6.0% of the
+          // time, and the production filter then discarded the class outright).
+          // Trading a wrong edge for a dead field is not a fix, so the payload is
+          // carried.
+          //
+          // Deliberately NARROW, and deliberately CSS-only, for the reason the
+          // comment above gives: widening `annotations` for every symbol in every
+          // language is a separate, larger change that needs its own measurement
+          // round. The keys below are the ones the CSS lane's F6/F8/CC1 checks
+          // read, so the channel carries facts that are consumed rather than
+          // facts that are merely produced.
+          // Emitted under the name the indexer already reads, so the existing
+          // `symbol.metadata -> annotations` INSERT path carries it with no
+          // change on the store side.
+          metadata: (() => {
+            const m = s.metadata;
+            if (!m) return void 0;
+            const out = {};
+            if (Array.isArray(m.declaresProperties)) out.declaresProperties = m.declaresProperties;
+            if (typeof m.declaredPropertyCount === "number") out.declaredPropertyCount = m.declaredPropertyCount;
+            if (typeof m.isSelector === "boolean") out.isSelector = m.isSelector;
+            if (typeof m.isComplex === "boolean") out.isComplex = m.isComplex;
+            if (typeof m.isUtility === "boolean") out.isUtility = m.isUtility;
+            if (typeof m.isCustomProperty === "boolean") out.isCustomProperty = m.isCustomProperty;
+            if (typeof m.isKeyframes === "boolean") out.isKeyframes = m.isKeyframes;
+            if (typeof m.isSupports === "boolean") out.isSupports = m.isSupports;
+            if (typeof m.isAtRule === "boolean") out.isAtRule = m.isAtRule;
+            if (typeof m.isCssModule === "boolean") out.isCssModule = m.isCssModule;
+            if (Array.isArray(m.specificity)) out.specificity = m.specificity;
+            if (Array.isArray(m.classNames)) out.classNames = m.classNames;
+            if (m.selectorComposition) out.selectorComposition = m.selectorComposition;
+            if (typeof m.supportsCondition === "string") out.supportsCondition = m.supportsCondition;
+            if (typeof m.atKeyword === "string") out.atKeyword = m.atKeyword;
+            if (Array.isArray(m.selectorChain)) out.selectorChain = m.selectorChain;
+            if (typeof m.nodeType === "string") out.nodeType = m.nodeType;
+            if (typeof m.headingLevel === "number") out.headingLevel = m.headingLevel;
+            if (typeof m.language === "string") out.language = m.language;
+            if (m.isMarkdownHeading === true) out.isMarkdownHeading = m.isMarkdownHeading;
+            if (m.isMarkdownTable === true) out.isMarkdownTable = m.isMarkdownTable;
+            if (m.isMarkdownTableColumn === true) out.isMarkdownTableColumn = m.isMarkdownTableColumn;
+            if (m.isMarkdownCodeBlock === true) out.isMarkdownCodeBlock = m.isMarkdownCodeBlock;
+            if (m.isMarkdownFrontMatter === true) out.isMarkdownFrontMatter = m.isMarkdownFrontMatter;
+            if (m.isRepeatedSite === true) out.isRepeatedSite = m.isRepeatedSite;
+            if (m.isExported === true) out.isExported = m.isExported;
+            if (m.isImplicitBinding === true) out.isImplicitBinding = m.isImplicitBinding;
+            if (typeof m.bindingSite === "string") out.bindingSite = m.bindingSite;
+            if (typeof m.isArray === "boolean") out.isArray = m.isArray;
+            if (Array.isArray(m.superTypes) && m.superTypes.length > 0) out.superTypes = m.superTypes;
+            return Object.keys(out).length > 0 ? out : void 0;
+          })(),
+          snippet
+        };
+      }),
+      imports: (parsed.imports || []).flatMap((i) => {
+        const items = Array.isArray(i.items) && i.items.length > 0 ? i.items : [i.localName || i.module || ""];
+        const baseType = i.isDefault || i.isDefaultImport ? "default" : i.isNamespace || i.isNamespaceImport ? "namespace" : "named";
+        const declared = i.metadata ?? {};
+        const external = declared.isSystemInclude === true || declared.isExternal === true || i.isExternal === true ? true : declared.isSystemInclude === false || declared.isExternal === false ? false : typeof i.module === "string" ? !i.module.startsWith(".") && !i.module.startsWith("/") : !!i.isExternal;
+        const line = i.range?.startLine ?? i.line ?? i.line_number ?? i.lineNumber ?? 0;
+        const bindings = /* @__PURE__ */ new Map();
+        for (const b of Array.isArray(i.itemBindings) ? i.itemBindings : []) {
+          if (b && typeof b.name === "string" && typeof b.as === "string" && b.name && b.as) {
+            bindings.set(b.name, b.as);
+          }
+        }
+        const itemCount = items.length;
+        const statementAlias = itemCount === 1 && typeof i.alias === "string" && i.alias ? i.alias : itemCount === 1 && typeof i.localName === "string" && i.localName ? i.localName : void 0;
+        return items.filter((name) => typeof name === "string" && name.length > 0).map((name) => {
+          const asMatch = name.match(/^(\S+)\s+as\s+(\S+)$/);
+          const importedName = asMatch ? asMatch[1] : name;
+          const cleanName = importedName.replace(/^type\s+/, "").trim();
+          const boundName = asMatch ? asMatch[2] : bindings.get(name) ?? statementAlias;
+          return {
+            name: cleanName,
+            path: i.module || i.path || "",
+            ...boundName ? { alias: boundName } : {},
+            // The analyzer's OWN classification, when it declares one. Five lanes do:
+            // makefile `make_include`, objective-c `include`, sql `sql_import`, xml
+            // `xml-doctype`, yaml `yaml_tag_include` / `yaml_keyword_include` /
+            // `github_action`. The fallback below is the JS/TS idiom
+            // (named/default/namespace), and applying it to every language made all
+            // 442 of this lane's corpus imports read `named` — so an Ansible
+            // `include_tasks: tasks.yml` PROJECT file dependency and a GitHub Actions
+            // `uses: actions/checkout@v4` EXTERNAL tool invocation became
+            // indistinguishable in the row the file-dependency engine reads. The
+            // relationships always carried the distinction; the row did not.
+            //
+            // Safe to prefer: the stored column is `import_type`, no fixture in the
+            // tree pins this field, and the only consumer that branches on an import's
+            // `type` (import-pruner.ts) reads JS/TS AST SPECIFIERS — a different
+            // structure entirely, not these rows. A lane that sets no `importType`
+            // keeps the historical value unchanged.
+            type: i.importType ?? (asMatch ? "alias" : baseType),
+            isExternal: external,
+            line
+          };
+        });
+      }),
+      // THE DROPPED-SYMBOL INVARIANT — see `droppedNames` above. An edge that names a symbol
+      // this call filtered out is not a weaker edge, it is an edge to nothing, so it goes with
+      // the symbol. Applied BEFORE the noise filter so the two are independent and either can
+      // be measured alone.
+      relationships: filterNoiseRelationships(
+        droppedNames.size ? (parsed.relationships ?? []).filter((r) => {
+          const type = String(r?.type ?? r?.relationshipType ?? "");
+          const src = String(r?.source ?? r?.from ?? "");
+          const tgt = String(r?.target ?? r?.to ?? "");
+          if ((type === "imports" || type === "exports") && droppedNames.has(src)) return true;
+          return !droppedNames.has(src) && !droppedNames.has(tgt);
+        }) : parsed.relationships,
+        language,
+        new Set((parsed.symbols ?? []).map((s) => String(s?.name ?? "")).filter(Boolean))
+      ),
+      // M60 LUA-14: the analyzer's `exports` were never forwarded here, so the
+      // entire export surface of every language was invisible to the index. This
+      // is the same defect the `metadata` line below already documents for
+      // metadata — two entry points that disagreed, with the worker the lossy one
+      // — except that nobody had measured the size of it. Now measured, over
+      // every Lua file of two pinned corpora: 1,587 exports on kong and 187 on
+      // luvit, emitted by the analyzer and returned by nobody. Zero of 1,774
+      // reached the product.
+      //
+      // `ParseResult.exports` was already declared optional and `engine.ts`
+      // already forwards it, so this adds no new contract: it makes the worker
+      // agree with the engine it wraps. `?? []` rather than a bare field, because
+      // `extractFallback` and the size/extension early-returns build their own
+      // objects and a consumer must not have to distinguish "no exports" from
+      // "this path never set the key".
+      exports: parsed.exports ?? [],
+      errors: parsed.errors || [],
+      // <-- Stage 4: propagate syntax errors from the AST Engine
+      // The analyzer's WHOLE `metadata` object was being dropped here, and this
+      // is the function `parallel-indexer.ts:889` uses — the production indexing
+      // path. `engine.ts` carries it (its own result type is
+      // `Omit<ParseResult, "language" | "metadata"> & { metadata?: ... }`), so the
+      // two entry points disagreed and the worker was the lossy one. Found by
+      // running the bash contract probe through `parseFile` rather than through
+      // the analyzer directly: the analyzer reported 10 patterns for
+      // `Deploy.sh` — Strict Error Handling, Insecure Pipe Execution, Privilege
+      // Escalation, Destructive File Operation — and `parseFile` returned none.
+      // Every pattern-based signal in every language was invisible to the index.
+      // Purely additive: nothing read this before, so no consumer changes
+      // behaviour, and the fields that WERE forwarded (`framework` above) are
+      // left exactly as they were.
+      metadata: parsed.metadata
+    };
+    if (ext === ".dart") {
+      try {
+        fs.appendFileSync(
+          bbDiagnosticsLogPath("worker-debug.log"),
+          `[Worker] Returning object with ${ret.relationships?.length || 0} relationships for ${filePath}
+`
+        );
+      } catch {
+      }
+    }
+    return ret;
+  } catch (parseError) {
+    const errMsg = parseError?.message || String(parseError);
+    const isExpected = errMsg.includes("Unsupported file type") || errMsg.includes("Failed to determine WASM path") || errMsg.includes("not yet implemented");
+    const lang = detectLanguageFromPath(filePath) ?? "unknown";
+    if (!isExpected) {
+      process.stderr.write(`[BB-PARSE-ERR] ${lang} | ${filePath} | ${errMsg.substring(0, 300)}
+`);
+    }
+    return extractFallback(content, lang, hash, sizeBytes, lastModified);
+  }
+}
+async function warmUpWorker() {
+  let wasm = "ok";
+  try {
+    const { ensureWasmRegistry } = await import("./wasm-NMWO3WXY.js");
+    await ensureWasmRegistry();
+  } catch (e) {
+    wasm = "unavailable";
+    reportStartupProblem("wasm registry unavailable \u2014 tree-sitter grammars may not load", e);
+  }
+  let engine = "ok";
+  try {
+    engineModule = await import("./engine-LO6L4JLQ.js");
+    if (!engineModule?.ASTEngine) {
+      engine = "unavailable";
+      reportStartupProblem("engine module loaded but exports no ASTEngine", new Error("ASTEngine missing"));
+    }
+  } catch (e) {
+    engine = "unavailable";
+    reportStartupProblem("engine module failed to load \u2014 falling back to regex extraction for EVERY file", e);
+  }
+  return { engine, wasm };
+}
+function persistStartupDiagnostics() {
+  if (startupDiagnostics.length === 0) return;
+  try {
+    fs.appendFileSync(
+      bbDiagnosticsLogPath("worker-startup.log"),
+      `${(/* @__PURE__ */ new Date()).toISOString()} | pid=${process.pid} | node=${process.version} | ${startupDiagnostics.join(" | ")}
+`
+    );
+  } catch {
+  }
+}
+async function runSelfTest() {
+  const { engine, wasm } = await warmUpWorker();
+  persistStartupDiagnostics();
+  const report = {
+    ok: engine === "ok" && wasm === "ok",
+    engine,
+    wasm,
+    node: process.version,
+    pid: process.pid,
+    execPath: process.execPath,
+    diagnostics: startupDiagnostics.slice(0, 5)
+  };
+  process.stdout.write(`[BB-WORKER-SELFTEST] ${JSON.stringify(report)}
+`);
+  return report.ok ? 0 : 1;
+}
+process.on("message", async (msg) => {
+  if (msg.type === "warmup") {
+    const watchdogMs = Number(process.env.BB_WORKER_STARTUP_TIMEOUT_MS || 0) || 3e4;
+    const slowWarmNote = setTimeout(() => {
+      process.stderr.write(
+        `[BB-WORKER-STARTUP] still warming after ${Math.round(watchdogMs / 2)}ms (loading tree-sitter grammars); the parent's watchdog is ${watchdogMs}ms
+`
+      );
+    }, Math.max(1, Math.round(watchdogMs / 2)));
+    slowWarmNote.unref?.();
+    const { engine: engineStatus, wasm: wasmStatus } = await warmUpWorker();
+    if (engineStatus === "unavailable") {
+      safeSend({ type: "engine_fail", workerId: msg.workerId, error: startupDiagnostics.join(" | ") });
+    }
+    if (process.env.BB_TEST_HOOKS === "1") {
+      const delayReady = Number(process.env.BB_WORKER_DELAY_READY_MS || 0);
+      if (delayReady > 0) await new Promise((r) => setTimeout(r, delayReady));
+    }
+    clearTimeout(slowWarmNote);
+    safeSend({
+      type: "ready",
+      workerId: msg.workerId,
+      pid: process.pid,
+      node: process.version,
+      execPath: process.execPath,
+      engine: engineStatus,
+      wasm: wasmStatus,
+      diagnostics: startupDiagnostics.slice(0, 5)
+    });
+    persistStartupDiagnostics();
+  } else if (msg.type === "parse_batch") {
+    const { batchId, files, projectPath, projectIndexes } = msg;
+    let indexCache = null;
+    if (projectIndexes !== void 0 && projectIndexes !== null) {
+      try {
+        const mod = await import("./project-index-5SDPHITE.js");
+        indexCache = /* @__PURE__ */ new Map();
+        for (const [lang, raw] of Object.entries(projectIndexes)) {
+          const built = mod.deserializeProjectIndex(raw);
+          if (built !== null) {
+            mod.buildResolutionTables(built);
+            indexCache.set(lang, built);
+          }
+        }
+      } catch (e) {
+        log(`[Worker] project index unavailable, continuing per-file: ${e?.message ?? e}`);
+        reportStartupProblem("project index unavailable, indexing per-file", e);
+        indexCache = null;
+      }
+    }
+    const extnameOf = (p) => {
+      const base = p.slice(p.lastIndexOf("/") + 1);
+      const dot = base.lastIndexOf(".");
+      return dot <= 0 ? "" : base.slice(dot).toLowerCase();
+    };
+    const contextFor = (filePath) => {
+      const root = String(projectPath ?? "") || void 0;
+      if (indexCache === null) return root === void 0 ? void 0 : { projectRoot: root };
+      const ext = extnameOf(filePath);
+      const built = indexCache.get(ext);
+      if (built === void 0) return root === void 0 ? void 0 : { projectRoot: root };
+      return { projectIndex: built, projectRoot: root };
+    };
+    const FILE_TIMEOUT_MS = Number(process.env.BB_FILE_TIMEOUT_MS || 45e3);
+    let delayParse = 0;
+    if (process.env.BB_TEST_HOOKS === "1") {
+      if (process.env.BB_WORKER_CRASH_ON_BATCH === "1") {
+        process.stderr.write(`[BB-WORKER-FIXTURE] crashing on parse_batch (batch ${batchId})
+`);
+        process.exit(1);
+      }
+      delayParse = Number(process.env.BB_WORKER_DELAY_PARSE_MS || 0);
+    }
+    for (const filePath of files) {
+      try {
+        safeSend({ type: "file_start", batchId, filePath });
+        await new Promise((r) => setTimeout(r, 0));
+        if (delayParse > 0) await new Promise((r) => setTimeout(r, delayParse));
+        const fileTimer = setTimeout(() => {
+          log(`Worker self-timeout: killing process after ${FILE_TIMEOUT_MS}ms on ${filePath}`);
+          process.exit(1);
+        }, FILE_TIMEOUT_MS);
+        const result = await parseFile(filePath, projectPath, contextFor(filePath));
+        clearTimeout(fileTimer);
+        safeSend({ type: "file_done", batchId, filePath, result });
+      } catch (err) {
+        safeSend({
+          type: "file_error",
+          batchId,
+          filePath,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    safeSend({ type: "batch_done", batchId });
+  }
+});
+process.on("disconnect", () => process.exit(0));
+if (process.connected) {
+  if (process.env.BB_POOL_WORKER !== "1") {
+    process.stderr.write(
+      `[BB-WORKER-STARTUP] forked with BB_POOL_WORKER=${JSON.stringify(process.env.BB_POOL_WORKER ?? null)} rather than "1"; serving anyway \u2014 unset BB_POOL_WORKER to use in-process indexing
+`
+    );
+  }
+  setInterval(() => {
+  }, 1 << 30);
+}
+if (process.env.BB_POOL_WORKER_SELFTEST === "1" && !process.connected) {
+  runSelfTest().then(
+    (code) => {
+      process.exitCode = code;
+    },
+    (e) => {
+      process.stderr.write(`[BB-WORKER-SELFTEST] failed: ${e?.message ?? String(e)}
+`);
+      process.exitCode = 1;
+    }
+  );
+}
+export {
+  extractFallback,
+  filterNoiseRelationships,
+  importBindingNames,
+  keepSymbol,
+  nameTheSymbolRule,
+  parseFile
+};