weavatrix 0.2.12 → 0.2.14

package/src/graph/builder/js/queries.js

@@ -0,0 +1,48 @@
+export const CALLABLE = /arrow_function|function|function_expression|generator_function/
+
+export const FUNCS = `
+  (function_declaration name: (identifier) @fn)
+  (generator_function_declaration name: (identifier) @fn)
+  (class_declaration name: (_) @class)
+  (method_definition name: (_) @method)`
+
+export const TOPVARS = `
+  (program (lexical_declaration (variable_declarator) @decl))
+  (program (variable_declaration (variable_declarator) @decl))
+  (program (export_statement (lexical_declaration (variable_declarator) @decl)))
+  (program (export_statement (variable_declaration (variable_declarator) @decl)))`
+
+export const TYPES = `
+  (interface_declaration name: (_) @interface)
+  (type_alias_declaration name: (_) @type)
+  (enum_declaration name: (_) @enum)`
+
+export const REQUIRE = `(variable_declarator name: (_) @lhs value: (call_expression function: (identifier) @req arguments: (arguments (string (string_fragment) @src))))`
+
+export function parseExportSpecifiers(raw) {
+  return String(raw || '').split(',').map((part) => {
+    const text = part.trim()
+    const typeOnly = /^type\s+/.test(text)
+    const clean = text.replace(/^type\s+/, '').trim()
+    const match = clean.match(/^([A-Za-z_$][\w$]*|default)(?:\s+as\s+([A-Za-z_$][\w$]*|default))?$/)
+    return match ? {imported: match[1], exported: match[2] || match[1], typeOnly} : null
+  }).filter(Boolean)
+}
+
+export function importTypeOnly(node) {
+  if (/^\s*import\s+type\b/.test(node.text)) return true
+  const clause = node.namedChildren.find((child) => child.type === 'import_clause')
+  if (!clause) return false
+  const parts = clause.namedChildren
+  if (parts.some((child) => child.type === 'identifier' || child.type === 'namespace_import')) return false
+  const named = parts.find((child) => child.type === 'named_imports')
+  const specifiers = named?.namedChildren.filter((child) => child.type === 'import_specifier') || []
+  return specifiers.length > 0 && specifiers.every((specifier) => /^\s*type\b/.test(specifier.text))
+}
+
+export function reexportTypeOnly(node) {
+  if (/^\s*export\s+type\b/.test(node.text)) return true
+  const clause = node.namedChildren.find((child) => child.type === 'export_clause')
+  const specifiers = clause?.namedChildren.filter((child) => child.type === 'export_specifier') || []
+  return specifiers.length > 0 && specifiers.every((specifier) => /^\s*type\b/.test(specifier.text))
+}

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

@@ -5,6 +5,61 @@
 // in the orchestrator; cross-pkg `pkg.Func()` is a selector — see resolveGoPackage/pass2). No inheritance.
 import { goSpecToPkg } from "./spec-pkg.js";
 
+// Return the named Go type behind pointers/generics/parentheses. Qualified names are
+// kept (`speaker.Speaker`) so pass 2 can route them through the import alias table.
+export function goTypeName(node) {
+  if (!node) return null;
+  if (node.type === "type_identifier") return node.text;
+  if (node.type === "qualified_type") return node.text.replace(/\s+/g, "");
+  if (node.type === "generic_type") return goTypeName(node.childForFieldName?.("type") || node.namedChildren?.[0]);
+  if (["pointer_type", "parenthesized_type", "unary_expression"].includes(node.type)) {
+    return goTypeName(node.childForFieldName?.("type") || node.childForFieldName?.("operand") || node.namedChildren?.[0]);
+  }
+  if ((node.namedChildren?.length || 0) === 1) return goTypeName(node.namedChildren[0]);
+  return null;
+}
+
+const namedFieldChildren = (node, name) => {
+  const children = node?.childrenForFieldName?.(name);
+  if (Array.isArray(children) && children.length) return children;
+  const child = node?.childForFieldName?.(name);
+  return child ? [child] : [];
+};
+
+function goStructFields(typeNode) {
+  if (typeNode?.type !== "struct_type") return null;
+  const fields = {};
+  const visit = (node) => {
+    if (!node) return;
+    if (node.type === "field_declaration") {
+      const type = goTypeName(node.childForFieldName?.("type"));
+      if (!type) return;
+      const names = namedFieldChildren(node, "name");
+      if (names.length) for (const name of names) fields[name.text] = type;
+      else {
+        // An embedded field is addressed by the base type name (`h.Speaker`).
+        const embedded = type.split(".").pop();
+        if (embedded) fields[embedded] = type;
+      }
+      return;
+    }
+    for (const child of node.namedChildren || []) visit(child);
+  };
+  visit(typeNode);
+  return fields;
+}
+
+function goResultType(declaration) {
+  const result = declaration?.childForFieldName?.("result");
+  if (!result) return null;
+  if (result.type !== "parameter_list") return goTypeName(result);
+  const declarations = (result.namedChildren || []).filter((child) => child.type === "parameter_declaration");
+  // A call used in `value, err := New()` contributes its first result to the
+  // first binding. Preserve that receiver type instead of discarding every
+  // multi-result signature just because a trailing error is present.
+  return goTypeName(declarations[0]?.childForFieldName?.("type"));
+}
+
 export default {
   family: "go",
   grammars: ["go"],
@@ -20,10 +75,40 @@ export default {
     const { grammar, tree, fileRel, caps, addSym, addImportEdge, addExternalImport, imports, resolveGoImport, dirFiles, goModule, goRequires } = ctx;
 
     // ---- symbols ----
-    for (const cap of caps(grammar, `(function_declaration name: (identifier) @fn) (method_declaration name: (field_identifier) @method)`, tree.rootNode))
-      addSym(cap.node.text, cap.node.startPosition.row + 1, true, { sourceNode: cap.node.parent });
-    for (const cap of caps(grammar, `(source_file (type_declaration (type_spec name: (type_identifier) @type)))`, tree.rootNode))
-      addSym(cap.node.text, cap.node.startPosition.row + 1, false, { sourceNode: cap.node.parent });
+    for (const cap of caps(grammar, `(function_declaration name: (identifier) @fn)`, tree.rootNode)) {
+      const declaration = cap.node.parent;
+      addSym(cap.node.text, cap.node.startPosition.row + 1, true, {
+        sourceNode: declaration,
+        selectionNode: cap.node,
+        symbolKind: "function",
+        returnType: goResultType(declaration),
+      });
+    }
+    for (const cap of caps(grammar, `(method_declaration name: (field_identifier) @method)`, tree.rootNode)) {
+      const declaration = cap.node.parent;
+      const receiver = declaration.childForFieldName?.("receiver");
+      const receiverDeclaration = receiver?.namedChildren?.find((child) => child.type === "parameter_declaration");
+      const receiverType = goTypeName(receiverDeclaration?.childForFieldName?.("type"));
+      addSym(cap.node.text, cap.node.startPosition.row + 1, true, {
+        sourceNode: declaration,
+        selectionNode: cap.node,
+        symbolKind: "method",
+        memberOf: receiverType || undefined,
+        receiverType: receiverType || undefined,
+        returnType: goResultType(declaration),
+      });
+    }
+    for (const cap of caps(grammar, `(source_file (type_declaration (type_spec name: (type_identifier) @type)))`, tree.rootNode)) {
+      const specification = cap.node.parent;
+      const typeNode = specification.childForFieldName?.("type");
+      addSym(cap.node.text, cap.node.startPosition.row + 1, false, {
+        sourceNode: specification,
+        selectionNode: cap.node,
+        symbolKind: typeNode?.type === "interface_type" ? "interface" : "type",
+        symbolSpace: "type",
+        fieldTypes: goStructFields(typeNode),
+      });
+    }
     for (const cap of caps(grammar, `(source_file (var_declaration (var_spec name: (identifier) @var))) (source_file (const_declaration (const_spec name: (identifier) @const)))`, tree.rootNode))
       addSym(cap.node.text, cap.node.startPosition.row + 1, false, { sourceNode: cap.node.parent });
 

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

@@ -2,33 +2,10 @@
 // Symbols: functions, generators, classes, methods, top-level const/let/var (data + arrow/fn consts).
 // Imports: ESM `import`, CJS `require`, path-aliases (tsconfig/vite), and barrel re-exports (`export … from`).
 // Calls: bare `foo()`. Heritage: `class X extends Y`. Everything runs through the shared ctx (see internal-builder.js).
-const CALLABLE = /arrow_function|function|function_expression|generator_function/;
-
-const FUNCS = `
-  (function_declaration name: (identifier) @fn)
-  (generator_function_declaration name: (identifier) @fn)
-  (class_declaration name: (_) @class)
-  (method_definition name: (_) @method)`;
-const TOPVARS = `
-  (program (lexical_declaration (variable_declarator) @decl))
-  (program (variable_declaration (variable_declarator) @decl))
-  (program (export_statement (lexical_declaration (variable_declarator) @decl)))
-  (program (export_statement (variable_declaration (variable_declarator) @decl)))`;
-const TYPES = `
-  (interface_declaration name: (_) @interface)
-  (type_alias_declaration name: (_) @type)
-  (enum_declaration name: (_) @enum)`;
-const REQUIRE = `(variable_declarator name: (_) @lhs value: (call_expression function: (identifier) @req arguments: (arguments (string (string_fragment) @src))))`;
-
-function parseExportSpecifiers(raw) {
-  return String(raw || "").split(",").map((part) => {
-    const text = part.trim();
-    const typeOnly = /^type\s+/.test(text);
-    const clean = text.replace(/^type\s+/, "").trim();
-    const match = clean.match(/^([A-Za-z_$][\w$]*|default)(?:\s+as\s+([A-Za-z_$][\w$]*|default))?$/);
-    return match ? { imported: match[1], exported: match[2] || match[1], typeOnly } : null;
-  }).filter(Boolean);
-}
+import {
+  CALLABLE, FUNCS, TOPVARS, TYPES, REQUIRE, parseExportSpecifiers,
+  importTypeOnly, reexportTypeOnly,
+} from './js/queries.js';
 
 export default {
   family: "js",
@@ -162,23 +139,6 @@ export default {
       });
     }
 
-    const importTypeOnly = (node) => {
-      if (/^\s*import\s+type\b/.test(node.text)) return true;
-      const clause = node.namedChildren.find((c) => c.type === "import_clause");
-      if (!clause) return false; // side-effect import executes the target module
-      const parts = clause.namedChildren;
-      if (parts.some((c) => c.type === "identifier" || c.type === "namespace_import")) return false;
-      const named = parts.find((c) => c.type === "named_imports");
-      const specs = named?.namedChildren.filter((c) => c.type === "import_specifier") || [];
-      return specs.length > 0 && specs.every((s) => /^\s*type\b/.test(s.text));
-    };
-    const reexportTypeOnly = (node) => {
-      if (/^\s*export\s+type\b/.test(node.text)) return true;
-      const clause = node.namedChildren.find((c) => c.type === "export_clause");
-      const specs = clause?.namedChildren.filter((c) => c.type === "export_specifier") || [];
-      return specs.length > 0 && specs.every((s) => /^\s*type\b/.test(s.text));
-    };
-
     // ---- ESM imports ----
     for (const cap of caps(grammar, `(import_statement) @imp`, tree.rootNode)) {
       const node = cap.node; const srcNode = field(node, "source");

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

@@ -0,0 +1,68 @@
+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')
+    for (const [file, names] of symIdsByFileName) {
+        if (!sharesDirScope(file)) continue
+        const dir = file.includes('/') ? file.slice(0, file.lastIndexOf('/')) : ''
+        let symbols = dirSymbols.get(dir)
+        if (!symbols) dirSymbols.set(dir, (symbols = new Map()))
+        for (const [name, ids] of names) for (const id of ids) {
+            const node = nodeById.get(id)
+            if (file.endsWith('.go') && node?.member_of && node?.symbol_kind === 'method') {
+                let receivers = dirMethods.get(dir)
+                if (!receivers) dirMethods.set(dir, (receivers = new Map()))
+                let methods = receivers.get(node.member_of)
+                if (!methods) receivers.set(node.member_of, (methods = new Map()))
+                const exact = methods.get(name) || []
+                exact.push(id); methods.set(name, exact)
+                let byName = dirMethodsByName.get(dir)
+                if (!byName) dirMethodsByName.set(dir, (byName = new Map()))
+                const candidates = byName.get(name) || []
+                candidates.push(id); byName.set(name, candidates)
+                continue
+            }
+            if (!symbols.has(name)) symbols.set(name, id)
+            if (file.endsWith('.go') && node?.symbol_space === 'type') {
+                let types = dirTypes.get(dir)
+                if (!types) dirTypes.set(dir, (types = new Map()))
+                if (!types.has(name)) types.set(name, id)
+            }
+        }
+    }
+    const symbolSpace = (node) => {
+        const explicit = String(node?.symbol_space || '')
+        if (['value', 'type', 'both'].includes(explicit)) return explicit
+        const kind = String(node?.symbol_kind || '').toLowerCase()
+        if (['interface', 'type'].includes(kind)) return 'type'
+        return ['class', 'enum'].includes(kind) ? 'both' : 'value'
+    }
+    const resolveNamedSymbol = (file, name, space = 'value') => {
+        const ids = symIdsByFileName.get(file)?.get(name) || []
+        const exact = ids.find((id) => symbolSpace(nodeById.get(id)) === space)
+        return exact || ids.find((id) => ['both', space].includes(symbolSpace(nodeById.get(id)))) || null
+    }
+    const resolveCall = (name, file) => {
+        const local = resolveNamedSymbol(file, name, 'value')
+        if (local) return local
+        if (sharesDirScope(file)) {
+            const dir = file.includes('/') ? file.slice(0, file.lastIndexOf('/')) : ''
+            const symbols = dirSymbols.get(dir)
+            if (symbols?.has(name)) return symbols.get(name)
+        }
+        const imported = importedLocals.get(file)?.get(name)
+        if (!imported?.targetFile) return null
+        return resolveNamedSymbol(imported.originFile || imported.targetFile, imported.originName || imported.imported, 'value')
+    }
+    const javaTypeKinds = new Set(['class', 'interface', 'enum', 'record', 'annotation'])
+    const resolveJavaType = (name, file) => {
+        const imported = importedLocals.get(file)?.get(name)
+        if (imported?.targetFile) {
+            const symbols = symByFileName.get(imported.targetFile)
+            const target = symbols?.get(imported.imported) || symbols?.get(name)
+            if (target && javaTypeKinds.has(nodeById.get(target)?.symbol_kind)) return target
+        }
+        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}
+}

package/src/graph/freshness-probe.js

@@ -9,7 +9,7 @@ import {childProcessEnv} from '../child-env.js'
 import {createRepoBoundary} from '../repo-path.js'
 
 export const REPOSITORY_FRESHNESS_PROBE_V = 1
-export const GRAPH_BUILDER_SCHEMA_V = 5
+export const GRAPH_BUILDER_SCHEMA_V = 6
 export const GRAPH_BUILDER_VERSION = (() => {
     try { return String(createRequire(import.meta.url)('../../package.json').version) }
     catch { return '0.0.0' }
@@ -23,6 +23,7 @@ const CURRENT_GRAPH_SCHEMA = Object.freeze({
     edgeTypesV: 2,
     edgeProvenanceV: 1,
     complexityV: 2,
+    physicalFileLocV: 1,
     repoBoundaryV: 1,
     barrelResolutionV: 1,
     reExportOccurrencesV: 1,

package/src/graph/incremental-refresh.js

@@ -163,7 +163,7 @@ function mergeScopedGraph(base, scoped, affected, snapshot) {
     controlHashes: snapshot.controlHashes,
     graphRevision: snapshot.revision,
   };
-  for (const key of ["extImportsV", "edgeTypesV", "edgeProvenanceV", "complexityV", "repoBoundaryV", "barrelResolutionV", "reExportOccurrencesV", "symbolSpacesV", "extractorSchemaV"]) {
+  for (const key of ["extImportsV", "edgeTypesV", "edgeProvenanceV", "complexityV", "physicalFileLocV", "repoBoundaryV", "barrelResolutionV", "reExportOccurrencesV", "symbolSpacesV", "extractorSchemaV"]) {
     merged[key] = Math.max(Number(base[key]) || 0, Number(scoped[key]) || 0);
   }
   return merged;
@@ -184,7 +184,8 @@ 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.reExportOccurrencesV) < 1
+    || Number(existingGraph.extractorSchemaV) < 5 || 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,11 +8,17 @@ 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 { addJavaReferences } from "./internal-builder.java.js";
 import { assignDeterministicCommunities } from "./community.js";
-import { resolveJsBarrels } from "./internal-builder.barrels.js";
 import { snapshotRepository } from "./incremental-refresh.js";
 import { EDGE_PROVENANCE_V, stampEdgeProvenance } from "./edge-provenance.js";
+import {runInternalGraphPass2} from './internal-builder.pass2.js'
+
+function physicalLineCount(text) {
+  if (!text.length) return 0;
+  let lines = 1;
+  for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) === 10) lines++;
+  return text.endsWith("\n") ? lines - 1 : lines;
+}
 
 // Parse a repo directory into a graph-builder-compatible { nodes, links } graph.
 export async function buildInternalGraph(repoDir, opts = {}) {
@@ -78,10 +84,13 @@ export async function buildInternalGraph(repoDir, opts = {}) {
   let _parsed = 0;
   for (const abs of files) {
     const fileRel = rel(abs); const ext = extname(abs);
-    addNode({ id: fileRel, label: fileRel.split("/").pop(), file_type: "code", source_file: fileRel, source_location: "L1" });
-    if (isDataFile(fileRel) || isDocFile(fileRel)) { perFileSymbols.set(fileRel, []); symByFileName.set(fileRel, new Map()); symIdsByFileName.set(fileRel, new Map()); continue; }  // config/infra/docs file-only node
+    const fileNode = { id: fileRel, label: fileRel.split("/").pop(), file_type: "code", source_file: fileRel, source_location: "L1" };
+    if (isDataFile(fileRel) || isDocFile(fileRel)) {
+      addNode(fileNode); perFileSymbols.set(fileRel, []); symByFileName.set(fileRel, new Map()); symIdsByFileName.set(fileRel, new Map()); continue;
+    }  // 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;
-    let code; try { code = readFileSync(abs, "utf8"); } catch { 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
@@ -144,7 +153,10 @@ export async function buildInternalGraph(repoDir, opts = {}) {
         ...(extra && extra.symbolSpace ? { symbol_space: extra.symbolSpace } : {}),
         ...(extra && extra.memberOf ? { member_of: extra.memberOf } : {}),
         ...(extra && extra.visibility ? { visibility: extra.visibility } : {}),
-        ...(Number.isInteger(extra?.parameterCount) ? { parameter_count: extra.parameterCount } : {})
+        ...(Number.isInteger(extra?.parameterCount) ? { parameter_count: extra.parameterCount } : {}),
+        ...(extra?.receiverType ? { receiver_type: extra.receiverType } : {}),
+        ...(extra?.returnType ? { return_type: extra.returnType } : {}),
+        ...(extra?.fieldTypes && Object.keys(extra.fieldTypes).length ? { field_types: extra.fieldTypes } : {})
       });
       links.push({ source: fileRel, target: id, relation: "contains", confidence: "EXTRACTED" });
       syms.push({
@@ -216,184 +228,10 @@ export async function buildInternalGraph(repoDir, opts = {}) {
   // ---- pass 2: scope-aware calls + inheritance (Go package = whole dir → same-dir symbols share scope;
   // C# gets the same treatment: one folder ≈ one namespace by convention, and `using` names namespaces,
   // not files, so the folder map is the only reliable cross-file resolver) ----
-  const goDirSymbols = new Map();
-  const sharesDirScope = (fr) => fr.endsWith(".go") || fr.endsWith(".cs") || fr.endsWith(".rs");
-  for (const [fr, m] of symByFileName) {
-    if (!sharesDirScope(fr)) continue;
-    const d = fr.includes("/") ? fr.slice(0, fr.lastIndexOf("/")) : "";
-    let dm = goDirSymbols.get(d); if (!dm) goDirSymbols.set(d, (dm = new Map()));
-    for (const [n, id] of m) if (!dm.has(n)) dm.set(n, id);
-  }
-  const inferredSymbolSpace = (node) => {
-    const explicit = String(node?.symbol_space || "");
-    if (["value", "type", "both"].includes(explicit)) return explicit;
-    const kind = String(node?.symbol_kind || "").toLowerCase();
-    if (["interface", "type"].includes(kind)) return "type";
-    if (["class", "enum"].includes(kind)) return "both";
-    return "value";
-  };
-  const resolveNamedSymbol = (file, name, space = "value") => {
-    const ids = symIdsByFileName.get(file)?.get(name) || [];
-    const accepts = (id) => {
-      const symbolSpace = inferredSymbolSpace(nodeById.get(id));
-      return symbolSpace === "both" || symbolSpace === space;
-    };
-    const exact = ids.find((id) => inferredSymbolSpace(nodeById.get(id)) === space);
-    return exact || ids.find(accepts) || null;
-  };
-  const { resolveNamespaceMember, reExportOccurrences } = resolveJsBarrels({
-    jsExports, importedLocals, links,
-    resolveSymbol: (file, name, typeOnly) => resolveNamedSymbol(file, name, typeOnly ? "type" : "value"),
+  const {reExportOccurrences} = runInternalGraphPass2({
+    files, rel, langs, caps, field, links, nodeById, perFileSymbols, symByFileName,
+    symIdsByFileName, importedLocals, jsExports,
   });
-  // Exact source ranges can overlap (a named function nested inside another function). Attribute a call
-  // to the innermost matching symbol, not whichever outer declaration happened to be added first.
-  const enclosing = (fileRel, line) => {
-    let best = null;
-    for (const s of perFileSymbols.get(fileRel) || []) {
-      if (line < s.start || line > s.end) continue;
-      if (!best || s.start > best.start || (s.start === best.start && s.end < best.end)) best = s;
-    }
-    return best;
-  };
-  const resolveCall = (name, fileRel) => {
-    const local = resolveNamedSymbol(fileRel, name, "value"); if (local) return local;
-    if (sharesDirScope(fileRel)) { const d = fileRel.includes("/") ? fileRel.slice(0, fileRel.lastIndexOf("/")) : ""; const dm = goDirSymbols.get(d); if (dm && dm.has(name)) return dm.get(name); }
-    const imp = importedLocals.get(fileRel) && importedLocals.get(fileRel).get(name);
-    if (imp && imp.targetFile) {
-      const targetFile = imp.originFile || imp.targetFile;
-      const importedName = imp.originName || imp.imported;
-      return resolveNamedSymbol(targetFile, importedName, "value");
-    }
-    return null;
-  };
-  const javaTypeKinds = new Set(["class", "interface", "enum", "record", "annotation"]);
-  const resolveJavaType = (name, fileRel) => {
-    const imp = importedLocals.get(fileRel)?.get(name);
-    if (imp?.targetFile) {
-      const symbols = symByFileName.get(imp.targetFile);
-      const target = symbols?.get(imp.imported) || symbols?.get(name);
-      if (target && javaTypeKinds.has(nodeById.get(target)?.symbol_kind)) return target;
-    }
-    const target = symByFileName.get(fileRel)?.get(name);
-    return target && javaTypeKinds.has(nodeById.get(target)?.symbol_kind) ? target : null;
-  };
-  for (const abs of files) {
-    const fileRel = rel(abs); const grammar = EXT_LANG[extname(abs)]; if (!grammar) continue;
-    const lang = LANGS[FAMILY[grammar]]; if (!lang || lang.isWeb || !langs[grammar]) continue;
-    let code; try { code = readFileSync(abs, "utf8"); } catch { continue; }
-    const parser = new Parser(); parser.setLanguage(langs[grammar]);
-    let tree; try { tree = parser.parse(code); } catch { continue; }
-    if (!lang.customCalls) for (const cap of caps(grammar, lang.calls, tree.rootNode)) {
-      const caller = enclosing(fileRel, cap.node.startPosition.row + 1); if (!caller) continue;
-      const target = resolveCall(cap.node.text, fileRel); if (!target || target === caller.id) continue;
-      links.push({ source: caller.id, target, relation: "calls", confidence: "INFERRED", line: cap.node.startPosition.row + 1 });
-    }
-    if (typeof lang.pass2 === "function") {
-      try {
-        lang.pass2({
-          grammar, tree, fileRel, code, caps, field, enclosing, links, nodeById,
-          perFileSymbols, symByFileName, symIdsByFileName, importedLocals, resolveCall, resolveJavaType,
-        });
-      } catch (e) { /* one language-specific resolver never sinks the graph */ void e; }
-    }
-    // qualified/selector calls (Go): `pkg.Func()` → the imported package's dir; else `receiver.Method()` → the
-    // SAME package (heuristic by method name — connects lifecycle methods like peer.Enable() that need type info).
-    if (lang.selectorCall) for (const cap of caps(grammar, lang.selectorCall, tree.rootNode)) {
-      const sel = cap.node; const operand = field(sel, "operand"), fld = field(sel, "field");
-      if (!operand || operand.type !== "identifier" || !fld) continue;
-      const caller = enclosing(fileRel, sel.startPosition.row + 1); if (!caller) continue;
-      const imp = importedLocals.get(fileRel) && importedLocals.get(fileRel).get(operand.text);
-      const dir = fileRel.includes("/") ? fileRel.slice(0, fileRel.lastIndexOf("/")) : "";
-      const dm = goDirSymbols.get(imp && imp.targetDir ? imp.targetDir : dir);
-      const target = dm && dm.get(fld.text);
-      if (target && target !== caller.id) links.push({ source: caller.id, target, relation: "calls", confidence: "INFERRED", line: cap.node.startPosition.row + 1 });
-    }
-    for (const heritageSpec of lang.heritage || []) {
-      const query = typeof heritageSpec === "string" ? heritageSpec : heritageSpec.query;
-      const relation = typeof heritageSpec === "string" ? "inherits" : (heritageSpec.relation || "inherits");
-      for (const cap of caps(grammar, query, tree.rootNode)) {
-        const cls = enclosing(fileRel, cap.node.startPosition.row + 1); if (!cls) continue;
-        const target = FAMILY[grammar] === "java" ? resolveJavaType(cap.node.text, fileRel) : resolveCall(cap.node.text, fileRel);
-        if (target && target !== cls.id) links.push({ source: cls.id, target, relation, confidence: "INFERRED" });
-      }
-    }
-    // JSX is a real symbol use even though it is not a call_expression. Resolve imported components to their
-    // declaration so component fan-in and unused-export checks do not claim `<SettingsView />` is unreferenced.
-    if (FAMILY[grammar] === "js") {
-      // Namespace calls (`ui.run()`) need the member name before an export-star facade can be resolved.
-      for (const cap of caps(grammar, `(call_expression function: (member_expression) @memberCall)`, tree.rootNode)) {
-        const object = field(cap.node, "object"), property = field(cap.node, "property");
-        if (!object || object.type !== "identifier" || !property) continue;
-        const imp = importedLocals.get(fileRel)?.get(object.text);
-        if (!imp || !["*", "default"].includes(imp.imported) || imp.typeOnly) continue;
-        const origin = resolveNamespaceMember(fileRel, imp, property.text, "call");
-        if (origin.status !== "resolved") continue;
-        const target = resolveNamedSymbol(origin.origin.file, origin.origin.name, "value");
-        const caller = enclosing(fileRel, cap.node.startPosition.row + 1);
-        if (target && caller && target !== caller.id) links.push({ source: caller.id, target, relation: "calls", confidence: "INFERRED", line: cap.node.startPosition.row + 1 });
-      }
-      for (const cap of caps(grammar, `[
-        (jsx_opening_element name: (_) @jsx)
-        (jsx_self_closing_element name: (_) @jsx)
-      ]`, tree.rootNode)) {
-        const jsxName = cap.node.text;
-        const parts = jsxName.split(".");
-        const localName = parts[0];
-        if (parts.length === 1 && !/^[A-Z_$]/.test(localName)) continue; // undotted lowercase tags are platform/intrinsic elements
-        const imp = importedLocals.get(fileRel)?.get(localName);
-        if (!imp || !imp.targetFile || imp.typeOnly) continue;
-        let targetFile = imp.originFile || imp.targetFile;
-        let importedName = imp.originName || imp.imported;
-        if (imp.imported === "*" && parts.length > 1) {
-          const origin = resolveNamespaceMember(fileRel, imp, parts[parts.length - 1], "jsx");
-          if (origin.status === "resolved") { targetFile = origin.origin.file; importedName = origin.origin.name; }
-        }
-        const target = resolveNamedSymbol(targetFile, importedName, "value") || resolveNamedSymbol(targetFile, localName, "value");
-        if (!target) continue;
-        const owner = enclosing(fileRel, cap.node.startPosition.row + 1);
-        links.push({ source: owner?.id || fileRel, target, relation: "references", confidence: "INFERRED", usage: "jsx", line: cap.node.startPosition.row + 1 });
-      }
-      // Type identifiers are a separate namespace in TypeScript. Resolve them to type/both-space
-      // declarations without creating runtime calls or keeping a same-named value symbol alive.
-      if (grammar !== "javascript") for (const cap of caps(grammar, `(type_identifier) @typeRef`, tree.rootNode)) {
-        const name = cap.node.text;
-        const imp = importedLocals.get(fileRel)?.get(name);
-        const targetFile = imp?.originFile || imp?.targetFile || fileRel;
-        const targetName = imp?.originName || imp?.imported || name;
-        const target = resolveNamedSymbol(targetFile, targetName, "type");
-        if (!target || String(target).startsWith(`${fileRel}#${name}@${cap.node.startPosition.row + 1}`)) continue;
-        const owner = enclosing(fileRel, cap.node.startPosition.row + 1);
-        const source = owner?.id || fileRel;
-        if (source === target) continue;
-        links.push({source, target, relation: "references", confidence: "EXTRACTED", provenance: "RESOLVED", typeOnly: true, line: cap.node.startPosition.row + 1, usage: "type"});
-      }
-    }
-    // Go value references: a top-level const/var/type/func used BY NAME (bare `X`, or cross-package `pkg.X`) in
-    // another file/scope → a `references` edge, so used-but-never-called symbols (message-type consts, etc.) are
-    // not falsely DEAD. (Same-file usage is already covered by graph-builder-analysis localRefs.) Go-only for now.
-    if (FAMILY[grammar] === "go") {
-      const refSeen = new Set();
-      const emitRef = (src, target) => { if (!target || target === src) return; const k = src + ">" + target; if (refSeen.has(k)) return; refSeen.add(k); links.push({ source: src, target, relation: "references", confidence: "INFERRED" }); };
-      const dir = fileRel.includes("/") ? fileRel.slice(0, fileRel.lastIndexOf("/")) : "";
-      const dm = goDirSymbols.get(dir);
-      for (const cap of caps(grammar, `[(identifier) (type_identifier)] @id`, tree.rootNode)) {   // type_identifier → struct/type usage
-        const target = dm && dm.get(cap.node.text); if (!target || target.slice(0, target.indexOf("#")) === fileRel) continue;
-        const caller = enclosing(fileRel, cap.node.startPosition.row + 1); emitRef(caller ? caller.id : fileRel, target);
-      }
-      for (const cap of caps(grammar, `(selector_expression) @sel`, tree.rootNode)) {
-        const sel = cap.node; const operand = field(sel, "operand"), fld = field(sel, "field");
-        if (!operand || operand.type !== "identifier" || !fld) continue;
-        const imp = importedLocals.get(fileRel) && importedLocals.get(fileRel).get(operand.text); if (!imp || !imp.targetDir) continue;
-        const tdm = goDirSymbols.get(imp.targetDir); const target = tdm && tdm.get(fld.text); if (!target) continue;
-        const caller = enclosing(fileRel, sel.startPosition.row + 1); emitRef(caller ? caller.id : fileRel, target);
-      }
-    }
-    if (FAMILY[grammar] === "java") {
-      addJavaReferences({ grammar, tree, fileRel, caps, resolveJavaType, enclosing, links });
-    }
-    tree.delete();
-  }
-
   // HTML class/id usage → the CSS file(s) defining that selector: file-level reference edges (deduped per pair).
   const htmlRefSeen = new Set();
   for (const u of htmlUsages) {
@@ -422,6 +260,7 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     edgeTypesV: 2,
     edgeProvenanceV: EDGE_PROVENANCE_V,
     complexityV: 2,
+    physicalFileLocV: 1,
     repoBoundaryV: 1,
     barrelResolutionV: 1,
     reExportOccurrencesV: 1,