graph-indexer 2.0.0 → 2.1.0

package/mcp/topology.mjs

@@ -339,27 +339,36 @@ export function classifyCallers(db, targetFunction, { targetClass = null } = {})
         let typeMatch = null;
         if (typeMatchSet.size) {
             for (const s of sites) {
+                // Precedence: intra-procedural receiver type → the opt-in inter-procedural
+                // fixpoint result (recv_resolved_type, written at index time) → the 1-hop
+                // query-time factory return-type fallback. The fixpoint resolves multi-hop /
+                // unannotated factory chains the 1-hop path cannot.
                 const toks = s.recv_type ? _typeMatchTokens(s.recv_type)
-                    : s.recv_via_call ? [...calleeReturnTokens(s.recv_via_call)] : null;
+                    : s.recv_resolved_type ? _typeMatchTokens(s.recv_resolved_type)
+                        : s.recv_via_call ? [...calleeReturnTokens(s.recv_via_call)] : null;
                 const m = toks && toks.find(t => typeMatchSet.has(t));
                 if (m) { typeMatch = m; break; }
             }
         }
 
-        let reason = '';
-        if (uniqueTarget && !classFiltered) reason = 'sole definition';
-        else if (recvs.has('this') && callerClass && targetClasses.has(callerClass)) reason = `this.${targetFunction}()`;
-        else if (recvs.has('') && targetIsFreeFn) reason = `${targetFunction}()`;
-        else if (typeMatch) reason = `${classDisplay.get(typeMatch) || typeMatch}.${targetFunction}()`;
-        else if (deps.some(d => targetFiles.has(d))) reason = 'imports definition';
-        else if (targetFiles.has(caller.file_path)) reason = 'same file';
-        else if (tcl && [...recvs].some(r => r && r.toLowerCase() === tcl)) reason = `${targetClass}.${targetFunction}()`;
+        // `proven` (A1): the binding is UNAMBIGUOUS — a sole definition, or pinned by the
+        // receiver's TYPE (typed receiver / A3 fixpoint / this-in-class / explicit target
+        // class). The precise resolver lifts these to the `resolved` edge tier. Import- and
+        // proximity-based reasons are likely-but-not-proven → stay `high`.
+        let reason = '', proven = false;
+        if (uniqueTarget && !classFiltered) { reason = 'sole definition'; proven = true; }
+        else if (recvs.has('this') && callerClass && targetClasses.has(callerClass)) { reason = `this.${targetFunction}()`; proven = true; }
+        else if (recvs.has('') && targetIsFreeFn) { reason = `${targetFunction}()`; proven = false; }
+        else if (typeMatch) { reason = `${classDisplay.get(typeMatch) || typeMatch}.${targetFunction}()`; proven = true; }
+        else if (deps.some(d => targetFiles.has(d))) { reason = 'imports definition'; proven = false; }
+        else if (targetFiles.has(caller.file_path)) { reason = 'same file'; proven = false; }
+        else if (tcl && [...recvs].some(r => r && r.toLowerCase() === tcl)) { reason = `${targetClass}.${targetFunction}()`; proven = true; }
 
         const recvHint = [...recvs].map(r =>
             r === '' ? `${targetFunction}()` : r === 'this' ? `this.${targetFunction}()` : `${r}.${targetFunction}()`
         ).join(', ');
 
-        (reason ? high : nameOnly).push({ chunk: caller, reason, recvHint });
+        (reason ? high : nameOnly).push({ chunk: caller, reason, recvHint, proven: reason ? proven : false });
     }
 
     return { high, nameOnly, targetDefs, ambiguous, hasSiteData, classFiltered };
@@ -403,15 +412,40 @@ export function findReferences(db, symbol, { targetClass = null } = {}) {
             : imports ? 'imports definition'
                 : sameFile ? 'same file' : '';
         const confidence = reason ? 'high' : 'name-only';
-        if ((ref.extends || []).some(t => t.toLowerCase() === key)) inherits.push({ chunk: ref, confidence, reason });
-        if ((ref.type_refs || []).some(t => t.toLowerCase() === key)) types.push({ chunk: ref, confidence, reason });
+        // proven (A1): a sole definition is an unambiguous binding → eligible for `resolved`.
+        const proven = uniqueTarget;
+        if ((ref.extends || []).some(t => t.toLowerCase() === key)) inherits.push({ chunk: ref, confidence, reason, proven });
+        if ((ref.type_refs || []).some(t => t.toLowerCase() === key)) types.push({ chunk: ref, confidence, reason, proven });
     }
     const order = (a, b) => (a.confidence === b.confidence
         ? a.chunk.file_path.localeCompare(b.chunk.file_path)
         : a.confidence === 'high' ? -1 : 1);
     inherits.sort(order); types.sort(order);
 
-    return { symbol, targetDefs, ambiguous, calls, inherits, types };
+    // A2 v2: precise cross-file references from a locally-generated SCIP index (--resolver scip).
+    // SCIP occurrences are kind-agnostic ("symbol used here"), so this is the binding-precise,
+    // cross-file "used by" set: it both DISAMBIGUATES same-named symbols (each referer is attached
+    // to the one definition SCIP bound it to) and RECOVERS references the AST/name heuristic above
+    // misses entirely. Confidence is `resolved` — trustworthy, not a name guess. Empty (and so
+    // byte-identical) on every index built without a SCIP resolver. Isolated artifact → parity-free.
+    const references = [];
+    if (db.hasScipRefs?.()) {
+        const seen = new Set();
+        for (const def of targetDefs) {
+            for (const refId of db.getScipReferers(def.id)) {
+                if (seen.has(refId)) continue;
+                seen.add(refId);
+                const chunk = db.getChunk(refId);
+                if (chunk) references.push({ chunk, confidence: 'resolved', reason: 'scip' });
+            }
+        }
+        references.sort((a, b) =>
+            a.chunk.file_path.localeCompare(b.chunk.file_path)
+            || ((a.chunk.start_line || 0) - (b.chunk.start_line || 0))
+            || (a.chunk.id < b.chunk.id ? -1 : a.chunk.id > b.chunk.id ? 1 : 0));
+    }
+
+    return { symbol, targetDefs, ambiguous, calls, inherits, types, references };
 }
 
 // ─── HTTP route → handler resolution ──────────────────────────────────────────────
@@ -549,3 +583,94 @@ export function buildSubgraph(db, seed, { maxNodes = 12, maxDepth = 2, tokenBudg
     }));
     return { seed, found: true, truncated, nodes: nodeList, edges };
 }
+
+/**
+ * Reverse-direction transitive blast radius (C4): from a set of seed chunks (the symbols /
+ * files about to change), the transitively-affected REFERRERS — callers, subclasses, and type
+ * users — bounded by hop depth and node count.
+ *
+ * Uses the persistent symbol graph (getEdges) when present — precise and chunk-level — and
+ * otherwise falls back to query-time classifyCallers / findReferences. HIGH-confidence
+ * referrers drive the transitive closure (a precise blast radius that does not explode on
+ * ambiguous names); the DIRECT name_only referrers of the seed are surfaced separately for the
+ * agent to verify. Fully deterministic (every list is sorted: depth, file, line, id).
+ *
+ * @param {object} db
+ * @param {object[]} seedChunks  The chunks being changed.
+ * @param {object} [opts]
+ * @param {number} [opts.maxDepth]  Transitive hops to follow (default 3).
+ * @param {number} [opts.maxNodes]  Cap on impacted chunks (default 200).
+ * @returns {{ impacted:Array<{chunk,depth,kind}>, ambiguous:Array<{chunk,kind}>,
+ *             truncated:boolean, usedGraph:boolean }}
+ */
+export function buildImpact(db, seedChunks, { maxDepth = 3, maxNodes = 200, precision = 'standard' } = {}) {
+    const hasGraph = typeof db.hasSymbolGraph === 'function' && db.hasSymbolGraph();
+    const seedIds = new Set(seedChunks.map(c => c.id));
+
+    // A1 precision dial. `standard` follows the high-confidence closure (resolved + high);
+    // `strict` follows ONLY provably-unambiguous bindings (the `resolved` edge tier, or — with
+    // no graph — the `proven` query-time callers) for a false-positive-free blast radius.
+    const strict = precision === 'strict';
+    const keepEdge = strict ? (c) => c === 'resolved' : (c) => c === 'high' || c === 'resolved';
+    const keepRef = (proven) => !strict || Boolean(proven);
+
+    const highReferrers = (chunk) => {
+        const out = [];
+        if (hasGraph) {
+            for (const e of db.getEdges(chunk.id, { direction: 'in' }))
+                if (e.chunk && keepEdge(e.confidence)) out.push({ chunk: e.chunk, kind: e.kind });
+            return out;
+        }
+        if (!chunk.name || chunk.name === 'anonymous') return out;
+        const tcl = chunk.class_context || null;
+        const seen = new Set();
+        for (const h of classifyCallers(db, chunk.name, { targetClass: tcl }).high)
+            if (keepRef(h.proven) && !seen.has(h.chunk.id)) { seen.add(h.chunk.id); out.push({ chunk: h.chunk, kind: 'calls' }); }
+        const refs = findReferences(db, chunk.name, { targetClass: tcl });
+        for (const r of refs.inherits) if (r.confidence === 'high' && keepRef(r.proven) && !seen.has(r.chunk.id)) { seen.add(r.chunk.id); out.push({ chunk: r.chunk, kind: 'extends' }); }
+        for (const r of refs.types) if (r.confidence === 'high' && keepRef(r.proven) && !seen.has(r.chunk.id)) { seen.add(r.chunk.id); out.push({ chunk: r.chunk, kind: 'type' }); }
+        return out;
+    };
+    const nameOnlyReferrers = (chunk) => {
+        const out = [];
+        if (hasGraph) {
+            for (const e of db.getEdges(chunk.id, { direction: 'in' }))
+                if (e.chunk && e.confidence === 'name_only') out.push({ chunk: e.chunk, kind: e.kind });
+            return out;
+        }
+        if (!chunk.name || chunk.name === 'anonymous') return out;
+        for (const n of classifyCallers(db, chunk.name, { targetClass: chunk.class_context || null }).nameOnly)
+            out.push({ chunk: n.chunk, kind: 'calls' });
+        return out;
+    };
+
+    const ambiguous = new Map();
+    for (const s of seedChunks) for (const r of nameOnlyReferrers(s))
+        if (!seedIds.has(r.chunk.id) && !ambiguous.has(r.chunk.id)) ambiguous.set(r.chunk.id, r);
+
+    const impacted = new Map();
+    const visited = new Set(seedIds);
+    let truncated = false;
+    let frontier = seedChunks.map(c => ({ chunk: c }));
+    for (let depth = 1; depth <= maxDepth && !truncated; depth++) {
+        const next = [];
+        for (const { chunk } of frontier) {
+            for (const r of highReferrers(chunk)) {
+                if (visited.has(r.chunk.id)) continue;
+                if (impacted.size >= maxNodes) { truncated = true; break; }
+                visited.add(r.chunk.id);
+                impacted.set(r.chunk.id, { chunk: r.chunk, depth, kind: r.kind });
+                next.push({ chunk: r.chunk });
+            }
+            if (truncated) break;
+        }
+        if (next.length === 0) break;
+        frontier = next;
+    }
+
+    const byPlace = (a, b) => (a.chunk.file_path < b.chunk.file_path ? -1 : a.chunk.file_path > b.chunk.file_path ? 1 : 0)
+        || (a.chunk.start_line - b.chunk.start_line) || (a.chunk.id < b.chunk.id ? -1 : 1);
+    const impactedList = [...impacted.values()].sort((a, b) => (a.depth - b.depth) || byPlace(a, b));
+    const ambiguousList = [...ambiguous.values()].sort(byPlace);
+    return { impacted: impactedList, ambiguous: ambiguousList, truncated, usedGraph: hasGraph, precision };
+}

package/mcp-server.mjs

@@ -21,10 +21,22 @@ import { ensureDataDir, migrateLegacyLayout } from './layout.mjs';
 import { daemonStatus } from './daemon-lock.mjs';
 import { createStore } from './storage.mjs';
 import { registerTools } from './mcp/tools.mjs';
+import { ensureLanguagesReady } from './parse/languages.mjs';
 import { createEmbedder, readEmbedMeta } from './embeddings.mjs';
 import { loadGitSignals } from './git-signals.mjs';
-
-const config = resolveConfig();
+import { installEgressGuard } from './seal.mjs';
+
+let config;
+try {
+    config = resolveConfig();
+} catch (err) {
+    if (err && err.name === 'SealViolation') { process.stderr.write(`🔒 ${err.message}\n`); process.exit(2); }
+    throw err;
+}
+// F1: install the deny-by-default egress guard before the store / embedder / providers load.
+if (config.sealed !== 'off') {
+    installEgressGuard({ allow: config.sealed === 'local' ? ['loopback'] : [] });
+}
 const PROJECT_ROOT = config.projectRoot;
 const PID_FILE = config.pidFile;
 const PACKAGE_DIR = path.dirname(fileURLToPath(import.meta.url));
@@ -32,6 +44,16 @@ const PACKAGE_DIR = path.dirname(fileURLToPath(import.meta.url));
 ensureDataDir(PROJECT_ROOT);
 migrateLegacyLayout(PROJECT_ROOT);
 
+// get_file_skeleton parses on demand at query time — grammars must be resolved
+// (and, outside sealed mode, installed if this server is starting before the
+// first `idx-index` run) before the transport connects and starts serving tools.
+await ensureLanguagesReady({
+    projectRoot: PROJECT_ROOT,
+    enabledLangs: config.languages,
+    autoInstall: config.sealed === 'off',
+    log: (msg) => process.stderr.write(msg + '\n'),
+});
+
 function readPackageVersion() {
     try {
         return JSON.parse(fs.readFileSync(path.join(PACKAGE_DIR, 'package.json'), 'utf-8')).version || '0.0.0';
@@ -166,6 +188,8 @@ registerTools(server, db, {
     mlxLmHost: config.mlxLmHost,
     gitSignals,
     gitRankBoost: config.gitRankBoost,
+    sealed: config.sealed,
+    ranker: config.ranker,
 });
 
 const transport = new StdioServerTransport();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "graph-indexer",
-    "version": "2.0.0",
+    "version": "2.1.0",
     "description": "Air-gapped code-retrieval MCP server: AST chunking, hybrid RRF search and cross-language call graph, with an optional zero-dependency SQLite backend for monorepo scale and optional local-LLM semantic enrichment.",
     "type": "module",
     "main": "engine/memory.mjs",
@@ -43,14 +43,21 @@
         "test:mcp": "node test/mcp.mjs",
         "test:scale": "node test/scale.mjs",
         "test:callgraph": "node test/callgraph.mjs",
+        "test:edges": "node test/edges.mjs",
         "test:references": "node test/references.mjs",
         "test:routes": "node test/routes.mjs",
         "test:jsonout": "node test/json-output.mjs",
         "test:gitsignals": "node test/git-signals.mjs",
         "test:security": "node test/security.mjs",
+        "test:seal": "node test/seal.mjs",
+        "test:taint": "node test/taint.mjs",
+        "test:scip": "node test/scip.mjs",
+        "test:ranker": "node test/ranker.mjs",
+        "test:sparse": "node test/sparse.mjs",
+        "test:colbert": "node test/colbert.mjs",
         "test:embed": "node test/embeddings.mjs",
         "test:languages": "node test/languages.mjs",
-        "test:all": "node test/unit.mjs && node test/sqlite.mjs && node test/enrichment.mjs && node test/mcp.mjs && node test/scale.mjs && node test/callgraph.mjs && node test/references.mjs && node test/routes.mjs && node test/json-output.mjs && node test/git-signals.mjs && node test/security.mjs && node test/embeddings.mjs && node test/languages.mjs",
+        "test:all": "node test/unit.mjs && node test/sqlite.mjs && node test/enrichment.mjs && node test/mcp.mjs && node test/scale.mjs && node test/callgraph.mjs && node test/edges.mjs && node test/references.mjs && node test/routes.mjs && node test/json-output.mjs && node test/git-signals.mjs && node test/security.mjs && node test/seal.mjs && node test/taint.mjs && node test/scip.mjs && node test/ranker.mjs && node test/sparse.mjs && node test/colbert.mjs && node test/embeddings.mjs && node test/languages.mjs",
         "test:eval": "node test/evaluate.mjs",
         "test:eval:embeddings": "OLLAMA_HOST=http://localhost:11434 node test/evaluate.mjs --embeddings",
         "test:setup": "node test/setup.mjs",
@@ -61,6 +68,7 @@
         "test:json": "node test/run.mjs --json",
         "test:reset": "rm -rf test/fixtures && node test/setup.mjs",
         "embed:setup:mlx": "node embedders/setup-mlx.mjs",
+        "embed:setup:local": "npm install @huggingface/transformers",
         "mcp:index": "idx-index --repo .",
         "mcp:index:sqlite": "node indexer.mjs --repo . --use-sqlite",
         "mcp:index:enriched": "node indexer.mjs --repo . --enrichment",
@@ -80,6 +88,25 @@
         "tree-sitter": "0.21.1",
         "zod": "^3.25.76"
     },
+    "devDependencies": {
+        "@huggingface/transformers": "3.8.1",
+        "hnswlib-node": "3.0.0",
+        "tree-sitter-bash": "0.23.3",
+        "tree-sitter-c": "0.21.4",
+        "tree-sitter-c-sharp": "0.21.3",
+        "tree-sitter-css": "0.21.1",
+        "tree-sitter-go": "0.21.0",
+        "tree-sitter-java": "0.21.0",
+        "tree-sitter-javascript": "0.21.4",
+        "tree-sitter-kotlin": "0.3.8",
+        "tree-sitter-php": "0.23.1",
+        "tree-sitter-python": "0.21.0",
+        "tree-sitter-ruby": "0.23.1",
+        "tree-sitter-rust": "0.21.0",
+        "tree-sitter-scss": "1.0.0",
+        "tree-sitter-swift": "0.5.0",
+        "tree-sitter-typescript": "0.21.2"
+    },
     "keywords": [
         "mcp",
         "model-context-protocol",
@@ -111,24 +138,5 @@
     },
     "publishConfig": {
         "access": "public"
-    },
-    "optionalDependencies": {
-        "@huggingface/transformers": "3.8.1",
-        "hnswlib-node": "3.0.0",
-        "tree-sitter-bash": "0.23.3",
-        "tree-sitter-c": "0.21.4",
-        "tree-sitter-c-sharp": "0.21.3",
-        "tree-sitter-css": "0.21.1",
-        "tree-sitter-go": "0.21.0",
-        "tree-sitter-java": "0.21.0",
-        "tree-sitter-javascript": "0.21.4",
-        "tree-sitter-kotlin": "0.3.8",
-        "tree-sitter-php": "0.23.1",
-        "tree-sitter-python": "0.21.0",
-        "tree-sitter-ruby": "0.23.1",
-        "tree-sitter-rust": "0.21.0",
-        "tree-sitter-scss": "1.0.0",
-        "tree-sitter-swift": "0.5.0",
-        "tree-sitter-typescript": "0.21.2"
     }
 }

package/parse/extractor.mjs

@@ -16,12 +16,14 @@ const { Query } = Parser;
 import { getParserForFile, LANGUAGE_MAP, EXTENSIONS } from './languages.mjs';
 import {
     extractParams, extractReturnType, extractClassContext,
-    extractDecorators, extractHeritage, extractTypeAnnotations, extractCallSites,
+    extractDecorators, extractHeritage, extractTypeAnnotations, extractCallSites, extractReturnVia,
 } from './metadata.mjs';
 
 export const MAX_FILE_SIZE_BYTES = 500000;
 
-const _hasSCSS = Boolean(LANGUAGE_MAP['.scss']) && LANGUAGE_MAP['.scss'] !== LANGUAGE_MAP['.css'];
+// Evaluated lazily (not at module load) — LANGUAGE_MAP populates asynchronously
+// via ensureLanguagesReady(), which callers await before extractSemanticChunks runs.
+function _hasSCSS() { return Boolean(LANGUAGE_MAP['.scss']) && LANGUAGE_MAP['.scss'] !== LANGUAGE_MAP['.css']; }
 
 const LANGUAGE_QUERIES = {
     ts: `
@@ -330,7 +332,7 @@ function _cDeclaratorName(node) {
     return null;
 }
 
-export function extractSemanticChunks(rootNode, relPath, sourceCode, ext) {
+export function extractSemanticChunks(rootNode, relPath, sourceCode, ext, { interprocedural = false } = {}) {
     const chunks = [];
     const parser = getParserForFile(ext);
     if (!parser) return chunks;
@@ -342,7 +344,7 @@ export function extractSemanticChunks(rootNode, relPath, sourceCode, ext) {
         // .scss uses the SCSS grammar+query when installed; otherwise it parses
         // with the CSS grammar, so it MUST use the css query (the scss query
         // references node types the CSS grammar doesn't have).
-        '.scss': _hasSCSS ? 'scss' : 'css',
+        '.scss': _hasSCSS() ? 'scss' : 'css',
         // C headers share the C grammar/query; .sh and .bash share the bash query.
         // (.c and .swift resolve via the ext.slice(1) fallback below.)
         '.h': 'c', '.sh': 'bash', '.bash': 'bash',
@@ -567,14 +569,23 @@ export function extractSemanticChunks(rootNode, relPath, sourceCode, ext) {
                 .update(`${relPath}::${chunkNode.startPosition.row}::${chunkNode.startPosition.column}`)
                 .digest('hex').slice(0, 24);
 
-            chunks.push({
+            const chunk = {
                 id, file_path: relPath, node_type: chunkNode.type, name: nameText,
                 docstring: docstring, code_snippet: snippet, content_hash: hash,
                 start_line: chunkNode.startPosition.row + 1, end_line: chunkNode.endPosition.row + 1,
                 calls: outgoingCalls, call_sites: callSites,
                 params, return_type: returnType, class_context: classContext,
                 type_refs: typeRefs, decorators, extends: heritage,
-            });
+            };
+            // Opt-in inter-procedural fixpoint: capture what this function returns so the
+            // indexer can propagate return types along factory chains. Transient — stripped
+            // before serialization (parse/interprocedural.mjs::applyInterprocedural). Off by
+            // default → the chunk is byte-identical to before.
+            if (interprocedural) {
+                const rv = extractReturnVia(chunkNode);
+                if (rv) chunk._return_via = rv;
+            }
+            chunks.push(chunk);
         }
     } catch (e) {
         process.stderr.write(`\n[parse/extractor] 💥 Query Error in ${relPath}: ${e.message}\n`);

package/parse/interprocedural.mjs

@@ -0,0 +1,134 @@
+/**
+ * @file parse/interprocedural.mjs
+ * @description Bounded, deterministic INTER-procedural return-type fixpoint (opt-in).
+ *
+ *              The intra-procedural inference in parse/metadata.mjs already resolves a
+ *              call-site receiver one hop: `const r = makeRepo(); r.save()` records
+ *              `recv_via_call = 'makeRepo'`, and classifyCallers reads makeRepo's recorded
+ *              `return_type` at query time. That misses MULTI-hop factory chains and
+ *              unannotated factories: `makeRepoIndirect()` returns `makeRepo()` returns
+ *              `new OrderRepo()` — the indirect factory has no return type to read.
+ *
+ *              This pass propagates return types along factory return-call edges with a
+ *              monotone worklist fixpoint, so `makeRepoIndirect` resolves transitively to
+ *              `OrderRepo`. It runs ONCE at index time over all chunks and writes the result
+ *              into each call site as `recv_resolved_type`; because call_sites is serialized
+ *              identically by both backends, the resolved data is parity-free. classifyCallers
+ *              prefers `recv_resolved_type` and keeps the 1-hop `recv_via_call` fallback, so an
+ *              index built without this pass (or a per-file daemon update) is never worse.
+ *
+ *              Determinism: iteration is over SORTED symbol/edge keys and the lattice is
+ *              monotone (each step only adds the single concrete type or transitions to an
+ *              absorbing CONFLICT), so the result is independent of map insertion order — a
+ *              hard requirement for memory↔sqlite parity.
+ * @author MaquinaTech <https://github.com/MaquinaTech>
+ * @copyright (c) 2026 MaquinaTech. All rights reserved.
+ * @license MIT
+ */
+
+// Hard safety net against pathological/cyclic graphs. Each iteration propagates types one
+// extra hop; real factory chains are 1–3 hops, so the `changed` flag normally converges well
+// before this — the bound only guarantees termination, it is not the expected stop condition.
+const MAX_ITERS = 8;
+
+// Absorbing "two distinct concrete types" state — contributes nothing (conservative DROP,
+// mirroring _inferLocalBindings' conflict handling in parse/metadata.mjs).
+const CONFLICT = Symbol('conflict');
+
+/**
+ * The single concrete type NAME a string denotes, or null when it is not exactly one
+ * type identifier (generics / unions / primitives are ambiguous → conservatively dropped).
+ * 'OrderRepo' → 'OrderRepo'; 'Promise<Order>' → null; 'number' → null.
+ */
+function singleTypeName(str) {
+    if (!str) return null;
+    const ids = String(str).match(/[A-Za-z_$][A-Za-z0-9_$]*/g) || [];
+    const types = ids.filter(t => /^[A-Z]/.test(t)); // PascalCase = a type (matches _typeMatchTokens)
+    return types.length === 1 ? types[0] : null;
+}
+
+/**
+ * Resolve, per function symbol (lowercased name), the single concrete return TYPE it
+ * yields — directly (annotation or `return new X()`) or transitively through factory
+ * return-call edges. Symbols whose chain yields ≥2 distinct types (or stays unresolved)
+ * are omitted.
+ *
+ * @param {object[]} chunks  Chunks carrying `name`, `return_type`, and the transient
+ *                           `_return_via` ({type}|{viaCall}) from extractReturnVia.
+ * @returns {Map<string,string>} nameLower → resolved type name.
+ */
+export function resolveReturnTypes(chunks) {
+    const symRet = new Map();   // nameLower → typeName | CONFLICT
+    const edges = new Map();    // nameLower → Set<calleeLower>  (only for symbols with no direct type)
+
+    const seed = (nm, type) => {
+        const prev = symRet.get(nm);
+        if (prev === CONFLICT) return;
+        if (prev === undefined) symRet.set(nm, type);
+        else if (prev !== type) symRet.set(nm, CONFLICT);
+    };
+
+    for (const c of chunks) {
+        if (!c.name || c.name === 'anonymous') continue;
+        const nm = c.name.toLowerCase();
+        const via = c._return_via;
+        const annot = singleTypeName(c.return_type);
+        // Direct type wins over the edge: annotation and/or `return new X()`.
+        let directType = annot || (via && via.type) || null;
+        if (annot && via && via.type && annot !== via.type) { symRet.set(nm, CONFLICT); directType = null; }
+        if (directType) {
+            seed(nm, directType);
+        } else if (via && via.viaCall) {
+            const callee = via.viaCall.toLowerCase();
+            if (!edges.has(nm)) edges.set(nm, new Set());
+            edges.get(nm).add(callee);
+        }
+    }
+
+    const sortedEdgeKeys = [...edges.keys()].sort();
+    for (let iter = 0; iter < MAX_ITERS; iter++) {
+        let changed = false;
+        for (const sym of sortedEdgeKeys) {
+            if (symRet.has(sym)) continue; // already resolved (or conflict)
+            let resolved = null, conflict = false;
+            for (const callee of [...edges.get(sym)].sort()) {
+                const ct = symRet.get(callee);
+                if (ct === undefined || ct === CONFLICT) continue;
+                if (resolved === null) resolved = ct;
+                else if (resolved !== ct) conflict = true;
+            }
+            if (conflict) { symRet.set(sym, CONFLICT); changed = true; }
+            else if (resolved !== null) { symRet.set(sym, resolved); changed = true; }
+        }
+        if (!changed) break;
+    }
+
+    const out = new Map();
+    for (const [nm, t] of symRet) if (t !== CONFLICT && typeof t === 'string') out.set(nm, t);
+    return out;
+}
+
+/**
+ * Run the fixpoint over a chunk list and annotate each factory-receiver call site with the
+ * resolved `recv_resolved_type`; strip the transient `_return_via` so it never serializes.
+ * Mutates chunks in place and returns them.
+ *
+ * @param {object[]} chunks
+ * @returns {object[]} the same array
+ */
+export function applyInterprocedural(chunks) {
+    const symRet = resolveReturnTypes(chunks);
+    for (const c of chunks) {
+        if (Array.isArray(c.call_sites)) {
+            for (const s of c.call_sites) {
+                // Only fill in what intra-procedural inference left unresolved.
+                if (s && !s.recv_type && s.recv_via_call) {
+                    const t = symRet.get(String(s.recv_via_call).toLowerCase());
+                    if (t) s.recv_resolved_type = t;
+                }
+            }
+        }
+        if ('_return_via' in c) delete c._return_via;
+    }
+    return chunks;
+}