weavatrix 0.3.9 → 0.3.11

package/src/graph/builder/lang-sql.js

@@ -0,0 +1,263 @@
+// SQL extractor. No SQL grammar ships in the pinned tree-sitter-wasms, so this module is textOnly:
+// a dependency-free statement scanner built for the graph's needs (symbols + references), NOT a SQL
+// parser. Symbols: CREATE TABLE/VIEW (+ columns as member symbols, ALTER TABLE ADD COLUMN included),
+// FUNCTION/PROCEDURE, INDEX, TRIGGER. References: FROM/JOIN/INSERT INTO/UPDATE…SET/DELETE FROM/
+// TRUNCATE/REFERENCES/EXECUTE FUNCTION/CALL inside .sql files, plus the same verbs found in string
+// literals of every other indexed language (scanEmbeddedSql) — that is what ties the code graph to
+// the database schema: a query in app code becomes a `references` edge onto the table it touches.
+// Known blind spots (kept honest downstream, see dead-check.js): ORM-generated SQL is invisible,
+// `SELECT *` consumes columns namelessly (tables get sql_star), DROP statements are not replayed.
+// String literals and comments are blanked before structural scanning so a quoted "SELECT" can
+// never fabricate a reference; dollar-quoted function bodies stay scannable on purpose.
+
+const NAME = String.raw`((?:[\`"\[]?[A-Za-z_][\w$]*[\`"\]]?\.)*[\`"\[]?[A-Za-z_][\w$]*[\`"\]]?)`;
+const cleanName = (raw) => String(raw || "").replace(/[`"\[\]]/g, "").split(".").pop();
+const CONSTRAINT_START = /^(?:CONSTRAINT|PRIMARY|FOREIGN|UNIQUE|CHECK|EXCLUDE|KEY|INDEX|LIKE|PERIOD)\b/i;
+
+// strings ('…' with '' doubling) and comments (-- …, /* … */) become spaces of equal length,
+// so offsets/line numbers survive and quoted text can't match structural patterns.
+function sanitizeSql(text) {
+  const out = text.split("");
+  let i = 0;
+  const blank = (from, to) => { for (let k = from; k < to; k++) if (out[k] !== "\n") out[k] = " "; };
+  while (i < text.length) {
+    const ch = text[i], next = text[i + 1];
+    if (ch === "-" && next === "-") { let j = i; while (j < text.length && text[j] !== "\n") j++; blank(i, j); i = j; continue; }
+    if (ch === "/" && next === "*") { let j = text.indexOf("*/", i + 2); j = j < 0 ? text.length : j + 2; blank(i, j); i = j; continue; }
+    if (ch === "'") {
+      let j = i + 1;
+      while (j < text.length) { if (text[j] === "'") { if (text[j + 1] === "'") { j += 2; continue; } break; } j++; }
+      blank(i + 1, Math.min(j, text.length)); i = j + 1; continue;
+    }
+    i++;
+  }
+  return out.join("");
+}
+
+const lineIndex = (text) => {
+  const starts = [0];
+  for (let i = 0; i < text.length; i++) if (text[i] === "\n") starts.push(i + 1);
+  return (offset) => {
+    let lo = 0, hi = starts.length - 1;
+    while (lo < hi) { const mid = (lo + hi + 1) >> 1; if (starts[mid] <= offset) lo = mid; else hi = mid - 1; }
+    return lo + 1;
+  };
+};
+
+// split a CREATE TABLE body on top-level commas, keeping each part's offset
+function splitColumns(body, base) {
+  const parts = [];
+  let depth = 0, start = 0;
+  for (let i = 0; i < body.length; i++) {
+    const ch = body[i];
+    if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    else if (ch === "," && depth === 0) { parts.push({ text: body.slice(start, i), offset: base + start }); start = i + 1; }
+  }
+  parts.push({ text: body.slice(start), offset: base + start });
+  return parts;
+}
+
+const REF_PATTERNS = [
+  new RegExp(String.raw`\bFROM\s+${NAME}`, "gi"),
+  new RegExp(String.raw`\bJOIN\s+${NAME}`, "gi"),
+  new RegExp(String.raw`\bINSERT\s+INTO\s+${NAME}`, "gi"),
+  new RegExp(String.raw`\bMERGE\s+INTO\s+${NAME}`, "gi"),
+  new RegExp(String.raw`\bUPDATE\s+(?:ONLY\s+)?${NAME}\s+SET\b`, "gi"),
+  new RegExp(String.raw`\bTRUNCATE\s+(?:TABLE\s+)?${NAME}`, "gi"),
+  new RegExp(String.raw`\bREFERENCES\s+${NAME}`, "gi"),
+  new RegExp(String.raw`\bEXECUTE\s+(?:FUNCTION|PROCEDURE)\s+${NAME}`, "gi"),
+];
+const STAR_RE = /\bSELECT\s+(?:[A-Za-z_]\w*\.)?\*/i;
+
+export default {
+  family: "sql",
+  grammars: [],
+  exts: { ".sql": "sql" },
+  isWeb: false,
+  textOnly: true,
+  calls: null,
+  heritage: [],
+
+  pass1(ctx) {
+    const { fileRel, code, addSym, links, sqlRefs } = ctx;
+    const text = sanitizeSql(String(code || ""));
+    const lineOf = lineIndex(text);
+    const fakeNode = (startOffset, endOffset) => ({
+      startPosition: { row: lineOf(startOffset) - 1, column: 0 },
+      endPosition: { row: lineOf(Math.max(startOffset, endOffset - 1)) - 1, column: 0 },
+    });
+
+    // statements with offsets (';' inside dollar-quoted bodies splits early — refs/lines still land right)
+    const statements = [];
+    let cursor = 0;
+    while (cursor <= text.length) {
+      let end = text.indexOf(";", cursor);
+      if (end < 0) end = text.length;
+      if (text.slice(cursor, end).trim()) statements.push({ text: text.slice(cursor, end), offset: cursor });
+      cursor = end + 1;
+    }
+
+    const addRef = (table, offset, star) => {
+      const name = cleanName(table);
+      if (/^[A-Za-z_][\w$]*$/.test(name)) sqlRefs.push({ file: fileRel, line: lineOf(offset), table: name, star: !!star });
+    };
+
+    for (const stmt of statements) {
+      const at = (m) => stmt.offset + m.index;
+      const definedHere = new Set();
+      const defineSym = (raw, m, callable, extra) => {
+        const name = cleanName(raw);
+        definedHere.add(name);
+        return addSym(name, lineOf(at(m)), callable, {
+          sourceNode: fakeNode(at(m), stmt.offset + stmt.text.length),
+          exported: true, moduleDeclaration: true, ...extra,
+        });
+      };
+
+      let m;
+      if ((m = stmt.text.match(new RegExp(String.raw`\bCREATE\s+(?:GLOBAL\s+|LOCAL\s+)?(?:TEMP(?:ORARY)?\s+|UNLOGGED\s+)?TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?${NAME}\s*\(`, "i")))) {
+        const tableName = cleanName(m[1]);
+        const open = stmt.offset + m.index + m[0].length - 1;
+        let depth = 0, close = open;
+        for (let i = open; i < text.length; i++) { if (text[i] === "(") depth++; else if (text[i] === ")" && --depth === 0) { close = i; break; } }
+        const fieldTypes = {};
+        const columns = [];
+        for (const part of splitColumns(text.slice(open + 1, close), open + 1)) {
+          const trimmed = part.text.trim();
+          if (!trimmed || CONSTRAINT_START.test(trimmed)) continue;
+          const col = trimmed.match(new RegExp(String.raw`^${NAME}\s+([A-Za-z_]\w*(?:\([^)]*\))?)`));
+          if (!col) continue;
+          const colName = cleanName(col[1]);
+          if (!/^[A-Za-z_][\w$]*$/.test(colName)) continue;
+          fieldTypes[colName] = col[2];
+          columns.push({ name: colName, offset: part.offset + part.text.indexOf(col[1]) });
+        }
+        const tableId = defineSym(m[1], m, false, { symbolKind: "table", fieldTypes });
+        for (const column of columns) {
+          const columnId = addSym(column.name, lineOf(column.offset), false, {
+            sourceNode: fakeNode(column.offset, column.offset + 1),
+            symbolKind: "column", memberOf: tableName,
+          });
+          if (tableId && columnId) links.push({ source: tableId, target: columnId, relation: "contains", confidence: "EXTRACTED" });
+        }
+      } else if ((m = stmt.text.match(new RegExp(String.raw`\bCREATE\s+(?:OR\s+REPLACE\s+)?(?:MATERIALIZED\s+)?VIEW\s+(?:IF\s+NOT\s+EXISTS\s+)?${NAME}`, "i")))) {
+        defineSym(m[1], m, false, { symbolKind: "view" });
+      } else if ((m = stmt.text.match(new RegExp(String.raw`\bCREATE\s+(?:OR\s+REPLACE\s+)?(?:FUNCTION|PROCEDURE)\s+${NAME}`, "i")))) {
+        defineSym(m[1], m, true, { symbolKind: "function" });
+      } else if ((m = stmt.text.match(new RegExp(String.raw`\bCREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:CONCURRENTLY\s+)?(?:IF\s+NOT\s+EXISTS\s+)?${NAME}\s+ON\s+(?:ONLY\s+)?${NAME}`, "i")))) {
+        defineSym(m[1], m, false, { symbolKind: "index" });
+        addRef(m[2], at(m), false);
+      } else if ((m = stmt.text.match(new RegExp(String.raw`\bCREATE\s+(?:OR\s+REPLACE\s+)?(?:CONSTRAINT\s+)?TRIGGER\s+${NAME}[\s\S]*?\bON\s+${NAME}`, "i")))) {
+        defineSym(m[1], m, false, { symbolKind: "trigger" });
+        addRef(m[2], at(m), false);
+      } else if ((m = stmt.text.match(new RegExp(String.raw`\bALTER\s+TABLE\s+(?:IF\s+EXISTS\s+)?(?:ONLY\s+)?${NAME}`, "i")))) {
+        const tableName = cleanName(m[1]);
+        addRef(m[1], at(m), false);
+        const addColumn = new RegExp(String.raw`\bADD\s+(?:COLUMN\s+)?(?:IF\s+NOT\s+EXISTS\s+)?(?!CONSTRAINT\b|PRIMARY\b|FOREIGN\b|UNIQUE\b|CHECK\b|EXCLUDE\b)${NAME}\s+[A-Za-z_]`, "gi");
+        for (const colMatch of stmt.text.matchAll(addColumn)) {
+          const colName = cleanName(colMatch[1]);
+          if (!/^[A-Za-z_][\w$]*$/.test(colName)) continue;
+          addSym(colName, lineOf(stmt.offset + colMatch.index), false, {
+            sourceNode: fakeNode(stmt.offset + colMatch.index, stmt.offset + colMatch.index + 1),
+            symbolKind: "column", memberOf: tableName,
+          });
+        }
+      }
+
+      const star = STAR_RE.test(stmt.text);
+      for (const pattern of REF_PATTERNS) {
+        pattern.lastIndex = 0;
+        for (const refMatch of stmt.text.matchAll(pattern)) {
+          const name = cleanName(refMatch[1]);
+          if (!definedHere.has(name)) addRef(refMatch[1], stmt.offset + refMatch.index, star);
+        }
+      }
+    }
+  },
+};
+
+// SQL verbs inside string literals of any host language — the cross-link between app code and schema.
+// Runs on RAW text (strings are exactly where the queries live); comments can over-match, which only
+// errs toward "referenced" and carries INFERRED confidence.
+const EMBEDDED = [
+  { re: new RegExp(String.raw`\bSELECT\b[^;]{0,2000}?\bFROM\s+${NAME}`, "gi"), star: true },
+  { re: new RegExp(String.raw`\bINSERT\s+INTO\s+${NAME}`, "gi") },
+  { re: new RegExp(String.raw`\bUPDATE\s+${NAME}\s+SET\b`, "gi") },
+  { re: new RegExp(String.raw`\bDELETE\s+FROM\s+${NAME}`, "gi") },
+  { re: new RegExp(String.raw`\bJOIN\s+${NAME}\b`, "gi") },
+  { re: new RegExp(String.raw`\bCALL\s+${NAME}\s*\(`, "gi") },
+];
+const EMBEDDED_PREFILTER = /\b(?:select|insert|update|delete|join|call)\b/i;
+
+export function scanEmbeddedSql(code, fileRel, sqlRefs) {
+  const text = String(code || "");
+  if (!EMBEDDED_PREFILTER.test(text)) return;
+  const lineOf = lineIndex(text);
+  for (const { re, star } of EMBEDDED) {
+    re.lastIndex = 0;
+    for (const m of text.matchAll(re)) {
+      const name = cleanName(m[1]);
+      if (!/^[A-Za-z_][\w$]*$/.test(name)) continue;
+      sqlRefs.push({ file: fileRel, line: lineOf(m.index), table: name, star: !!(star && STAR_RE.test(m[0])) });
+    }
+  }
+}
+
+// Dead-code policy for SQL schema objects, consumed by analysis/dead-check.js. Static liveness can
+// only be judged where the repo demonstrably uses literal SQL the scanner can read: without a single
+// embedded-SQL edge from host code, DB consumers (ORMs, external services) are invisible and every
+// verdict would be a guess. Indexes and triggers are DB-engine surface — never judged. Columns of a
+// `SELECT *`-consumed table are consumed namelessly — never judged by name.
+export function createSqlDeadVerdict({ nodes, links, ep, bareName }) {
+  const usageFromCode = links.some((l) => l.usage === "sql" && !String(ep(l.source)).split("#")[0].endsWith(".sql"));
+  const starTables = new Set(nodes.filter((n) => n.sql_star).map((n) => bareName(n.label)));
+  const classify = (n) => {
+    if (!String(n.source_file || "").endsWith(".sql")) return null;
+    const kind = String(n.symbol_kind || "");
+    if (kind === "index" || kind === "trigger" || !usageFromCode) return "veto";
+    if (kind === "column" && starTables.has(String(n.member_of || ""))) return "veto";
+    return "flag";
+  };
+  return {
+    veto: (n) => classify(n) === "veto",
+    reason: (n) => (classify(n) === "flag" ? "no SQL statement in the indexed sources references it" : null),
+  };
+}
+
+// After both passes: resolve collected refs against every table/view/function DEFINED in .sql files.
+// Unknown names drop silently — only schema objects the repo actually declares can gain edges.
+export function resolveSqlReferences({ sqlRefs, links, nodeById, perFileSymbols }) {
+  if (!sqlRefs?.length) return;
+  const index = new Map();
+  for (const [file, syms] of perFileSymbols) {
+    if (!file.endsWith(".sql")) continue;
+    for (const sym of syms) {
+      if (!["table", "view", "function"].includes(sym.symbolKind)) continue;
+      (index.get(sym.name) || index.set(sym.name, []).get(sym.name)).push(sym.id);
+    }
+  }
+  if (!index.size) return;
+  const enclosing = (file, line) => {
+    let best = null;
+    for (const symbol of perFileSymbols.get(file) || []) {
+      if (line < symbol.start || line > symbol.end) continue;
+      if (!best || symbol.start > best.start || (symbol.start === best.start && symbol.end < best.end)) best = symbol;
+    }
+    return best;
+  };
+  const seen = new Set();
+  for (const ref of sqlRefs) {
+    const targets = index.get(ref.table);
+    if (!targets) continue;
+    const source = enclosing(ref.file, ref.line)?.id || ref.file;
+    for (const target of targets) {
+      if (ref.star) { const node = nodeById.get(target); if (node) node.sql_star = true; }
+      if (target === source) continue;
+      const key = source + ">" + target;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      links.push({ source, target, relation: "references", confidence: "INFERRED", usage: "sql", line: ref.line });
+    }
+  }
+}

package/src/graph/builder/pass2-resolution.js

@@ -1,6 +1,8 @@
 export function createPass2Resolution({symIdsByFileName, nodeById, importedLocals, symByFileName}) {
     const dirSymbols = new Map(), dirMethods = new Map(), dirMethodsByName = new Map(), dirTypes = new Map()
-    const sharesDirScope = (file) => file.endsWith('.go') || file.endsWith('.cs') || file.endsWith('.rs')
+    // .sol shares dir scope because Solidity's project namespace is flat: `import "./Base.sol"` names no
+    // symbols yet pulls every declaration into scope, so same-dir name resolution is the honest static proxy.
+    const sharesDirScope = (file) => file.endsWith('.go') || file.endsWith('.cs') || file.endsWith('.rs') || file.endsWith('.sol')
     for (const [file, names] of symIdsByFileName) {
         if (!sharesDirScope(file)) continue
         const dir = file.includes('/') ? file.slice(0, file.lastIndexOf('/')) : ''

package/src/graph/freshness-probe.js

@@ -27,7 +27,7 @@ const CURRENT_GRAPH_SCHEMA = Object.freeze({
     barrelResolutionV: 1,
     reExportOccurrencesV: 1,
     symbolSpacesV: 1,
-    extractorSchemaV: 5,
+    extractorSchemaV: 7,
 })
 const CONTROL_FILES = ['.gitignore', '.weavatrixignore', '.weavatrix.json']
 const MAX_CONTROL_BYTES = 1_000_000

package/src/graph/graph-filter.js

@@ -22,12 +22,14 @@ export function filterGraphForMode(graph, mode, { repoRoot = null } = {}) {
   const links = graph.links || [];
   const endpoint = (value) => (value && typeof value === "object" ? value.id : value);
   const classifier = createPathClassifier(repoRoot);
-  const isTest = (path) => hasPathClass(classifier.explain(path), "test", "e2e");
+  // A node is a test surface when its file is test-classified OR the extractor proved the symbol
+  // itself is compiled only under test (Rust #[cfg(test)] inline modules live in production files).
+  const isTest = (node) => node.test_surface === true || hasPathClass(classifier.explain(node.source_file), "test", "e2e");
   let keep;
   if (mode === "no-tests") {
-    keep = new Set(nodes.filter((node) => !isTest(node.source_file)).map((node) => node.id));
+    keep = new Set(nodes.filter((node) => !isTest(node)).map((node) => node.id));
   } else {
-    const testIds = new Set(nodes.filter((node) => isTest(node.source_file)).map((node) => node.id));
+    const testIds = new Set(nodes.filter((node) => isTest(node)).map((node) => node.id));
     keep = new Set(testIds);
     for (const link of links) {
       if (testIds.has(endpoint(link.source))) keep.add(endpoint(link.target)); // a test's dependency

package/src/graph/incremental-refresh.js

@@ -184,7 +184,7 @@ export async function refreshGraphIncrementally(repoDir, existingGraph, {
 
   if (!existingGraph || !existingGraph.fileHashes || !existingGraph.fileExportSignatures
     || !existingGraph.controlHashes || !existingGraph.jsExportRecords || Number(existingGraph.barrelResolutionV) < 1
-    || Number(existingGraph.extractorSchemaV) < 5 || Number(existingGraph.physicalFileLocV) < 1
+    || Number(existingGraph.extractorSchemaV) < 7 || Number(existingGraph.physicalFileLocV) < 1
     || Number(existingGraph.reExportOccurrencesV) < 1
     || Number(existingGraph.symbolSpacesV) < 1 || Number(existingGraph.edgeProvenanceV) < 1) {
     return full("incremental-baseline-unavailable");

package/src/graph/internal-builder.build.js

@@ -8,6 +8,7 @@ import { specToPkg } from "./builder/spec-pkg.js";
 import { analyzeSyntaxComplexity } from "../analysis/source-complexity.js";
 import { Parser, Query, GRAMMARS, LANGS, EXT_LANG, FAMILY, isDataFile, isDocFile, MAX_PARSE_BYTES, ensureParser, walk } from "./internal-builder.langs.js";
 import { buildResolvers } from "./internal-builder.resolvers.js";
+import { scanEmbeddedSql, resolveSqlReferences } from "./builder/lang-sql.js";
 import { assignDeterministicCommunities } from "./community.js";
 import { snapshotRepository } from "./incremental-refresh.js";
 import { EDGE_PROVENANCE_V, stampEdgeProvenance } from "./edge-provenance.js";
@@ -72,6 +73,9 @@ export async function buildInternalGraph(repoDir, opts = {}) {
   // Bare-package imports (axios, node:fs, @scope/x) — the graph can't resolve them to a repo file, but
   // dependency analysis NEEDS them (unused/missing deps). Additive top-level array; nodes/links untouched.
   const externalImports = [];
+  // SQL references (from .sql statements AND string literals in host-language code) collect during
+  // pass 1 and resolve after both passes, once every schema object the repo declares is indexed.
+  const sqlRefs = [];
 
   const resolvers = buildResolvers(repoDir, fileSet);          // aliases, go.mod, java index, href, selectors
   const { selectorIndex, htmlUsages } = resolvers;
@@ -90,13 +94,16 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     }  // config/infra/docs file-only node
     let code; try { code = readFileSync(abs, "utf8"); } catch { addNode(fileNode); continue; }
     addNode({ ...fileNode, physical_loc: physicalLineCount(code) });
-    const grammar = EXT_LANG[ext]; const lang = LANGS[FAMILY[grammar]]; if (!lang || !langs[grammar]) continue;
+    const grammar = EXT_LANG[ext]; const lang = LANGS[FAMILY[grammar]]; if (!lang || (!langs[grammar] && !lang.textOnly)) continue;
     // giant / generated / minified file → keep the file NODE but don't parse symbols (avoids a wedged parse)
     if (code.length > MAX_PARSE_BYTES) { perFileSymbols.set(fileRel, []); symByFileName.set(fileRel, new Map()); symIdsByFileName.set(fileRel, new Map()); continue; }
     if ((++_parsed % 24) === 0) await new Promise((r) => setImmediate(r)); // breathe: let the UI paint between chunks
     if (typeof opts.onParseFile === "function") opts.onParseFile(fileRel);
-    const parser = new Parser(); parser.setLanguage(langs[grammar]);
-    let tree; try { tree = parser.parse(code); } catch { continue; }
+    let tree = null;   // textOnly languages (SQL) scan `code` directly — no grammar, no parse
+    if (!lang.textOnly) {
+      const parser = new Parser(); parser.setLanguage(langs[grammar]);
+      try { tree = parser.parse(code); } catch { continue; }
+    }
 
     const syms = []; const nameToId = new Map(); const nameToIds = new Map(); const moduleNameToId = new Map();
     const addSym = (name, line, callable, extra) => {
@@ -148,6 +155,7 @@ export async function buildInternalGraph(repoDir, opts = {}) {
         } : {}),
         ...(complexity ? { complexity } : {}),
         ...(extra && extra.exported ? { exported: true } : {}),
+        ...(extra && extra.testSurface ? { test_surface: true } : {}),
         ...(extra && extra.decorated ? { decorated: true } : {}),
         ...(extra && extra.symbolKind ? { symbol_kind: extra.symbolKind } : {}),
         ...(extra && extra.symbolSpace ? { symbol_space: extra.symbolSpace } : {}),
@@ -213,8 +221,10 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     // Post-hoc export flag (export {a}, export default X, CJS module.exports) — declarations are flagged at addSym time.
     const markExported = (name) => { const id = moduleNameToId.get(name); const n = id && nodeById.get(id); if (n) n.exported = true; };
 
-    try { lang.pass1({ grammar, tree, fileRel, code, caps, field, addSym, addNode, links, nodeIds, syms, nameToId, imports, addImportEdge, addExternalImport, markExported, recordJsExport, fileSet, ...resolvers }); }
+    try { lang.pass1({ grammar, tree, fileRel, code, caps, field, addSym, addNode, links, nodeIds, syms, nameToId, imports, addImportEdge, addExternalImport, markExported, recordJsExport, fileSet, sqlRefs, ...resolvers }); }
     catch (e) { /* one bad file never sinks the whole build */ void e; }
+    // string-literal SQL in host-language code → schema reference candidates (resolved post-pass-2)
+    if (!lang.textOnly && !lang.isWeb) try { scanEmbeddedSql(code, fileRel, sqlRefs); } catch { /* never sinks the build */ }
 
     syms.sort((a, b) => a.start - b.start);
     const eof = code.split("\n").length;
@@ -222,7 +232,7 @@ export async function buildInternalGraph(repoDir, opts = {}) {
       if (!syms[i].end || syms[i].end < syms[i].start) syms[i].end = i + 1 < syms.length ? syms[i + 1].start - 1 : eof;
     }
     perFileSymbols.set(fileRel, syms); symByFileName.set(fileRel, nameToId); symIdsByFileName.set(fileRel, nameToIds);
-    tree.delete();
+    if (tree) tree.delete();
   }
 
   // ---- pass 2: scope-aware calls + inheritance (Go package = whole dir → same-dir symbols share scope;
@@ -242,6 +252,8 @@ export async function buildInternalGraph(repoDir, opts = {}) {
       links.push({ source: u.htmlFile, target: cssFile, relation: "references", confidence: "INFERRED" });
     }
   }
+  // code/SQL → schema-object edges (tables/views/functions declared in .sql files)
+  try { resolveSqlReferences({ sqlRefs, links, nodeById, perFileSymbols }); } catch { /* never sinks the build */ }
 
   // community = folder bucket (top 2 path parts) — deterministic, mirrors the folder-based module grouping the
   // app already uses (graph-builder-analysis.js). Populates Modules/community cards without a heavy clustering pass.
@@ -265,7 +277,7 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     barrelResolutionV: 1,
     reExportOccurrencesV: 1,
     symbolSpacesV: 1,
-    extractorSchemaV: 5,
+    extractorSchemaV: 7,   // v7 = Solidity + SQL indexing (schema objects, embedded-SQL edges)
     reExportOccurrences,
     jsExportRecords: Object.fromEntries([...jsExports.entries()].sort(([a], [b]) => a.localeCompare(b))),
     fileHashes: snapshot.fileHashes,

package/src/graph/internal-builder.langs.js

@@ -16,6 +16,8 @@ import LANG_GO from "./builder/lang-go.js";
 import LANG_JAVA from "./builder/lang-java.js";
 import LANG_CSHARP from "./builder/lang-csharp.js";
 import LANG_RUST from "./builder/lang-rust.js";
+import LANG_SOLIDITY from "./builder/lang-solidity.js";
+import LANG_SQL from "./builder/lang-sql.js";
 import LANG_HTML from "./builder/lang-html.js";
 import LANG_CSS from "./builder/lang-css.js";
 
@@ -27,7 +29,7 @@ const NODE_MODULES = dirname(WTS_DIR);
 const DEFAULT_WASM_DIR = join(NODE_MODULES, "tree-sitter-wasms", "out");
 
 // ---- language registry (derived from the per-language modules) ----
-const LANG_MODULES = [LANG_JS, LANG_PY, LANG_GO, LANG_JAVA, LANG_CSHARP, LANG_RUST, LANG_HTML, LANG_CSS];
+const LANG_MODULES = [LANG_JS, LANG_PY, LANG_GO, LANG_JAVA, LANG_CSHARP, LANG_RUST, LANG_SOLIDITY, LANG_SQL, LANG_HTML, LANG_CSS];
 const LANGS = {};                 // family -> module
 const EXT_LANG = {};              // ext -> grammar
 const FAMILY = {};                // grammar -> family

package/src/graph/internal-builder.resolvers.js

@@ -207,6 +207,36 @@ export function buildResolvers(repoDir, fileSet) {
     if (seg[0] === "src" && seg.length > 2) pyTopDirs.add(seg[1]);
   }
 
+  // Solidity: relative imports, Foundry remappings (remappings.txt beats foundry.toml, longest prefix
+  // wins), then root-anchored specs (`src/X.sol` — forge resolves those against the project root).
+  // Nested remapping files are intentionally not scoped per-package: one remapping table per repo is the
+  // overwhelmingly common layout, and a wrong guess here would fabricate cross-package edges.
+  const solRemappings = [];
+  const addRemapping = (entry) => {
+    const m = /^\s*([^=\s]+)\s*=\s*(\S+)\s*$/.exec(String(entry || ""));
+    if (m && !solRemappings.some((r) => r.prefix === m[1])) solRemappings.push({ prefix: m[1], target: cleanRel(m[2]) });
+  };
+  // neither file has an indexed extension, so probe the filesystem directly rather than fileSet
+  try { for (const line of readLocal("remappings.txt").split(/\r?\n/)) addRemapping(line); } catch { /* absent/unreadable */ }
+  try {
+    const toml = readLocal("foundry.toml");
+    for (const m of toml.matchAll(/remappings\s*=\s*\[([^\]]*)\]/g)) for (const s of m[1].matchAll(/["']([^"']+)["']/g)) addRemapping(s[1]);
+  } catch { /* absent/unreadable */ }
+  solRemappings.sort((a, b) => b.prefix.length - a.prefix.length);
+  const resolveSolidityImport = (fromRel, spec) => {
+    if (!spec || !spec.endsWith(".sol")) return null;
+    if (spec.startsWith(".")) {
+      const candidate = cleanRel(join(dirname(fromRel), spec));
+      return fileSet.has(candidate) ? candidate : null;
+    }
+    for (const { prefix, target } of solRemappings) {
+      if (spec !== prefix && !spec.startsWith(prefix)) continue;
+      const candidate = cleanRel(target + "/" + spec.slice(prefix.length)).replace(/\/+/g, "/");
+      if (fileSet.has(candidate)) return candidate;
+    }
+    return fileSet.has(spec) ? spec : null;
+  };
+
   const selectorIndex = new Map();
   const htmlUsages = [];
   const resolveHref = (fromRel, href) => {
@@ -217,5 +247,5 @@ export function buildResolvers(repoDir, fileSet) {
     return fileSet.has(cand) ? cand : null;
   };
 
-  return { resolveJsImport, resolveAlias, resolvePyPath, pyBaseDir, pyTopDirs, resolveGoImport, dirFiles, resolveRustMod, resolveRustPath, resolveJavaImport, resolveHref, selectorIndex, htmlUsages, goModule, goModules, goRequires };
+  return { resolveJsImport, resolveAlias, resolvePyPath, pyBaseDir, pyTopDirs, resolveGoImport, dirFiles, resolveRustMod, resolveRustPath, resolveJavaImport, resolveSolidityImport, resolveHref, selectorIndex, htmlUsages, goModule, goModules, goRequires };
 }

package/src/graph/parser-artifact-boundary.js

@@ -17,6 +17,7 @@ const GRAMMAR_SHA256 = Object.freeze({
   java: '637aac4415fb39a211a4f4292d63c66b5ce9c32fa2cd35464af4f681d91b9a1f',
   c_sharp: '6266a7e32d68a3459104d994dc848df15d5672b0ea8e86d327274b694f8e6991',
   rust: '4409921a70d0aa5bec7d1d7ce809a557a8ee1cf6ace901e3ac6a76e62cfea903',
+  solidity: '160745e470f234cae903a9ba445d19e758d0b02e1197401fc765976c6254d2b6',
   html: '11b3405c1543fb012f5ed7f8ee73125076dce8b168301e1e787e4c717da6b456',
   css: '5fc615467b1b98420ed7517e5bf9e1f88468132dd903d842dfb13714f6a1cb0c',
 })

package/src/mcp/actions/graph-lifecycle.mjs

@@ -1,7 +1,7 @@
 import {existsSync, readFileSync, realpathSync, statSync, writeFileSync} from 'node:fs'
 import {dirname, isAbsolute, join} from 'node:path'
 import {diffGraphs, formatGraphDiff, prevGraphPathFor} from '../graph-context.mjs'
-import {buildGraphForRepo, defaultPrecisionMode} from '../../build-graph.js'
+import {buildGraphForRepo, defaultPrecisionMode, precisionStatusLine} from '../../build-graph.js'
 import {graphHomeDir, graphOutDirForModule, graphOutDirForRepo} from '../../graph/layout.js'
 import {liveRepositoryRecords, registerRepository} from '../../graph/repo-registry.js'
 import {precisionSemanticInputsMatch, readPrecisionOverlay} from '../../precision/lsp-overlay.js'
@@ -76,7 +76,7 @@ export async function tOpenRepo(g, args, ctx) {
             savedPrecision = ['lsp', 'off'].includes(saved.graphPrecisionMode) ? saved.graphPrecisionMode : defaultPrecisionMode()
             schemaUpgrade = !Number.isInteger(saved.edgeTypesV) || saved.edgeTypesV < 2
                 || !Number.isInteger(saved.edgeProvenanceV) || saved.edgeProvenanceV < 1
-                || !Number.isInteger(saved.extractorSchemaV) || saved.extractorSchemaV < 5
+                || !Number.isInteger(saved.extractorSchemaV) || saved.extractorSchemaV < 7
                 || !Number.isInteger(saved.reExportOccurrencesV) || saved.reExportOccurrencesV < 1
                 || !Number.isInteger(saved.symbolSpacesV) || saved.symbolSpacesV < 1
                 || !Number.isInteger(saved.physicalFileLocV) || saved.physicalFileLocV < 1
@@ -128,7 +128,7 @@ export async function tOpenRepo(g, args, ctx) {
         `Opened ${repoPath}${buildNote}: ${loaded.nodes.length} nodes / ${loaded.links.length} edges. All tools now target this repo.`,
         `Graph: ${graphPath}`,
         `Build mode: ${loaded.graphBuildMode || 'full'}`,
-        `Semantic precision: ${loaded.precision?.state || 'UNAVAILABLE'} (${loaded.precision?.verifiedEdges || 0} EXACT_LSP edge(s))`,
+        precisionStatusLine(loaded.precision),
     ].join('\n')
 }
 

package/src/mcp/architecture-starter.mjs

@@ -28,7 +28,7 @@ const BUDGET_PROPOSALS = Object.freeze(Object.entries(PROVISIONAL_BUDGETS)
 const SOURCE_ROOTS = new Set(['src', 'app', 'lib', 'packages', 'services'])
 const CODE_EXTENSIONS = new Set([
     '.cjs', '.cs', '.css', '.go', '.htm', '.html', '.java', '.js', '.jsx', '.less', '.mjs', '.py', '.pyi',
-    '.rs', '.scss', '.ts', '.tsx',
+    '.rs', '.scss', '.sol', '.sql', '.ts', '.tsx',
 ])
 const CLASSIFIED = ['test', 'e2e', 'generated', 'mock', 'story', 'docs', 'benchmark', 'temp']
 const EDGE_RELATIONS = new Set(['imports', 're_exports', 'calls', 'references'])

package/src/mcp/catalog.mjs

@@ -128,8 +128,8 @@ function buildTools({tg, ti, th, ts, tb, te, ta, tar, thi, tc, tv, caps}) {
         {cap: 'health', name: 'hot_path_review', description: 'Rank a focused production-symbol hot-path queue from parser-derived local complexity, inside-loop allocations/copies/scans/sorts/recursion, graph fan-in/fan-out, and measured coverage or clearly labelled static test reachability. The default score gate is 85 with a narrow strong-local fallback; set min_score=0 for the full diagnostic queue. This is not profiler data or interprocedural Big-O.', inputSchema: {type: 'object', properties: {path: {type: 'string', maxLength: 1024, description: 'Optional repository-relative path prefix'}, top_n: {type: 'integer', minimum: 1, maximum: 100, default: 20}, min_score: {type: 'integer', minimum: 0, maximum: 100, default: 85, description: 'Focused default is 85; lower explicitly to broaden, or use 0 for every threshold-matching diagnostic candidate'}, cyclomatic_threshold: {type: 'integer', minimum: 2, maximum: 1000, default: 8}, call_threshold: {type: 'integer', minimum: 1, maximum: 10000, default: 12}, loop_depth_threshold: {type: 'integer', minimum: 1, maximum: 10, default: 2}, time_rank_threshold: {type: 'integer', minimum: 0, maximum: 5, default: 2}, include_tests: {type: 'boolean', default: false}, include_classified: {type: 'boolean', default: false, description: 'Include generated/mock/story/docs/benchmark/temp and explicitly excluded paths; tests still require include_tests'}}}, run: (g, a, ctx) => th.tHotPathReview(g, a, ctx)},
         {cap: 'graph', name: 'list_communities', description: 'List graph communities named by their dominant folder (largest first) with sample files — a readable module overview; feed the list position into get_community.', inputSchema: {type: 'object', properties: {top_n: {type: 'integer', description: 'Max communities to list, default 20'}}}, run: (g, a, ctx) => th.tListCommunities(g, a, ctx)},
         {cap: 'graph', name: 'module_map', description: 'First orientation view for understanding an unfamiliar application with little context: a production-first folder architecture map with file/symbol counts and strongest module dependencies, separating runtime, TypeScript type-only and language compile-only coupling.', inputSchema: {type: 'object', properties: {top_n: {type: 'integer', description: 'Max modules to list, default 25'}, include_non_product: {type: 'boolean', default: false, description: 'Include tests, fixtures, benchmarks, generated output, docs and other classified non-product files; false by default'}}}, run: (g, a, ctx) => th.tModuleMap(g, a, ctx)},
-        {cap: 'source', refreshGraph: true, name: 'list_endpoints', description: 'Inventory of HTTP endpoints defined in the repo (Express/Fastify/Nest/Flask/FastAPI/Go mux/Rust axum and actix-web/Spring MVC and WebFlux): declared and reachable composed paths, static mount provenance, confidence, handler, file:line, and Spring conditional/default-active state.', inputSchema: {type: 'object', properties: {method: {type: 'string', enum: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS', 'TRACE', 'CONNECT', 'ALL', 'ANY']}, path: {type: 'string', maxLength: 2048, description: 'Optional exact composed path or segment-aligned suffix'}, max_results: {type: 'integer', description: 'Max endpoints to list, default 100'}}}, run: (g, a, ctx) => th.tListEndpoints(g, a, ctx)},
-        {cap: 'source', refreshGraph: true, name: 'trace_endpoint', description: 'Resolve one exact reachable HTTP endpoint, prove its router mount chain, bind its handler symbol, and return a bounded production-only multi-hop call graph with call-site excerpts. This is a focused projection of the repository graph, not text-search inference.', inputSchema: {type: 'object', properties: {path: {type: 'string', minLength: 1, maxLength: 2048, description: 'Exact composed path; a suffix is accepted only when unambiguous'}, method: {type: 'string', enum: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS', 'TRACE', 'CONNECT', 'ALL', 'ANY']}, max_depth: {type: 'integer', minimum: 1, maximum: 4, default: 3}, max_nodes: {type: 'integer', minimum: 2, maximum: 40, default: 20}, max_excerpts: {type: 'integer', minimum: 0, maximum: 12, default: 6}, context_lines: {type: 'integer', minimum: 0, maximum: 6, default: 2}, include_classified: {type: 'boolean', default: false, description: 'Include test/e2e/generated/mock/story/docs/benchmark/temp and explicitly excluded targets'}}, required: ['path']}, run: (g, a, ctx) => te.tTraceEndpoint(g, a, ctx)},
+        {cap: 'source', refreshGraph: true, name: 'list_endpoints', description: 'Inventory of HTTP endpoints defined in the repo (Express/Fastify/Nest/Flask/FastAPI/Go mux/Rust axum and actix-web/Spring MVC and WebFlux): declared and reachable composed paths, static mount provenance, confidence, handler, file:line, and Spring conditional/default-active state.', inputSchema: {type: 'object', properties: {method: {type: 'string', enum: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS', 'TRACE', 'CONNECT', 'ALL', 'ANY']}, path: {type: 'string', maxLength: 2048, description: 'Optional exact composed path or segment-aligned suffix'}, max_results: {type: 'integer', description: 'Max endpoints to list, default 100'}, include_classified: {type: 'boolean', default: false, description: 'Include test/e2e/generated/mock/story/docs/benchmark/temp and explicitly excluded targets'}}}, run: (g, a, ctx) => th.tListEndpoints(g, a, ctx)},
+        {cap: 'source', refreshGraph: true, name: 'trace_endpoint', description: 'Resolve one exact reachable HTTP endpoint, prove its router mount chain, bind its handler symbol, and return a bounded production-only multi-hop call graph with call-site excerpts. This is a focused projection of the repository graph, not text-search inference.', inputSchema: {type: 'object', properties: {path: {type: 'string', minLength: 1, maxLength: 2048, description: 'Exact composed path; a suffix is accepted only when unambiguous'}, method: {type: 'string', enum: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS', 'TRACE', 'CONNECT', 'ALL', 'ANY']}, handler_file: {type: 'string', maxLength: 1024, description: 'Repo-relative file path (or unambiguous path suffix) declaring the handler; use after an AMBIGUOUS_HANDLER result.'}, max_depth: {type: 'integer', minimum: 1, maximum: 4, default: 3}, max_nodes: {type: 'integer', minimum: 2, maximum: 40, default: 20}, max_excerpts: {type: 'integer', minimum: 0, maximum: 12, default: 6}, context_lines: {type: 'integer', minimum: 0, maximum: 6, default: 2}, include_classified: {type: 'boolean', default: false, description: 'Include test/e2e/generated/mock/story/docs/benchmark/temp and explicitly excluded targets'}}, required: ['path']}, run: (g, a, ctx) => te.tTraceEndpoint(g, a, ctx)},
         {cap: 'build', name: 'rebuild_graph', description: "Rebuild the active full-repository graph and report a structural delta. Omitted mode/precision preserve the active graph; a first build uses full and the startup precision setting (lsp unless WEAVATRIX_PRECISION=off). The local TypeScript/JavaScript LSP overlay validates bounded ambiguous edges; precision:off is an explicit fallback. With scope, build an isolated diagnostic graph without replacing or diffing the full graph.", inputSchema: {type: 'object', properties: {mode: {type: 'string', enum: ['full', 'no-tests', 'tests-only'], description: 'Build mode; omit to preserve the active mode (or use full for a first build)'}, precision: {type: 'string', enum: ['lsp', 'off'], description: 'Semantic precision; omit to preserve the active mode (or use the startup setting for a first build)'}, scope: {type: 'string', description: 'Optional isolated diagnostic path prefix; never replaces the active full graph'}}}, run: (g, a, ctx) => ta.tRebuildGraph(g, a, ctx)},
         {cap: 'graph', name: 'graph_diff', description: 'Structural graph diff: compare the current graph with an immutable Git-ref baseline (base_ref such as HEAD~1 or main), or with graph.prev.json from the last rebuild when base_ref is omitted. Reports architecture drift, cycle changes and symbols that lost their last caller.', inputSchema: {type: 'object', properties: {base_ref: {type: 'string', maxLength: 256, description: 'Optional immutable Git baseline to build in isolation, e.g. HEAD~1, main or origin/main; never checks out or mutates the working tree'}, path: {type: 'string', description: 'Optional node-id/path prefix to scope the diff, e.g. src/query'}}}, run: (g, a, ctx) => ti.tGraphDiff(g, a, ctx)},
         {cap: 'graph', name: 'get_architecture_contract', description: 'Read the owner-approved architecture target or safely bootstrap one. With action=preview, returns an adaptive candidate, observed-but-not-enforced dependency directions, verification, exact file content/hash and a short-lived confirmation token. action=approve creates the local contract only after explicit token confirmation and never overwrites an active target.', inputSchema: {type: 'object', properties: {action: {type: 'string', enum: ['preview', 'approve'], description: 'Omit to read; preview is dry-run only; approve requires the preview token'}, candidate_contract: {type: 'object', description: 'Optional reviewed candidate to normalize and verify during preview'}, baseline_mode: {type: 'string', enum: ['none', 'accept-current'], default: 'none', description: 'Whether preview should materialize current violations as an explicit ratchet baseline'}, confirm_token: {type: 'string', description: 'One-time token returned by preview; required for approve'}}}, run: (g, a, ctx) => tar.tGetArchitectureContract(g, a, ctx)},

package/src/mcp/evidence-snapshot.structure.mjs

@@ -1,6 +1,6 @@
 import {createHash} from 'node:crypto'
 import {readFileSync} from 'node:fs'
-import {buildFileImportGraph, checkBoundaries, findSccs, representativeCycle} from '../analysis/dep-rules.js'
+import {buildFileImportGraph, checkBoundaries, findSccs, isRustModuleTreeComponent, representativeCycle} from '../analysis/dep-rules.js'
 import {createRepoBoundary} from '../repo-path.js'
 import {CAPS, bounded, compareText, repoRelativePath, safeToken} from './evidence-snapshot.common.mjs'
 
@@ -59,7 +59,10 @@ export function buildStructureEvidence(graph, repoRoot) {
         const imports = buildFileImportGraph(graph)
         const runtimeSccs = sortedSccs(imports.runtimeAdj)
         const runtimeKeys = new Set(runtimeSccs.map((members) => members.join('\0')))
-        const compileSccs = sortedSccs(imports.allAdj).filter((members) => !runtimeKeys.has(members.join('\0')))
+        // Same suppression as computeStructureFindings: a synced snapshot must not contradict the
+        // local structure findings on idiomatic Rust module trees.
+        const compileSccs = sortedSccs(imports.allAdj)
+            .filter((members) => !runtimeKeys.has(members.join('\0')) && !isRustModuleTreeComponent(members))
         const allCycles = [
             ...runtimeSccs.map((members) => cycleFact('runtime', imports.runtimeAdj, members)),
             ...compileSccs.map((members) => cycleFact('compile-time', imports.allAdj, members)),

package/src/mcp/graph/context-seeds.mjs

@@ -17,11 +17,12 @@ const TOOL_EXECUTION_TERMS = QUERY_INTENTS.find(([id]) => id === 'tool-execution
 const TOOL_EXECUTION_TRIGGERS = new Set(['tool', 'tools', 'tooling', 'mcp'])
 const wordsOf = (value) => String(value ?? '').replace(/([a-z0-9])([A-Z])/g, '$1 $2').toLowerCase().split(/[^a-z0-9_]+/).filter(Boolean)
 const normPath = (value) => String(value ?? '').replace(/\\/g, '/').replace(/^\.\//, '').toLowerCase()
-const CODE_FILE_RE = /\.(?:[cm]?[jt]sx?|py|go|java|rs|kt|kts|cs|rb|php)$/i
+const CODE_FILE_RE = /\.(?:[cm]?[jt]sx?|py|go|java|rs|kt|kts|cs|rb|php|sol|sql)$/i
 const DATA_OR_PROSE_RE = /\.(?:json|ya?ml|toml|ini|md|mdx|rst|adoc|html?|css|scss|less|svg)$/i
 const LANGUAGE_EXTENSIONS = Object.freeze({
     rust: ['rs'], python: ['py', 'pyi'], typescript: ['ts', 'tsx', 'mts', 'cts'],
     javascript: ['js', 'jsx', 'mjs', 'cjs'], go: ['go'], java: ['java'], csharp: ['cs'],
+    solidity: ['sol'], sql: ['sql'],
 })
 
 function requestedLanguages(query) {
@@ -33,6 +34,8 @@ function requestedLanguages(query) {
     if (words.has('golang') || /(?:^|[^A-Za-z])Go(?:[^A-Za-z]|$)/.test(raw)) requested.add('go')
     if (words.has('java')) requested.add('java')
     if (words.has('csharp') || words.has('dotnet') || /csharp|(?:^|[^A-Za-z])C#(?:[^A-Za-z]|$)/i.test(raw)) requested.add('csharp')
+    if (words.has('solidity') || words.has('contract') || words.has('contracts')) requested.add('solidity')
+    if (words.has('sql') || words.has('schema') || words.has('migration') || words.has('migrations')) requested.add('sql')
     return new Set([...requested].flatMap((language) => LANGUAGE_EXTENSIONS[language]))
 }
 
@@ -52,6 +55,7 @@ export function requestedPathClasses(query) {
 }
 
 function isQueryEligible(node, requestedClasses, classificationCache, classifier) {
+    if (node?.test_surface === true && !requestedClasses.has('test')) return false
     const source = sourceFileOf(node)
     if (!source) return true
     if (!classificationCache.has(source)) classificationCache.set(source, classifier.explain(source, {content: ''}))
@@ -140,7 +144,7 @@ function conceptScore(g, node, concept, queryContext) {
         else if (term.length >= 4 && term !== 'tool' && term !== 'tools' && (id.includes(term) || label.includes(term))) match = Math.max(match, primary ? 12 : 7)
     })
     const extension = (/\.([^.\/]+)$/.exec(source) || [])[1] || ''
-    const languageConcept = {rust: ['rs'], python: ['py', 'pyi'], py: ['py', 'pyi'], typescript: ['ts', 'tsx', 'mts', 'cts'], ts: ['ts', 'tsx', 'mts', 'cts'], javascript: ['js', 'jsx', 'mjs', 'cjs'], js: ['js', 'jsx', 'mjs', 'cjs'], nodejs: ['js', 'jsx', 'mjs', 'cjs'], golang: ['go'], go: ['go'], java: ['java'], csharp: ['cs'], dotnet: ['cs']}[concept.raw]
+    const languageConcept = {rust: ['rs'], python: ['py', 'pyi'], py: ['py', 'pyi'], typescript: ['ts', 'tsx', 'mts', 'cts'], ts: ['ts', 'tsx', 'mts', 'cts'], javascript: ['js', 'jsx', 'mjs', 'cjs'], js: ['js', 'jsx', 'mjs', 'cjs'], nodejs: ['js', 'jsx', 'mjs', 'cjs'], golang: ['go'], go: ['go'], java: ['java'], csharp: ['cs'], dotnet: ['cs'], solidity: ['sol'], sql: ['sql'], schema: ['sql']}[concept.raw]
     if (languageConcept?.includes(extension) && queryContext.languageExtensions.has(extension)) match = Math.max(match, 58)
     const fileNode = !isSymbol(node.id), depth = source ? source.split('/').length : 9
     if (concept.id === 'bootstrap') match = Math.max(match, entrypointSignal(g, node, source, stem))