weavatrix 0.2.4 → 0.2.6

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

@@ -11,11 +11,12 @@ export default {
   grammars: ["python"],
   exts: { ".py": "python", ".pyi": "python" },
   isWeb: false,
+  customCalls: true,
   calls: `(call function: (identifier) @callee)`,
   heritage: [`(class_definition superclasses: (argument_list (identifier) @super))`],
 
   pass1(ctx) {
-    const { grammar, tree, fileRel, caps, field, addSym, addImportEdge, addExternalImport, imports, resolvePyPath, pyBaseDir, pyTopDirs } = ctx;
+    const { grammar, tree, fileRel, code, caps, field, addSym, addImportEdge, addExternalImport, markExported, imports, links, nameToId, resolvePyPath, pyBaseDir, pyTopDirs } = ctx;
     // the importing file's own dir is on sys.path when it runs as a script — try siblings for absolute
     // imports, EXCEPT stdlib names (a sibling logging.py must not shadow `import logging`; py3 absolute
     // imports always pick the stdlib, and a wrong internal edge distorts dead-code + reachability)
@@ -30,15 +31,37 @@ export default {
 
     // ---- symbols (decorated defs are framework-entered — @app.route/@app.event/@pytest.fixture — the
     // flag keeps dead-code checks from calling them dead; tree wraps them in decorated_definition) ----
+    const ownedMethods = [];
     for (const cap of caps(grammar, `(function_definition name: (identifier) @fn) (class_definition name: (identifier) @class)`, tree.rootNode)) {
       const decorated = cap.node.parent?.parent?.type === "decorated_definition";
-      addSym(cap.node.text, cap.node.startPosition.row + 1, cap.name === "fn", {
+      let ownerName = null;
+      if (cap.name === "fn") {
+        let parent = cap.node.parent?.parent;
+        while (parent && !["function_definition", "class_definition", "module"].includes(parent.type)) parent = parent.parent;
+        if (parent?.type === "class_definition") ownerName = field(parent, "name")?.text || null;
+      }
+      const visibility = /^__[^_].*/.test(cap.node.text) ? "private"
+        : /^_[^_]/.test(cap.node.text) ? "protected" : "public";
+      const id = addSym(cap.node.text, cap.node.startPosition.row + 1, cap.name === "fn", {
         sourceNode: cap.node.parent,
-        ...(decorated ? { decorated: true } : {})
+        selectionNode: cap.node,
+        ...(decorated ? { decorated: true } : {}),
+        symbolKind: cap.name === "class" ? "class" : ownerName ? "method" : "function",
+        ...(ownerName ? {memberOf: ownerName, visibility} : {moduleDeclaration: true}),
       });
+      if (ownerName) ownedMethods.push({ownerName, id});
+    }
+    for (const method of ownedMethods) {
+      const ownerId = nameToId.get(method.ownerName);
+      if (ownerId) links.push({source: ownerId, target: method.id, relation: "contains", confidence: "EXTRACTED"});
     }
     for (const cap of caps(grammar, `(module (expression_statement (assignment left: (identifier) @var)))`, tree.rootNode))
-      addSym(cap.node.text, cap.node.startPosition.row + 1, false, { sourceNode: cap.node.parent });
+      addSym(cap.node.text, cap.node.startPosition.row + 1, false, { sourceNode: cap.node.parent, selectionNode: cap.node, symbolKind: "variable", moduleDeclaration: true });
+
+    // Static __all__ is authoritative for wildcard imports. The assignment itself remains indexed,
+    // while listed declarations are marked as the explicit public module surface.
+    const allMatch = String(code || "").match(/(?:^|\n)\s*__all__\s*=\s*[\[(]([\s\S]*?)[\])]/m);
+    if (allMatch) for (const match of allMatch[1].matchAll(/["']([A-Za-z_]\w*)["']/g)) markExported(match[1]);
 
     // ---- import a.b [as c] ----
     for (const cap of caps(grammar, `(import_statement) @imp`, tree.rootNode)) {
@@ -61,6 +84,15 @@ export default {
         else if (modNode.type === "dotted_name") modParts = modNode.text.split(".");
       }
       const baseDir = pyBaseDir(fileRel, dots);
+      const wildcard = node.namedChildren.some((child) => child.type === "wildcard_import");
+      if (wildcard) {
+        const modFile = resolvePyPath(baseDir, modParts) || (dots === 0 ? resolveAbs(modParts) : null);
+        if (modFile) {
+          addImportEdge(modFile);
+          imports.set(`*:${node.startPosition.row + 1}`, {imported: "*", targetFile: modFile, wildcard: true, line: node.startPosition.row + 1});
+        } else if (dots === 0 && modParts.length) recordExternal(modParts.join("."), node.startPosition.row + 1);
+        continue;
+      }
       const names = node.namedChildren.filter((c) => c !== modNode && (c.type === "dotted_name" || c.type === "aliased_import"));
       let externalDone = false; // one record per statement, not per imported name
       for (const nm of names) {
@@ -75,4 +107,129 @@ export default {
       }
     }
   },
+
+  pass2(ctx) {
+    const {grammar, tree, fileRel, caps, field, enclosing, links, nodeById, perFileSymbols, symByFileName, importedLocals, resolveCall} = ctx;
+    const imports = importedLocals.get(fileRel) || new Map();
+    const wildcardImports = [...imports.values()].filter((entry) => entry?.wildcard && entry.targetFile);
+    const emitted = new Set();
+    const addCall = (caller, target, line, evidence) => {
+      if (!caller || !target || target === caller.id) return;
+      const key = `${caller.id}\0${target}\0${line}`;
+      if (emitted.has(key) || links.some((link) => link.source === caller.id && link.target === target && link.relation === "calls" && link.line === line)) return;
+      emitted.add(key);
+      const provenance = ["receiver-type", "wildcard-import", "module-member"].includes(evidence) ? "RESOLVED" : "INFERRED";
+      links.push({source: caller.id, target, relation: "calls", confidence: "INFERRED", provenance, line, pythonResolution: evidence});
+    };
+    const moduleSymbol = (targetFile, name) => {
+      const id = symByFileName.get(targetFile)?.get(name);
+      if (!id) return null;
+      const node = nodeById.get(id);
+      return node?.member_of ? null : id;
+    };
+    const wildcardCandidates = (name) => {
+      const candidates = [];
+      for (const imp of wildcardImports) {
+        const symbols = perFileSymbols.get(imp.targetFile) || [];
+        const explicitAll = symbols.some((symbol) => symbol.name === "__all__");
+        const symbol = symbols.find((entry) => entry.name === name && !entry.memberOf);
+        if (!symbol || (explicitAll ? nodeById.get(symbol.id)?.exported !== true : name.startsWith("_"))) continue;
+        candidates.push(symbol.id);
+      }
+      return [...new Set(candidates)];
+    };
+    const classInfo = (name) => {
+      const local = symByFileName.get(fileRel)?.get(name);
+      if (local && nodeById.get(local)?.symbol_kind === "class") return {id: local, name, file: fileRel};
+      const imp = imports.get(name);
+      if (imp?.targetFile && !imp.wildcard) {
+        const targetFile = imp.originFile || imp.targetFile;
+        const targetName = imp.originName || imp.imported || name;
+        const id = symByFileName.get(targetFile)?.get(targetName);
+        if (id && nodeById.get(id)?.symbol_kind === "class") return {id, name: targetName, file: targetFile};
+      }
+      const wildcard = wildcardCandidates(name).filter((id) => nodeById.get(id)?.symbol_kind === "class");
+      if (wildcard.length === 1) {
+        const node = nodeById.get(wildcard[0]);
+        return {id: wildcard[0], name: node.label || name, file: node.source_file};
+      }
+      return null;
+    };
+    const methodOf = (klass, method) => (perFileSymbols.get(klass.file) || [])
+      .find((symbol) => symbol.memberOf === String(nodeById.get(klass.id)?.label || klass.name).replace(/\(.*$/, "") && symbol.name === method)?.id || null;
+    const bindings = new Map();
+    const shadows = new Set();
+    const scopeKey = (caller, name) => `${caller?.id || ""}\0${name}`;
+    const bind = (caller, name, klass) => { if (caller && name && klass) bindings.set(scopeKey(caller, name), klass); };
+    const typeName = (node) => {
+      const text = String(node?.text || "").replace(/^['"]|['"]$/g, "");
+      return (text.match(/[A-Za-z_]\w*/) || [])[0] || "";
+    };
+
+    for (const cap of caps(grammar, `(parameters (identifier) @param) (typed_parameter) @typed`, tree.rootNode)) {
+      const line = cap.node.startPosition.row + 1;
+      const caller = enclosing(fileRel, line);
+      if (!caller) continue;
+      if (cap.name === "param") {
+        shadows.add(scopeKey(caller, cap.node.text));
+        continue;
+      }
+      const name = cap.node.namedChildren.find((child) => child.type === "identifier")?.text;
+      if (!name) continue;
+      shadows.add(scopeKey(caller, name));
+      bind(caller, name, classInfo(typeName(field(cap.node, "type"))));
+    }
+    for (const cap of caps(grammar, `(assignment) @assign`, tree.rootNode)) {
+      const assignment = cap.node;
+      const caller = enclosing(fileRel, assignment.startPosition.row + 1);
+      if (!caller) continue;
+      const left = field(assignment, "left");
+      const right = field(assignment, "right");
+      let receiver = "";
+      if (left?.type === "identifier") receiver = left.text;
+      else if (left?.type === "attribute") receiver = left.text;
+      if (!receiver) continue;
+      shadows.add(scopeKey(caller, receiver));
+      const annotation = typeName(field(assignment, "type"));
+      const constructor = right?.type === "call" && field(right, "function")?.type === "identifier"
+        ? field(right, "function").text : "";
+      bind(caller, receiver, classInfo(annotation || constructor));
+    }
+
+    for (const cap of caps(grammar, `(call function: (identifier) @callee)`, tree.rootNode)) {
+      const line = cap.node.startPosition.row + 1;
+      const caller = enclosing(fileRel, line);
+      if (!caller || shadows.has(scopeKey(caller, cap.node.text))) continue;
+      let target = resolveCall(cap.node.text, fileRel);
+      if (target && nodeById.get(target)?.member_of) target = null;
+      let evidence = "bare";
+      if (!target) {
+        const candidates = wildcardCandidates(cap.node.text);
+        if (candidates.length === 1) { target = candidates[0]; evidence = "wildcard-import"; }
+      }
+      addCall(caller, target, line, evidence);
+    }
+
+    for (const cap of caps(grammar, `(call function: (attribute) @attributeCall)`, tree.rootNode)) {
+      const attribute = cap.node;
+      const object = field(attribute, "object");
+      const member = field(attribute, "attribute");
+      if (!object || !member) continue;
+      const line = attribute.startPosition.row + 1;
+      const caller = enclosing(fileRel, line);
+      if (!caller) continue;
+      if (object.type === "identifier") {
+        const moduleImport = imports.get(object.text);
+        if (moduleImport?.targetFile && moduleImport.imported === "*" && !moduleImport.wildcard) {
+          addCall(caller, moduleSymbol(moduleImport.targetFile, member.text), line, "module-member");
+          continue;
+        }
+      }
+      let klass = null;
+      if (["self", "cls"].includes(object.text) && caller.memberOf) klass = classInfo(caller.memberOf);
+      if (!klass) klass = bindings.get(scopeKey(caller, object.text));
+      if (!klass && object.type === "call" && field(object, "function")?.type === "identifier") klass = classInfo(field(object, "function").text);
+      addCall(caller, klass && methodOf(klass, member.text), line, "receiver-type");
+    }
+  },
 };

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 = 3
+export const GRAPH_BUILDER_SCHEMA_V = 5
 export const GRAPH_BUILDER_VERSION = (() => {
     try { return String(createRequire(import.meta.url)('../../package.json').version) }
     catch { return '0.0.0' }
@@ -22,10 +22,12 @@ const CURRENT_GRAPH_SCHEMA = Object.freeze({
     extImportsV: 2,
     edgeTypesV: 2,
     edgeProvenanceV: 1,
-    complexityV: 1,
+    complexityV: 2,
     repoBoundaryV: 1,
     barrelResolutionV: 1,
-    extractorSchemaV: 3,
+    reExportOccurrencesV: 1,
+    symbolSpacesV: 1,
+    extractorSchemaV: 5,
 })
 const CONTROL_FILES = ['.gitignore', '.weavatrixignore', '.weavatrix.json']
 const MAX_CONTROL_BYTES = 1_000_000

package/src/graph/incremental-refresh.js

@@ -157,12 +157,13 @@ function mergeScopedGraph(base, scoped, affected, snapshot) {
     links,
     externalImports,
     jsExportRecords: scoped.jsExportRecords || base.jsExportRecords || {},
+    reExportOccurrences: scoped.reExportOccurrences || base.reExportOccurrences || [],
     fileHashes: snapshot.fileHashes,
     fileExportSignatures: snapshot.fileExportSignatures,
     controlHashes: snapshot.controlHashes,
     graphRevision: snapshot.revision,
   };
-  for (const key of ["extImportsV", "edgeTypesV", "edgeProvenanceV", "complexityV", "repoBoundaryV", "barrelResolutionV", "extractorSchemaV"]) {
+  for (const key of ["extImportsV", "edgeTypesV", "edgeProvenanceV", "complexityV", "repoBoundaryV", "barrelResolutionV", "reExportOccurrencesV", "symbolSpacesV", "extractorSchemaV"]) {
     merged[key] = Math.max(Number(base[key]) || 0, Number(scoped[key]) || 0);
   }
   return merged;
@@ -183,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) < 3 || Number(existingGraph.edgeProvenanceV) < 1) {
+    || Number(existingGraph.extractorSchemaV) < 5 || Number(existingGraph.reExportOccurrencesV) < 1
+    || Number(existingGraph.symbolSpacesV) < 1 || Number(existingGraph.edgeProvenanceV) < 1) {
     return full("incremental-baseline-unavailable");
   }
   if (!sameRecord(existingGraph.controlHashes, snapshot.controlHashes)) return full("ignore-or-control-config-changed");

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

@@ -28,15 +28,22 @@ function withTypeOnly(result, typeOnly) {
   return resolved(result.origin.file, result.origin.name, true);
 }
 
-export function resolveJsBarrels({ jsExports, importedLocals, links }) {
+export function resolveJsBarrels({ jsExports, importedLocals, links, resolveSymbol = () => null }) {
   const tables = new Map();
   for (const [file, records] of jsExports) {
-    const table = { explicit: new Map(), stars: [] };
+    const table = { explicit: new Map(), stars: [], facadeMembers: new Map() };
     for (const record of records || []) {
       if (record.kind === "star") {
         table.stars.push(record);
         continue;
       }
+      if (record.kind === "facade-member") {
+        if (!record.member) continue;
+        const list = table.facadeMembers.get(record.member) || [];
+        list.push(record);
+        table.facadeMembers.set(record.member, list);
+        continue;
+      }
       if (!record.exported) continue;
       const list = table.explicit.get(record.exported) || [];
       list.push(record);
@@ -87,6 +94,60 @@ export function resolveJsBarrels({ jsExports, importedLocals, links }) {
     return result;
   };
 
+  const resolveFacadeMember = (file, member, trail = new Set()) => {
+    const key = `${file}\0default.${member}`;
+    if (trail.has(key)) return MISSING;
+    const records = tables.get(file)?.facadeMembers.get(member) || [];
+    if (!records.length) return MISSING;
+    const nextTrail = new Set(trail);
+    nextTrail.add(key);
+    return mergeCandidates(records.map((record) => {
+      const local = record.local || member;
+      const binding = importedLocals.get(file)?.get(local);
+      if (binding?.targetFile && binding.imported && binding.imported !== "*") {
+        return withTypeOnly(resolveExport(binding.targetFile, binding.imported, nextTrail), record.typeOnly || binding.typeOnly);
+      }
+      return resolved(file, local, record.typeOnly);
+    }));
+  };
+
+  // Materialize source-free, occurrence-level re-export evidence. Named/local alias records retain
+  // their exact public name and final declaration origin; wildcard/namespace records retain the
+  // concrete facade statement and target for on-demand propagation in context tools.
+  const reExportOccurrences = [];
+  for (const [file, records] of jsExports) for (const record of records || []) {
+    if (["facade-root", "facade-member"].includes(record.kind)) continue;
+    const resolution = record.kind === "star" || !record.exported
+      ? MISSING
+      : resolveExport(file, record.exported);
+    if (resolution.status === "resolved") {
+      record.originFile = resolution.origin.file;
+      record.originName = resolution.origin.name;
+      record.originTypeOnly = resolution.origin.typeOnly === true;
+      record.originId = resolveSymbol(resolution.origin.file, resolution.origin.name, resolution.origin.typeOnly === true) || null;
+    }
+    const reExportedLocal = record.kind === "local" && resolution.status === "resolved" && resolution.origin.file !== file;
+    if (!record.targetFile && !reExportedLocal) continue;
+    reExportOccurrences.push({
+      file,
+      line: Number(record.line) || 1,
+      kind: record.kind,
+      exported: record.exported || record.member || "*",
+      imported: record.imported || record.local || "*",
+      targetFile: record.targetFile || resolution.origin?.file || file,
+      typeOnly: record.typeOnly === true || resolution.origin?.typeOnly === true,
+      ...(record.specifier ? {specifier: record.specifier} : {}),
+      status: record.kind === "star" ? "wildcard" : resolution.status,
+      ...(resolution.status === "resolved" ? {
+        originFile: resolution.origin.file,
+        originName: resolution.origin.name,
+        ...(record.originId ? {originId: record.originId} : {}),
+      } : {}),
+    });
+  }
+  reExportOccurrences.sort((left, right) => left.file.localeCompare(right.file)
+    || left.line - right.line || left.exported.localeCompare(right.exported));
+
   // Every internal re-export is a physical facade hop. It remains in the graph for runtime cycle truth,
   // but semantic consumers ignore it in favor of importer -> declaration edges below.
   for (const link of links) {
@@ -149,8 +210,13 @@ export function resolveJsBarrels({ jsExports, importedLocals, links }) {
   // Namespace member usage is only knowable in pass 2 (`ui.Button`, `ui.run`). Expose a bounded helper
   // that uses the same cache and emits the corresponding semantic file edge exactly once.
   const resolveNamespaceMember = (source, imp, member, usage = null) => {
-    if (!imp?.targetFile || imp.imported !== "*") return MISSING;
-    const result = resolveExport(imp.targetFile, member);
+    if (!imp?.targetFile) return MISSING;
+    const defaultFacade = imp.imported === "default" || imp.originName === "default";
+    const result = imp.imported === "*"
+      ? resolveExport(imp.targetFile, member)
+      : defaultFacade
+        ? resolveFacadeMember(imp.originFile || imp.targetFile, member)
+        : MISSING;
     if (result.status !== "resolved") return result;
     if (result.origin.file !== imp.targetFile) {
       for (const link of links) {
@@ -165,5 +231,5 @@ export function resolveJsBarrels({ jsExports, importedLocals, links }) {
     return result;
   };
 
-  return { resolveExport, resolveNamespaceMember };
+  return { resolveExport, resolveNamespaceMember, resolveFacadeMember, reExportOccurrences };
 }

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

@@ -37,6 +37,7 @@ export async function buildInternalGraph(repoDir, opts = {}) {
   const addNode = (n) => { if (!nodeIds.has(n.id)) { nodeIds.add(n.id); nodes.push(n); nodeById.set(n.id, n); } };
   const perFileSymbols = new Map();
   const symByFileName = new Map();
+  const symIdsByFileName = new Map();
   const importedLocals = new Map();
   const jsExports = new Map();
   if (requestedFiles && opts.baseGraph?.jsExportRecords) {
@@ -54,6 +55,11 @@ export async function buildInternalGraph(repoDir, opts = {}) {
       let names = symByFileName.get(file);
       if (!names) symByFileName.set(file, (names = new Map()));
       if (!names.has(match[1])) names.set(match[1], id);
+      let idsByName = symIdsByFileName.get(file);
+      if (!idsByName) symIdsByFileName.set(file, (idsByName = new Map()));
+      const ids = idsByName.get(match[1]) || [];
+      ids.push(id);
+      idsByName.set(match[1], ids);
       nodeById.set(id, node);
     }
   }
@@ -73,17 +79,17 @@ export async function buildInternalGraph(repoDir, opts = {}) {
   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()); continue; }  // config/infra/docs file-only node
+    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 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()); continue; }
+    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; }
 
-    const syms = []; const nameToId = new Map(); const moduleNameToId = new Map();
+    const syms = []; const nameToId = new Map(); const nameToIds = new Map(); const moduleNameToId = new Map();
     const addSym = (name, line, callable, extra) => {
       if (!name || !/^[A-Za-z_$][\w$]*$/.test(name)) return;
       const suffix = /^:[A-Za-z0-9_-]+$/.test(extra?.idSuffix || "") ? extra.idSuffix : "";
@@ -135,12 +141,24 @@ export async function buildInternalGraph(repoDir, opts = {}) {
         ...(extra && extra.exported ? { exported: true } : {}),
         ...(extra && extra.decorated ? { decorated: true } : {}),
         ...(extra && extra.symbolKind ? { symbol_kind: extra.symbolKind } : {}),
+        ...(extra && extra.symbolSpace ? { symbol_space: extra.symbolSpace } : {}),
         ...(extra && extra.memberOf ? { member_of: extra.memberOf } : {}),
         ...(extra && extra.visibility ? { visibility: extra.visibility } : {})
       });
       links.push({ source: fileRel, target: id, relation: "contains", confidence: "EXTRACTED" });
-      syms.push({ id, name, start: line, end: endLine >= line ? endLine : 0 });
+      syms.push({
+        id,
+        name,
+        start: line,
+        end: endLine >= line ? endLine : 0,
+        ...(extra?.memberOf ? {memberOf: extra.memberOf} : {}),
+        ...(extra?.symbolKind ? {symbolKind: extra.symbolKind} : {}),
+        ...(extra?.symbolSpace ? {symbolSpace: extra.symbolSpace} : {}),
+      });
       if (!nameToId.has(name)) nameToId.set(name, id);
+      const ids = nameToIds.get(name) || [];
+      ids.push(id);
+      nameToIds.set(name, ids);
       if (extra?.moduleDeclaration && !moduleNameToId.has(name)) moduleNameToId.set(name, id);
       return id;
     };
@@ -189,7 +207,7 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     for (let i = 0; i < syms.length; i++) {
       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);
+    perFileSymbols.set(fileRel, syms); symByFileName.set(fileRel, nameToId); symIdsByFileName.set(fileRel, nameToIds);
     tree.delete();
   }
 
@@ -204,7 +222,27 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     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 { resolveNamespaceMember } = resolveJsBarrels({ jsExports, importedLocals, links });
+  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"),
+  });
   // 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) => {
@@ -216,13 +254,13 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     return best;
   };
   const resolveCall = (name, fileRel) => {
-    const local = symByFileName.get(fileRel); if (local && local.has(name)) return local.get(name);
+    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;
-      const tf = symByFileName.get(targetFile); if (tf && tf.has(importedName)) return tf.get(importedName);
+      return resolveNamedSymbol(targetFile, importedName, "value");
     }
     return null;
   };
@@ -243,11 +281,19 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     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; }
-    for (const cap of caps(grammar, lang.calls, tree.rootNode)) {
+    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, importedLocals, resolveCall,
+        });
+      } 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)) {
@@ -277,10 +323,10 @@ export async function buildInternalGraph(repoDir, opts = {}) {
         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 || imp.imported !== "*" || imp.typeOnly) continue;
+        if (!imp || !["*", "default"].includes(imp.imported) || imp.typeOnly) continue;
         const origin = resolveNamespaceMember(fileRel, imp, property.text, "call");
         if (origin.status !== "resolved") continue;
-        const target = symByFileName.get(origin.origin.file)?.get(origin.origin.name);
+        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 });
       }
@@ -300,13 +346,25 @@ export async function buildInternalGraph(repoDir, opts = {}) {
           const origin = resolveNamespaceMember(fileRel, imp, parts[parts.length - 1], "jsx");
           if (origin.status === "resolved") { targetFile = origin.origin.file; importedName = origin.origin.name; }
         }
-        const targetSymbols = symByFileName.get(targetFile);
-        if (!targetSymbols) continue;
-        const target = targetSymbols.get(importedName) || targetSymbols.get(localName);
+        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
@@ -361,10 +419,13 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     extImportsV: 2,
     edgeTypesV: 2,
     edgeProvenanceV: EDGE_PROVENANCE_V,
-    complexityV: 1,
+    complexityV: 2,
     repoBoundaryV: 1,
     barrelResolutionV: 1,
-    extractorSchemaV: 3,
+    reExportOccurrencesV: 1,
+    symbolSpacesV: 1,
+    extractorSchemaV: 5,
+    reExportOccurrences,
     jsExportRecords: Object.fromEntries([...jsExports.entries()].sort(([a], [b]) => a.localeCompare(b))),
     fileHashes: snapshot.fileHashes,
     fileExportSignatures: snapshot.fileExportSignatures,