weavatrix 0.3.10 → 0.3.12

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,11 @@
 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')
+    // Rust associated functions / methods indexed by their owning type, per directory: `Type::method`
+    // resolves to the exact impl member instead of any same-named function in the directory.
+    const rustMethods = new Map() // dir -> Map(typeName -> Map(methodName -> id))
+    // .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('/')) : ''
@@ -22,6 +27,13 @@ export function createPass2Resolution({symIdsByFileName, nodeById, importedLocal
                 continue
             }
             if (!symbols.has(name)) symbols.set(name, id)
+            if (file.endsWith('.rs') && node?.member_of) {
+                let byType = rustMethods.get(dir)
+                if (!byType) rustMethods.set(dir, (byType = new Map()))
+                let methods = byType.get(node.member_of)
+                if (!methods) byType.set(node.member_of, (methods = new Map()))
+                if (!methods.has(name)) methods.set(name, id)
+            }
             if (file.endsWith('.go') && node?.symbol_space === 'type') {
                 let types = dirTypes.get(dir)
                 if (!types) dirTypes.set(dir, (types = new Map()))
@@ -53,6 +65,7 @@ export function createPass2Resolution({symIdsByFileName, nodeById, importedLocal
         if (!imported?.targetFile) return null
         return resolveNamedSymbol(imported.originFile || imported.targetFile, imported.originName || imported.imported, 'value')
     }
+    const resolveRustMethod = (dir, typeName, methodName) => rustMethods.get(dir)?.get(typeName)?.get(methodName) || null
     const javaTypeKinds = new Set(['class', 'interface', 'enum', 'record', 'annotation'])
     const resolveJavaType = (name, file) => {
         const imported = importedLocals.get(file)?.get(name)
@@ -64,5 +77,5 @@ export function createPass2Resolution({symIdsByFileName, nodeById, importedLocal
         const target = symByFileName.get(file)?.get(name)
         return target && javaTypeKinds.has(nodeById.get(target)?.symbol_kind) ? target : null
     }
-    return {dirSymbols, dirMethods, dirMethodsByName, dirTypes, resolveNamedSymbol, resolveCall, resolveJavaType}
+    return {dirSymbols, dirMethods, dirMethodsByName, dirTypes, resolveNamedSymbol, resolveCall, resolveJavaType, resolveRustMethod}
 }

package/src/graph/freshness-probe.js

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

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) < 6 || 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) => {
@@ -214,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;
@@ -223,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;
@@ -231,7 +240,7 @@ export async function buildInternalGraph(repoDir, opts = {}) {
   // not files, so the folder map is the only reliable cross-file resolver) ----
   const {reExportOccurrences} = runInternalGraphPass2({
     files, rel, langs, caps, field, links, nodeById, perFileSymbols, symByFileName,
-    symIdsByFileName, importedLocals, jsExports,
+    symIdsByFileName, importedLocals, jsExports, resolvers,
   });
   // HTML class/id usage → the CSS file(s) defining that selector: file-level reference edges (deduped per pair).
   const htmlRefSeen = new Set();
@@ -243,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.
@@ -266,7 +277,7 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     barrelResolutionV: 1,
     reExportOccurrencesV: 1,
     symbolSpacesV: 1,
-    extractorSchemaV: 6,
+    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.pass2.js

@@ -8,10 +8,11 @@ import {createGoReceiverResolution} from './builder/go-receiver-resolution.js'
 
 export function runInternalGraphPass2({
     files, rel, langs, caps, field, links, nodeById, perFileSymbols, symByFileName,
-    symIdsByFileName, importedLocals, jsExports,
+    symIdsByFileName, importedLocals, jsExports, resolvers,
 }) {
     const resolution = createPass2Resolution({symIdsByFileName, nodeById, importedLocals, symByFileName})
-    const {dirSymbols, resolveNamedSymbol, resolveCall, resolveJavaType} = resolution
+    const {dirSymbols, resolveNamedSymbol, resolveCall, resolveJavaType, resolveRustMethod} = resolution
+    const {resolveRustPath, resolveRustCratePath} = resolvers || {}
     const {resolveNamespaceMember, reExportOccurrences} = resolveJsBarrels({
         jsExports, importedLocals, links,
         resolveSymbol: (file, name, typeOnly) => resolveNamedSymbol(file, name, typeOnly ? 'type' : 'value'),
@@ -46,6 +47,7 @@ export function runInternalGraphPass2({
             lang.pass2({
                 grammar, tree, fileRel: file, code, caps, field, enclosing, links, nodeById,
                 perFileSymbols, symByFileName, symIdsByFileName, importedLocals, resolveCall, resolveJavaType,
+                dirSymbols, resolveNamedSymbol, resolveRustMethod, resolveRustPath, resolveRustCratePath,
             })
         } catch { /* one language-specific resolver never sinks the graph */ }
         if (lang.selectorCall) for (const capture of caps(grammar, lang.selectorCall, tree.rootNode)) {

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

@@ -5,6 +5,7 @@
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { parseGoMod } from "../analysis/manifests.js";
+import { parseCargoToml, cargoName } from "../analysis/cargo-manifests.js";
 import { createRepoBoundary } from "../repo-path.js";
 import { listRepoFiles } from "../analysis/internal-audit/repo-files.js";
 import { createRustResolvers } from "./resolvers/rust.js";
@@ -61,6 +62,40 @@ export function buildResolvers(repoDir, fileSet) {
 
   const { resolveRustMod, resolveRustPath } = createRustResolvers(fileSet);
 
+  // Workspace crate map: normalized package name → its crate source root file (lib.rs/main.rs). A path or
+  // `use` that starts with a sibling crate's name (`use radiochron::wlan`) then resolves INTO that crate's
+  // files instead of being logged as an external crates.io dependency — so cross-crate imports and calls
+  // become real graph edges rather than a false "unused dependency" plus missing coupling.
+  // Cargo.toml (like go.mod) is a manifest, not a parsed source file, so it is read via listRepoFiles
+  // rather than the source fileSet. The crate root .rs it points at IS in fileSet (it is parsed).
+  const rustCrates = new Map();
+  const ambiguousCrates = new Set();
+  for (const manifest of listRepoFiles(repoDir).filter((file) => /(^|\/)Cargo\.toml$/i.test(file))) {
+    let parsed;
+    try { parsed = parseCargoToml(readLocal(manifest)); } catch { continue; }
+    if (!parsed.packageName) continue;
+    const dir = manifest.includes("/") ? manifest.slice(0, manifest.lastIndexOf("/")) : "";
+    const rootFile = ["src/lib.rs", "src/main.rs", "lib.rs", "main.rs"]
+      .map((candidate) => [dir, candidate].filter(Boolean).join("/"))
+      .find((path) => fileSet.has(path));
+    if (!rootFile) continue;
+    const key = cargoName(parsed.packageName);
+    // A repo can hold two crates with the same package name (independent workspaces, vendored copies).
+    // Cross-crate resolution has no way to pick the right one from a bare `name::path`, so treat the name
+    // as ambiguous and resolve nothing for it — better a missing edge than a confident wrong one.
+    if (rustCrates.has(key) && rustCrates.get(key) !== rootFile) ambiguousCrates.add(key);
+    else rustCrates.set(key, rootFile);
+  }
+  // Resolve `<crate>::<segments...>` against the named sibling crate's root, reusing the crate-anchored
+  // module resolver. Returns {targetFile, remaining} or null when the head is not an unambiguous workspace crate.
+  const resolveRustCratePath = (crateName, segments = []) => {
+    const key = cargoName(crateName);
+    if (ambiguousCrates.has(key)) return null;
+    const rootFile = rustCrates.get(key);
+    if (!rootFile) return null;
+    return resolveRustPath(rootFile, ["crate", ...segments], { unqualified: false });
+  };
+
   // Path aliases (tsconfig compilerOptions.paths + vite/webpack alias) are scoped to their config folder.
   // Without nearest-config resolution, a monorepo's root `@/*` can hijack the same alias in web/.
   const aliasContexts = new Map();
@@ -207,6 +242,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 +282,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, resolveRustCratePath, 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

@@ -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 < 6
+                || !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

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'])