gitnexus 1.6.4-rc.2 → 1.6.4-rc.21

package/dist/core/ingestion/scope-resolution/passes/compound-receiver.js

@@ -24,6 +24,16 @@ import { findClassBindingInScope, findExportedDefByName, findReceiverTypeBinding
  *  Practical code rarely exceeds 3-4 hops; the cap prevents
  *  pathological recursion if the receiver text is malformed. */
 const COMPOUND_RECEIVER_MAX_DEPTH = 4;
+const MAP_TUPLE_SENTINEL_RE = /^__MAP_TUPLE_(\d+)__:(.+)$/;
+function parseMapTupleSentinel(text) {
+    const match = MAP_TUPLE_SENTINEL_RE.exec(text);
+    if (match === null)
+        return null;
+    const [, idxStr, rhs] = match;
+    if (idxStr === undefined || rhs === undefined)
+        return null;
+    return { tupleIdx: Number(idxStr), rhs };
+}
 export function resolveCompoundReceiverClass(receiverText, inScope, scopes, index, options = {}, depth = 0) {
     const classScopeByDefId = index.classScopeByDefId;
     if (depth > COMPOUND_RECEIVER_MAX_DEPTH)
@@ -32,12 +42,57 @@ export function resolveCompoundReceiverClass(receiverText, inScope, scopes, inde
     if (text.length === 0)
         return undefined;
     const fieldFallback = options.fieldFallback ?? true;
-    // Bare identifier — resolve via typeBinding then class lookup.
+    // Bare identifier — resolve via typeBinding first, then fall back to
+    // a direct class-name lookup. The class-name fallback handles
+    // "static receiver" shapes like `UserService.findUser()` where
+    // `UserService` isn't a variable but a class imported into scope.
     if (!text.includes('.') && !text.includes('(')) {
+        const mapTuple = parseMapTupleSentinel(text);
+        if (mapTuple !== null) {
+            const rhsTb = findReceiverTypeBinding(inScope, mapTuple.rhs, scopes);
+            if (rhsTb === undefined)
+                return undefined;
+            const arg = extractShallowMapTypeArgByIndex(rhsTb.rawName, mapTuple.tupleIdx);
+            if (arg === undefined)
+                return undefined;
+            return findClassBindingInScope(rhsTb.declaredAtScope, arg, scopes);
+        }
         const tb = findReceiverTypeBinding(inScope, text, scopes);
-        if (tb === undefined)
-            return undefined;
-        return findClassBindingInScope(tb.declaredAtScope, tb.rawName, scopes);
+        if (tb !== undefined) {
+            // Map for-of: binding name is `user` but rawType is
+            // `__MAP_TUPLE_i__:entries` (see captures.ts) — same extraction as
+            // the literal-sentinel branch above.
+            const boundMapTuple = parseMapTupleSentinel(tb.rawName);
+            if (boundMapTuple !== null) {
+                const rhsTb = findReceiverTypeBinding(inScope, boundMapTuple.rhs, scopes);
+                if (rhsTb === undefined)
+                    return undefined;
+                const arg = extractShallowMapTypeArgByIndex(rhsTb.rawName, boundMapTuple.tupleIdx);
+                if (arg === undefined)
+                    return undefined;
+                return findClassBindingInScope(rhsTb.declaredAtScope, arg, scopes);
+            }
+            const viaTb = findClassBindingInScope(tb.declaredAtScope, tb.rawName, scopes);
+            if (viaTb !== undefined)
+                return viaTb;
+            // Member-alias / call-result shapes store the RHS path on rawName
+            // (`user.address`, `addr.getCity`) — resolve as a compound chain.
+            if (tb.rawName.includes('.') && !tb.rawName.includes('(')) {
+                const dotted = resolveCompoundReceiverClass(tb.rawName, inScope, scopes, index, options, depth + 1);
+                if (dotted !== undefined)
+                    return dotted;
+                const dottedCall = resolveCompoundReceiverClass(`${tb.rawName}()`, inScope, scopes, index, options, depth + 1);
+                if (dottedCall !== undefined)
+                    return dottedCall;
+            }
+            // Callable alias (`const user = getUser()` → type rawName `getUser`)
+            if (!tb.rawName.includes('.') && !tb.rawName.includes('(')) {
+                const callAlias = resolveCompoundReceiverClass(`${tb.rawName}()`, inScope, scopes, index, options, depth + 1);
+                if (callAlias !== undefined)
+                    return callAlias;
+            }
+        }
+        return findClassBindingInScope(inScope, text, scopes);
     }
     // Trailing `()` — call expression. Strip it and resolve the function
     // expression's return type. We only handle the canonical `f()` /
@@ -120,12 +175,33 @@ export function resolveCompoundReceiverClass(receiverText, inScope, scopes, inde
                 }
             }
         }
+        // `Map<K,V>.values()` / `this.repos.values()` — lib `Map` often has no
+        // parsed return-type binding; infer `V` from the receiver field's
+        // `Map<…>` annotation when the method is `values`.
+        if (retType === undefined && methodName === 'values') {
+            const mapVal = resolveMapValueTypeNameFromPrefix(objExpr, inScope, scopes, index, options);
+            if (mapVal !== undefined) {
+                retType = {
+                    rawName: mapVal,
+                    declaredAtScope: inScope,
+                    source: 'return-annotation',
+                };
+            }
+        }
         if (retType === undefined)
             return undefined;
         return findClassBindingInScope(retType.declaredAtScope, retType.rawName, scopes);
     }
-    // Pure dotted access `obj.field[.field]…` — walk fields.
-    const parts = text.split('.');
+    // Mixed dotted + call chain: `obj.field.method().field.method()…`.
+    // Split at top-level `.` (those NOT inside balanced `(...)`) so a
+    // middle segment like `getUser()` stays intact. Each segment is
+    // either a bare identifier `field` OR `method(...)` — the former
+    // resolves via the current class's typeBindings (field → type),
+    // the latter resolves via the current class's typeBindings
+    // (method return-type). We accept both on each hop because class
+    // scopes store both method return types and field types under
+    // `typeBindings` keyed by the member name.
+    const parts = splitChainAtTopLevel(text);
     // Language-specific collection-accessor suffix (C#'s `data.Values`
     // on Dictionary<K,V>, etc.). When the provider hook recognizes
     // the final segment and unwraps the receiver's generic, return
@@ -133,6 +209,9 @@ export function resolveCompoundReceiverClass(receiverText, inScope, scopes, inde
     // because Dictionary-family types aren't local class defs.
     if (options.unwrapCollectionAccessor !== undefined && parts.length >= 2) {
         const last = parts[parts.length - 1];
+        const headInner = parts[0];
+        if (last === undefined || headInner === undefined)
+            return undefined;
         const prefix = parts.slice(0, -1).join('.');
         let prefixType;
         if (parts.length === 2) {
@@ -143,16 +222,18 @@ export function resolveCompoundReceiverClass(receiverText, inScope, scopes, inde
             // to find its typeRef. We need the TypeRef (not the class def)
             // because the hook inspects the raw generic args (e.g.
             // `Dictionary<string, User>`).
-            const headInner = parts[0];
             let cur = findReceiverTypeBinding(inScope, headInner, scopes);
             for (let i = 1; i < parts.length - 1 && cur !== undefined; i++) {
+                const segment = parts[i];
+                if (segment === undefined)
+                    break;
                 const cls = findClassBindingInScope(cur.declaredAtScope, cur.rawName, scopes);
                 if (cls === undefined) {
                     cur = undefined;
                     break;
                 }
                 const cs = classScopeByDefId.get(cls.nodeId);
-                cur = cs?.typeBindings.get(parts[i]);
+                cur = cs?.typeBindings.get(segment);
             }
             prefixType = cur;
         }
@@ -164,20 +245,108 @@ export function resolveCompoundReceiverClass(receiverText, inScope, scopes, inde
         }
     }
     const head = parts[0];
-    const headType = findReceiverTypeBinding(inScope, head, scopes);
+    if (head === undefined)
+        return undefined;
+    const headMemberName = stripCallParens(head);
+    const headType = findReceiverTypeBinding(inScope, headMemberName, scopes);
     let currentClass = headType
         ? findClassBindingInScope(headType.declaredAtScope, headType.rawName, scopes)
-        : undefined;
+        : findClassBindingInScope(inScope, headMemberName, scopes);
+    // `const user = getUser(); user.address` — the typeBinding for `user`
+    // is an alias to the callee name (`getUser`), not a class. When
+    // `findClassBinding` on that rawName fails, treat it as a zero-arg
+    // call so return-type hoisting resolves to the class (`User`).
+    if (currentClass === undefined &&
+        headType !== undefined &&
+        !headType.rawName.includes('.') &&
+        !headType.rawName.includes('(')) {
+        currentClass = resolveCompoundReceiverClass(`${headType.rawName}()`, inScope, scopes, index, options, depth + 1);
+    }
     for (let i = 1; i < parts.length && currentClass !== undefined; i++) {
-        const fieldName = parts[i];
+        const segment = parts[i];
+        if (segment === undefined)
+            break;
+        const memberName = stripCallParens(segment);
         const cs = classScopeByDefId.get(currentClass.nodeId);
-        const fieldType = cs?.typeBindings.get(fieldName);
-        if (fieldType === undefined)
+        let memberType = cs?.typeBindings.get(memberName);
+        if (memberType === undefined &&
+            options.hoistTypeBindingsToModule === true &&
+            cs !== undefined) {
+            let curId = cs.parent;
+            while (curId !== null) {
+                const curScope = scopes.scopeTree.getScope(curId);
+                if (curScope === undefined)
+                    break;
+                const cand = curScope.typeBindings.get(memberName);
+                if (cand !== undefined) {
+                    memberType = cand;
+                    break;
+                }
+                curId = curScope.parent;
+            }
+        }
+        if (memberType === undefined) {
+            // Trailing segment may be a method name without `()` — e.g.
+            // `this.repos.values` from a for-of iterable capture. Try the
+            // call-shaped resolver before giving up.
+            if (!segment.includes('(')) {
+                const prefix = parts.slice(0, i).join('.');
+                const asCall = resolveCompoundReceiverClass(`${prefix}.${memberName}()`, inScope, scopes, index, options, depth + 1);
+                if (asCall !== undefined)
+                    return asCall;
+            }
             return undefined;
-        currentClass = findClassBindingInScope(fieldType.declaredAtScope, fieldType.rawName, scopes);
+        }
+        let nextClass = findClassBindingInScope(memberType.declaredAtScope, memberType.rawName, scopes);
+        if (nextClass === undefined) {
+            const fromMap = unwrapMapValueToClass(memberType, scopes);
+            if (fromMap !== undefined)
+                nextClass = fromMap;
+        }
+        currentClass = nextClass;
     }
     return currentClass;
 }
+/**
+ * Split a chain expression like `a.b().c.d()` at top-level `.`
+ * separators — i.e. `.` characters NOT nested inside balanced
+ * `(...)`, `[...]`, or `<...>` delimiters. Returns the segments in
+ * order: `['a', 'b()', 'c', 'd()']`. Malformed input falls back to
+ * a plain `split('.')`.
+ */
+function splitChainAtTopLevel(text) {
+    const out = [];
+    let depth = 0;
+    let last = 0;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === '(' || ch === '[' || ch === '<')
+            depth++;
+        else if (ch === ')' || ch === ']' || ch === '>')
+            depth = Math.max(0, depth - 1);
+        else if (ch === '.' && depth === 0) {
+            out.push(text.slice(last, i));
+            last = i + 1;
+        }
+    }
+    out.push(text.slice(last));
+    // Guard against pathological input (`a.` / `.a`) — drop empties.
+    return out.filter((s) => s.length > 0);
+}
+/**
+ * Strip a trailing `(...)` from a chain segment so typeBinding lookup
+ * uses the member name: `'getUser()'` → `'getUser'`. Leaves bare
+ * identifiers (`'address'`) unchanged. Arguments inside the parens
+ * are discarded — the compound resolver is return-type only.
+ */
+function stripCallParens(segment) {
+    if (!segment.endsWith(')'))
+        return segment;
+    const open = segment.indexOf('(');
+    if (open === -1)
+        return segment;
+    return segment.slice(0, open);
+}
 /** Find the index of the `(` that matches the trailing `)` of a
  *  call-expression text. Returns -1 if unbalanced. */
 function matchingOpenParen(text) {
@@ -196,3 +365,103 @@ function matchingOpenParen(text) {
     }
     return -1;
 }
+/** Type arguments of a shallow `Map<K,V>` / `ReadonlyMap<K,V>` (depth-aware). */
+function extractShallowMapTypeArgByIndex(mapText, wantIndex) {
+    const t = mapText.trim();
+    const m = /^(?:ReadonlyMap|Map)\s*</.exec(t);
+    if (m === null || m.index !== 0)
+        return undefined;
+    const openIdx = m[0].length - 1;
+    if (t[openIdx] !== '<')
+        return undefined;
+    let depth = 1;
+    const args = [];
+    let segStart = openIdx + 1;
+    for (let i = openIdx + 1; i < t.length; i++) {
+        const ch = t[i];
+        if (ch === '<')
+            depth++;
+        else if (ch === '>') {
+            depth--;
+            if (depth === 0) {
+                const tail = t.slice(segStart, i).trim();
+                if (tail.length > 0)
+                    args.push(tail);
+                break;
+            }
+        }
+        else if (ch === ',' && depth === 1) {
+            args.push(t.slice(segStart, i).trim());
+            segStart = i + 1;
+        }
+    }
+    const picked = args[wantIndex]?.trim();
+    return picked !== undefined && picked.length > 0 ? picked : undefined;
+}
+function unwrapMapValueToClass(memberType, scopes) {
+    const v = extractShallowMapTypeArgByIndex(memberType.rawName, 1);
+    if (v === undefined)
+        return undefined;
+    return findClassBindingInScope(memberType.declaredAtScope, v, scopes);
+}
+/**
+ * Walk `objExpr` as a field chain (`this.repos`) and return the `V`
+ * type name from a terminal `Map<K,V>` field binding — used when
+ * resolving `.values()` without a parsed stdlib return type.
+ */
+function resolveMapValueTypeNameFromPrefix(objExpr, inScope, scopes, index, options) {
+    const classScopeByDefId = index.classScopeByDefId;
+    const parts = splitChainAtTopLevel(objExpr);
+    const head = parts[0];
+    if (head === undefined)
+        return undefined;
+    const headMemberName = stripCallParens(head);
+    const headType = findReceiverTypeBinding(inScope, headMemberName, scopes);
+    let currentClass = headType
+        ? findClassBindingInScope(headType.declaredAtScope, headType.rawName, scopes)
+        : findClassBindingInScope(inScope, headMemberName, scopes);
+    if (currentClass === undefined &&
+        headType !== undefined &&
+        !headType.rawName.includes('.') &&
+        !headType.rawName.includes('(')) {
+        currentClass = resolveCompoundReceiverClass(`${headType.rawName}()`, inScope, scopes, index, options, 1);
+    }
+    let lastMemberType;
+    for (let i = 1; i < parts.length && currentClass !== undefined; i++) {
+        const segment = parts[i];
+        if (segment === undefined)
+            break;
+        const memberName = stripCallParens(segment);
+        const cs = classScopeByDefId.get(currentClass.nodeId);
+        if (cs === undefined)
+            return undefined;
+        let memberType = cs.typeBindings.get(memberName);
+        if (memberType === undefined && options.hoistTypeBindingsToModule === true) {
+            let curId = cs.parent;
+            while (curId !== null) {
+                const curScope = scopes.scopeTree.getScope(curId);
+                if (curScope === undefined)
+                    break;
+                const cand = curScope.typeBindings.get(memberName);
+                if (cand !== undefined) {
+                    memberType = cand;
+                    break;
+                }
+                curId = curScope.parent;
+            }
+        }
+        if (memberType === undefined)
+            return undefined;
+        lastMemberType = memberType;
+        let nextClass = findClassBindingInScope(memberType.declaredAtScope, memberType.rawName, scopes);
+        if (nextClass === undefined) {
+            const fromMap = unwrapMapValueToClass(memberType, scopes);
+            if (fromMap !== undefined)
+                nextClass = fromMap;
+        }
+        currentClass = nextClass;
+    }
+    if (lastMemberType === undefined)
+        return undefined;
+    return extractShallowMapTypeArgByIndex(lastMemberType.rawName, 1);
+}

package/dist/core/ingestion/scope-resolution/passes/imported-return-types.d.ts

@@ -14,8 +14,29 @@
  *     populated) but BEFORE `resolveReferenceSites` (so resolution
  *     sees the propagated types).
  *
- * Generic; promoted from `languages/python/scope-resolver.ts` per the scope-resolution
- * generalization plan.
+ * **Ordering invariant (added 2026-04-24, RFC #909 Ring 3 / PR #1050):**
+ * The pass walks files in `indexes.sccs` reverse-topological order
+ * (leaves first per `tarjanSccs`). For each importer we chain-follow
+ * the source module's typeBindings BEFORE mirroring, so a multi-hop
+ * alias chain like
+ *
+ *   models.ts: function getUser(): User
+ *   service.ts: export const user = getUser()        // user → getUser
+ *   app.ts: import { user } from './service'         // user → ?
+ *
+ * collapses to `app.user → User` in a single pass instead of stopping
+ * at the intermediate `getUser` ref. The motivating regression is the
+ * `ts-simple` integration fixture (`gitnexus/test/fixtures/scope-
+ * resolution/cross-file-binding/ts-simple/`), where `user.save()` and
+ * `user.getName()` only resolve when the chain collapse happens
+ * topologically.
+ *
+ * Cyclic SCCs reach a partial fixpoint via the same mirror step but
+ * are not guaranteed to fully resolve — see the `ts-circular`
+ * fixture, which only asserts pipeline-no-throw.
+ *
+ * Generic; promoted from `languages/python/scope-resolver.ts` per the
+ * scope-resolution generalization plan.
  */
 import type { ParsedFile } from '../../../../_shared/index.js';
 import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';

package/dist/core/ingestion/scope-resolution/passes/imported-return-types.js

@@ -14,10 +14,39 @@
  *     populated) but BEFORE `resolveReferenceSites` (so resolution
  *     sees the propagated types).
  *
- * Generic; promoted from `languages/python/scope-resolver.ts` per the scope-resolution
- * generalization plan.
+ * **Ordering invariant (added 2026-04-24, RFC #909 Ring 3 / PR #1050):**
+ * The pass walks files in `indexes.sccs` reverse-topological order
+ * (leaves first per `tarjanSccs`). For each importer we chain-follow
+ * the source module's typeBindings BEFORE mirroring, so a multi-hop
+ * alias chain like
+ *
+ *   models.ts: function getUser(): User
+ *   service.ts: export const user = getUser()        // user → getUser
+ *   app.ts: import { user } from './service'         // user → ?
+ *
+ * collapses to `app.user → User` in a single pass instead of stopping
+ * at the intermediate `getUser` ref. The motivating regression is the
+ * `ts-simple` integration fixture (`gitnexus/test/fixtures/scope-
+ * resolution/cross-file-binding/ts-simple/`), where `user.save()` and
+ * `user.getName()` only resolve when the chain collapse happens
+ * topologically.
+ *
+ * Cyclic SCCs reach a partial fixpoint via the same mirror step but
+ * are not guaranteed to fully resolve — see the `ts-circular`
+ * fixture, which only asserts pipeline-no-throw.
+ *
+ * Generic; promoted from `languages/python/scope-resolver.ts` per the
+ * scope-resolution generalization plan.
+ */
+import { lookupBindingsAt, namesAtScope } from '../scope/walkers.js';
+/**
+ * Max chain depth for the post-finalize re-follow. Effective end-to-end
+ * depth is roughly 2× this number, because chain-following runs once
+ * inside each importer's source module before mirroring AND once on
+ * the importer's own typeBindings after mirroring; deeply nested
+ * intra-module aliases can compose with cross-file aliases of the same
+ * depth. 8 covers all production fixtures with headroom.
  */
-/** Max chain depth for the post-finalize re-follow. */
 const RECHAIN_MAX_DEPTH = 8;
 /** Walk `ref.rawName` through the scope chain's typeBindings looking
  *  for a terminal class-like rawName. Mirrors the in-extractor
@@ -78,47 +107,90 @@ function followChainPostFinalize(start, fromScopeId, scopes) {
  */
 export function propagateImportedReturnTypes(parsedFiles, indexes, index) {
     const moduleScopeByFile = index.moduleScopeByFile;
-    for (const parsed of parsedFiles) {
-        const importerModule = moduleScopeByFile.get(parsed.filePath);
-        if (importerModule === undefined)
-            continue;
-        const finalizedBindings = indexes.bindings.get(importerModule.id);
-        if (finalizedBindings === undefined)
-            continue;
-        for (const [localName, refs] of finalizedBindings) {
-            // Skip if importer already has a typeBinding for this name (e.g.
-            // an explicit local annotation should win over import-derived).
-            if (importerModule.typeBindings.has(localName))
+    // Walk SCCs in reverse-topological order (`indexes.sccs` is leaves-
+    // first per `tarjanSccs`). For each file we mirror import bindings
+    // AFTER chain-following the source module's typeBindings, so a
+    // multi-hop alias chain like
+    //   models.ts: function getUser(): User
+    //   service.ts: export const user = getUser()        // user → getUser
+    //   app.ts: import { user } from './service'         // user → ?
+    // collapses to `app.user → User` instead of stopping at the
+    // intermediate `getUser` ref. Without topological ordering, app.ts
+    // could be processed before service.ts had its own typeBindings
+    // chain-followed, leaving the importer with an unresolvable interim
+    // ref. Cyclic SCCs reach a partial fixpoint via the same mirror
+    // step but are not guaranteed to fully resolve — see the
+    // ts-circular cross-file-binding fixture which only asserts that
+    // the pipeline does not throw.
+    for (const scc of indexes.sccs) {
+        for (const filePath of scc.files) {
+            const importerModule = moduleScopeByFile.get(filePath);
+            if (importerModule === undefined)
                 continue;
-            for (const ref of refs) {
-                if (ref.origin !== 'import' && ref.origin !== 'reexport')
-                    continue;
-                const sourceModule = moduleScopeByFile.get(ref.def.filePath);
-                if (sourceModule === undefined)
+            // Iterate finalized + augmented binding names at this scope so
+            // post-finalize hooks (e.g. `using static` augmentations from
+            // `populateCsharpNamespaceSiblings`) are visible to the
+            // import-derived typeBinding mirror. Both helpers fast-path when
+            // no augmentations exist for the scope, so the common case is
+            // allocation-free. See I8.
+            for (const localName of namesAtScope(importerModule.id, indexes)) {
+                // Skip if importer already has a typeBinding for this name —
+                // an explicit local annotation must win over import-derived.
+                if (importerModule.typeBindings.has(localName))
                     continue;
-                // The source file's typeBinding is keyed by the def's simple
-                // name (e.g. `get_user`), not the importer's local alias. Use
-                // the def's qualifiedName tail.
-                const qn = ref.def.qualifiedName;
-                if (qn === undefined)
-                    continue;
-                const dot = qn.lastIndexOf('.');
-                const sourceName = dot === -1 ? qn : qn.slice(dot + 1);
-                const sourceTypeRef = sourceModule.typeBindings.get(sourceName);
-                if (sourceTypeRef === undefined)
-                    continue;
-                // Mirror the binding under the importer's local alias —
-                // mutating typeBindings is safe because draftToScope produced
-                // a non-frozen Map.
-                importerModule.typeBindings.set(localName, sourceTypeRef);
-                break;
+                const refs = lookupBindingsAt(importerModule.id, localName, indexes);
+                for (const ref of refs) {
+                    if (ref.origin !== 'import' && ref.origin !== 'reexport')
+                        continue;
+                    const sourceModule = moduleScopeByFile.get(ref.def.filePath);
+                    if (sourceModule === undefined)
+                        continue;
+                    // The source file's typeBinding is keyed by the def's simple
+                    // name (e.g. `get_user`), not the importer's local alias.
+                    const qn = ref.def.qualifiedName;
+                    if (qn === undefined)
+                        continue;
+                    const dot = qn.lastIndexOf('.');
+                    const sourceName = dot === -1 ? qn : qn.slice(dot + 1);
+                    const sourceTypeRef = sourceModule.typeBindings.get(sourceName);
+                    if (sourceTypeRef === undefined)
+                        continue;
+                    // Chain-follow inside the source module so we mirror the
+                    // terminal type, not an intermediate intra-source reference.
+                    const terminal = followChainPostFinalize(sourceTypeRef, sourceModule.id, indexes);
+                    // Mutating typeBindings is safe because draftToScope
+                    // produced a non-frozen Map (Contract Invariant I3/I8).
+                    importerModule.typeBindings.set(localName, terminal);
+                    // First-write-wins for the local alias: if the same
+                    // `localName` was registered multiple times via
+                    // `mergeBindings` (rare; happens with conflicting
+                    // re-exports), only the first ref with a usable
+                    // typeBinding source is mirrored. Conflict resolution
+                    // among multiple sources is the merger's job, not ours.
+                    break;
+                }
+            }
+            // Chain-follow this importer's own module typeBindings now —
+            // any local `const x = importedFn()` resolves while we have
+            // freshly-mirrored bindings, and downstream importers in a
+            // later (closer-to-root) SCC will see x's terminal type rather
+            // than an intra-module call ref.
+            for (const [name, ref] of importerModule.typeBindings) {
+                const resolved = followChainPostFinalize(ref, importerModule.id, indexes);
+                if (resolved !== ref) {
+                    importerModule.typeBindings.set(name, resolved);
+                }
             }
         }
     }
-    // Re-follow chains across every scope so chains terminating in a
-    // freshly-propagated import binding resolve to their terminal type.
+    // Final pass: chain-follow non-module scopes (function-local
+    // typeBindings). Module scopes were already followed inside the
+    // SCC loop above.
     for (const parsed of parsedFiles) {
+        const moduleScopeId = moduleScopeByFile.get(parsed.filePath)?.id;
         for (const scope of parsed.scopes) {
+            if (scope.id === moduleScopeId)
+                continue;
             for (const [name, ref] of scope.typeBindings) {
                 const resolved = followChainPostFinalize(ref, scope.id, indexes);
                 if (resolved !== ref) {

package/dist/core/ingestion/scope-resolution/passes/mro.js

@@ -86,8 +86,10 @@ export const defaultLinearize = (_classDefId, directParents, parentsByDefId) =>
     const ancestors = [];
     const visited = new Set();
     const queue = [...directParents];
-    while (queue.length > 0) {
+    for (;;) {
         const cur = queue.shift();
+        if (cur === undefined)
+            break;
         if (visited.has(cur))
             continue;
         visited.add(cur);

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.js

@@ -234,10 +234,10 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                 }
             }
             // ── Case 3b: chain-typebinding (`city → user.get_city`) ──────
-            if (typeRef !== undefined &&
-                typeRef.rawName.includes('.') &&
-                !typeRef.rawName.includes('(') &&
-                !namespaceTargets.has(typeRef.rawName.split('.')[0])) {
+            const chainHead = typeRef !== undefined && typeRef.rawName.includes('.') && !typeRef.rawName.includes('(')
+                ? (typeRef.rawName.split('.', 1)[0] ?? '')
+                : undefined;
+            if (typeRef !== undefined && chainHead !== undefined && !namespaceTargets.has(chainHead)) {
                 // Try the plain dotted-field walk first — covers property /
                 // collection-accessor shapes (`.Values`, Kotlin `.size`) and
                 // field chains. Fall back to call-form (`x()`) which treats
@@ -269,7 +269,15 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
             }
             // ── Case 4: simple typeBinding (`u: U`) ──────────────────────
             if (typeRef !== undefined && !typeRef.rawName.includes('.')) {
-                const ownerDef = findClassBindingInScope(site.inScope, typeRef.rawName, scopes);
+                let ownerDef = findClassBindingInScope(site.inScope, typeRef.rawName, scopes);
+                // `findClassBindingInScope(..., typeRef.rawName)` only works when
+                // rawName is itself a class symbol. Map for-of tuple bindings
+                // (`__MAP_TUPLE_i__:mapId`), callable aliases (`getUser` → User),
+                // and other compound-friendly shapes need the compound resolver
+                // keyed by the receiver identifier.
+                if (ownerDef === undefined) {
+                    ownerDef = resolveCompoundReceiverClass(receiverName, site.inScope, scopes, index, compoundOpts);
+                }
                 if (ownerDef !== undefined) {
                     const chain = [ownerDef.nodeId, ...scopes.methodDispatch.mroFor(ownerDef.nodeId)];
                     let memberDef;

package/dist/core/ingestion/scope-resolution/pipeline/phase.js

@@ -32,7 +32,7 @@ import { getLanguageFromFilename } from '../../../../_shared/index.js';
 import { readFileContents } from '../../filesystem-walker.js';
 import { runScopeResolution } from './run.js';
 import { SCOPE_RESOLVERS } from './registry.js';
-import { isDev } from '../../utils/env.js';
+import { isDev, isSemanticModelValidatorEnabled } from '../../utils/env.js';
 const NOOP_OUTPUT = Object.freeze({
     ran: false,
     filesProcessed: 0,
@@ -87,14 +87,23 @@ export const scopeResolutionPhase = {
                 if (content !== undefined)
                     files.push({ path: fp, content });
             }
+            // Load per-language import-resolution config (tsconfig paths,
+            // composer.json autoload, go.mod, ...). One I/O round trip per
+            // workspace pass — cached implicitly by the result handed to
+            // every `resolveImportTarget` call below.
+            const resolutionConfig = provider.loadResolutionConfig !== undefined
+                ? await provider.loadResolutionConfig(ctx.repoPath)
+                : undefined;
             const stats = runScopeResolution({
                 graph: ctx.graph,
                 model,
                 files,
                 treeCache: scopeTreeCache,
+                resolutionConfig,
                 onWarn: (msg) => {
-                    if (isDev)
+                    if (isSemanticModelValidatorEnabled()) {
                         console.warn(`[scope-resolution:${lang}] ${msg}`);
+                    }
                 },
             }, provider);
             anyRan = true;