@zuvia-software-solutions/code-mapper 1.4.0 → 2.0.0

package/dist/core/ingestion/call-processor.js

@@ -5,10 +5,12 @@ import { TIER_CONFIDENCE } from './resolution-context.js';
 import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
 import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
 import { generateId } from '../../lib/utils.js';
+import { toNodeId, toEdgeId } from '../db/schema.js';
 import { getLanguageFromFilename, isVerboseIngestionEnabled, yieldToEventLoop, FUNCTION_NODE_TYPES, extractFunctionName, isBuiltInOrNoise, countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, findEnclosingClassId, CALL_EXPRESSION_TYPES, extractCallChain, } from './utils.js';
 import { buildTypeEnv } from './type-env.js';
 import { getTreeSitterBufferSize } from './constants.js';
 import { callRouters } from './call-routing.js';
+import path from 'node:path';
 /** Walk up the AST to find the enclosing function/method, or null for top-level code */
 const findEnclosingFunction = (node, filePath, ctx) => {
     let current = node.parent;
@@ -18,7 +20,9 @@ const findEnclosingFunction = (node, filePath, ctx) => {
             if (funcName) {
                 const resolved = ctx.resolve(funcName, filePath);
                 if (resolved?.tier === 'same-file' && resolved.candidates.length > 0) {
-                    return resolved.candidates[0].nodeId;
+                    const first = resolved.candidates[0];
+                    if (first)
+                        return first.nodeId;
                 }
                 return generateId(label, `${filePath}:${funcName}`);
             }
@@ -46,7 +50,7 @@ const verifyConstructorBindings = (bindings, filePath, ctx, graph) => {
                     const narrowed = callableDefs.filter(d => {
                         if (!d.ownerId)
                             return false;
-                        const owner = graph.getNode(d.ownerId);
+                        const owner = graph.getNode(toNodeId(d.ownerId));
                         return owner?.properties.name === receiverClassName;
                     });
                     if (narrowed.length > 0)
@@ -63,8 +67,9 @@ const verifyConstructorBindings = (bindings, filePath, ctx, graph) => {
                     }
                 }
             }
-            if (callableDefs && callableDefs.length === 1 && callableDefs[0].returnType) {
-                const typeName = extractReturnTypeName(callableDefs[0].returnType);
+            const singleDef = callableDefs && callableDefs.length === 1 ? callableDefs[0] : undefined;
+            if (singleDef && singleDef.returnType) {
+                const typeName = extractReturnTypeName(singleDef.returnType);
                 if (typeName) {
                     verified.set(receiverKey(scope, varName), typeName);
                 }
@@ -105,6 +110,8 @@ export const processCalls = async (graph, files, astCache, ctx, onProgress) => {
     const skippedByLang = logSkipped ? new Map() : null;
     for (let i = 0; i < files.length; i++) {
         const file = files[i];
+        if (!file)
+            continue;
         onProgress?.(i + 1, files.length);
         if (i % 20 === 0)
             await yieldToEventLoop();
@@ -190,15 +197,16 @@ export const processCalls = async (graph, files, astCache, ctx, onProgress) => {
                                 },
                             });
                             ctx.symbols.add(file.path, item.propName, nodeId, 'Property', propEnclosingClassId ? { ownerId: propEnclosingClassId } : undefined);
-                            const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
+                            const relId = toEdgeId(`DEFINES:${fileId}->${nodeId}`);
                             graph.addRelationship({
                                 id: relId, sourceId: fileId, targetId: nodeId,
                                 type: 'DEFINES', confidence: 1.0, reason: '',
                             });
                             if (propEnclosingClassId) {
+                                const ownerNodeId = toNodeId(propEnclosingClassId);
                                 graph.addRelationship({
-                                    id: generateId('HAS_METHOD', `${propEnclosingClassId}->${nodeId}`),
-                                    sourceId: propEnclosingClassId, targetId: nodeId,
+                                    id: toEdgeId(`HAS_METHOD:${propEnclosingClassId}->${nodeId}`),
+                                    sourceId: ownerNodeId, targetId: nodeId,
                                     type: 'HAS_METHOD', confidence: 1.0, reason: '',
                                 });
                             }
@@ -239,7 +247,7 @@ export const processCalls = async (graph, files, astCache, ctx, onProgress) => {
                                     const importedName = child.text;
                                     if (importedName && !isBuiltInOrNoise(importedName)) {
                                         const enclosingFuncId = findEnclosingFunction(callNode, file.path, ctx);
-                                        const sourceId = enclosingFuncId || generateId('File', file.path);
+                                        const sourceId = enclosingFuncId ? toNodeId(enclosingFuncId) : generateId('File', file.path);
                                         // Try module-scoped resolution first: extract the target filename
                                         // from the import path and look up the name in that file
                                         let targetId = null;
@@ -261,16 +269,19 @@ export const processCalls = async (graph, files, astCache, ctx, onProgress) => {
                                         if (!targetId) {
                                             const resolved = ctx.resolve(importedName, file.path);
                                             if (resolved && resolved.candidates.length > 0) {
-                                                targetId = resolved.candidates[0].nodeId;
-                                                confidence = Math.max(TIER_CONFIDENCE[resolved.tier] ?? 0.5, 0.8);
-                                                reason = `dynamic-import:${resolved.tier}`;
+                                                const firstCandidate = resolved.candidates[0];
+                                                if (firstCandidate) {
+                                                    targetId = firstCandidate.nodeId;
+                                                    confidence = Math.max(TIER_CONFIDENCE[resolved.tier] ?? 0.5, 0.8);
+                                                    reason = `dynamic-import:${resolved.tier}`;
+                                                }
                                             }
                                         }
                                         if (targetId) {
                                             graph.addRelationship({
-                                                id: generateId('CALLS', `${sourceId}:dyn_import:${importedName}->${targetId}`),
+                                                id: toEdgeId(`CALLS:${sourceId}:dyn_import:${importedName}->${targetId}`),
                                                 sourceId,
-                                                targetId,
+                                                targetId: toNodeId(targetId),
                                                 type: 'CALLS',
                                                 confidence,
                                                 reason,
@@ -336,22 +347,28 @@ export const processCalls = async (graph, files, astCache, ctx, onProgress) => {
             const GENERIC_MEMBER_METHODS = new Set(['has', 'get', 'set', 'add', 'remove', 'delete', 'close', 'stop', 'clear', 'reset', 'toString', 'valueOf', 'push', 'pop', 'entries', 'keys', 'values']);
             if (callForm === 'member' && !receiverTypeName && GENERIC_MEMBER_METHODS.has(calledName))
                 return;
-            const resolved = resolveCallTarget({
-                calledName,
-                argCount: countCallArguments(callNode),
-                callForm,
-                receiverTypeName,
-            }, file.path, ctx);
+            const argCount = countCallArguments(callNode);
+            const callInfo = { calledName };
+            if (argCount !== undefined)
+                callInfo.argCount = argCount;
+            if (callForm !== undefined)
+                callInfo.callForm = callForm;
+            if (receiverTypeName !== undefined)
+                callInfo.receiverTypeName = receiverTypeName;
+            const resolved = resolveCallTarget(callInfo, file.path, ctx);
             if (!resolved)
                 return;
             const enclosingFuncId = findEnclosingFunction(callNode, file.path, ctx);
-            const sourceId = enclosingFuncId || generateId('File', file.path);
-            const relId = generateId('CALLS', `${sourceId}:${calledName}->${resolved.nodeId}`);
+            const sourceId = enclosingFuncId ? toNodeId(enclosingFuncId) : generateId('File', file.path);
+            // Suppress self-referencing edges from unresolved method chains
+            if (sourceId === toNodeId(resolved.nodeId) && callForm === 'member' && !receiverTypeName)
+                return;
+            const relId = toEdgeId(`CALLS:${sourceId}:${calledName}->${resolved.nodeId}`);
             const callContext = isInsideCatch(callNode) ? 'error-handler' : isInsideConditional(callNode) ? 'conditional' : '';
             graph.addRelationship({
                 id: relId,
                 sourceId,
-                targetId: resolved.nodeId,
+                targetId: toNodeId(resolved.nodeId),
                 type: 'CALLS',
                 confidence: resolved.confidence,
                 reason: callContext || resolved.reason,
@@ -387,13 +404,15 @@ export const processCalls = async (graph, files, astCache, ctx, onProgress) => {
                                             const importedName = child.text;
                                             if (importedName && !isBuiltInOrNoise(importedName)) {
                                                 const enclosingFuncId = findEnclosingFunction(node, file.path, ctx);
-                                                const sourceId = enclosingFuncId || generateId('File', file.path);
+                                                const sourceId = enclosingFuncId ? toNodeId(enclosingFuncId) : generateId('File', file.path);
                                                 const resolved = ctx.resolve(importedName, file.path);
-                                                if (resolved && resolved.candidates.length > 0) {
+                                                const firstResolved = resolved && resolved.candidates.length > 0 ? resolved.candidates[0] : undefined;
+                                                if (firstResolved) {
+                                                    const targetNodeId = toNodeId(firstResolved.nodeId);
                                                     graph.addRelationship({
-                                                        id: generateId('CALLS', `${sourceId}:dyn:${importedName}->${resolved.candidates[0].nodeId}`),
+                                                        id: toEdgeId(`CALLS:${sourceId}:dyn:${importedName}->${targetNodeId}`),
                                                         sourceId,
-                                                        targetId: resolved.candidates[0].nodeId,
+                                                        targetId: targetNodeId,
                                                         type: 'CALLS',
                                                         confidence: 0.85,
                                                         reason: 'dynamic-import',
@@ -476,7 +495,10 @@ const toResolveResult = (definition, tier) => ({
 function resolveChainedReceiver(chainNames, baseReceiverTypeName, currentFile, ctx) {
     let currentType = baseReceiverTypeName;
     for (const name of chainNames) {
-        const resolved = resolveCallTarget({ calledName: name, callForm: 'member', receiverTypeName: currentType }, currentFile, ctx);
+        const chainCallInfo = { calledName: name, callForm: 'member' };
+        if (currentType !== undefined)
+            chainCallInfo.receiverTypeName = currentType;
+        const resolved = resolveCallTarget(chainCallInfo, currentFile, ctx);
         if (!resolved)
             return undefined;
         const candidates = ctx.symbols.lookupFuzzy(name);
@@ -516,14 +538,16 @@ const resolveCallTarget = (call, currentFile, ctx) => {
                 : filteredCandidates;
             // D3. File-based: prefer candidates in the resolved type's file
             const fileFiltered = methodPool.filter(c => typeFiles.has(c.filePath));
-            if (fileFiltered.length === 1) {
-                return toResolveResult(fileFiltered[0], tiered.tier);
+            const firstFileFiltered = fileFiltered.length === 1 ? fileFiltered[0] : undefined;
+            if (firstFileFiltered) {
+                return toResolveResult(firstFileFiltered, tiered.tier);
             }
             // D4. ownerId fallback: narrow by ownerId matching type's nodeId
             const pool = fileFiltered.length > 0 ? fileFiltered : methodPool;
             const ownerFiltered = pool.filter(c => c.ownerId && typeNodeIds.has(c.ownerId));
-            if (ownerFiltered.length === 1) {
-                return toResolveResult(ownerFiltered[0], tiered.tier);
+            const firstOwnerFiltered = ownerFiltered.length === 1 ? ownerFiltered[0] : undefined;
+            if (firstOwnerFiltered) {
+                return toResolveResult(firstOwnerFiltered, tiered.tier);
             }
             if (fileFiltered.length > 1 || ownerFiltered.length > 1)
                 return null;
@@ -534,13 +558,17 @@ const resolveCallTarget = (call, currentFile, ctx) => {
     // Deduplicate by nodeId — the same symbol can appear multiple times from different resolution paths
     if (filteredCandidates.length > 1) {
         const uniqueById = new Map(filteredCandidates.map(c => [c.nodeId, c]));
-        if (uniqueById.size === 1) {
-            return toResolveResult(filteredCandidates[0], tiered.tier);
+        const firstUnique = uniqueById.size === 1 ? filteredCandidates[0] : undefined;
+        if (firstUnique) {
+            return toResolveResult(firstUnique, tiered.tier);
         }
         // Multiple distinct candidates — ambiguous, skip
         return null;
     }
-    return toResolveResult(filteredCandidates[0], tiered.tier);
+    const firstCandidate = filteredCandidates[0];
+    if (!firstCandidate)
+        return null;
+    return toResolveResult(firstCandidate, tiered.tier);
 };
 // Return type text helpers
 // Operates on raw return-type text in SymbolDefinition (e.g. "User", "Promise<User>",
@@ -612,15 +640,19 @@ export const extractReturnTypeName = (raw, depth = 0) => {
     // Handle union types ("User | null" -> "User")
     if (text.includes('|')) {
         const parts = text.split('|').map(p => p.trim()).filter(p => p !== 'null' && p !== 'undefined' && p !== 'void' && p !== 'None' && p !== 'nil');
-        if (parts.length === 1)
-            text = parts[0];
+        const singlePart = parts.length === 1 ? parts[0] : undefined;
+        if (singlePart)
+            text = singlePart;
         else
             return undefined; // genuine union, too complex
     }
     // Handle generics (Promise<User> -> unwrap if wrapper, else take base)
     const genericMatch = text.match(/^(\w+)\s*<(.+)>$/);
     if (genericMatch) {
-        const [, base, args] = genericMatch;
+        const base = genericMatch[1];
+        const args = genericMatch[2];
+        if (!base || !args)
+            return undefined;
         if (WRAPPER_GENERICS.has(base)) {
             // Take the first non-lifetime type argument using bracket-balanced splitting
             const firstArg = extractFirstTypeArg(args);
@@ -634,7 +666,10 @@ export const extractReturnTypeName = (raw, depth = 0) => {
         return undefined;
     // Handle qualified names (models.User -> User, Models::User -> User)
     if (text.includes('::') || text.includes('.') || text.includes('\\')) {
-        text = text.split(/::|[.\\]/).pop();
+        const lastSegment = text.split(/::|[.\\]/).pop();
+        if (!lastSegment)
+            return undefined;
+        text = lastSegment;
     }
     // Skip primitives
     if (PRIMITIVE_TYPES.has(text) || PRIMITIVE_TYPES.has(text.toLowerCase()))
@@ -649,8 +684,6 @@ export const extractReturnTypeName = (raw, depth = 0) => {
 // Source IDs: "Label:filepath:funcName" (parse-worker.ts)
 // NUL (\0) separates composite keys to prevent ambiguous concatenation
 // receiverKey uses full scope to distinguish overloaded methods (e.g. User.save@100 vs Repo.save@200)
-/** Extract function name from a scope key ("funcName@startIndex" -> "funcName") */
-const extractFuncNameFromScope = (scope) => scope.slice(0, scope.indexOf('@'));
 /** Extract trailing function name from a sourceId ("Function:filepath:funcName" -> "funcName") */
 const extractFuncNameFromSourceId = (sourceId) => {
     const lastColon = sourceId.lastIndexOf(':');
@@ -694,8 +727,128 @@ const lookupReceiverType = (map, funcName, varName) => {
     // Fallback: file-level scope
     return map.get(fileLevelKey);
 };
+/** Check if a file is TypeScript or JavaScript (extensions tsgo can handle) */
+function isTypeScriptOrJavaScript(filePath) {
+    return /\.(ts|tsx|js|jsx|mts|mjs|cts|cjs)$/.test(filePath);
+}
+/**
+ * Batch-resolve call sites via tsgo LSP before heuristic resolution.
+ *
+ * For each TS/JS call with line+column info, asks tsgo for go-to-definition.
+ * Returns a Map from callKey -> ResolveResult for calls that tsgo resolved.
+ *
+ * Call key format: "sourceId\0calledName\0callLine" — unique per call site.
+ */
+async function batchResolveTsgo(tsgoService, extractedCalls, ctx, graph, repoPath) {
+    const results = new Map();
+    // Collect eligible calls (TS/JS files with line+column info)
+    const eligible = [];
+    for (const call of extractedCalls) {
+        if (isTypeScriptOrJavaScript(call.filePath) &&
+            call.callLine !== undefined &&
+            call.callColumn !== undefined) {
+            eligible.push(call);
+        }
+    }
+    if (eligible.length === 0)
+        return results;
+    // Group calls by file — process one file at a time so tsgo only needs
+    // one file hot in memory. LSP is sequential over stdio, so concurrent
+    // requests just create a queue that causes timeouts.
+    const byFile = new Map();
+    for (const call of eligible) {
+        let list = byFile.get(call.filePath);
+        if (!list) {
+            list = [];
+            byFile.set(call.filePath, list);
+        }
+        list.push(call);
+    }
+    let resolved = 0;
+    let failed = 0;
+    const t0 = Date.now();
+    console.error(`Code Mapper: tsgo resolving ${eligible.length} calls across ${byFile.size} files...`);
+    for (const [filePath, calls] of byFile) {
+        const absFilePath = path.resolve(repoPath, filePath);
+        // Resolve all calls in this file sequentially
+        for (const call of calls) {
+            try {
+                const def = await tsgoService.resolveDefinition(absFilePath, call.callLine - 1, call.callColumn);
+                if (!def) {
+                    failed++;
+                    continue;
+                }
+                const targetSymbols = ctx.symbols.lookupAllInFile(def.filePath);
+                if (targetSymbols.length === 0) {
+                    failed++;
+                    continue;
+                }
+                // Match by exact startLine, then by range containment
+                let bestMatch;
+                for (const sym of targetSymbols) {
+                    const node = graph.getNode(toNodeId(sym.nodeId));
+                    if (node && node.properties.startLine === def.line) {
+                        bestMatch = sym;
+                        break;
+                    }
+                }
+                if (!bestMatch) {
+                    for (const sym of targetSymbols) {
+                        const node = graph.getNode(toNodeId(sym.nodeId));
+                        if (node) {
+                            const sl = node.properties.startLine;
+                            const el = node.properties.endLine;
+                            if (sl !== undefined && el !== undefined && def.line >= sl && def.line <= el) {
+                                bestMatch = sym;
+                                break;
+                            }
+                        }
+                    }
+                }
+                if (bestMatch) {
+                    // Drop self-referencing tsgo edges: these come from property access
+                    // on parameters (req.params, res.json) that tsgo resolves back to
+                    // the enclosing function's definition. Legitimate recursion is captured
+                    // by the heuristic path (free-form calls to the function's own name).
+                    if (bestMatch.nodeId === call.sourceId) {
+                        failed++;
+                        continue;
+                    }
+                    const callKey = `${call.sourceId}\0${call.calledName}\0${call.callLine}`;
+                    results.set(callKey, {
+                        nodeId: bestMatch.nodeId,
+                        confidence: TIER_CONFIDENCE['tsgo-resolved'],
+                        reason: 'tsgo-lsp',
+                    });
+                    resolved++;
+                }
+                else {
+                    failed++;
+                }
+            }
+            catch {
+                failed++;
+            }
+        }
+    }
+    const elapsed = Date.now() - t0;
+    console.error(`Code Mapper: tsgo resolved ${resolved}/${eligible.length} calls in ${elapsed}ms (${failed} unresolvable)`);
+    return results;
+}
+/** Generic method names that produce false edges when receiver type is unknown (worker-extracted path) */
+const GENERIC_MEMBER_METHODS_WORKER = new Set([
+    'has', 'get', 'set', 'add', 'remove', 'delete', 'close', 'stop', 'clear', 'reset',
+    'toString', 'valueOf', 'push', 'pop', 'entries', 'keys', 'values',
+    'all', 'any', 'race', 'resolve', 'reject', // Promise methods
+    'map', 'filter', 'reduce', 'forEach', 'find', 'some', 'every', 'includes', // Array methods
+    'then', 'catch', 'finally', // Promise chain
+    'next', 'return', 'throw', // Iterator
+    'emit', 'on', 'off', 'once', 'subscribe', 'unsubscribe', // EventEmitter
+    'log', 'warn', 'error', 'info', 'debug', // Console
+    'json', 'text', 'blob', 'status', 'send', 'end', // HTTP response
+]);
 /** Resolve pre-extracted call sites from workers (no AST parsing needed) */
-export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onProgress, constructorBindings) => {
+export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onProgress, constructorBindings, tsgoService, repoPath) => {
     // Scope-aware receiver types keyed by filePath -> scope\0varName -> typeName
     const fileReceiverTypes = new Map();
     if (constructorBindings) {
@@ -715,6 +868,11 @@ export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onPr
         }
         list.push(call);
     }
+    // Batch pre-resolve via tsgo LSP (highest confidence, TS/JS only)
+    let tsgoResolved;
+    if (tsgoService?.isReady() && repoPath) {
+        tsgoResolved = await batchResolveTsgo(tsgoService, extractedCalls, ctx, graph, repoPath);
+    }
     const totalFiles = byFile.size;
     let filesProcessed = 0;
     for (const [filePath, calls] of byFile) {
@@ -758,19 +916,172 @@ export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onPr
                     effectiveCall = { ...effectiveCall, receiverTypeName: chainedType };
                 }
             }
-            const resolved = resolveCallTarget(effectiveCall, effectiveCall.filePath, ctx);
+            // Skip generic method names on unknown receivers (matches sequential path filter)
+            // Prevents false edges like Promise.all() → bookingKeys.all()
+            if (effectiveCall.callForm === 'member' && !effectiveCall.receiverTypeName && GENERIC_MEMBER_METHODS_WORKER.has(effectiveCall.calledName)) {
+                continue;
+            }
+            // Check tsgo pre-resolved map first (highest confidence)
+            let resolved;
+            if (tsgoResolved && effectiveCall.callLine !== undefined) {
+                const callKey = `${effectiveCall.sourceId}\0${effectiveCall.calledName}\0${effectiveCall.callLine}`;
+                resolved = tsgoResolved.get(callKey);
+            }
+            // Fall through to heuristic resolution if tsgo didn't resolve
+            if (!resolved) {
+                resolved = resolveCallTarget(effectiveCall, effectiveCall.filePath, ctx);
+            }
+            // RC-I: Interface dispatch — when receiver type is an Interface, find implementations.
+            // Strategy 1: Classes with IMPLEMENTS edges to the interface.
+            // Strategy 2: Factory functions whose return type matches the interface name.
+            // Covers both class-based and closure-based (factory pattern) implementations.
+            if (!resolved && effectiveCall.callForm === 'member' && effectiveCall.receiverTypeName) {
+                const receiverResolved = ctx.resolve(effectiveCall.receiverTypeName, effectiveCall.filePath);
+                if (receiverResolved) {
+                    const interfaceDefs = receiverResolved.candidates.filter(d => d.type === 'Interface' || d.type === 'Trait');
+                    if (interfaceDefs.length > 0) {
+                        for (const ifaceDef of interfaceDefs) {
+                            // Strategy 1: Class-based — find IMPLEMENTS edges
+                            const implRows = graph.relationships.filter(r => r.type === 'IMPLEMENTS' && r.targetId === toNodeId(ifaceDef.nodeId));
+                            for (const implRel of implRows) {
+                                const methodEdges = graph.relationships.filter(r => r.type === 'HAS_METHOD' && r.sourceId === implRel.sourceId);
+                                for (const methodEdge of methodEdges) {
+                                    const methodNode = graph.getNode(methodEdge.targetId);
+                                    if (methodNode && methodNode.properties.name === effectiveCall.calledName) {
+                                        resolved = { nodeId: methodEdge.targetId, confidence: 0.85, reason: 'interface-dispatch' };
+                                        break;
+                                    }
+                                }
+                                if (resolved)
+                                    break;
+                            }
+                            if (resolved)
+                                break;
+                            // Strategy 2: Factory/closure pattern — find functions returning this interface
+                            // e.g. createEventBus(): EventBus → the closure has emit/subscribe as inner functions
+                            // Look for the method name in files that import the interface's file
+                            if (!resolved) {
+                                const methodName = effectiveCall.calledName;
+                                const ifaceFile = ifaceDef.filePath;
+                                // Check: which files import the interface's file?
+                                const importingFiles = [];
+                                for (const [file, importedFiles] of ctx.importMap) {
+                                    if (importedFiles.has(ifaceFile)) {
+                                        importingFiles.push(file);
+                                    }
+                                }
+                                // Also check the interface's own file
+                                importingFiles.push(ifaceFile);
+                                for (const file of importingFiles) {
+                                    const method = ctx.symbols.lookupExactFull(file, methodName);
+                                    if (method && (method.type === 'Function' || method.type === 'Method')) {
+                                        resolved = { nodeId: method.nodeId, confidence: 0.75, reason: 'interface-factory-dispatch' };
+                                        break;
+                                    }
+                                }
+                            }
+                            if (resolved)
+                                break;
+                        }
+                    }
+                }
+            }
+            // RC-G: ORM chain recognition — for member chains like prisma.booking.findMany(),
+            // match the model name against entity classes (e.g. "Booking", "BookingEntity").
+            // Requires: (1) terminal method is a known ORM operation, (2) base receiver is a known ORM client name.
+            // Both gates prevent false positives from generic chains like filePath.includes().
+            if (!resolved && effectiveCall.callForm === 'member' && effectiveCall.receiverCallChain?.length) {
+                const ORM_METHODS = new Set([
+                    'findMany', 'findFirst', 'findUnique', 'findUniqueOrThrow', 'findFirstOrThrow',
+                    'create', 'createMany', 'update', 'updateMany', 'upsert', 'deleteMany',
+                    'count', 'aggregate', 'groupBy', // Prisma
+                    'findOne', 'findOneBy', 'findAndCount', 'save', 'softDelete',
+                    'createQueryBuilder', // TypeORM
+                    '$queryRaw', '$executeRaw', // Prisma raw
+                    'bulkCreate', 'bulkUpdate', 'findAll', 'findByPk', // Sequelize
+                ]);
+                // Known ORM client variable names — the base of the chain must match
+                const ORM_CLIENTS = new Set([
+                    'prisma', 'db', 'knex', 'sequelize', 'typeorm', 'orm',
+                    'repo', 'repository', 'em', 'entityManager', 'dataSource',
+                    'connection', 'pool', 'client',
+                ]);
+                // Extract the base receiver from the chain (the outermost object)
+                // For prisma.booking.findMany: receiverCallChain=['booking'], receiverName might be undefined
+                // but the chain's base should be 'prisma'
+                const chainBase = effectiveCall.receiverCallChain[0];
+                const baseReceiver = effectiveCall.receiverName?.toLowerCase();
+                const isOrmChain = (baseReceiver && ORM_CLIENTS.has(baseReceiver))
+                    || (chainBase && ORM_CLIENTS.has(chainBase.toLowerCase()));
+                if (isOrmChain && ORM_METHODS.has(effectiveCall.calledName)) {
+                    // The model name is the intermediate chain element (e.g. "booking" from prisma.booking.findMany)
+                    const modelName = effectiveCall.receiverCallChain.length > 0
+                        ? effectiveCall.receiverCallChain[effectiveCall.receiverCallChain.length - 1]
+                        : effectiveCall.receiverName;
+                    if (modelName && modelName.length > 2) {
+                        const capitalized = modelName.charAt(0).toUpperCase() + modelName.slice(1);
+                        const allEntityCandidates = ctx.symbols.lookupFuzzy(capitalized)
+                            .filter(d => d.type === 'Class' || d.type === 'Interface' || d.type === 'Struct');
+                        // Prefer entities sharing the closest common ancestor directory
+                        // e.g. cross-boundary/server/src/services/ calling → cross-boundary/server/src/models/ (same project)
+                        // but NOT → lang-resolution/ruby-calls/ (different project)
+                        const callerParts = effectiveCall.filePath.split('/');
+                        const entityCandidates = allEntityCandidates.filter(d => {
+                            const entityParts = d.filePath.split('/');
+                            // Require at least 4 shared path segments — no fallback to global.
+                            // A missing match is better than a false cross-project match.
+                            let shared = 0;
+                            for (let i = 0; i < Math.min(callerParts.length, entityParts.length); i++) {
+                                if (callerParts[i] === entityParts[i])
+                                    shared++;
+                                else
+                                    break;
+                            }
+                            return shared >= 4;
+                        });
+                        if (entityCandidates.length === 1) {
+                            resolved = {
+                                nodeId: entityCandidates[0].nodeId,
+                                confidence: 0.7,
+                                reason: 'orm-entity-match',
+                            };
+                        }
+                        else if (entityCandidates.length === 0) {
+                            const entitySuffix = ctx.symbols.lookupFuzzy(capitalized + 'Entity')
+                                .filter(d => d.type === 'Class');
+                            if (entitySuffix.length === 1) {
+                                resolved = {
+                                    nodeId: entitySuffix[0].nodeId,
+                                    confidence: 0.7,
+                                    reason: 'orm-entity-match',
+                                };
+                            }
+                        }
+                    }
+                }
+            }
             if (!resolved)
                 continue;
-            const relId = generateId('CALLS', `${effectiveCall.sourceId}:${effectiveCall.calledName}->${resolved.nodeId}`);
-            graph.addRelationship({
+            // Suppress self-referencing edges from unresolved method chains
+            // (e.g. db('table').select().where() falsely resolving chain methods to the enclosing function)
+            // Preserve legitimate recursion: only suppress member calls with no resolved receiver type
+            const sourceNodeId = toNodeId(effectiveCall.sourceId);
+            const targetNodeId = toNodeId(resolved.nodeId);
+            if (sourceNodeId === targetNodeId && effectiveCall.callForm === 'member' && !effectiveCall.receiverTypeName) {
+                continue;
+            }
+            const relId = toEdgeId(`CALLS:${effectiveCall.sourceId}:${effectiveCall.calledName}->${resolved.nodeId}`);
+            const rel = {
                 id: relId,
-                sourceId: effectiveCall.sourceId,
-                targetId: resolved.nodeId,
+                sourceId: sourceNodeId,
+                targetId: targetNodeId,
                 type: 'CALLS',
                 confidence: resolved.confidence,
                 reason: resolved.reason,
-                callLine: effectiveCall.callLine,
-            });
+            };
+            if (effectiveCall.callLine !== undefined)
+                rel.callLine = effectiveCall.callLine;
+            graph.addRelationship(rel);
         }
         ctx.clearCache();
     }
@@ -780,6 +1091,8 @@ export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onPr
 export const processRoutesFromExtracted = async (graph, extractedRoutes, ctx, onProgress) => {
     for (let i = 0; i < extractedRoutes.length; i++) {
         const route = extractedRoutes[i];
+        if (!route)
+            continue;
         if (i % 50 === 0) {
             onProgress?.(i, extractedRoutes.length);
             await yieldToEventLoop();
@@ -792,13 +1105,16 @@ export const processRoutesFromExtracted = async (graph, extractedRoutes, ctx, on
         if (controllerResolved.tier === 'global' && controllerResolved.candidates.length > 1)
             continue;
         const controllerDef = controllerResolved.candidates[0];
+        if (!controllerDef)
+            continue;
         const confidence = TIER_CONFIDENCE[controllerResolved.tier];
         const methodResolved = ctx.resolve(route.methodName, controllerDef.filePath);
-        const methodId = methodResolved?.tier === 'same-file' ? methodResolved.candidates[0]?.nodeId : undefined;
+        const firstMethodCandidate = methodResolved?.tier === 'same-file' ? methodResolved.candidates[0] : undefined;
+        const methodId = firstMethodCandidate?.nodeId;
         const sourceId = generateId('File', route.filePath);
         if (!methodId) {
             const guessedId = generateId('Method', `${controllerDef.filePath}:${route.methodName}`);
-            const relId = generateId('CALLS', `${sourceId}:route->${guessedId}`);
+            const relId = toEdgeId(`CALLS:${sourceId}:route->${guessedId}`);
             graph.addRelationship({
                 id: relId,
                 sourceId,
@@ -809,11 +1125,11 @@ export const processRoutesFromExtracted = async (graph, extractedRoutes, ctx, on
             });
             continue;
         }
-        const relId = generateId('CALLS', `${sourceId}:route->${methodId}`);
+        const relId = toEdgeId(`CALLS:${sourceId}:route->${methodId}`);
         graph.addRelationship({
             id: relId,
             sourceId,
-            targetId: methodId,
+            targetId: toNodeId(methodId),
             type: 'CALLS',
             confidence,
             reason: 'laravel-route',
@@ -868,9 +1184,9 @@ export const createDependsOnEdges = async (graph, ctx) => {
                 continue;
             seen.add(edgeKey);
             graph.addRelationship({
-                id: generateId('DEPENDS_ON', edgeKey),
-                sourceId: symDef.ownerId,
-                targetId: target.nodeId,
+                id: toEdgeId(`DEPENDS_ON:${edgeKey}`),
+                sourceId: toNodeId(symDef.ownerId),
+                targetId: toNodeId(target.nodeId),
                 type: 'DEPENDS_ON',
                 confidence: TIER_CONFIDENCE[resolved.tier],
                 reason: 'constructor-injection',
@@ -895,14 +1211,16 @@ export const createProvidesEdges = async (graph, ctx) => {
     const candidates = [];
     graph.forEachNode(n => {
         if ((n.label === 'Method' || n.label === 'Function') && n.properties.returnType) {
-            candidates.push({
+            const entry = {
                 id: n.id,
                 filePath: n.properties.filePath,
                 returnType: n.properties.returnType,
                 startLine: n.properties.startLine ?? 0,
                 endLine: n.properties.endLine ?? 0,
-                frameworkReason: n.properties.astFrameworkReason,
-            });
+            };
+            if (n.properties.astFrameworkReason !== undefined)
+                entry.frameworkReason = n.properties.astFrameworkReason;
+            candidates.push(entry);
         }
     });
     for (const node of candidates) {
@@ -924,9 +1242,9 @@ export const createProvidesEdges = async (graph, ctx) => {
         if (bodyLength > 20 && !isDIAnnotated)
             continue;
         graph.addRelationship({
-            id: generateId('PROVIDES', `${node.id}->${interfaceTarget.nodeId}`),
+            id: toEdgeId(`PROVIDES:${node.id}->${interfaceTarget.nodeId}`),
             sourceId: node.id,
-            targetId: interfaceTarget.nodeId,
+            targetId: toNodeId(interfaceTarget.nodeId),
             type: 'PROVIDES',
             confidence: TIER_CONFIDENCE[resolved.tier] * 0.9,
             reason: 'factory-return-type',
@@ -935,3 +1253,73 @@ export const createProvidesEdges = async (graph, ctx) => {
     }
     return edgesCreated;
 };
+/**
+ * Post-pass: connect interface method DECLARATIONS to their IMPLEMENTATIONS.
+ *
+ * For each interface Method node (e.g. EventBus.emit), find the matching
+ * implementation Function in files that import the interface definition.
+ * Creates CALLS edges: InterfaceMethod → ImplementationFunction.
+ *
+ * This makes the call chain traversable:
+ *   register() →[tsgo]→ EventBus.emit (Method) →[dispatch]→ emit (Function in event-bus.ts)
+ */
+export const resolveInterfaceDispatches = async (graph, ctx) => {
+    let edgesCreated = 0;
+    const seen = new Set();
+    // Step 1: Find all interface/trait Method nodes (via HAS_METHOD edges)
+    const ifaceMethods = [];
+    graph.forEachRelationship(rel => {
+        if (rel.type !== 'HAS_METHOD')
+            return;
+        const parentNode = graph.getNode(rel.sourceId);
+        if (!parentNode || (parentNode.label !== 'Interface' && parentNode.label !== 'Trait'))
+            return;
+        const methodNode = graph.getNode(rel.targetId);
+        if (!methodNode)
+            return;
+        ifaceMethods.push({
+            methodId: rel.targetId,
+            methodName: methodNode.properties.name,
+            ifaceFile: parentNode.properties.filePath,
+        });
+    });
+    // Step 2: For each interface method, find implementation in files that import the interface
+    for (const ifaceMethod of ifaceMethods) {
+        const implFiles = [];
+        const ifaceFileBase = ifaceMethod.ifaceFile.replace(/\.[^.]+$/, '');
+        for (const [file, importedFiles] of ctx.importMap) {
+            // Check exact match OR suffix match (import paths may differ in extension)
+            let found = importedFiles.has(ifaceMethod.ifaceFile);
+            if (!found) {
+                for (const imp of importedFiles) {
+                    if (imp.replace(/\.[^.]+$/, '') === ifaceFileBase || imp.endsWith(ifaceFileBase) || ifaceFileBase.endsWith(imp.replace(/\.[^.]+$/, ''))) {
+                        found = true;
+                        break;
+                    }
+                }
+            }
+            if (found)
+                implFiles.push(file);
+        }
+        for (const implFile of implFiles) {
+            // Look for a Function with the same name in the implementation file
+            const implSym = ctx.symbols.lookupExactFull(implFile, ifaceMethod.methodName);
+            if (!implSym || (implSym.type !== 'Function' && implSym.type !== 'Method'))
+                continue;
+            const edgeKey = `${ifaceMethod.methodId}->${implSym.nodeId}`;
+            if (seen.has(edgeKey))
+                continue;
+            seen.add(edgeKey);
+            graph.addRelationship({
+                id: toEdgeId(`CALLS:iface-dispatch:${edgeKey}`),
+                sourceId: toNodeId(ifaceMethod.methodId),
+                targetId: toNodeId(implSym.nodeId),
+                type: 'CALLS',
+                confidence: 0.80,
+                reason: 'interface-dispatch',
+            });
+            edgesCreated++;
+        }
+    }
+    return edgesCreated;
+};