gitnexus 1.6.6-rc.98 → 1.6.6

package/dist/core/ingestion/scope-resolution/scope/walkers.js

@@ -19,6 +19,7 @@
  * "resolve member on owner with MRO" pattern. All four are reusable
  * as-is for TypeScript, Java, Kotlin, Ruby, etc.
  */
+import { normalizeQualifiedName, splitQualifiedName, stripTrailingTypeArguments, } from '../../utils/qualified-name.js';
 const EMPTY_BINDINGS = Object.freeze([]);
 /**
  * Look up binding refs at `scopeId` for `name`, consulting both the
@@ -45,41 +46,69 @@ export function lookupBindingsAt(scopeId, name, scopes) {
     const finalized = scopes.bindings.get(scopeId)?.get(name);
     const augmented = scopes.bindingAugmentations.get(scopeId)?.get(name);
     const workspace = scopes.workspaceFqnBindings?.get(name);
+    // Per-namespace channel (#1871 named-namespace generalization). Gated by
+    // accessibility: only a *module* scope carries an `accessibleNamespacesByScope`
+    // entry, so this collects nothing at child scopes and at module scopes only for
+    // the namespaces that file can see. Empty (no entry) for every non-C# bundle,
+    // so the behavior of the three pre-existing channels is unchanged.
+    const namespaceRefs = collectNamespaceFqnBindings(scopeId, name, scopes);
     const fLen = finalized?.length ?? 0;
     const aLen = augmented?.length ?? 0;
     const wLen = workspace?.length ?? 0;
-    if (fLen === 0 && aLen === 0 && wLen === 0)
+    const nLen = namespaceRefs?.length ?? 0;
+    if (fLen === 0 && aLen === 0 && wLen === 0 && nLen === 0)
         return EMPTY_BINDINGS;
-    if (aLen === 0 && wLen === 0)
+    if (aLen === 0 && wLen === 0 && nLen === 0)
         return finalized;
-    if (fLen === 0 && wLen === 0)
+    if (fLen === 0 && wLen === 0 && nLen === 0)
         return augmented;
-    if (fLen === 0 && aLen === 0)
+    if (fLen === 0 && aLen === 0 && nLen === 0)
         return workspace;
+    if (fLen === 0 && aLen === 0 && wLen === 0)
+        return namespaceRefs;
+    // Merge in precedence order, deduped by `def.nodeId` so the strongest source
+    // wins duplicate metadata. Named-namespace refs come BEFORE the flat global
+    // `workspace` channel: pre-#1871 these lived in `bindingAugmentations` (which
+    // `lookupBindingsAt` already ranks above `workspaceFqnBindings`), so a name in
+    // both an accessible named namespace and the global namespace must still
+    // resolve named-first. Order: finalized > augmented > namespace > workspace.
     const seen = new Set();
     const out = [];
-    if (fLen > 0) {
-        for (const r of finalized) {
-            seen.add(r.def.nodeId);
-            out.push(r);
-        }
-    }
-    if (aLen > 0) {
-        for (const r of augmented) {
+    for (const src of [finalized, augmented, namespaceRefs, workspace]) {
+        if (src === undefined)
+            continue;
+        for (const r of src) {
             if (seen.has(r.def.nodeId))
                 continue;
             seen.add(r.def.nodeId);
             out.push(r);
         }
     }
-    if (wLen > 0) {
-        for (const r of workspace) {
-            if (seen.has(r.def.nodeId))
-                continue;
-            out.push(r);
+    return out;
+}
+/**
+ * Collect `BindingRef`s for `name` from the per-namespace channel
+ * (`namespaceFqnBindings`) across every namespace accessible from `scopeId`.
+ * Accessibility comes from `accessibleNamespacesByScope`, which is keyed by
+ * *module* scope id — so this returns `undefined` at non-module scopes and at
+ * every scope in a bundle that didn't populate the channel (all non-C# today).
+ * Language-neutral: keyed only by namespace strings and the index.
+ */
+function collectNamespaceFqnBindings(scopeId, name, scopes) {
+    const namespaces = scopes.accessibleNamespacesByScope?.get(scopeId);
+    if (namespaces === undefined || namespaces.length === 0)
+        return undefined;
+    let collected;
+    for (const ns of namespaces) {
+        const bucket = scopes.namespaceFqnBindings?.get(ns)?.get(name);
+        if (bucket !== undefined && bucket.length > 0) {
+            if (collected === undefined)
+                collected = [];
+            for (const r of bucket)
+                collected.push(r);
         }
     }
-    return out;
+    return collected;
 }
 const EMPTY_NAMES = Object.freeze([]);
 /**
@@ -142,6 +171,7 @@ export function isClassLike(t) {
 export function findReceiverTypeBinding(startScope, receiverName, scopes) {
     let currentId = startScope;
     const visited = new Set();
+    let moduleScopeId = null;
     while (currentId !== null) {
         if (visited.has(currentId))
             return undefined;
@@ -152,10 +182,65 @@ export function findReceiverTypeBinding(startScope, receiverName, scopes) {
         const typeRef = scope.typeBindings.get(receiverName);
         if (typeRef !== undefined)
             return typeRef;
+        if (scope.kind === 'Module')
+            moduleScopeId = currentId;
         currentId = scope.parent;
     }
+    // Fallback 1 — named namespaces accessible from this file (own + `using`d),
+    // gated by `accessibleNamespacesByScope`. Consulted BEFORE the global channel
+    // so a more-specific named binding wins, matching the pre-#1871 order where
+    // these lived in the file's own `Scope.typeBindings` (the chain, above the
+    // global fallback). Shared-channel routing avoids the O(files × names) blow-up.
+    const named = namespaceTypeBindingFor(moduleScopeId, receiverName, scopes);
+    if (named !== undefined)
+        return named;
+    // Fallback 2 — global/default namespace: C# global types are visible from
+    // every file (see `workspaceTypeBindings` doc), so this flat channel is the
+    // final, unconditional fallback (#1871).
+    return scopes.workspaceTypeBindings?.get(receiverName);
+}
+/**
+ * Resolve a typeBinding for `name` from the per-namespace channel
+ * (`namespaceTypeBindings`) across the namespaces accessible from `moduleScopeId`.
+ * First accessible-namespace hit wins. Returns `undefined` when the module has no
+ * accessibility entry (non-module scope id, or a bundle that didn't populate the
+ * channel — all non-C# today). Shared by the two typeBindings chain-walkers so
+ * the named-namespace fallback stays identical between them.
+ */
+export function namespaceTypeBindingFor(moduleScopeId, name, scopes) {
+    if (moduleScopeId === null)
+        return undefined;
+    const namespaces = scopes.accessibleNamespacesByScope?.get(moduleScopeId);
+    if (namespaces === undefined)
+        return undefined;
+    for (const ns of namespaces) {
+        const hit = scopes.namespaceTypeBindings?.get(ns)?.get(name);
+        if (hit !== undefined)
+            return hit;
+    }
     return undefined;
 }
+/**
+ * Walk the scope chain from `startScope` to its enclosing Module scope id, or
+ * `null` if none is found. Used by chain-followers that need the module scope to
+ * consult the accessibility-gated per-namespace channels.
+ */
+export function moduleScopeIdOf(startScope, scopes) {
+    let currentId = startScope;
+    const visited = new Set();
+    while (currentId !== null) {
+        if (visited.has(currentId))
+            return null;
+        visited.add(currentId);
+        const scope = scopes.scopeTree.getScope(currentId);
+        if (scope === undefined)
+            return null;
+        if (scope.kind === 'Module')
+            return currentId;
+        currentId = scope.parent;
+    }
+    return null;
+}
 /**
  * Look up a class-like binding by name in the given scope's chain.
  *
@@ -202,6 +287,242 @@ export function findClassBindingInScope(startScope, receiverName, scopes) {
     }
     return undefined;
 }
+/**
+ * Resolve a class-like inheritance target using the shared inheritance
+ * resolution chain. Keeps pre-emitted heritage edges and language-specific
+ * consumers of `inherits` sites aligned.
+ */
+export function resolveInheritanceBaseInScope(startScope, baseName, scopes, rawQualifiedName, enclosingClassDef) {
+    // #1982: when the source wrote a qualified base (`Other::Inner`), resolve it
+    // against the full-path QualifiedNameIndex FIRST, so a same-tail nested base
+    // binds to the matching sibling instead of the first-inserted one that the
+    // simple-tail scope walk picks. Falls through to the existing walk when the
+    // base is unqualified, unknown, or the qualified lookup can't pick a unique
+    // winner — so unqualified bases and the cross-file single-candidate case are
+    // unchanged. `enclosingClassDef` (the deriving class) is threaded from the
+    // caller to skip a redundant enclosing-class walk (#1982 perf).
+    if (rawQualifiedName !== undefined) {
+        const qualified = resolveQualifiedInheritanceBase(startScope, rawQualifiedName, scopes, enclosingClassDef);
+        if (qualified !== undefined)
+            return qualified;
+    }
+    return (findClassBindingInScope(startScope, baseName, scopes) ??
+        resolveAmbiguousInheritanceBaseViaImports(startScope, baseName, scopes));
+}
+/**
+ * Resolve a qualified inheritance base (`Other::Inner`, `ns::Base`) against the
+ * full-path `QualifiedNameIndex` (keyed by `def.qualifiedName`, which carries
+ * the promoted dotted path post-`populateOwners`). Tries the referencing site's
+ * enclosing-scope segments as progressive prefixes (longest first) before the
+ * root-anchored qualifier, so a *relative* base like `Outer::Inner` written
+ * inside `namespace NS` resolves to the root-anchored key `NS.Outer.Inner`.
+ * Returns a unique class-like def, or `undefined` when the base is unqualified,
+ * unknown, or genuinely ambiguous at a key (refuse-on-tie — never guess; a
+ * wrong EXTENDS edge silently corrupts impact analysis).
+ */
+function resolveQualifiedInheritanceBase(startScope, rawQualifiedName, scopes, enclosingClassDef) {
+    const normalized = stripTrailingTypeArguments(normalizeQualifiedName(rawQualifiedName));
+    // No qualifier after normalization → nothing the simple-tail walk doesn't do.
+    if (normalized.length === 0 || !normalized.includes('.'))
+        return undefined;
+    // #1982: a root-anchored base (`::Net::X`) names the GLOBAL scope, so it must
+    // NOT be prefixed with the referencing site's enclosing segments — try only
+    // the root-anchored key. normalizeQualifiedName strips the leading `::`, so
+    // detect the anchor on the raw text (after leading whitespace).
+    const isRootAnchored = /^\s*::/.test(rawQualifiedName);
+    const enclosing = isRootAnchored
+        ? []
+        : enclosingScopeSegments(startScope, scopes, enclosingClassDef);
+    // Candidate keys: longest enclosing prefix first for *relative* qualified
+    // bases (`Outer.Inner` inside `NS.Outer.Derived` → `NS.Outer.Inner`). When the
+    // qualifier names a *different* namespace than the enclosing scope (`new B.Foo()`
+    // inside `namespace A` → `B.Foo`, not `A.Foo`), try the raw normalized key
+    // FIRST so same-tail local bindings don't win (#2046 / #1991).
+    const normParts = splitQualifiedName(normalized);
+    const isRelativeToEnclosing = enclosing.length > 0 &&
+        normParts.length > 0 &&
+        normParts[0] === enclosing[enclosing.length - 1];
+    const keys = [];
+    if (!isRelativeToEnclosing) {
+        keys.push(normalized);
+    }
+    for (let i = enclosing.length; i >= 1; i--) {
+        keys.push([...enclosing.slice(0, i), normalized].join('.'));
+    }
+    if (!keys.includes(normalized)) {
+        keys.push(normalized);
+    }
+    for (const key of keys) {
+        const ids = scopes.qualifiedNames.get(key);
+        if (ids.length === 0)
+            continue;
+        let unique;
+        let count = 0;
+        for (const id of ids) {
+            const def = scopes.defs.get(id);
+            if (def !== undefined && isClassLike(def.type)) {
+                unique = def;
+                count++;
+            }
+        }
+        if (count === 1)
+            return unique;
+        if (count > 1) {
+            // #1993: same-tail bases collide at this namespace-omitted key (`NS1::A::Inner`
+            // and `NS2::A::Inner` both key `A.Inner`). Break the tie with the bridge's
+            // `namespacePrefix` sidecar — prefer the candidate in the SAME enclosing
+            // namespace as the deriving class. Bridge-held: `def.qualifiedName` and the
+            // index keys are untouched; still refuse when the sidecar can't pick a unique.
+            const childPrefix = enclosingClassDef?.namespacePrefix;
+            if (childPrefix !== undefined && childPrefix.length > 0) {
+                let nsUnique;
+                let nsCount = 0;
+                for (const id of ids) {
+                    const def = scopes.defs.get(id);
+                    if (def !== undefined && isClassLike(def.type) && def.namespacePrefix === childPrefix) {
+                        nsUnique = def;
+                        nsCount++;
+                    }
+                }
+                if (nsCount === 1)
+                    return nsUnique;
+            }
+            return undefined; // genuine tie → refuse, don't guess
+        }
+    }
+    // Qualifier-vs-sidecar fallback (#2046). Languages whose class `qualifiedName`
+    // is the SIMPLE name (C#) never populate a qualified key in the index, so the
+    // keyed loop above can't see `B.Foo`. Resolve the simple TAIL and break the
+    // same-tail collision by matching the explicit qualifier (`B`) against each
+    // candidate's `namespacePrefix` sidecar. Commit only on a unique match — a
+    // still-ambiguous qualifier refuses (never guesses a wrong EXTENDS/CALLS edge).
+    const tail = normParts[normParts.length - 1];
+    const qualifier = normParts.slice(0, -1).join('.');
+    if (tail !== undefined && qualifier.length > 0) {
+        const tailIds = scopes.qualifiedNames.get(tail);
+        let qUnique;
+        let qCount = 0;
+        for (const id of tailIds) {
+            const def = scopes.defs.get(id);
+            if (def === undefined || !isClassLike(def.type))
+                continue;
+            const np = def.namespacePrefix;
+            if (np === undefined || np.length === 0)
+                continue;
+            if (np === qualifier || np.endsWith(`.${qualifier}`)) {
+                qUnique = def;
+                qCount++;
+            }
+        }
+        if (qCount === 1)
+            return qUnique;
+    }
+    return undefined;
+}
+/**
+ * Enclosing scope segments of an inheritance site, derived from the deriving
+ * (child) class def's `qualifiedName` minus its own tail. For child
+ * `NS.Other.Derived` this is `['NS', 'Other']`; empty for a file-scope child.
+ * Used to build progressive-prefix lookup keys for relative qualified bases.
+ */
+function enclosingScopeSegments(startScope, scopes, enclosingClassDef) {
+    // Reuse the caller-provided deriving class when available (#1982 perf); only
+    // walk the scope chain when it wasn't threaded in.
+    const child = enclosingClassDef ?? findEnclosingClassDef(startScope, scopes);
+    const q = child?.qualifiedName;
+    if (q === undefined || q.length === 0)
+        return [];
+    const segs = q.split('.').filter(Boolean);
+    return segs.slice(0, -1);
+}
+/**
+ * Import/include-aware disambiguation for an *ambiguous* class-like base
+ * name. Engages ONLY as a fallback after `findClassBindingInScope` has
+ * already returned `undefined` — i.e. the scope-chain walk and the
+ * single-match `qualifiedNames` fast paths could not pick a winner because
+ * several same-named class-like defs exist (e.g. two `class Handler`s in
+ * different headers/namespaces).
+ *
+ * Disambiguates by the referencing file's import graph: the enclosing
+ * module scope's finalized `ImportEdge[]` (C++ `#include`, C# `using`, etc.)
+ * each carry the exporting file in `targetFile`. A candidate whose defining
+ * file is brought in by one of those edges is preferred. Resolution is
+ * tiered, strictest first, and only commits when EXACTLY ONE candidate
+ * survives a tier — so a still-ambiguous name keeps the historical
+ * "return undefined" refusal:
+ *
+ *   1. Exact file match — candidate.filePath === an import's `targetFile`
+ *      (covers C++ `#include "handler_a.h"` → that header's class).
+ *   2. Same-directory match — candidate.filePath sits in the same directory
+ *      as some import target file (covers C# `using MyApp.Models;`, where the
+ *      namespace import resolves to ONE representative file in the namespace's
+ *      directory, not necessarily the file declaring the referenced type).
+ *
+ * Language-neutral: keyed only on the finalized import edges and the
+ * candidate defs' `filePath`. Returns `undefined` (preserving refusal) when
+ * the name is single-match-resolvable already (never reached — caller gates
+ * on `findClassBindingInScope` miss), when no import disambiguates, or when
+ * a tier leaves more than one survivor.
+ */
+export function resolveAmbiguousInheritanceBaseViaImports(startScope, baseName, scopes) {
+    // Gather the class-like candidates that share this simple name. Defs are
+    // indexed by their `qualifiedName` in `qualifiedNames`; for languages whose
+    // class qualifiedName IS the simple name (C++, C#, etc.) this is the full
+    // candidate set. A single candidate is not "ambiguous" — leave it to the
+    // existing single-match fast path (this fallback shouldn't have been called).
+    const candidateIds = scopes.qualifiedNames.get(baseName);
+    if (candidateIds.length < 2)
+        return undefined;
+    const candidates = [];
+    for (const id of candidateIds) {
+        const def = scopes.defs.get(id);
+        if (def !== undefined && isClassLike(def.type))
+            candidates.push(def);
+    }
+    if (candidates.length < 2)
+        return undefined;
+    // Collect the exporting files imported by the referencing file's enclosing
+    // module scope (the chain may carry function-local imports too, but the
+    // module scope is where `#include` / `using` land).
+    const moduleScopeId = moduleScopeIdOf(startScope, scopes);
+    if (moduleScopeId === null)
+        return undefined;
+    const importEdges = scopes.imports.get(moduleScopeId);
+    if (importEdges === undefined || importEdges.length === 0)
+        return undefined;
+    const importedFiles = new Set();
+    const importedDirs = new Set();
+    for (const edge of importEdges) {
+        if (edge.targetFile === null)
+            continue;
+        importedFiles.add(edge.targetFile);
+        importedDirs.add(dirnameOf(edge.targetFile));
+    }
+    if (importedFiles.size === 0)
+        return undefined;
+    // Tier 1 — exact file match (C++ `#include "handler_a.h"`).
+    const exact = candidates.filter((c) => importedFiles.has(c.filePath));
+    if (exact.length === 1)
+        return exact[0];
+    if (exact.length > 1)
+        return undefined; // still ambiguous → refuse
+    // Tier 2 — same-directory match (C# namespace `using`, where the namespace
+    // import resolves to one representative file in the namespace's directory).
+    const sameDir = candidates.filter((c) => importedDirs.has(dirnameOf(c.filePath)));
+    if (sameDir.length === 1)
+        return sameDir[0];
+    return undefined;
+}
+/**
+ * Directory portion of a forward-slash workspace-relative path. Returns `''`
+ * for a bare filename (no directory). Workspace paths are always normalized to
+ * `/` separators upstream, so a simple `lastIndexOf('/')` is sufficient and
+ * keeps this dependency-free.
+ */
+function dirnameOf(filePath) {
+    const idx = filePath.lastIndexOf('/');
+    return idx === -1 ? '' : filePath.slice(0, idx);
+}
 /**
  * Predicate for value-receiver bridge: the labels for which
  * `reconcileOwnership` registers methods/fields under the def's
@@ -472,6 +793,97 @@ export function populateClassOwnedMembers(parsed) {
         }
     }
 }
+/**
+ * Tag every def declared inside one or more `Namespace` scopes with its
+ * enclosing-namespace path (`NS`, `Outer.Inner`) on a sidecar `namespacePrefix`
+ * field — WITHOUT touching `qualifiedName`.
+ *
+ * Some scope-extractors qualify a nested type by its enclosing CLASS chain
+ * (`A.Inner`) but drop the enclosing NAMESPACE, while the structure phase keys
+ * the graph node by the full path (`NS.A.Inner`). `resolveDefGraphId` reads this
+ * tag to retry the node lookup with the namespace-prefixed key before the
+ * simple-name fallback, so same-tail nested bases don't collapse across sibling
+ * namespace members (#1982). `qualifiedName` is deliberately left unchanged, so
+ * the `qualifiedName`-keyed resolution index and existing namespace resolution
+ * (brace-init, UDC ranking, two-phase lookup) are untouched.
+ *
+ * Language-agnostic: it acts only on `Namespace`-kind scopes (a namespace-free
+ * language is a no-op) and is opt-in per provider (call after `populateOwners`).
+ * Namespace segments are taken as each namespace def's own tail, so it composes
+ * for nested namespaces regardless of whether the inner namespace's name is
+ * stored simple or already dotted. Skips defs already carrying the prefix.
+ */
+export function tagNamespacePrefixes(parsed) {
+    const scopesById = new Map();
+    for (const scope of parsed.scopes)
+        scopesById.set(scope.id, scope);
+    // Enclosing-namespace prefix for a scope: the dotted path of each ancestor
+    // Namespace scope's name, outermost-first (`['Outer','Inner'] → 'Outer.Inner'`).
+    const namespacePrefixOf = (scope) => {
+        const segments = [];
+        let parentId = scope.parent;
+        while (parentId !== null) {
+            const parent = scopesById.get(parentId);
+            if (parent === undefined)
+                break;
+            if (parent.kind === 'Namespace') {
+                const nsDef = parent.ownedDefs.find((d) => d.type === 'Namespace');
+                const nsQ = nsDef?.qualifiedName;
+                if (nsQ !== undefined && nsQ.length > 0) {
+                    const dot = nsQ.lastIndexOf('.');
+                    segments.unshift(dot === -1 ? nsQ : nsQ.slice(dot + 1));
+                }
+            }
+            parentId = parent.parent;
+        }
+        return segments.join('.');
+    };
+    for (const scope of parsed.scopes) {
+        if (scope.kind === 'Namespace')
+            continue;
+        const prefix = namespacePrefixOf(scope);
+        if (prefix.length === 0)
+            continue;
+        for (const def of scope.ownedDefs) {
+            const q = def.qualifiedName;
+            if (q === undefined || q.length === 0)
+                continue;
+            if (q === prefix || q.startsWith(`${prefix}.`))
+                continue; // already namespaced
+            def.namespacePrefix = prefix;
+        }
+    }
+    // #1993: also tag defs declared DIRECTLY in a Namespace scope with that
+    // namespace's OWN full path. The loop above only reaches class-nested defs
+    // (`A::Inner`); a deriving class like `NS1::DA` lives in the namespace scope and
+    // is skipped, so it would carry no prefix and a same-tail cross-namespace base
+    // tie (`NS1::A::Inner` vs `NS2::A::Inner`) could not be broken by the deriving
+    // side. Composed identically to the class-nested path (enclosing tails + own
+    // tail) so the two agree; still sidecar-only (`qualifiedName` untouched).
+    for (const scope of parsed.scopes) {
+        if (scope.kind !== 'Namespace')
+            continue;
+        const ownNsDef = scope.ownedDefs.find((d) => d.type === 'Namespace');
+        const ownQ = ownNsDef?.qualifiedName;
+        if (ownQ === undefined || ownQ.length === 0)
+            continue;
+        const ownTail = ownQ.slice(ownQ.lastIndexOf('.') + 1);
+        const parentPrefix = namespacePrefixOf(scope);
+        const fullPrefix = parentPrefix.length > 0 ? `${parentPrefix}.${ownTail}` : ownTail;
+        for (const def of scope.ownedDefs) {
+            if (def.type === 'Namespace')
+                continue;
+            const q = def.qualifiedName;
+            if (q === undefined || q.length === 0)
+                continue;
+            if (q === fullPrefix || q.startsWith(`${fullPrefix}.`))
+                continue; // already namespaced
+            if (def.namespacePrefix !== undefined)
+                continue;
+            def.namespacePrefix = fullPrefix;
+        }
+    }
+}
 /**
  * Walk a scope chain upward looking for the innermost enclosing
  * Class scope and return that class's def. Used by per-language
@@ -532,27 +944,16 @@ export function findExportedDefByName(name, inScope, scopes, index) {
         }
         currentId = scope.parent;
     }
-    // Workspace-wide fallback: iterate every file's Module scope (via
-    // the scope-tied `moduleScopeByFile` lookup) and return the first
-    // locally-declared callable binding matching `name`. First-seen-
-    // by-file wins; bindings filtered to `origin === 'local'` and the
-    // callable types Function/Method/Constructor. We walk scopes here
-    // rather than consult `SemanticModel.symbols.lookupCallableByName`
-    // because the `origin === 'local'` module-export-visibility filter
-    // is a scope concept the raw symbol index doesn't express.
-    for (const [, moduleScope] of index.moduleScopeByFile) {
-        const refs = moduleScope.bindings.get(name);
-        if (refs === undefined)
-            continue;
-        for (const ref of refs) {
-            if (ref.origin !== 'local')
-                continue;
-            const t = ref.def.type;
-            if (t === 'Function' || t === 'Method' || t === 'Constructor')
-                return ref.def;
-        }
-    }
-    return undefined;
+    // Workspace-wide fallback: the first locally-declared callable binding
+    // matching `name` across every file's Module scope (first-seen-by-file wins;
+    // `origin === 'local'`, callable types Function/Method/Constructor). This is
+    // precomputed ONCE into `index.exportedCallableByName` — byte-identical to the
+    // old per-call scan over `moduleScopeByFile`, but O(1) and disk-read-free
+    // (the old scan faulted every module scope in from disk under the out-of-core scope index). We use
+    // this scope-derived index rather than `SemanticModel.symbols.lookupCallableByName`
+    // because the `origin === 'local'` module-export-visibility filter is a scope
+    // concept the raw symbol index doesn't express.
+    return index.exportedCallableByName.get(name);
 }
 /**
  * Find a member of a class by simple name — delegates to

package/dist/core/ingestion/scope-resolution/workspace-index.d.ts

@@ -38,7 +38,7 @@
  *
  * Build cost is O(totalScopes). Read-only after construction.
  */
-import type { ParsedFile, Scope, ScopeId } from '../../../_shared/index.js';
+import type { ParsedFile, Scope, ScopeId, ScopeTree, SymbolDefinition } from '../../../_shared/index.js';
 export interface WorkspaceResolutionIndex {
     /** Class def `nodeId` → that class's `Scope`. */
     readonly classScopeByDefId: ReadonlyMap<string, Scope>;
@@ -48,5 +48,21 @@ export interface WorkspaceResolutionIndex {
     readonly classScopeIdToDefId: ReadonlyMap<ScopeId, string>;
     /** Module scope by file path. */
     readonly moduleScopeByFile: ReadonlyMap<string, Scope>;
+    /** Precomputed `simpleName → first module-local callable def` (the
+     *  workspace-wide fallback of `findExportedDefByName`). Materialized here
+     *  ONCE from the resident module scopes so that fallback is an O(1) lookup
+     *  instead of an O(files) scan over every module scope's bindings on each
+     *  unresolved free call — which, under the disk-backed scopeTree, would
+     *  otherwise fault every module scope in from disk per call (the throughput
+     *  killer). "First module-local callable in `moduleScopeByFile` order" is the
+     *  exact semantics the old scan returned, so it is byte-identical. */
+    readonly exportedCallableByName: ReadonlyMap<string, SymbolDefinition>;
 }
-export declare function buildWorkspaceResolutionIndex(parsedFiles: readonly ParsedFile[]): WorkspaceResolutionIndex;
+/**
+ * Build the workspace scope-lookup index. When `scopeTree` is supplied (the live
+ * pipeline), the `Scope`-valued maps are id-backed views that delegate to it —
+ * so this index never pins `Scope` objects and the disk seal can actually
+ * reclaim them. Without it (unit tests), the legacy direct `Map<K, Scope>` form
+ * is returned unchanged.
+ */
+export declare function buildWorkspaceResolutionIndex(parsedFiles: readonly ParsedFile[], scopeTree?: ScopeTree): WorkspaceResolutionIndex;