gitnexus 1.5.2 → 1.6.0

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

@@ -1,22 +1,76 @@
+import { CLASS_TYPES, CALL_TARGET_TYPES } from './model/symbol-table.js';
 import Parser from 'tree-sitter';
-import { TIER_CONFIDENCE } from './resolution-context.js';
+import { TIER_CONFIDENCE } from './model/resolution-context.js';
 import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
 import { getProvider } from './languages/index.js';
 import { generateId } from '../../lib/utils.js';
-import { getLanguageFromFilename } from '../../_shared/index.js';
+import { getLanguageFromFilename, SupportedLanguages } from '../../_shared/index.js';
 import { isVerboseIngestionEnabled } from './utils/verbose.js';
 import { yieldToEventLoop } from './utils/event-loop.js';
-import { FUNCTION_NODE_TYPES, extractFunctionName, findEnclosingClassId, } from './utils/ast-helpers.js';
+import { FUNCTION_NODE_TYPES, findEnclosingClassId, findEnclosingClassInfo, genericFuncName, inferFunctionLabel, } from './utils/ast-helpers.js';
+import { typeTagForId, constTagForId, buildCollisionGroups } from './utils/method-props.js';
 import { countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, extractMixedChain, extractCallArgTypes, } from './utils/call-analysis.js';
 import { buildTypeEnv, isSubclassOf } from './type-env.js';
-import { resolveExtendsType } from './heritage-processor.js';
 import { getTreeSitterBufferSize } from './constants.js';
 import { normalizeFetchURL, routeMatches } from './route-extractors/nextjs.js';
+import { extractTemplateComponents } from './vue-sfc-extractor.js';
 import { extractReturnTypeName, stripNullable } from './type-extractors/shared.js';
+import { extractParsedCallSite } from './call-sites/extract-language-call-site.js';
+import { lookupMethodByOwnerWithMRO } from './model/resolve.js';
+/**
+ * Type labels treated as class-like **method-dispatch receivers** by the call
+ * resolver — the set walked by the MRO / heritage path for member and static
+ * method calls.
+ *
+ * Derived from `CLASS_TYPES` (the heritage-index set in symbol-table) plus
+ * `Impl` — Rust `impl` blocks are the definition site of methods for a struct
+ * and must be walkable as receiver-type candidates even though they are not
+ * indexed by `lookupClassByName` (which keys off struct/trait names). Keeping
+ * this set a strict superset of `CLASS_TYPES` guarantees that anything
+ * reachable via `lookupClassByName` also passes this filter, so the two call
+ * paths cannot diverge silently.
+ *
+ * `Interface` is included even though interfaces cannot be directly
+ * instantiated in Java/C#/TypeScript: the resolver still needs to reach
+ * interface nodes for static-method dispatch (`Interface.staticMethod()`) and
+ * default-method resolution via the MRO walker.
+ *
+ * **Do not reuse this set for constructor-fallback filtering.** Constructors
+ * can only instantiate a narrower subset — see `INSTANTIABLE_CLASS_TYPES`
+ * below. `resolveStaticCall`'s step-5 class-node fallback uses the narrower
+ * set to prevent false `CALLS` edges from constructor-shaped calls to
+ * `Interface`, `Trait`, or `Impl` nodes.
+ */
+const CLASS_LIKE_TYPES = new Set([...CLASS_TYPES, 'Impl']);
+/**
+ * Type labels that can be the target of a constructor-shaped call when no
+ * explicit `Constructor` symbol is indexed — the "return the type itself as
+ * the call target" fallback set.
+ *
+ * Strict subset of both `CLASS_LIKE_TYPES` and `CONSTRUCTOR_TARGET_TYPES`.
+ * Excludes:
+ *   - `Interface` / `Trait` — not instantiable by definition in any
+ *     supported language.
+ *   - `Impl` — Rust `impl` blocks are method-definition containers, not
+ *     the type itself; the owning `Struct` is the correct target.
+ *   - `Enum` — excluded pending language-specific support with motivating
+ *     test fixtures (matches `CONSTRUCTOR_TARGET_TYPES`).
+ *
+ * Used exclusively by `resolveStaticCall`'s step-5 class-node fallback.
+ * Keep in sync with `CONSTRUCTOR_TARGET_TYPES` (which additionally contains
+ * `'Constructor'` for explicit-constructor-node filtering) when extending.
+ */
+const INSTANTIABLE_CLASS_TYPES = new Set(['Class', 'Struct', 'Record']);
 const MAX_EXPORTS_PER_FILE = 500;
 const MAX_TYPE_NAME_LENGTH = 256;
 /** Build a map of imported callee names → return types for cross-file call-result binding.
- *  Consulted ONLY when SymbolTable has no unambiguous local match (local-first principle). */
+ *  Consulted ONLY when SymbolTable has no unambiguous local match (local-first principle).
+ *
+ *  Overlapping mechanism (1 of 3): this is the SymbolTable-backed path.
+ *  See also:
+ *    2. collectExportedBindings (~line 168) / enrichExportedTypeMap — TypeEnv + graph isExported
+ *    3. Phase 9 fallback in verifyConstructorBindings (~line 563) — namedImportMap + BindingAccumulator
+ *  A future cleanup should merge these into a single resolution pass. */
 export function buildImportedReturnTypes(filePath, namedImportMap, symbolTable) {
     const result = new Map();
     const fileImports = namedImportMap.get(filePath);
@@ -50,7 +104,20 @@ export function buildImportedRawReturnTypes(filePath, namedImportMap, symbolTabl
     return result;
 }
 /** Collect resolved type bindings for exported file-scope symbols.
- *  Uses graph node isExported flag — does NOT require isExported on SymbolDefinition. */
+ *  Uses graph node isExported flag — does NOT require isExported on SymbolDefinition.
+ *
+ *  **Counterpart**: the worker path populates `exportedTypeMap` via the
+ *  accumulator enrichment loop in `pipeline.ts` (search for "Worker path
+ *  quality enrichment"). Both sites populate the same map with subtly
+ *  different export-check semantics — this site uses SymbolTable +
+ *  graph lookup, the worker loop uses three-candidate-ID graph lookup.
+ *  They must stay in sync until unified. If you edit one, check the other.
+ *
+ *  Overlapping mechanism (2 of 3): this is the TypeEnv + graph isExported path.
+ *  See also:
+ *    1. buildImportedReturnTypes (~line 109) — namedImportMap + SymbolTable
+ *    3. Phase 9 fallback in verifyConstructorBindings (~line 563) — namedImportMap + BindingAccumulator
+ *  A future cleanup should merge these into a single resolution pass. */
 function collectExportedBindings(typeEnv, filePath, symbolTable, graph) {
     const fileScope = typeEnv.fileScope();
     if (!fileScope || fileScope.size === 0)
@@ -85,8 +152,10 @@ export function buildExportedTypeMapFromGraph(graph, symbolTable) {
         const name = node.properties.name;
         if (!name || name.length > MAX_TYPE_NAME_LENGTH)
             return;
-        // For callable symbols, use returnType; for properties/variables, use declaredType
-        const def = symbolTable.lookupExactFull(filePath, name);
+        // For callable symbols, use returnType; for properties/variables, use declaredType.
+        // Use lookupExactAll + nodeId match to handle same-name methods in different classes.
+        const defs = symbolTable.lookupExactAll(filePath, name);
+        const def = defs.find((d) => d.nodeId === node.id) ?? defs[0];
         if (!def)
             return;
         const typeName = def.returnType ?? def.declaredType;
@@ -156,6 +225,10 @@ const TYPE_PRESERVING_METHODS = new Set([
     'get', // Kotlin/Java Optional.get()
     'orElseThrow', // Java Optional
 ]);
+/** Cache for method extraction results in findEnclosingFunction fallback path.
+ *  Keyed by classNode.id to avoid re-extracting the same class body per call site.
+ *  Cleared between files at line ~611 in the processCalls file loop. */
+const enclosingFnExtractCache = new Map();
 /**
  * Walk up the AST from a node to find the enclosing function/method.
  * Returns null if the call is at module/file level (top-level code).
@@ -164,20 +237,100 @@ const findEnclosingFunction = (node, filePath, ctx, provider) => {
     let current = node.parent;
     while (current) {
         if (FUNCTION_NODE_TYPES.has(current.type)) {
-            const { funcName, label } = extractFunctionName(current);
+            const efnResult = provider.methodExtractor?.extractFunctionName?.(current);
+            const funcName = efnResult?.funcName ?? genericFuncName(current);
+            const label = efnResult?.label ?? inferFunctionLabel(current.type);
             if (funcName) {
                 const resolved = ctx.resolve(funcName, filePath);
                 if (resolved?.tier === 'same-file' && resolved.candidates.length > 0) {
-                    return resolved.candidates[0].nodeId;
+                    // Disambiguate by enclosing class when multiple candidates
+                    if (resolved.candidates.length === 1) {
+                        return resolved.candidates[0].nodeId;
+                    }
+                    const classInfo = findEnclosingClassInfo(current, filePath);
+                    if (classInfo) {
+                        const classMatches = resolved.candidates.filter((c) => c.ownerId === classInfo.classId);
+                        // Unique class match — return it (no same-arity ambiguity)
+                        if (classMatches.length === 1)
+                            return classMatches[0].nodeId;
+                        // Multiple same-class candidates (same-arity overloads) — fall through
+                        // to the fallback path which computes the exact ID with type-hash.
+                        if (classMatches.length > 1) {
+                            /* fall through to manual ID construction below */
+                        }
+                        else {
+                            // No class match — return first candidate as before
+                            return resolved.candidates[0].nodeId;
+                        }
+                    }
+                    else {
+                        return resolved.candidates[0].nodeId;
+                    }
                 }
-                // Apply labelOverride so label matches the definition phase (single source of truth).
+                // Fallback: qualify the generated ID to match definition-phase node IDs
                 let finalLabel = label;
                 if (provider.labelOverride) {
                     const override = provider.labelOverride(current, label);
                     if (override !== null)
                         finalLabel = override;
                 }
-                return generateId(finalLabel, `${filePath}:${funcName}`);
+                const classInfo2 = findEnclosingClassInfo(current, filePath);
+                const qualifiedName = classInfo2 ? `${classInfo2.className}.${funcName}` : funcName;
+                // Include #<arity> and ~typeTag suffix to match definition-phase Method/Constructor IDs.
+                const language = getLanguageFromFilename(filePath);
+                let arity;
+                let encTypeTag = '';
+                if ((finalLabel === 'Method' || finalLabel === 'Constructor') &&
+                    provider.methodExtractor &&
+                    language) {
+                    // Get class method map (cached per classNode.id) and look up current method
+                    // by funcName:line. This avoids per-call-site extractFromNode AST walks.
+                    let classNode = current.parent;
+                    while (classNode && !provider.methodExtractor.isTypeDeclaration(classNode)) {
+                        classNode = classNode.parent;
+                    }
+                    let info;
+                    if (classNode) {
+                        let extracted = enclosingFnExtractCache.get(classNode.id);
+                        if (extracted === undefined) {
+                            extracted =
+                                provider.methodExtractor.extract(classNode, { filePath, language }) ?? null;
+                            enclosingFnExtractCache.set(classNode.id, extracted);
+                        }
+                        if (extracted?.methods?.length) {
+                            const defLine = current.startPosition.row + 1;
+                            info = extracted.methods.find((m) => m.name === funcName && m.line === defLine);
+                            if (info) {
+                                arity = info.parameters.some((p) => p.isVariadic)
+                                    ? undefined
+                                    : info.parameters.length;
+                            }
+                            if (arity !== undefined && info) {
+                                const methodMap = new Map();
+                                for (const m of extracted.methods)
+                                    methodMap.set(`${m.name}:${m.line}`, m);
+                                const groups = buildCollisionGroups(methodMap);
+                                encTypeTag =
+                                    typeTagForId(methodMap, funcName, arity, info, language, groups) +
+                                        constTagForId(methodMap, funcName, arity, info, groups);
+                            }
+                        }
+                    }
+                    // Fallback: extractFromNode for top-level methods without a class
+                    if (!info && provider.methodExtractor.extractFromNode) {
+                        const nodeInfo = provider.methodExtractor.extractFromNode(current, {
+                            filePath,
+                            language,
+                        });
+                        if (nodeInfo) {
+                            arity = nodeInfo.parameters.some((p) => p.isVariadic)
+                                ? undefined
+                                : nodeInfo.parameters.length;
+                        }
+                    }
+                }
+                const arityTag = arity !== undefined ? `#${arity}${encTypeTag}` : '';
+                return generateId(finalLabel, `${filePath}:${qualifiedName}${arityTag}`);
             }
         }
         // Language-specific enclosing function resolution (e.g., Dart where
@@ -185,10 +338,26 @@ const findEnclosingFunction = (node, filePath, ctx, provider) => {
         if (provider.enclosingFunctionFinder) {
             const customResult = provider.enclosingFunctionFinder(current);
             if (customResult) {
-                // Try SymbolTable first (same pattern as the FUNCTION_NODE_TYPES branch above).
                 const resolved = ctx.resolve(customResult.funcName, filePath);
                 if (resolved?.tier === 'same-file' && resolved.candidates.length > 0) {
-                    return resolved.candidates[0].nodeId;
+                    if (resolved.candidates.length === 1) {
+                        return resolved.candidates[0].nodeId;
+                    }
+                    const classInfo = findEnclosingClassInfo(current.previousSibling ?? current, filePath);
+                    if (classInfo) {
+                        const classMatches = resolved.candidates.filter((c) => c.ownerId === classInfo.classId);
+                        if (classMatches.length === 1)
+                            return classMatches[0].nodeId;
+                        if (classMatches.length > 1) {
+                            /* fall through to manual ID construction below */
+                        }
+                        else {
+                            return resolved.candidates[0].nodeId;
+                        }
+                    }
+                    else {
+                        return resolved.candidates[0].nodeId;
+                    }
                 }
                 let finalLabel = customResult.label;
                 if (provider.labelOverride) {
@@ -196,7 +365,63 @@ const findEnclosingFunction = (node, filePath, ctx, provider) => {
                     if (override !== null)
                         finalLabel = override;
                 }
-                return generateId(finalLabel, `${filePath}:${customResult.funcName}`);
+                const classInfo2 = findEnclosingClassInfo(current.previousSibling ?? current, filePath);
+                const qualifiedName = classInfo2
+                    ? `${classInfo2.className}.${customResult.funcName}`
+                    : customResult.funcName;
+                // Include #<arity> and ~typeTag suffix to match definition-phase Method/Constructor IDs.
+                const sigNode = current.previousSibling ?? current;
+                const language2 = getLanguageFromFilename(filePath);
+                let arity2;
+                let encTypeTag2 = '';
+                if ((finalLabel === 'Method' || finalLabel === 'Constructor') &&
+                    provider.methodExtractor &&
+                    language2) {
+                    let classNode2 = (current.previousSibling ?? current).parent;
+                    while (classNode2 && !provider.methodExtractor.isTypeDeclaration(classNode2)) {
+                        classNode2 = classNode2.parent;
+                    }
+                    let info2;
+                    if (classNode2) {
+                        let extracted2 = enclosingFnExtractCache.get(classNode2.id);
+                        if (extracted2 === undefined) {
+                            extracted2 =
+                                provider.methodExtractor.extract(classNode2, { filePath, language: language2 }) ??
+                                    null;
+                            enclosingFnExtractCache.set(classNode2.id, extracted2);
+                        }
+                        if (extracted2?.methods?.length) {
+                            const defLine2 = sigNode.startPosition.row + 1;
+                            info2 = extracted2.methods.find((m) => m.name === customResult.funcName && m.line === defLine2);
+                            if (info2) {
+                                arity2 = info2.parameters.some((p) => p.isVariadic)
+                                    ? undefined
+                                    : info2.parameters.length;
+                            }
+                            if (arity2 !== undefined && info2) {
+                                const methodMap = new Map();
+                                for (const m of extracted2.methods)
+                                    methodMap.set(`${m.name}:${m.line}`, m);
+                                const groups2 = buildCollisionGroups(methodMap);
+                                encTypeTag2 =
+                                    typeTagForId(methodMap, customResult.funcName, arity2, info2, language2, groups2) + constTagForId(methodMap, customResult.funcName, arity2, info2, groups2);
+                            }
+                        }
+                    }
+                    if (!info2 && provider.methodExtractor.extractFromNode) {
+                        const nodeInfo = provider.methodExtractor.extractFromNode(sigNode, {
+                            filePath,
+                            language: language2,
+                        });
+                        if (nodeInfo) {
+                            arity2 = nodeInfo.parameters.some((p) => p.isVariadic)
+                                ? undefined
+                                : nodeInfo.parameters.length;
+                        }
+                    }
+                }
+                const arityTag2 = arity2 !== undefined ? `#${arity2}${encTypeTag2}` : '';
+                return generateId(finalLabel, `${filePath}:${qualifiedName}${arityTag2}`);
             }
         }
         current = current.parent;
@@ -207,7 +432,7 @@ const findEnclosingFunction = (node, filePath, ctx, provider) => {
  * Verify constructor bindings against SymbolTable and infer receiver types.
  * Shared between sequential (processCalls) and worker (processCallsFromExtracted) paths.
  */
-const verifyConstructorBindings = (bindings, filePath, ctx, graph) => {
+const verifyConstructorBindings = (bindings, filePath, ctx, graph, bindingAccumulator) => {
     const verified = new Map();
     for (const { scope, varName, calleeName, receiverClassName } of bindings) {
         const tiered = ctx.resolve(calleeName, filePath);
@@ -242,74 +467,66 @@ const verifyConstructorBindings = (bindings, filePath, ctx, graph) => {
                     }
                 }
             }
+            let typeName;
             if (callableDefs && callableDefs.length === 1 && callableDefs[0].returnType) {
-                const typeName = extractReturnTypeName(callableDefs[0].returnType);
-                if (typeName) {
-                    verified.set(receiverKey(scope, varName), typeName);
-                }
+                typeName = extractReturnTypeName(callableDefs[0].returnType);
             }
-        }
-    }
-    return verified;
-};
-/**
- * Build an ImplementorMap from extracted heritage data.
- * Only direct `implements` relationships are tracked (transitive not needed for
- * the common Java/Kotlin/C# interface dispatch pattern).
- * `extends` is ignored — dispatch keyed on abstract class bases is not modeled here.
- */
-/**
- * Maps interface name → file paths of classes that implement it (direct only).
- * When `ctx` is set, `kind: 'extends'` rows are classified like heritage-processor
- * (C#/Java base_list: class vs interface parents share one capture name).
- */
-export const buildImplementorMap = (heritage, ctx) => {
-    const map = new Map();
-    for (const h of heritage) {
-        let record = false;
-        if (h.kind === 'implements') {
-            record = true;
-        }
-        else if (h.kind === 'extends' && ctx) {
-            const lang = getLanguageFromFilename(h.filePath);
-            if (lang) {
-                const { type } = resolveExtendsType(h.parentName, h.filePath, ctx, lang);
-                record = type === 'IMPLEMENTS';
+            // Phase 9: BindingAccumulator fallback for cross-file return types.
+            // Used when the SymbolTable has no return type for a cross-file callee
+            // (e.g., a return type that TypeEnv resolved via fixpoint in the source
+            // file but was not stored as a SymbolTable returnType annotation).
+            // namedImportMap tells us which source file exported the callee so we
+            // can look up its file-scope binding via the O(1) fileScopeGet method.
+            //
+            // Tier gating: only fall back to the accumulator when resolution is
+            // unambiguously import-scoped or global. When tiered.tier is 'same-file',
+            // the local definition is authoritative even without a return type
+            // annotation — using the accumulator here would let an imported callee
+            // with the same name shadow the local one, producing false CALLS edges.
+            // When multiple callable candidates exist, the accumulator would pick
+            // arbitrarily — skip to avoid fabricated edges.
+            //
+            // Quality note: worker-path accumulator entries are Tier 0/1 only
+            // (annotation-declared + same-file constructor inference) — see the
+            // BindingAccumulator class JSDoc. For large repos where the worker
+            // path dominates, Phase 9 binding accuracy is structurally lower
+            // than for sequential-path repos where Tier 2 cross-file propagation
+            // is available.
+            //
+            // Overlapping mechanism note: this is one of three cross-file
+            // return-type resolution paths in the codebase:
+            //   1. buildImportedReturnTypes (~line 109) — namedImportMap +
+            //      SymbolTable.lookupExactFull (structure-processor captured)
+            //   2. collectExportedBindings (~line 168) / enrichExportedTypeMap
+            //      — TypeEnv + graph isExported flag
+            //   3. This fallback — namedImportMap + BindingAccumulator
+            // A future cleanup should merge these into a single resolution pass.
+            const shouldFallback = tiered?.tier !== 'same-file' && (!callableDefs || callableDefs.length <= 1);
+            if (!typeName && bindingAccumulator && shouldFallback) {
+                const namedImports = ctx.namedImportMap.get(filePath);
+                const importBinding = namedImports?.get(calleeName);
+                if (importBinding) {
+                    const rawType = bindingAccumulator.fileScopeGet(importBinding.sourcePath, importBinding.exportedName);
+                    if (rawType) {
+                        typeName = extractReturnTypeName(rawType);
+                    }
+                }
             }
-        }
-        if (record) {
-            let files = map.get(h.parentName);
-            if (!files) {
-                files = new Set();
-                map.set(h.parentName, files);
+            if (typeName) {
+                verified.set(receiverKey(scope, varName), typeName);
             }
-            files.add(h.filePath);
-        }
-    }
-    return map;
-};
-/**
- * Merge a chunk's implementor map into the global accumulator.
- */
-export const mergeImplementorMaps = (target, source) => {
-    for (const [name, files] of source) {
-        let existing = target.get(name);
-        if (!existing) {
-            existing = new Set();
-            target.set(name, existing);
         }
-        for (const f of files)
-            existing.add(f);
     }
+    return verified;
 };
 /**
  * After resolving a call to an interface method, find additional targets
  * in classes implementing that interface. Returns implementation method
  * results with lower confidence ('interface-dispatch').
  */
-function findInterfaceDispatchTargets(calledName, receiverTypeName, currentFile, ctx, implementorMap, primaryNodeId) {
-    const implFiles = implementorMap.get(receiverTypeName);
-    if (!implFiles || implFiles.size === 0)
+function findInterfaceDispatchTargets(calledName, receiverTypeName, currentFile, ctx, heritageMap, primaryNodeId) {
+    const implFiles = heritageMap.getImplementorFiles(receiverTypeName);
+    if (implFiles.size === 0)
         return [];
     const typeResolved = ctx.resolve(receiverTypeName, currentFile);
     if (!typeResolved)
@@ -318,7 +535,7 @@ function findInterfaceDispatchTargets(calledName, receiverTypeName, currentFile,
         return [];
     const results = [];
     for (const implFile of implFiles) {
-        const methods = ctx.symbols.lookupExactAll(implFile, calledName);
+        const methods = ctx.model.symbols.lookupExactAll(implFile, calledName);
         for (const method of methods) {
             if (method.nodeId !== primaryNodeId) {
                 results.push({
@@ -338,7 +555,7 @@ importedBindingsMap,
  *  Consulted ONLY when SymbolTable has no unambiguous match (local-first principle). */
 importedReturnTypesMap, 
 /** Phase 14 E3: cross-file RAW return types for for-loop element extraction. Keyed by filePath → Map<calleeName, rawReturnType>. */
-importedRawReturnTypesMap, implementorMap) => {
+importedRawReturnTypesMap, heritageMap, bindingAccumulator) => {
     const parser = await loadParser();
     const collectedHeritage = [];
     const pendingWrites = [];
@@ -350,9 +567,9 @@ importedRawReturnTypesMap, implementorMap) => {
     const globalParentSeen = new Map();
     const logSkipped = isVerboseIngestionEnabled();
     const skippedByLang = logSkipped ? new Map() : null;
+    const prepared = [];
     for (let i = 0; i < files.length; i++) {
         const file = files[i];
-        onProgress?.(i + 1, files.length);
         if (i % 20 === 0)
             await yieldToEventLoop();
         const language = getLanguageFromFilename(file.path);
@@ -381,18 +598,17 @@ importedRawReturnTypesMap, implementorMap) => {
             }
             astCache.set(file.path, tree);
         }
-        let query;
         let matches;
         try {
-            const language = parser.getLanguage();
-            query = new Parser.Query(language, queryStr);
+            const lang = parser.getLanguage();
+            const query = new Parser.Query(lang, queryStr);
             matches = query.matches(tree.rootNode);
         }
         catch (queryError) {
             console.warn(`Query error for ${file.path}:`, queryError);
             continue;
         }
-        // Pre-pass: extract heritage from query matches to build parentMap for buildTypeEnv.
+        // Extract heritage from query matches to build parentMap for buildTypeEnv.
         // Heritage-processor runs in PARALLEL, so graph edges don't exist when buildTypeEnv runs.
         const fileParentMap = new Map();
         for (const match of matches) {
@@ -416,7 +632,6 @@ importedRawReturnTypesMap, implementorMap) => {
         }
         const parentMap = fileParentMap;
         // Merge per-file heritage into globalParentMap for cross-file isSubclassOf lookups.
-        // Uses a parallel Set (globalParentSeen) for O(1) deduplication instead of O(n) includes().
         for (const [cls, parents] of fileParentMap) {
             let global = globalParentMap.get(cls);
             let seen = globalParentSeen.get(cls);
@@ -439,21 +654,38 @@ importedRawReturnTypesMap, implementorMap) => {
         const importedReturnTypes = importedReturnTypesMap?.get(file.path);
         const importedRawReturnTypes = importedRawReturnTypesMap?.get(file.path);
         const typeEnv = buildTypeEnv(tree, language, {
-            symbolTable: ctx.symbols,
+            model: ctx.model,
             parentMap,
             importedBindings,
             importedReturnTypes,
             importedRawReturnTypes,
             enclosingFunctionFinder: provider?.enclosingFunctionFinder,
+            extractFunctionName: provider?.methodExtractor?.extractFunctionName,
         });
         if (typeEnv && exportedTypeMap) {
-            const fileExports = collectExportedBindings(typeEnv, file.path, ctx.symbols, graph);
+            const fileExports = collectExportedBindings(typeEnv, file.path, ctx.model.symbols, graph);
             if (fileExports)
                 exportedTypeMap.set(file.path, fileExports);
         }
+        if (bindingAccumulator) {
+            typeEnv.flush(file.path, bindingAccumulator);
+        }
+        prepared.push({ file, language, provider, tree, matches, parentMap, typeEnv });
+    }
+    // ── Resolution loop: verify constructor bindings and resolve calls ──
+    // The accumulator (if present) is now fully populated from the preparation
+    // loop above, so verifyConstructorBindings sees all provider bindings
+    // regardless of file processing order.
+    for (let i = 0; i < prepared.length; i++) {
+        const { file, language, provider, tree, matches, parentMap, typeEnv } = prepared[i];
+        enclosingFnExtractCache.clear();
+        onProgress?.(i + 1, files.length);
+        if (i % 20 === 0)
+            await yieldToEventLoop();
         const callRouter = provider.callRouter;
         const verifiedReceivers = typeEnv.constructorBindings.length > 0
-            ? verifyConstructorBindings(typeEnv.constructorBindings, file.path, ctx)
+            ? verifyConstructorBindings(typeEnv.constructorBindings, file.path, ctx, undefined, // graph not available on the sequential path here
+            bindingAccumulator)
             : new Map();
         const receiverIndex = buildReceiverTypeIndex(verifiedReceivers);
         ctx.enableCache(file.path);
@@ -481,12 +713,7 @@ importedRawReturnTypesMap, implementorMap) => {
                 }
                 if (!receiverTypeName && receiverText) {
                     const resolved = ctx.resolve(receiverText, file.path);
-                    if (resolved?.candidates.some((d) => d.type === 'Class' ||
-                        d.type === 'Struct' ||
-                        d.type === 'Interface' ||
-                        d.type === 'Enum' ||
-                        d.type === 'Record' ||
-                        d.type === 'Impl')) {
+                    if (resolved?.candidates.some((d) => CLASS_LIKE_TYPES.has(d.type))) {
                         receiverTypeName = receiverText;
                     }
                 }
@@ -505,6 +732,54 @@ importedRawReturnTypesMap, implementorMap) => {
             }
             if (!captureMap['call'])
                 return;
+            const callNode = captureMap['call'];
+            const languageSeed = extractParsedCallSite(language, callNode);
+            if (languageSeed) {
+                if (provider.isBuiltInName(languageSeed.calledName))
+                    return;
+                const sourceId = findEnclosingFunction(callNode, file.path, ctx, provider) ||
+                    generateId('File', file.path);
+                const receiverName = languageSeed.callForm === 'member' ? languageSeed.receiverName : undefined;
+                let receiverTypeName = receiverName && typeEnv ? typeEnv.lookup(receiverName, callNode) : undefined;
+                if (receiverName !== undefined &&
+                    receiverTypeName === undefined &&
+                    languageSeed.callForm === 'member' &&
+                    (language === 'java' || language === 'csharp' || language === 'kotlin')) {
+                    const c0 = receiverName.charCodeAt(0);
+                    if (c0 >= 65 && c0 <= 90)
+                        receiverTypeName = receiverName;
+                }
+                const resolved = resolveCallTarget({
+                    calledName: languageSeed.calledName,
+                    callForm: languageSeed.callForm,
+                    ...(receiverTypeName !== undefined ? { receiverTypeName } : {}),
+                    ...(receiverName !== undefined ? { receiverName } : {}),
+                }, file.path, ctx, undefined, widenCache, undefined, heritageMap);
+                if (!resolved)
+                    return;
+                graph.addRelationship({
+                    id: generateId('CALLS', `${sourceId}:${languageSeed.calledName}->${resolved.nodeId}`),
+                    sourceId,
+                    targetId: resolved.nodeId,
+                    type: 'CALLS',
+                    confidence: resolved.confidence,
+                    reason: resolved.reason,
+                });
+                if (heritageMap && languageSeed.callForm === 'member' && receiverTypeName) {
+                    const implTargets = findInterfaceDispatchTargets(languageSeed.calledName, receiverTypeName, file.path, ctx, heritageMap, resolved.nodeId);
+                    for (const impl of implTargets) {
+                        graph.addRelationship({
+                            id: generateId('CALLS', `${sourceId}:${languageSeed.calledName}->${impl.nodeId}`),
+                            sourceId,
+                            targetId: impl.nodeId,
+                            type: 'CALLS',
+                            confidence: impl.confidence,
+                            reason: impl.reason,
+                        });
+                    }
+                }
+                return;
+            }
             const nameNode = captureMap['call.name'];
             if (!nameNode)
                 return;
@@ -543,7 +818,7 @@ importedRawReturnTypesMap, implementorMap) => {
                                     description: item.accessorType,
                                 },
                             });
-                            ctx.symbols.add(file.path, item.propName, nodeId, 'Property', {
+                            ctx.model.symbols.add(file.path, item.propName, nodeId, 'Property', {
                                 ...(propEnclosingClassId ? { ownerId: propEnclosingClassId } : {}),
                                 ...(item.declaredType ? { declaredType: item.declaredType } : {}),
                             });
@@ -575,7 +850,6 @@ importedRawReturnTypesMap, implementorMap) => {
             }
             if (provider.isBuiltInName(calledName))
                 return;
-            const callNode = captureMap['call'];
             const callForm = inferCallForm(callNode, nameNode);
             const receiverName = callForm === 'member' ? extractReceiverName(nameNode) : undefined;
             let receiverTypeName = receiverName && typeEnv ? typeEnv.lookup(receiverName, callNode) : undefined;
@@ -591,7 +865,7 @@ importedRawReturnTypesMap, implementorMap) => {
                 let p = callNode.parent;
                 while (p) {
                     if (FUNCTION_NODE_TYPES.has(p.type)) {
-                        const { funcName } = extractFunctionName(p);
+                        const funcName = provider.methodExtractor?.extractFunctionName?.(p)?.funcName ?? genericFuncName(p);
                         if (funcName) {
                             scope = `${funcName}@${p.startIndex}`;
                             break;
@@ -611,12 +885,8 @@ importedRawReturnTypesMap, implementorMap) => {
                     // not compile if Sub didn't extend Base.
                     if (isSubclassOf(ctorType, receiverTypeName, parentMap) ||
                         isSubclassOf(ctorType, receiverTypeName, globalParentMap) ||
-                        (ctx.symbols
-                            .lookupFuzzy(ctorType)
-                            .some((d) => d.type === 'Class' || d.type === 'Struct') &&
-                            ctx.symbols
-                                .lookupFuzzy(receiverTypeName)
-                                .some((d) => d.type === 'Class' || d.type === 'Struct' || d.type === 'Interface'))) {
+                        (ctx.model.types.lookupClassByName(ctorType).length > 0 &&
+                            ctx.model.types.lookupClassByName(receiverTypeName).length > 0)) {
                         receiverTypeName = ctorType;
                     }
                 }
@@ -668,7 +938,7 @@ importedRawReturnTypesMap, implementorMap) => {
                             }
                         }
                         if (currentType) {
-                            receiverTypeName = walkMixedChain(extracted.chain, currentType, file.path, ctx, makeAccessEmitter(graph, sourceId));
+                            receiverTypeName = walkMixedChain(extracted.chain, currentType, file.path, ctx, makeAccessEmitter(graph, sourceId), heritageMap);
                         }
                     }
                 }
@@ -685,7 +955,7 @@ importedRawReturnTypesMap, implementorMap) => {
                 callForm,
                 receiverTypeName,
                 receiverName,
-            }, file.path, ctx, hints, widenCache);
+            }, file.path, ctx, hints, widenCache, undefined, heritageMap);
             if (!resolved)
                 return;
             const relId = generateId('CALLS', `${sourceId}:${calledName}->${resolved.nodeId}`);
@@ -697,8 +967,8 @@ importedRawReturnTypesMap, implementorMap) => {
                 confidence: resolved.confidence,
                 reason: resolved.reason,
             });
-            if (implementorMap && callForm === 'member' && receiverTypeName) {
-                const implTargets = findInterfaceDispatchTargets(calledName, receiverTypeName, file.path, ctx, implementorMap, resolved.nodeId);
+            if (heritageMap && callForm === 'member' && receiverTypeName) {
+                const implTargets = findInterfaceDispatchTargets(calledName, receiverTypeName, file.path, ctx, heritageMap, resolved.nodeId);
                 for (const impl of implTargets) {
                     graph.addRelationship({
                         id: generateId('CALLS', `${sourceId}:${calledName}->${impl.nodeId}`),
@@ -711,6 +981,39 @@ importedRawReturnTypesMap, implementorMap) => {
                 }
             }
         });
+        // Vue: emit CALLS edges for PascalCase components used in <template>.
+        // Template components are default-imported (not named), so we match the
+        // component name against imported .vue file basenames via the import map.
+        if (language === SupportedLanguages.Vue) {
+            const templateComponents = extractTemplateComponents(file.content);
+            if (templateComponents.length > 0) {
+                const fileId = generateId('File', file.path);
+                const importedFiles = ctx.importMap.get(file.path);
+                if (importedFiles) {
+                    for (const componentName of templateComponents) {
+                        for (const importedPath of importedFiles) {
+                            if (!importedPath.endsWith('.vue'))
+                                continue;
+                            const basename = importedPath.slice(importedPath.lastIndexOf('/') + 1, importedPath.lastIndexOf('.'));
+                            if (basename !== componentName)
+                                continue;
+                            const targetFileId = generateId('File', importedPath);
+                            if (graph.getNode(targetFileId)) {
+                                graph.addRelationship({
+                                    id: generateId('CALLS', `${fileId}:${componentName}->${targetFileId}`),
+                                    sourceId: fileId,
+                                    targetId: targetFileId,
+                                    type: 'CALLS',
+                                    confidence: 0.9,
+                                    reason: 'vue-template-component',
+                                });
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+        }
         ctx.clearCache();
     }
     // ── Resolve deferred write-access edges ──
@@ -735,7 +1038,7 @@ importedRawReturnTypesMap, implementorMap) => {
     }
     return collectedHeritage;
 };
-const CALLABLE_SYMBOL_TYPES = new Set(['Function', 'Method', 'Constructor', 'Macro', 'Delegate']);
+// FREE_CALLABLE_TYPES imported from symbol-table.ts — single source of truth.
 const CONSTRUCTOR_TARGET_TYPES = new Set(['Constructor', 'Class', 'Struct', 'Record']);
 const filterCallableCandidates = (candidates, argCount, callForm) => {
     let kindFiltered;
@@ -747,11 +1050,15 @@ const filterCallableCandidates = (candidates, argCount, callForm) => {
         else {
             const types = candidates.filter((c) => CONSTRUCTOR_TARGET_TYPES.has(c.type));
             kindFiltered =
-                types.length > 0 ? types : candidates.filter((c) => CALLABLE_SYMBOL_TYPES.has(c.type));
+                types.length > 0 ? types : candidates.filter((c) => CALL_TARGET_TYPES.has(c.type));
         }
     }
     else {
-        kindFiltered = candidates.filter((c) => CALLABLE_SYMBOL_TYPES.has(c.type));
+        // CALL_TARGET_TYPES (not FREE_CALLABLE_TYPES) — the post-A4 filter must
+        // also admit Method and Constructor candidates, which are now unioned
+        // into the pool from `model.methods.lookupMethodByName` rather than
+        // `symbols.lookupCallableByName`.
+        kindFiltered = candidates.filter((c) => CALL_TARGET_TYPES.has(c.type));
     }
     if (kindFiltered.length === 0)
         return [];
@@ -764,6 +1071,33 @@ const filterCallableCandidates = (candidates, argCount, callForm) => {
         (argCount >= (candidate.requiredParameterCount ?? candidate.parameterCount) &&
             argCount <= candidate.parameterCount));
 };
+/**
+ * Count callable candidates matching the kind + arity filter without
+ * allocating an intermediate array. Short-circuits once count exceeds
+ * `threshold` (default 1) — used by the dispatcher's `skipMember` check
+ * where we only need to know "more than one survivor".
+ */
+const countCallableCandidates = (candidates, argCount, callForm, threshold = 1) => {
+    let count = 0;
+    for (const c of candidates) {
+        // Kind filter (mirrors filterCallableCandidates)
+        const typeOk = callForm === 'constructor'
+            ? CONSTRUCTOR_TARGET_TYPES.has(c.type)
+            : CALL_TARGET_TYPES.has(c.type);
+        if (!typeOk)
+            continue;
+        // Arity filter
+        if (argCount !== undefined &&
+            c.parameterCount !== undefined &&
+            (argCount < (c.requiredParameterCount ?? c.parameterCount) || argCount > c.parameterCount)) {
+            continue;
+        }
+        count++;
+        if (count > threshold)
+            return count; // early exit
+    }
+    return count;
+};
 const toResolveResult = (definition, tier) => ({
     nodeId: definition.nodeId,
     confidence: TIER_CONFIDENCE[tier],
@@ -827,131 +1161,265 @@ const tryOverloadDisambiguation = (candidates, hints) => {
         return null;
     return matchCandidatesByArgTypes(candidates, argTypes);
 };
-const resolveCallTarget = (call, currentFile, ctx, overloadHints, widenCache, preComputedArgTypes) => {
-    const tiered = ctx.resolve(call.calledName, currentFile);
+/**
+ * Apply overload-hint or arg-type disambiguation to a pre-filtered candidate
+ * pool. Returns the unique survivor, or null when neither signal is present,
+ * neither can disambiguate, or the pool remains ambiguous.
+ *
+ * Precedence rule: `overloadHints` wins over `preComputedArgTypes` when both
+ * are supplied. The AST-based disambiguator has access to live type inference
+ * hooks, whereas `preComputedArgTypes` is a worker-path pre-computation that
+ * may be coarser-grained.
+ *
+ * Single source of truth for the narrowing-signal precedence used by member
+ * and constructor resolution paths. Add a new narrowing signal here once, not
+ * at each call site.
+ */
+const disambiguateByOverloadOrArgTypes = (pool, overloadHints, preComputedArgTypes) => {
+    if (!overloadHints && !preComputedArgTypes)
+        return null;
+    if (overloadHints)
+        return tryOverloadDisambiguation(pool, overloadHints);
+    if (preComputedArgTypes)
+        return matchCandidatesByArgTypes(pool, preComputedArgTypes);
+    return null;
+};
+/**
+ * Collapse Swift-extension duplicate Class/Struct candidates to the primary
+ * definition, preferring the shortest file path.
+ *
+ * Swift extensions (`extension User { ... }` in a separate file) create
+ * multiple `Class` nodes sharing the same symbol name — one for the primary
+ * declaration and one per extension file. When overload disambiguation and
+ * receiver narrowing both fail to converge on a single candidate, this
+ * heuristic picks the primary definition based on the assumption that it
+ * lives at the shortest file path (e.g. `User.swift` over `UserExtensions.swift`).
+ *
+ * Intentionally narrower than {@link INSTANTIABLE_CLASS_TYPES}: only `Class`
+ * and `Struct` are considered, not `Record`. Swift extensions only produce
+ * `Class` duplicates in practice, and C#/Kotlin records do not exhibit the
+ * same multi-file-definition pattern, so widening this set risks accidental
+ * dedup of legitimately distinct record types.
+ *
+ * Returns a `ResolveResult` when the heuristic fires, `null` when the
+ * candidate pool does not match the shape (mixed types, non-Class/Struct
+ * kinds, or `length <= 1`). Callers should fall through to their own null
+ * return when this helper returns `null`.
+ *
+ * Used by `resolveFreeCall`. Having a single source of truth prevents
+ * duplication if the heuristic is ever tuned.
+ */
+const dedupSwiftExtensionCandidates = (candidates, tier) => {
+    if (candidates.length <= 1)
+        return null;
+    const allSameType = candidates.every((c) => c.type === candidates[0].type);
+    if (!allSameType)
+        return null;
+    if (candidates[0].type !== 'Class' && candidates[0].type !== 'Struct')
+        return null;
+    const sorted = [...candidates].sort((a, b) => a.filePath.length - b.filePath.length);
+    return toResolveResult(sorted[0], tier);
+};
+/**
+ * Thin dispatcher that routes a call to the appropriate specialized resolver.
+ *
+ * - `free`        → {@link resolveFreeCall}
+ * - `constructor` → {@link resolveStaticCall}  (with pre-resolved tiered pool)
+ * - `member` with a known receiver type → {@link resolveMemberCall}, with
+ *   file-based fallback for traits/interfaces
+ * - `member` without receiver type → module-alias check, then tiered lookup
+ *
+ * Replaces the former 200+ line function (SM-19: fuzzy-free call resolution).
+ */
+/**
+ * Module-alias resolution for member calls without a receiver type.
+ *
+ * Handles Python/Ruby `import mod; mod.Symbol()` patterns where the receiver
+ * is a module name, not a typed variable. Uses `moduleAliasMap` to scope
+ * candidates to the correct module file.
+ */
+const resolveModuleAliasedCall = (call, currentFile, ctx, widenCache, tieredOverride) => {
+    if (!call.receiverName)
+        return null;
+    const aliasMap = ctx.moduleAliasMap?.get(currentFile);
+    if (!aliasMap)
+        return null;
+    const moduleFile = aliasMap.get(call.receiverName);
+    if (!moduleFile)
+        return null;
+    // Reuse the caller's pre-computed tiered result when available —
+    // the dispatcher already called ctx.resolve(call.calledName, currentFile).
+    const tiered = tieredOverride ?? ctx.resolve(call.calledName, currentFile);
     if (!tiered)
         return null;
-    let filteredCandidates = filterCallableCandidates(tiered.candidates, call.argCount, call.callForm);
-    // Swift/Kotlin: constructor calls look like free function calls (no `new` keyword).
-    // If free-form filtering found no callable candidates but the symbol resolves to a
-    // Class/Struct, retry with constructor form so CONSTRUCTOR_TARGET_TYPES applies.
-    if (filteredCandidates.length === 0 && call.callForm === 'free') {
-        const hasTypeTarget = tiered.candidates.some((c) => c.type === 'Class' || c.type === 'Struct' || c.type === 'Enum');
-        if (hasTypeTarget) {
-            filteredCandidates = filterCallableCandidates(tiered.candidates, call.argCount, 'constructor');
-        }
-    }
-    // Module-qualified constructor pattern: e.g. Python `import models; models.User()`.
-    // The attribute access gives callForm='member', but the callee may be a Class — a valid
-    // constructor target. Re-try with constructor-form filtering so that `module.ClassName()`
-    // emits a CALLS edge to the class node.
-    if (filteredCandidates.length === 0 && call.callForm === 'member') {
-        filteredCandidates = filterCallableCandidates(tiered.candidates, call.argCount, 'constructor');
-    }
-    // Module-alias disambiguation: Python `import auth; auth.User()` — receiverName='auth'
-    // selects auth.py via moduleAliasMap. Runs for ALL member calls with a known module alias,
-    // not just ambiguous ones — same-file tier may shadow the correct cross-module target when
-    // the caller defines a function with the same name as the callee (Issue #417).
-    if (call.callForm === 'member' && call.receiverName) {
-        const aliasMap = ctx.moduleAliasMap?.get(currentFile);
-        if (aliasMap) {
-            const moduleFile = aliasMap.get(call.receiverName);
-            if (moduleFile) {
-                const aliasFiltered = filteredCandidates.filter((c) => c.filePath === moduleFile);
-                if (aliasFiltered.length > 0) {
-                    filteredCandidates = aliasFiltered;
-                }
-                else {
-                    // Same-file tier returned a local match, but the alias points elsewhere.
-                    // Widen to global candidates and filter to the aliased module's file.
-                    // Use per-file widenCache to avoid repeated lookupFuzzy for the same
-                    // calledName+moduleFile from multiple call sites in the same file.
-                    const cacheKey = `${call.calledName}\0${moduleFile}`;
-                    let fuzzyDefs = widenCache?.get(cacheKey);
-                    if (!fuzzyDefs) {
-                        fuzzyDefs = ctx.symbols.lookupFuzzy(call.calledName);
-                        widenCache?.set(cacheKey, fuzzyDefs);
-                    }
-                    const widened = filterCallableCandidates(fuzzyDefs, call.argCount, call.callForm).filter((c) => c.filePath === moduleFile);
-                    if (widened.length > 0)
-                        filteredCandidates = widened;
-                }
-            }
-        }
+    // Try member-form, then constructor-form (for `module.ClassName()` patterns)
+    let filtered = filterCallableCandidates(tiered.candidates, call.argCount, call.callForm).filter((c) => c.filePath === moduleFile);
+    if (filtered.length === 0) {
+        filtered = filterCallableCandidates(tiered.candidates, call.argCount, 'constructor').filter((c) => c.filePath === moduleFile);
     }
-    // D. Receiver-type filtering: for member calls with a known receiver type,
-    // resolve the type through the same tiered import infrastructure, then
-    // filter method candidates to the type's defining file. Fall back to
-    // fuzzy ownerId matching only when file-based narrowing is inconclusive.
-    //
-    // Applied regardless of candidate count — the sole same-file candidate may
-    // belong to the wrong class (e.g. super.save() should hit the parent's save,
-    // not the child's own save method in the same file).
-    if (call.callForm === 'member' && call.receiverTypeName) {
-        // D1. Resolve the receiver type
-        const typeResolved = ctx.resolve(call.receiverTypeName, currentFile);
-        if (typeResolved && typeResolved.candidates.length > 0) {
-            const typeNodeIds = new Set(typeResolved.candidates.map((d) => d.nodeId));
-            const typeFiles = new Set(typeResolved.candidates.map((d) => d.filePath));
-            // D2. Widen candidates: same-file tier may miss the parent's method when
-            //     it lives in another file. Query the symbol table directly for all
-            //     global methods with this name, then apply arity/kind filtering.
-            const methodPool = filteredCandidates.length <= 1
-                ? filterCallableCandidates(ctx.symbols.lookupFuzzy(call.calledName), call.argCount, call.callForm)
-                : filteredCandidates;
-            // D3. File-based: prefer candidates whose filePath matches the resolved type's file
-            const fileFiltered = methodPool.filter((c) => typeFiles.has(c.filePath));
-            if (fileFiltered.length === 1) {
-                return toResolveResult(fileFiltered[0], tiered.tier);
-            }
-            // D4. ownerId fallback: narrow by ownerId matching the 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);
+    if (filtered.length === 0) {
+        // Widen to global callable+method indexes scoped to the aliased module
+        // file. Function+ownerId (Python/Rust/Kotlin) is still routed to both
+        // indexes until Unit 5 unblocks, so dedup by nodeId.
+        const cacheKey = `${call.calledName}\0${moduleFile}`;
+        let defs = widenCache?.get(cacheKey);
+        if (!defs) {
+            const rawCallable = ctx.model.symbols.lookupCallableByName(call.calledName);
+            const rawMethods = ctx.model.methods.lookupMethodByName(call.calledName);
+            const widenCombined = [];
+            const widenSeen = new Set();
+            for (const d of rawCallable) {
+                if (widenSeen.has(d.nodeId))
+                    continue;
+                widenSeen.add(d.nodeId);
+                widenCombined.push(d);
             }
-            // E. Try overload disambiguation on the narrowed pool
-            if (fileFiltered.length > 1 || ownerFiltered.length > 1) {
-                const overloadPool = ownerFiltered.length > 1 ? ownerFiltered : fileFiltered;
-                const disambiguated = overloadHints
-                    ? tryOverloadDisambiguation(overloadPool, overloadHints)
-                    : preComputedArgTypes
-                        ? matchCandidatesByArgTypes(overloadPool, preComputedArgTypes)
-                        : null;
-                if (disambiguated)
-                    return toResolveResult(disambiguated, tiered.tier);
-                return null;
+            for (const d of rawMethods) {
+                if (widenSeen.has(d.nodeId))
+                    continue;
+                widenSeen.add(d.nodeId);
+                widenCombined.push(d);
             }
+            defs = widenCombined;
+            widenCache?.set(cacheKey, defs);
+        }
+        filtered = filterCallableCandidates(defs, call.argCount, call.callForm).filter((c) => c.filePath === moduleFile);
+        if (filtered.length === 0) {
+            filtered = filterCallableCandidates(defs, call.argCount, 'constructor').filter((c) => c.filePath === moduleFile);
         }
     }
-    // E. Overload disambiguation: when multiple candidates survive arity + receiver filtering,
-    // try matching argument types against parameter types (Phase P).
-    // Sequential path uses AST-based hints; worker path uses pre-computed argTypes.
-    if (filteredCandidates.length > 1) {
-        const disambiguated = overloadHints
-            ? tryOverloadDisambiguation(filteredCandidates, overloadHints)
-            : preComputedArgTypes
-                ? matchCandidatesByArgTypes(filteredCandidates, preComputedArgTypes)
-                : null;
+    return filtered.length === 1 ? toResolveResult(filtered[0], tiered.tier) : null;
+};
+/**
+ * File-based fallback for member calls where owner-scoped resolution fails.
+ *
+ * Resolves the receiver type via `ctx.resolve()` and narrows all callable
+ * symbols with the method name to the receiver type's defining file(s),
+ * then applies ownerId filtering and overload disambiguation.
+ *
+ * Handles Rust trait dispatch (`repo.find()` where `find` is on a trait impl),
+ * cross-file overloaded methods, and similar patterns where ownerId
+ * relationships may not be established on all candidates.
+ */
+const resolveMemberCallByFile = (calledName, receiverTypeName, currentFile, ctx, argCount, callForm, overloadHints, preComputedArgTypes) => {
+    const typeResolved = ctx.resolve(receiverTypeName, currentFile);
+    if (!typeResolved || typeResolved.candidates.length === 0)
+        return null;
+    const typeNodeIds = new Set(typeResolved.candidates.map((d) => d.nodeId));
+    const typeFiles = new Set(typeResolved.candidates.map((d) => d.filePath));
+    // A4 (plan 006, Unit 4): consult both indexes. Strictly-labeled
+    // Method/Constructor are disjoint, but Function+ownerId (Python/Rust/
+    // Kotlin) is routed into BOTH indexes by `wrappedAdd` until Unit 5
+    // unblocks — dedup by nodeId so overload disambiguation doesn't see
+    // phantom duplicates.
+    const rawCallablePool = ctx.model.symbols.lookupCallableByName(calledName);
+    const rawMethodPool = ctx.model.methods.lookupMethodByName(calledName);
+    const combinedPool = [];
+    const combinedSeen = new Set();
+    for (const def of rawCallablePool) {
+        if (combinedSeen.has(def.nodeId))
+            continue;
+        combinedSeen.add(def.nodeId);
+        combinedPool.push(def);
+    }
+    for (const def of rawMethodPool) {
+        if (combinedSeen.has(def.nodeId))
+            continue;
+        combinedSeen.add(def.nodeId);
+        combinedPool.push(def);
+    }
+    const methodPool = filterCallableCandidates(combinedPool, argCount, callForm);
+    const fileFiltered = methodPool.filter((c) => typeFiles.has(c.filePath));
+    if (fileFiltered.length === 1) {
+        return toResolveResult(fileFiltered[0], typeResolved.tier);
+    }
+    // ownerId fallback: narrow by ownerId matching the 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], typeResolved.tier);
+    // Overload disambiguation on the narrowed pool
+    if (fileFiltered.length > 1 || ownerFiltered.length > 1) {
+        const overloadPool = ownerFiltered.length > 1 ? ownerFiltered : fileFiltered;
+        const disambiguated = disambiguateByOverloadOrArgTypes(overloadPool, overloadHints, preComputedArgTypes);
         if (disambiguated)
-            return toResolveResult(disambiguated, tiered.tier);
+            return toResolveResult(disambiguated, typeResolved.tier);
     }
-    if (filteredCandidates.length !== 1) {
-        // Deduplicate: Swift extensions create multiple Class nodes with the same name.
-        // When all candidates share the same type and differ only by file (extension vs
-        // primary definition), they represent the same symbol. Prefer the primary
-        // definition (shortest file path: Product.swift over ProductExtension.swift).
-        if (filteredCandidates.length > 1) {
-            const allSameType = filteredCandidates.every((c) => c.type === filteredCandidates[0].type);
-            if (allSameType &&
-                (filteredCandidates[0].type === 'Class' || filteredCandidates[0].type === 'Struct')) {
-                const sorted = [...filteredCandidates].sort((a, b) => a.filePath.length - b.filePath.length);
-                return toResolveResult(sorted[0], tiered.tier);
-            }
-        }
+    // Zero-match null-route: receiver type resolved but no candidate matched
+    // after file-based and owner-based narrowing. Refuse to emit a CALLS edge
+    // rather than guess — matches the SM-10 R3 null-route contract.
+    return null;
+};
+/** Return the sole survivor from a tiered pool after callable + arity filtering, or null. */
+const singleCandidate = (tiered, argCount, callForm) => {
+    const filtered = filterCallableCandidates(tiered.candidates, argCount, callForm);
+    return filtered.length === 1 ? toResolveResult(filtered[0], tiered.tier) : null;
+};
+/** @internal Exported for unit tests. Do not use outside tests. */
+export const _resolveCallTargetForTesting = (call, currentFile, ctx, opts) => resolveCallTarget(call, currentFile, ctx, opts?.overloadHints, opts?.widenCache, opts?.preComputedArgTypes, opts?.heritageMap);
+const resolveCallTarget = (call, currentFile, ctx, overloadHints, widenCache, preComputedArgTypes, heritageMap) => {
+    const tiered = ctx.resolve(call.calledName, currentFile);
+    if (!tiered)
         return null;
+    if (call.callForm === 'free') {
+        return resolveFreeCall(call.calledName, currentFile, ctx, call.argCount, tiered, overloadHints, preComputedArgTypes);
     }
-    return toResolveResult(filteredCandidates[0], tiered.tier);
+    if (call.callForm === 'constructor') {
+        return (resolveStaticCall(call.calledName, currentFile, ctx, call.argCount, tiered, overloadHints, preComputedArgTypes) ?? singleCandidate(tiered, call.argCount, 'constructor'));
+    }
+    if (call.receiverTypeName) {
+        // Skip the owner-scoped MRO path when the tiered pool has genuine
+        // overload ambiguity that needs D1-D4+E handling, not D0.
+        const skipMember = (!!overloadHints || !!preComputedArgTypes) &&
+            countCallableCandidates(tiered.candidates, call.argCount, call.callForm) > 1;
+        // Try owner-scoped (resolveMemberCall) then file-scoped (resolveMemberCallByFile).
+        const memberResult = (!skipMember
+            ? resolveMemberCall(call.receiverTypeName, call.calledName, currentFile, ctx, heritageMap, call.argCount)
+            : null) ??
+            resolveMemberCallByFile(call.calledName, call.receiverTypeName, currentFile, ctx, call.argCount, call.callForm, overloadHints, preComputedArgTypes);
+        if (memberResult)
+            return memberResult;
+        // Module-alias narrowing runs as a FALLBACK, after owner/file-scoped
+        // resolvers have returned null. This ordering is load-bearing: placing
+        // alias narrowing first would short-circuit unique owner-scoped answers
+        // when a local variable coincidentally matches an alias name, leaking
+        // unrelated homonyms from the aliased file onto the wrong receiver type.
+        //
+        // The type-file verification guard is load-bearing for SM-10 R3: an
+        // alias is only a VALID narrowing signal when the alias target file is
+        // among the receiver type's defining files. If the alias points at a
+        // file that does not hold `receiverTypeName`, any candidate we would
+        // pick from there would belong to an unrelated class — a cross-type
+        // false positive. ctx.resolve is cached per (name, file), so resolving
+        // the receiver type a second time here is free.
+        const typeResolves = ctx.resolve(call.receiverTypeName, currentFile);
+        const aliasMap = ctx.moduleAliasMap?.get(currentFile);
+        const aliasTargetFile = call.receiverName && aliasMap ? aliasMap.get(call.receiverName) : undefined;
+        if (aliasTargetFile &&
+            typeResolves &&
+            typeResolves.candidates.some((c) => c.filePath === aliasTargetFile)) {
+            const aliasResult = resolveModuleAliasedCall(call, currentFile, ctx, widenCache, tiered);
+            if (aliasResult)
+                return aliasResult;
+        }
+        // SM-10 R3 null-route: when the receiver type resolves to indexed types
+        // but no scoped resolver (nor the guarded alias fallback) produced a
+        // match, that's a genuine miss — refuse to emit a CALLS edge rather
+        // than guess via an unscoped singleCandidate that ignores the class
+        // hierarchy. When the type is NOT in the index (PHP `mixed`, dynamic
+        // types, unresolvable aliases), the scoped resolvers had nothing to
+        // work with and singleCandidate is the correct last resort.
+        if (typeResolves && typeResolves.candidates.length > 0) {
+            return null; // null-route: type resolved, no candidate matched
+        }
+        return singleCandidate(tiered, call.argCount, call.callForm);
+    }
+    // Member call with no inferred receiver type — e.g. Python `mod.fn()`
+    // where `mod` is a module alias. Module-alias narrowing is the primary
+    // disambiguation signal here. Also consulted from the typed-member
+    // branch above as a guarded fallback after owner/file-scoped resolvers.
+    return (resolveModuleAliasedCall(call, currentFile, ctx, widenCache, tiered) ??
+        singleCandidate(tiered, call.argCount, call.callForm));
 };
 // ── Scope key helpers ────────────────────────────────────────────────────
 // Scope keys use the format "funcName@startIndex" (produced by type-env.ts).
@@ -963,12 +1431,18 @@ const resolveCallTarget = (call, currentFile, ctx, overloadHints, widenCache, pr
 // collisions between overloaded methods with the same name in different
 // classes (e.g. User.save@100 and Repo.save@200 are distinct keys).
 // Lookup uses a secondary funcName-only index built in lookupReceiverType.
-/** Extract the function name from a scope key ("funcName@startIndex" → "funcName"). */
-const extractFuncNameFromScope = (scope) => scope.slice(0, scope.indexOf('@'));
-/** Extract the trailing function name from a sourceId ("Function:filepath:funcName" → "funcName"). */
+/** Extract the bare function name from a sourceId.
+ *  Handles both unqualified ("Function:filepath:funcName" → "funcName")
+ *  and qualified ("Function:filepath:ClassName.funcName" → "funcName").
+ *  Strips any trailing #<arity> suffix from Method/Constructor IDs. */
 const extractFuncNameFromSourceId = (sourceId) => {
     const lastColon = sourceId.lastIndexOf(':');
-    return lastColon >= 0 ? sourceId.slice(lastColon + 1) : '';
+    const segment = lastColon >= 0 ? sourceId.slice(lastColon + 1) : '';
+    const dotIdx = segment.lastIndexOf('.');
+    const raw = dotIdx >= 0 ? segment.slice(dotIdx + 1) : segment;
+    // Strip #<arity> suffix (e.g. "save#2" → "save")
+    const hashIdx = raw.indexOf('#');
+    return hashIdx >= 0 ? raw.slice(0, hashIdx) : raw;
 };
 /**
  * Build a composite key for receiver type storage.
@@ -981,6 +1455,12 @@ const receiverKey = (scope, varName) => `${scope}\0${varName}`;
  * The verified map is keyed by `scope\0varName` where scope is either
  * "funcName@startIndex" (inside a function) or "" (file level).
  * Index structure: Map<funcName, Map<varName, ReceiverTypeEntry>>
+ *
+ * Known limitation: the index collapses scope keys to bare funcName,
+ * so two same-arity overloads with the same local variable name but
+ * different types will mark that variable as ambiguous. A future
+ * enhancement should key by full scope (funcName@startIndex) and carry
+ * scope keys through findEnclosingFunction's return type.
  */
 const buildReceiverTypeIndex = (map) => {
     const index = new Map();
@@ -1058,15 +1538,373 @@ const resolveFieldOwnership = (receiverName, fieldName, filePath, ctx) => {
     const typeResolved = ctx.resolve(receiverName, filePath);
     if (!typeResolved)
         return undefined;
-    const classDef = typeResolved.candidates.find((d) => d.type === 'Class' ||
-        d.type === 'Struct' ||
-        d.type === 'Interface' ||
-        d.type === 'Enum' ||
-        d.type === 'Record' ||
-        d.type === 'Impl');
+    const classDef = typeResolved.candidates.find((d) => CLASS_LIKE_TYPES.has(d.type));
     if (!classDef)
         return undefined;
-    return ctx.symbols.lookupFieldByOwner(classDef.nodeId, fieldName) ?? undefined;
+    return ctx.model.fields.lookupFieldByOwner(classDef.nodeId, fieldName) ?? undefined;
+};
+/**
+ * Resolve a method by owner type name using the eagerly-populated methodByOwner index.
+ * Returns `{ def, tier }` when an unambiguous method is found, `undefined` otherwise.
+ *
+ * **Multi-candidate iteration (homonym disambiguation):** when `ctx.resolve(ownerType)`
+ * returns multiple class-like candidates (e.g. two classes named `User` in different
+ * files reachable from the call site), each is probed with `lookupMethodByOwnerWithMRO`.
+ * Results are deduplicated by `nodeId` so that:
+ *
+ *   - homonym classes that both walk up to the SAME ancestor's method collapse to 1 hit
+ *   - aliased re-exports that produce two candidates pointing at the same def collapse too
+ *
+ * After deduplication:
+ *
+ *   - 0 unique matches → `undefined` (owner-scoped path has no answer)
+ *   - 1 unique match   → return it
+ *   - ≥2 unique matches → `undefined` (genuine homonym ambiguity; don't silently pick one)
+ *
+ * The returned `tier` reflects how the owner TYPE was resolved (not the method name).
+ * Threaded out here so callers don't need a second `ctx.resolve(ownerType, ...)` call —
+ * this decouples callers from `ctx.resolve`'s per-file caching contract.
+ */
+const resolveMethodByOwner = (receiverTypeName, methodName, filePath, ctx, heritageMap, argCount) => {
+    const typeResolved = ctx.resolve(receiverTypeName, filePath);
+    if (!typeResolved)
+        return undefined;
+    // MRO walking needs a language hint so we can derive the per-language
+    // strategy; compute it once and reuse for every candidate. Unknown
+    // extension → fall back to plain direct lookup (D1-D4 still runs on miss).
+    const language = heritageMap ? getLanguageFromFilename(filePath) : null;
+    const mroStrategy = language != null ? getProvider(language).mroStrategy : null;
+    const canWalkMRO = heritageMap != null && mroStrategy != null;
+    // Iterate all class-like candidates tracking the first unambiguous hit.
+    // Zero-allocation fast path: the common case is exactly one class candidate,
+    // so we avoid building a Map. A second hit with a different `nodeId` flips
+    // `ambiguous` and short-circuits the loop. Diamond MRO convergence on the
+    // same inherited method collapses to one hit because `nodeId` matches.
+    //
+    //   firstDef === undefined → owner-scoped resolution found nothing
+    //   firstDef && !ambiguous → unambiguous answer
+    //   ambiguous              → genuine homonym ambiguity — refuse to pick
+    //
+    // argCount is threaded through so arity-differing overloads
+    // (e.g. C++ `greet()` vs `greet(string)`) are disambiguated inside the
+    // owner-scoped lookup rather than collapsing to an arbitrary first pick.
+    let firstDef;
+    let ambiguous = false;
+    for (const candidate of typeResolved.candidates) {
+        if (!CLASS_LIKE_TYPES.has(candidate.type))
+            continue;
+        const def = canWalkMRO
+            ? lookupMethodByOwnerWithMRO(candidate.nodeId, methodName, heritageMap, ctx.model, mroStrategy, argCount)
+            : ctx.model.methods.lookupMethodByOwner(candidate.nodeId, methodName, argCount);
+        if (!def)
+            continue;
+        if (!firstDef) {
+            firstDef = def;
+        }
+        else if (def.nodeId !== firstDef.nodeId) {
+            ambiguous = true;
+            break;
+        }
+    }
+    if (!firstDef || ambiguous)
+        return undefined;
+    return { def: firstDef, tier: typeResolved.tier };
+};
+// ---------------------------------------------------------------------------
+// SM-11: Owner-scoped + MRO member-call resolution (no fuzzy lookup)
+// ---------------------------------------------------------------------------
+/**
+ * Resolve a member call using owner-scoped + MRO resolution only (no fuzzy lookup).
+ * Used for `obj.method()` calls where the receiver type is known.
+ *
+ * Delegates to {@link resolveMethodByOwner} which performs an O(1) owner-scoped
+ * method lookup and, when a {@link HeritageMap} is provided, walks the MRO chain
+ * via {@link lookupMethodByOwnerWithMRO}.
+ *
+ * {@link resolveCallTarget} delegates here for member calls.
+ *
+ * **SEMANTIC CHANGE (2026-04-09):** The confidence tier reflects how the
+ * owner TYPE was resolved, not how the method NAME was resolved globally.
+ * more accurate for owner-scoped resolution (the discriminant IS the class,
+ * not the method name). Downstream consumers that filter CALLS edges by
+ * confidence threshold may see shifted values on otherwise-unchanged code.
+ * See the "returns result with correct confidence tier" tests below for the
+ * locked-in behavior.
+ *
+ * **Performance:** Callers that only need the return type (e.g. `walkMixedChain`)
+ * should call {@link resolveMethodByOwner} directly and use the `.def.returnType`
+ * field instead, to avoid building a throwaway `ResolveResult`.
+ *
+ * @param ownerType   - The receiver's type name (e.g. 'User')
+ * @param methodName  - The method being called (e.g. 'save')
+ * @param currentFile - File path of the call site
+ * @param ctx         - Resolution context
+ * @param heritageMap - Optional heritage map for MRO-aware ancestor walking
+ */
+export const resolveMemberCall = (ownerType, methodName, currentFile, ctx, heritageMap, argCount) => {
+    const resolved = resolveMethodByOwner(ownerType, methodName, currentFile, ctx, heritageMap, argCount);
+    if (!resolved)
+        return null;
+    return toResolveResult(resolved.def, resolved.tier);
+};
+// ---------------------------------------------------------------------------
+// SM-13: Free-function call resolution
+// ---------------------------------------------------------------------------
+/**
+ * Resolve a free-function call using `lookupExact` (same-file) + import-scoped
+ * resolution via `ctx.resolve()`.
+ *
+ * Used for `foo()`, `doStuff()` — unqualified calls with no receiver.
+ * Also handles Swift/Kotlin implicit constructors (`User()` without `new`)
+ * by delegating to {@link resolveStaticCall} when the tiered pool contains
+ * class-like targets.
+ *
+ * {@link resolveCallTarget} delegates here for `callForm === 'free'`.
+ *
+ * `resolveFreeCall` does not take a `widenCache` parameter. Free calls
+ * have no receiver type and rely exclusively on the tiered pool
+ * from `ctx.resolve()`.
+ *
+ * @param calledName  - The called function name (e.g. 'doStuff')
+ * @param filePath    - File path of the call site
+ * @param ctx         - Resolution context
+ * @param argCount    - Optional argument count for arity filtering
+ * @param tieredOverride - Pre-computed tiered candidates from an upstream
+ *                       `ctx.resolve` call. When provided, skips the redundant
+ *                       lookup inside this function.
+ * @param overloadHints  - Optional AST-based overload disambiguation hints
+ * @param preComputedArgTypes - Optional pre-computed argument types (worker path)
+ */
+export const resolveFreeCall = (calledName, filePath, ctx, argCount, tieredOverride, overloadHints, preComputedArgTypes) => {
+    const tiered = tieredOverride ?? ctx.resolve(calledName, filePath);
+    if (!tiered)
+        return null;
+    let filteredCandidates = filterCallableCandidates(tiered.candidates, argCount, 'free');
+    // Class-target fast path: Swift/Kotlin `User()` — free-form call targeting a
+    // class. Delegates to resolveStaticCall for O(1) class + constructor lookup.
+    // The `.some()` trigger must stay aligned with `INSTANTIABLE_CLASS_TYPES` —
+    // any type admitted here that is not in that set will cause resolveStaticCall
+    // to return null, wasting two lookup passes per call. `Enum` is deliberately
+    // excluded; `Record` is included so C# records and Kotlin data classes reach
+    // the fast path.
+    // Align with INSTANTIABLE_CLASS_TYPES by reusing the set directly rather
+    // than enumerating literal strings. This converts an invariant that was
+    // previously enforced by a comment ("keep this list aligned with
+    // INSTANTIABLE_CLASS_TYPES") into one enforced structurally — any future
+    // extension of the set (e.g. Kotlin `object`) propagates here automatically.
+    // The `dedupSwiftExtensionCandidates` helper used in the tail of this
+    // function deliberately uses a narrower literal `'Class' | 'Struct'` check
+    // — Swift extensions only produce Class duplicates in practice, so Record
+    // is excluded there by design. Do not collapse that helper into
+    // INSTANTIABLE_CLASS_TYPES.
+    const hasClassTarget = filteredCandidates.length === 0 &&
+        tiered.candidates.some((c) => INSTANTIABLE_CLASS_TYPES.has(c.type));
+    if (hasClassTarget) {
+        const staticResult = resolveStaticCall(calledName, filePath, ctx, argCount, tiered);
+        if (staticResult)
+            return staticResult;
+        // Retry with constructor form: Swift/Kotlin constructor calls look like
+        // free function calls (no `new` keyword). If resolveStaticCall didn't
+        // match, re-filter with constructor form so CONSTRUCTOR_TARGET_TYPES
+        // applies.
+        //
+        // The retry fires for every null return from `resolveStaticCall`, which
+        // can happen for three distinct reasons — all three are handled below:
+        //
+        //   (a) No explicit `Constructor` node found and zero instantiable
+        //       class candidates (e.g. Interface/Trait/Impl only — the SM-12
+        //       null-route contract). `filterCallableCandidates` with
+        //       `'constructor'` form will also return nothing → we fall
+        //       through to the final null return. Correct.
+        //
+        //   (b) Homonym ambiguity — two or more instantiable class candidates
+        //       share the name (e.g. `User` in two files, same tier). The
+        //       retry repopulates `filteredCandidates` with both Classes and
+        //       they flow into `dedupSwiftExtensionCandidates` below, which
+        //       either picks the shortest-path primary or null-routes.
+        //       Covered by the R7 Swift-extension dedup test.
+        //
+        //   (c) `resolveStaticCall` step 4 bailed because the tiered pool
+        //       contains ownerless `Constructor` nodes (some extractors emit
+        //       constructors without `ownerId`). Those `Constructor` nodes
+        //       survive the constructor-form filter below and reach overload
+        //       disambiguation, giving the existing filter path a chance to
+        //       pick the right one. Correct but currently uncovered by a
+        //       dedicated test — the R5 `preComputedArgTypes` path exercises
+        //       overload disambiguation for Functions, which is structurally
+        //       the same code.
+        filteredCandidates = filterCallableCandidates(tiered.candidates, argCount, 'constructor');
+    }
+    // E. Overload disambiguation
+    if (filteredCandidates.length > 1) {
+        const disambiguated = overloadHints
+            ? tryOverloadDisambiguation(filteredCandidates, overloadHints)
+            : preComputedArgTypes
+                ? matchCandidatesByArgTypes(filteredCandidates, preComputedArgTypes)
+                : null;
+        if (disambiguated)
+            return toResolveResult(disambiguated, tiered.tier);
+    }
+    if (filteredCandidates.length !== 1) {
+        // See `dedupSwiftExtensionCandidates` — shared helper, single source of
+        // truth for the Swift-extension same-name collision heuristic.
+        const deduped = dedupSwiftExtensionCandidates(filteredCandidates, tiered.tier);
+        if (deduped)
+            return deduped;
+        return null;
+    }
+    return toResolveResult(filteredCandidates[0], tiered.tier);
+};
+// ---------------------------------------------------------------------------
+// SM-12: Constructor/static call resolution (no fuzzy lookup)
+// ---------------------------------------------------------------------------
+/**
+ * Resolve a constructor or static call using class-scoped lookup (no fuzzy lookup).
+ * Used for `new User()` / `User()` calls where the calledName targets a class.
+ *
+ * Uses {@link TypeRegistry.lookupClassByName} for O(1) class lookup and
+ * {@link MethodRegistry.lookupMethodByOwner} for constructor resolution.
+ * {@link resolveCallTarget} delegates here for constructor and free-form calls
+ * that target a class.
+ *
+ * Resolution strategy:
+ *   1. `lookupClassByName(className)` — O(1) pre-check; bail early if no class exists.
+ *   2. `ctx.resolve(className, currentFile)` — import-scoped tier for confidence.
+ *   3. Filter to class-like candidates via `CLASS_LIKE_TYPES` and walk each
+ *      with `lookupMethodByOwner(classNodeId, className, argCount)` — O(1)
+ *      constructor lookup. Only accept results with `type === 'Constructor'`.
+ *   4. If step 3 found nothing and the tiered pool contains ownerless
+ *      `Constructor` nodes (common in some extractors), bail out so
+ *      `filterCallableCandidates` downstream handles Constructor-vs-Class
+ *      preference correctly.
+ *   5. Class-node fallback: filter `classCandidates` through
+ *      `INSTANTIABLE_CLASS_TYPES` and return the sole survivor when there is
+ *      exactly one. Null-route on zero survivors (Interface / Trait / Impl
+ *      stripped) or multiple (homonym ambiguity).
+ *
+ * @param className   - The class name (e.g. 'User'). Also used as the method
+ *                       name for the `lookupMethodByOwner` scan, because the
+ *                       only constructor-shaped call we handle today is
+ *                       `ClassName(...)` / `new ClassName(...)`. Named
+ *                       constructors like Dart `User.fromJson()` arrive as
+ *                       member calls and route through `resolveMemberCall`,
+ *                       so this function does not yet need a separate
+ *                       `methodName` parameter. Revisit if a language surfaces
+ *                       a static-method-shaped call with a distinct member
+ *                       name.
+ * @param currentFile - File path of the call site
+ * @param ctx         - Resolution context
+ * @param argCount    - Optional argument count for arity filtering
+ * @param tieredOverride - Pre-computed tiered candidates for `className` from
+ *                       an upstream `ctx.resolve` call. When provided, skips
+ *                       the redundant lookup inside this function. Leave
+ *                       unset for direct callers without a prior resolution.
+ */
+export const resolveStaticCall = (className, currentFile, ctx, argCount, tieredOverride, overloadHints, preComputedArgTypes) => {
+    // 1. Pre-check: does a class with this name exist at all? (O(1))
+    //    This guards against the expensive `ctx.resolve` walk when the name
+    //    is clearly not class-like (e.g. plain functions). When `tieredOverride`
+    //    is supplied, the caller has already paid for the tiered lookup, so this
+    //    pre-check still prevents the class-candidate filter + lookupMethodByOwner
+    //    loop from running on obviously non-class targets.
+    const allClasses = ctx.model.types.lookupClassByName(className);
+    if (allClasses.length === 0)
+        return null;
+    // 2. Scope via ctx.resolve for import-tier information. Reuse the caller's
+    //    tiered result when provided — it is computed from the same name and
+    //    file context, so re-running the walk would be a pure waste.
+    const typeResolved = tieredOverride ?? ctx.resolve(className, currentFile);
+    if (!typeResolved)
+        return null;
+    const classCandidates = typeResolved.candidates.filter((c) => CLASS_LIKE_TYPES.has(c.type));
+    if (classCandidates.length === 0)
+        return null;
+    // 3. Try lookupMethodByOwner for explicit Constructor nodes.
+    //    Only accept results with type === 'Constructor' — a Method or Function
+    //    that happens to share the class name (e.g. C++ methods named after
+    //    their class) is not a constructor for resolution purposes.
+    //    Same dedup logic as resolveMethodByOwner: diamond inheritance converging
+    //    on the same constructor collapses to one hit.
+    //
+    //    Same-name assumption: the lookup key is `${candidate.nodeId}\0${className}`,
+    //    so this finds Constructor nodes whose symbol name equals the class name
+    //    (`class User` with a `Constructor` named `User`). Constructors indexed
+    //    under a different name (e.g. Python `__init__`) will not be found here —
+    //    but they also won't appear in the tiered pool for `ctx.resolve(className)`
+    //    for the same reason, so step 4's Constructor-presence check will not
+    //    see them either. The two miss cases are symmetric. If a future extractor
+    //    indexes Constructor nodes under an alternative name while still setting
+    //    `ownerId`, this assumption will need revisiting.
+    let firstDef;
+    let ambiguous = false;
+    for (const candidate of classCandidates) {
+        const def = ctx.model.methods.lookupMethodByOwner(candidate.nodeId, className, argCount);
+        if (!def || def.type !== 'Constructor')
+            continue;
+        if (!firstDef) {
+            firstDef = def;
+        }
+        else if (def.nodeId !== firstDef.nodeId) {
+            ambiguous = true;
+            break;
+        }
+    }
+    if (firstDef && !ambiguous) {
+        return toResolveResult(firstDef, typeResolved.tier);
+    }
+    // 4. lookupMethodByOwner found nothing — check whether the tiered pool
+    //    contains Constructor nodes that lack ownerId (common in some extractors).
+    //    If so, bail out so the existing filterCallableCandidates path handles
+    //    Constructor-vs-Class preference correctly.
+    //
+    //    This branch also catches the step-3 ambiguous case (`ambiguous = true`
+    //    with two distinct Constructor nodes across multiple class candidates):
+    //    the same Constructor nodes are indexed under the class name in the
+    //    tiered pool, so `.some(Constructor)` is true here and we defer to
+    //    step 4.5 (overload/arg-type disambiguation) or the caller's fallback.
+    //    Do not remove this check without also handling the ambiguous step-3
+    //    path explicitly.
+    if (typeResolved.candidates.some((c) => c.type === 'Constructor')) {
+        // 4.5. Overload / arg-type disambiguation for ambiguous or ownerless
+        //      Constructor pools. When the caller supplied a narrowing signal
+        //      (AST-based overload hints from the sequential path, or pre-
+        //      computed arg types from the worker path), give disambiguation a
+        //      chance before null-routing. Symmetric with resolveMemberCallByFile's
+        //      disambiguation pass — both resolvers now share the same signal
+        //      precedence via disambiguateByOverloadOrArgTypes. Only fires when
+        //      at least one narrowing signal is present; preserves SM-10 R3 for
+        //      genuinely ambiguous cases with no disambiguating input.
+        if (overloadHints || preComputedArgTypes) {
+            const ctorPool = filterCallableCandidates(typeResolved.candidates, argCount, 'constructor');
+            if (ctorPool.length > 1) {
+                const disambiguated = disambiguateByOverloadOrArgTypes(ctorPool, overloadHints, preComputedArgTypes);
+                if (disambiguated)
+                    return toResolveResult(disambiguated, typeResolved.tier);
+            }
+        }
+        return null;
+    }
+    // 5. No constructor nodes at all — fall back to the class node itself, but
+    //    ONLY when it is actually instantiable. Interface / Trait / Impl / Enum
+    //    are deliberately excluded via `INSTANTIABLE_CLASS_TYPES` to prevent
+    //    false `CALLS` edges from constructor-shaped calls to non-instantiable
+    //    nodes. This also disambiguates the Rust same-file shadowing case
+    //    (`struct User` + `impl User` both present at same-file tier): the
+    //    Impl is stripped, leaving the Struct as the sole instantiable target.
+    //    Addresses Codex review finding on PR #754.
+    const instantiableCandidates = classCandidates.filter((c) => INSTANTIABLE_CLASS_TYPES.has(c.type));
+    // Three outcomes below, in order of likelihood after the fix:
+    //   length === 0 → all candidates were stripped as non-instantiable (e.g.
+    //     Interface / Trait / Impl). Null-route via the fall-through `return
+    //     null` — this is the dominant Codex-fix case.
+    //   length === 1 → a single instantiable candidate remains, return it.
+    //   length  >  1 → two or more instantiable classes share the name (e.g.
+    //     homonym classes across files with no import narrowing). Fall through
+    //     to `return null` so the caller null-routes rather than guess.
+    if (instantiableCandidates.length === 1) {
+        return toResolveResult(instantiableCandidates[0], typeResolved.tier);
+    }
+    return null;
 };
 /**
  * Create a deduplicated ACCESSES edge emitter for a single source node.
@@ -1089,7 +1927,7 @@ const makeAccessEmitter = (graph, sourceId) => {
         });
     };
 };
-const walkMixedChain = (chain, startType, filePath, ctx, onFieldResolved) => {
+const walkMixedChain = (chain, startType, filePath, ctx, onFieldResolved, heritageMap) => {
     let currentType = startType;
     for (const step of chain) {
         if (!currentType)
@@ -1113,7 +1951,24 @@ const walkMixedChain = (chain, startType, filePath, ctx, onFieldResolved) => {
                 currentType = fieldResolved.typeName;
                 continue;
             }
-            const resolved = resolveCallTarget({ calledName: step.name, callForm: 'member', receiverTypeName: currentType }, filePath, ctx);
+            // Fast path: O(1) owner-scoped method lookup via methodByOwner index.
+            // Note: CALLS edges for intermediate chain steps are NOT emitted here — walkMixedChain
+            // only threads types. CALLS edges come from the outer per-call-expression loop in processCalls.
+            //
+            // We call `resolveMethodByOwner` directly (NOT `resolveMemberCall`) because this is
+            // a hot path — called per chain step per call expression — and we only need the
+            // return type string. Going through `resolveMemberCall` would allocate a throwaway
+            // `ResolveResult` with confidence/reason that we immediately discard.
+            const owned = resolveMethodByOwner(currentType, step.name, filePath, ctx, heritageMap);
+            if (owned?.def.returnType) {
+                const fastRetType = extractReturnTypeName(owned.def.returnType);
+                if (fastRetType) {
+                    currentType = fastRetType;
+                    continue;
+                }
+            }
+            // Fallback: resolve via resolveCallTarget dispatcher (delegates to resolveMemberCall)
+            const resolved = resolveCallTarget({ calledName: step.name, callForm: 'member', receiverTypeName: currentType }, filePath, ctx, undefined, undefined, undefined, heritageMap);
             if (!resolved) {
                 // Stdlib passthrough: unwrap(), clone(), etc. preserve the receiver type
                 if (TYPE_PRESERVING_METHODS.has(step.name))
@@ -1138,15 +1993,21 @@ const walkMixedChain = (chain, startType, filePath, ctx, onFieldResolved) => {
 /**
  * Fast path: resolve pre-extracted call sites from workers.
  * No AST parsing — workers already extracted calledName + sourceId.
+ *
+ * @param bindingAccumulator  Phase 9: optional accumulator carrying file-scope
+ *   TypeEnv bindings from all worker-processed files. When the SymbolTable has
+ *   no return type for a cross-file callee, `verifyConstructorBindings` falls
+ *   back to the accumulator via `namedImportMap` to bind the variable to the
+ *   callee's resolved type (e.g. `var x = getUser()` → `x: User`).
  */
-export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onProgress, constructorBindings, implementorMap) => {
+export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onProgress, constructorBindings, heritageMap, bindingAccumulator) => {
     // Scope-aware receiver types: keyed by filePath → "funcName\0varName" → typeName.
     // The scope dimension prevents collisions when two functions in the same file
     // have same-named locals pointing to different constructor types.
     const fileReceiverTypes = new Map();
     if (constructorBindings) {
         for (const { filePath, bindings } of constructorBindings) {
-            const verified = verifyConstructorBindings(bindings, filePath, ctx, graph);
+            const verified = verifyConstructorBindings(bindings, filePath, ctx, graph, bindingAccumulator);
             if (verified.size > 0) {
                 fileReceiverTypes.set(filePath, buildReceiverTypeIndex(verified));
             }
@@ -1215,15 +2076,41 @@ export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onPr
                     }
                 }
                 if (currentType) {
-                    const walkedType = walkMixedChain(effectiveCall.receiverMixedChain, currentType, effectiveCall.filePath, ctx, makeAccessEmitter(graph, effectiveCall.sourceId));
+                    const walkedType = walkMixedChain(effectiveCall.receiverMixedChain, currentType, effectiveCall.filePath, ctx, makeAccessEmitter(graph, effectiveCall.sourceId), heritageMap);
                     if (walkedType) {
                         effectiveCall = { ...effectiveCall, receiverTypeName: walkedType };
                     }
                 }
             }
-            const resolved = resolveCallTarget(effectiveCall, effectiveCall.filePath, ctx, undefined, widenCache, effectiveCall.argTypes);
-            if (!resolved)
+            const resolved = resolveCallTarget(effectiveCall, effectiveCall.filePath, ctx, undefined, widenCache, effectiveCall.argTypes, heritageMap);
+            if (!resolved) {
+                // Vue template component fallback: match calledName against imported .vue basenames
+                if (effectiveCall.filePath.endsWith('.vue') && effectiveCall.sourceId.startsWith('File:')) {
+                    const importedFiles = ctx.importMap.get(effectiveCall.filePath);
+                    if (importedFiles) {
+                        for (const importedPath of importedFiles) {
+                            if (!importedPath.endsWith('.vue'))
+                                continue;
+                            const basename = importedPath.slice(importedPath.lastIndexOf('/') + 1, importedPath.lastIndexOf('.'));
+                            if (basename !== effectiveCall.calledName)
+                                continue;
+                            const targetFileId = generateId('File', importedPath);
+                            if (graph.getNode(targetFileId)) {
+                                graph.addRelationship({
+                                    id: generateId('CALLS', `${effectiveCall.sourceId}:${effectiveCall.calledName}->${targetFileId}`),
+                                    sourceId: effectiveCall.sourceId,
+                                    targetId: targetFileId,
+                                    type: 'CALLS',
+                                    confidence: 0.9,
+                                    reason: 'vue-template-component',
+                                });
+                            }
+                            break;
+                        }
+                    }
+                }
                 continue;
+            }
             const relId = generateId('CALLS', `${effectiveCall.sourceId}:${effectiveCall.calledName}->${resolved.nodeId}`);
             graph.addRelationship({
                 id: relId,
@@ -1233,8 +2120,8 @@ export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onPr
                 confidence: resolved.confidence,
                 reason: resolved.reason,
             });
-            if (implementorMap && effectiveCall.callForm === 'member' && effectiveCall.receiverTypeName) {
-                const implTargets = findInterfaceDispatchTargets(effectiveCall.calledName, effectiveCall.receiverTypeName, effectiveCall.filePath, ctx, implementorMap, resolved.nodeId);
+            if (heritageMap && effectiveCall.callForm === 'member' && effectiveCall.receiverTypeName) {
+                const implTargets = findInterfaceDispatchTargets(effectiveCall.calledName, effectiveCall.receiverTypeName, effectiveCall.filePath, ctx, heritageMap, resolved.nodeId);
                 for (const impl of implTargets) {
                     graph.addRelationship({
                         id: generateId('CALLS', `${effectiveCall.sourceId}:${effectiveCall.calledName}->${impl.nodeId}`),
@@ -1256,12 +2143,12 @@ export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onPr
  * Accepts optional constructorBindings for return-type-aware receiver inference,
  * mirroring processCallsFromExtracted's verified binding lookup.
  */
-export const processAssignmentsFromExtracted = (graph, assignments, ctx, constructorBindings) => {
+export const processAssignmentsFromExtracted = (graph, assignments, ctx, constructorBindings, bindingAccumulator) => {
     // Build per-file receiver type indexes from verified constructor bindings
     const fileReceiverTypes = new Map();
     if (constructorBindings) {
         for (const { filePath, bindings } of constructorBindings) {
-            const verified = verifyConstructorBindings(bindings, filePath, ctx, graph);
+            const verified = verifyConstructorBindings(bindings, filePath, ctx, graph, bindingAccumulator);
             if (verified.size > 0) {
                 fileReceiverTypes.set(filePath, buildReceiverTypeIndex(verified));
             }
@@ -1281,12 +2168,7 @@ export const processAssignmentsFromExtracted = (graph, assignments, ctx, constru
         // Tier 3: static class-as-receiver fallback
         if (!receiverTypeName) {
             const resolved = ctx.resolve(asn.receiverText, asn.filePath);
-            if (resolved?.candidates.some((d) => d.type === 'Class' ||
-                d.type === 'Struct' ||
-                d.type === 'Interface' ||
-                d.type === 'Enum' ||
-                d.type === 'Record' ||
-                d.type === 'Impl')) {
+            if (resolved?.candidates.some((d) => CLASS_LIKE_TYPES.has(d.type))) {
                 receiverTypeName = asn.receiverText;
             }
         }