weavatrix 0.2.5 → 0.2.7

package/src/analysis/task-retrieval.js

@@ -0,0 +1,116 @@
+import {createPathClassifier, hasPathClass} from '../path-classification.js'
+
+const words = (value) => new Set(String(value || '').toLowerCase().match(/[\p{L}_$][\p{L}\p{N}_$-]{2,}/gu) || [])
+const fileOf = (node) => String(node?.source_file || (String(node?.id || '').includes('#') ? String(node.id).split('#')[0] : node?.id || '')).replace(/\\/g, '/')
+const isSymbol = (id) => String(id || '').includes('#')
+const NON_PRODUCT_CLASSES = Object.freeze(['test', 'e2e', 'generated', 'mock', 'story', 'docs', 'benchmark', 'temp'])
+const CLASS_TERMS = Object.freeze({
+  test: ['test', 'tests', 'testing', 'spec', 'coverage', 'verify'],
+  e2e: ['e2e', 'playwright', 'cypress'],
+  generated: ['generated', 'autogenerated', 'dist'],
+  mock: ['mock', 'mocks', 'fixture', 'fixtures', 'fake'],
+  story: ['story', 'stories', 'storybook'],
+  docs: ['doc', 'docs', 'documentation', 'readme', 'guide'],
+  benchmark: ['benchmark', 'benchmarks', 'bench'],
+  temp: ['temp', 'temporary', 'tmp'],
+})
+
+const INTENT_TRANSLATIONS = [
+  [/авториз|аутентиф|логин|сесси|токен/iu, 'auth authentication login session token'],
+  [/маршрут|роут|эндпоинт|апи|http/iu, 'route router endpoint api http'],
+  [/тест|покрыти/iu, 'test spec coverage verify'],
+  [/к[эе]ш|хранилищ/iu, 'cache store storage'],
+  [/баз[аы]|запрос|sql/iu, 'database query sql'],
+  [/конфиг|настройк/iu, 'config settings configuration'],
+  [/безопас|вредонос|секрет/iu, 'security malware secret'],
+  [/зависим|импорт/iu, 'dependency import module'],
+  [/дублик|клон/iu, 'duplicate clone'],
+]
+
+export function expandTaskQuery(task) {
+  const text = String(task || '')
+  const expansions = INTENT_TRANSLATIONS.filter(([pattern]) => pattern.test(text)).map(([, value]) => value)
+  return [...new Set([text, ...expansions])].join(' ')
+}
+
+function overlapScore(taskWords, node) {
+  const haystack = words(`${node?.label || ''} ${node?.id || ''} ${node?.symbol_kind || ''}`)
+  let score = 0
+  for (const word of taskWords) if (haystack.has(word)) score += 8
+  return score
+}
+
+function addCandidate(map, node, score, reason) {
+  if (!node?.id) return
+  const id = String(node.id)
+  const current = map.get(id) || {node, score: 0, reasons: new Set()}
+  current.score += score
+  current.reasons.add(reason)
+  map.set(id, current)
+}
+
+function containedSymbols(g, node) {
+  if (isSymbol(node?.id)) return [node]
+  return (g.out.get(String(node?.id)) || [])
+    .filter((edge) => edge.relation === 'contains')
+    .map((edge) => g.byId.get(String(edge.id)))
+    .filter(Boolean)
+}
+
+// Combines intent-expanded search seeds with exact changed symbols. The result deliberately stays
+// deterministic and source-free; exact LSP/source evidence is collected by context_bundle later.
+export function retrieveTaskContext(g, {
+  task, semanticSeeds = [], changedSeedIds = [], maxSymbols = 3, repoRoot = null, includeClassified = false,
+} = {}) {
+  const expandedTask = expandTaskQuery(task)
+  const taskWords = words(expandedTask)
+  const requestedClasses = new Set(Object.entries(CLASS_TERMS)
+    .filter(([, terms]) => terms.some((term) => taskWords.has(term)))
+    .map(([name]) => name))
+  if (requestedClasses.has('test')) requestedClasses.add('e2e')
+  if (requestedClasses.has('e2e')) requestedClasses.add('test')
+  const classifier = createPathClassifier(repoRoot)
+  const classificationCache = new Map()
+  const changedFiles = new Set((changedSeedIds || []).map((id) => fileOf(g.byId.get(String(id)) || {id})))
+  const pathAllowed = (node) => {
+    const file = fileOf(node)
+    if (!file || changedFiles.has(file) || includeClassified === true) return true
+    if (!classificationCache.has(file)) classificationCache.set(file, classifier.explain(file, {content: ''}))
+    const info = classificationCache.get(file)
+    const classes = NON_PRODUCT_CLASSES.filter((name) => hasPathClass(info, name))
+    if (!info?.excluded && !classes.length) return true
+    return classes.some((name) => requestedClasses.has(name))
+  }
+  const candidates = new Map()
+  for (const id of changedSeedIds || []) {
+    const node = g.byId.get(String(id))
+    if (node) addCandidate(candidates, node, 100 + overlapScore(taskWords, node), 'changed-symbol')
+  }
+  for (const seed of semanticSeeds || []) addCandidate(candidates, seed, 45 + overlapScore(taskWords, seed), 'task-intent')
+
+  for (const candidate of [...candidates.values()]) {
+    for (const symbol of containedSymbols(g, candidate.node)) {
+      const degree = (g.out.get(String(symbol.id)) || []).length + (g.inn.get(String(symbol.id)) || []).length
+      addCandidate(candidates, symbol, 22 + overlapScore(taskWords, symbol) + Math.min(12, degree), `symbol-in:${fileOf(candidate.node)}`)
+    }
+  }
+
+  const symbolCandidates = [...candidates.values()].filter((item) => isSymbol(item.node.id))
+  const ranked = symbolCandidates
+    .filter((item) => pathAllowed(item.node))
+    .sort((left, right) => right.score - left.score || String(left.node.id).localeCompare(String(right.node.id)))
+  const limit = Math.max(1, Math.min(5, Number(maxSymbols) || 3))
+  return {
+    method: 'intent-expanded graph retrieval + exact changed-symbol seeds',
+    status: ranked.length ? 'COMPLETE' : 'NO_SYMBOLS',
+    selected: ranked.slice(0, limit).map((item) => ({
+      id: String(item.node.id), label: item.node.label || String(item.node.id), file: fileOf(item.node),
+      kind: item.node.symbol_kind || null, score: item.score, reasons: [...item.reasons].sort(),
+    })),
+    candidateCount: ranked.length,
+    suppressedClassified: symbolCandidates.length - ranked.length,
+    pathPolicy: includeClassified === true
+      ? {mode: 'ALL_CLASSIFIED'}
+      : {mode: 'PRODUCTION_FIRST', requestedClasses: [...requestedClasses].sort(), changedFilesPinned: changedFiles.size},
+  }
+}

package/src/bounds.js

@@ -0,0 +1,4 @@
+export function boundedInteger(value, fallback, minimum, maximum) {
+  const number = Number(value);
+  return Math.max(minimum, Math.min(maximum, Number.isFinite(number) ? Math.floor(number) : fallback));
+}

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

@@ -14,6 +14,10 @@ const TOPVARS = `
   (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) {
@@ -95,7 +99,13 @@ export default {
         sourceNode: cap.node.parent,
         selectionNode: cap.node,
         ...(exportStatement ? { exported: true } : {}),
-        ...(isMethod ? methodMetadata(cap.node) : { symbolKind: cap.name === "class" ? "class" : "function", moduleDeclaration: isModuleDeclaration(cap.node) })
+        ...(isMethod
+          ? {...methodMetadata(cap.node), symbolSpace: "value"}
+          : {
+              symbolKind: cap.name === "class" ? "class" : "function",
+              symbolSpace: cap.name === "class" ? "both" : "value",
+              moduleDeclaration: isModuleDeclaration(cap.node),
+            })
       });
       if (exportStatement) {
         recordJsExport({
@@ -103,6 +113,7 @@ export default {
           exported: /^\s*export\s+default\b/.test(exportStatement.text) ? "default" : cap.node.text,
           local: cap.node.text,
           typeOnly: false,
+          line: exportStatement.startPosition.row + 1,
         });
       }
     }
@@ -115,9 +126,40 @@ export default {
         selectionNode: nameNode,
         ...(exported ? { exported: true } : {}),
         symbolKind: "variable",
+        symbolSpace: "value",
         moduleDeclaration: true
       });
-      if (exported) recordJsExport({ kind: "local", exported: nameNode.text, local: nameNode.text, typeOnly: false });
+      if (exported) recordJsExport({
+        kind: "local", exported: nameNode.text, local: nameNode.text, typeOnly: false,
+        line: exportStatementOf(cap.node)?.startPosition.row + 1 || nameNode.startPosition.row + 1,
+      });
+    }
+
+    // TypeScript has separate type and value namespaces. Keep interface/type declarations as
+    // first-class type-space nodes instead of folding them into a same-named runtime declaration.
+    // Enums and classes intentionally occupy both spaces because TypeScript emits runtime values.
+    if (grammar !== "javascript") for (const cap of caps(grammar, TYPES, tree.rootNode)) {
+      const declaration = cap.node.parent;
+      const exportStatement = exportStatementOf(cap.node);
+      const symbolKind = cap.name === "interface" ? "interface" : cap.name === "type" ? "type" : "enum";
+      const symbolSpace = cap.name === "enum" ? "both" : "type";
+      addSym(cap.node.text, cap.node.startPosition.row + 1, false, {
+        sourceNode: declaration,
+        selectionNode: cap.node,
+        idSuffix: symbolSpace === "type" ? ":type" : "",
+        ...(exportStatement ? {exported: true} : {}),
+        symbolKind,
+        symbolSpace,
+        moduleDeclaration: isModuleDeclaration(cap.node),
+      });
+      if (exportStatement) recordJsExport({
+        kind: "local",
+        exported: cap.node.text,
+        local: cap.node.text,
+        typeOnly: symbolSpace === "type",
+        line: exportStatement.startPosition.row + 1,
+        symbolSpace,
+      });
     }
 
     const importTypeOnly = (node) => {
@@ -218,12 +260,12 @@ export default {
         const namespace = text.match(/^export\s+(type\s+)?\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\b/);
         const clause = text.match(/^export\s+(type\s+)?\{([\s\S]*?)\}\s+from\b/);
         if (namespace) {
-          recordJsExport({ kind: "namespace", exported: namespace[2], targetFile: tgt, typeOnly: !!namespace[1] });
+          recordJsExport({ kind: "namespace", exported: namespace[2], imported: "*", targetFile: tgt, typeOnly: !!namespace[1], line, specifier: rawSpec });
         } else if (star) {
-          recordJsExport({ kind: "star", targetFile: tgt, typeOnly: !!star[1] });
+          recordJsExport({ kind: "star", exported: "*", imported: "*", targetFile: tgt, typeOnly: !!star[1], line, specifier: rawSpec });
         } else if (clause) {
           for (const spec of parseExportSpecifiers(clause[2])) {
-            recordJsExport({ kind: "named", exported: spec.exported, imported: spec.imported, targetFile: tgt, typeOnly: !!clause[1] || spec.typeOnly });
+            recordJsExport({ kind: "named", exported: spec.exported, imported: spec.imported, targetFile: tgt, typeOnly: !!clause[1] || spec.typeOnly, line, specifier: rawSpec });
           }
         }
       }
@@ -239,26 +281,19 @@ export default {
       const text = node.text.trim();
       const clause = text.match(/^export\s+(type\s+)?\{([\s\S]*?)\}/);
       if (clause) for (const spec of parseExportSpecifiers(clause[2])) {
-        recordJsExport({ kind: "local", exported: spec.exported, local: spec.imported, typeOnly: !!clause[1] || spec.typeOnly });
+        recordJsExport({ kind: "local", exported: spec.exported, local: spec.imported, typeOnly: !!clause[1] || spec.typeOnly, line: node.startPosition.row + 1 });
       }
       const identifierDefault = text.match(/^export\s+default\s+([A-Za-z_$][\w$]*)\s*;?$/);
-      if (identifierDefault) recordJsExport({ kind: "local", exported: "default", local: identifierDefault[1], typeOnly: false });
-      const typedDeclaration = text.match(/^export\s+(?:declare\s+)?(type|interface|enum)\s+([A-Za-z_$][\w$]*)\b/);
-      if (typedDeclaration) recordJsExport({
-        kind: "local",
-        exported: typedDeclaration[2],
-        local: typedDeclaration[2],
-        typeOnly: typedDeclaration[1] !== "enum",
-      });
+      if (identifierDefault) recordJsExport({ kind: "local", exported: "default", local: identifierDefault[1], typeOnly: false, line: node.startPosition.row + 1 });
       const defaultValue = field(node, "value");
       if (defaultValue?.type === "object") {
         // Service facades commonly expose local helpers through `export default { getSchema,
         // save: persist }`. Record the public member -> local binding instead of treating the
         // object as an opaque default export.
-        recordJsExport({kind: "facade-root", exported: "default", local: "default", typeOnly: false});
+        recordJsExport({kind: "facade-root", exported: "default", local: "default", typeOnly: false, line: node.startPosition.row + 1});
         for (const property of defaultValue.namedChildren || []) {
           if (["shorthand_property_identifier", "shorthand_property_identifier_pattern"].includes(property.type)) {
-            recordJsExport({kind: "facade-member", member: property.text, local: property.text, typeOnly: false});
+            recordJsExport({kind: "facade-member", member: property.text, local: property.text, typeOnly: false, line: node.startPosition.row + 1});
             markExported(property.text);
             continue;
           }
@@ -268,7 +303,7 @@ export default {
           if (!key || value?.type !== "identifier") continue;
           const member = key.text.replace(/^['"`]|['"`]$/g, "");
           if (!/^[A-Za-z_$][\w$]*$/.test(member)) continue;
-          recordJsExport({kind: "facade-member", member, local: value.text, typeOnly: false});
+          recordJsExport({kind: "facade-member", member, local: value.text, typeOnly: false, line: node.startPosition.row + 1});
           markExported(value.text);
         }
       }

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 = 4
+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' }
@@ -25,7 +25,9 @@ const CURRENT_GRAPH_SCHEMA = Object.freeze({
     complexityV: 2,
     repoBoundaryV: 1,
     barrelResolutionV: 1,
-    extractorSchemaV: 4,
+    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) < 4 || 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,7 +28,7 @@ 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: [], facadeMembers: new Map() };
@@ -111,6 +111,43 @@ export function resolveJsBarrels({ jsExports, importedLocals, links }) {
     }));
   };
 
+  // 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) {
@@ -194,5 +231,5 @@ export function resolveJsBarrels({ jsExports, importedLocals, links }) {
     return result;
   };
 
-  return { resolveExport, resolveNamespaceMember, resolveFacadeMember };
+  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,6 +141,7 @@ 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 } : {})
       });
@@ -146,8 +153,12 @@ export async function buildInternalGraph(repoDir, opts = {}) {
         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;
     };
@@ -196,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();
   }
 
@@ -211,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) => {
@@ -223,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;
   };
@@ -295,7 +326,7 @@ export async function buildInternalGraph(repoDir, opts = {}) {
         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 });
       }
@@ -315,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
@@ -379,7 +422,10 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     complexityV: 2,
     repoBoundaryV: 1,
     barrelResolutionV: 1,
-    extractorSchemaV: 4,
+    reExportOccurrencesV: 1,
+    symbolSpacesV: 1,
+    extractorSchemaV: 5,
+    reExportOccurrences,
     jsExportRecords: Object.fromEntries([...jsExports.entries()].sort(([a], [b]) => a.localeCompare(b))),
     fileHashes: snapshot.fileHashes,
     fileExportSignatures: snapshot.fileExportSignatures,