@quolu/lattice 0.69.5 → 0.71.0

package/sensor/dist/resolution/name-matcher.js

@@ -4,15 +4,52 @@
  *
  * Handles symbol name matching for reference resolution.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.matchByFilePath = matchByFilePath;
 exports.sameLanguageFamily = sameLanguageFamily;
-exports.isKnownLanguageFamily = isKnownLanguageFamily;
-exports.crossesKnownFamily = crossesKnownFamily;
+exports.crossesCodeBoundary = crossesCodeBoundary;
+exports.gateLanguageMatch = gateLanguageMatch;
 exports.matchFunctionRef = matchFunctionRef;
+exports.isVisibleAcrossFiles = isVisibleAcrossFiles;
 exports.matchByExactName = matchByExactName;
 exports.matchByQualifiedName = matchByQualifiedName;
 exports.preferCallSiteFile = preferCallSiteFile;
+exports.resolveObjectLiteralMember = resolveObjectLiteralMember;
+exports.objectLiteralMemberBinding = objectLiteralMemberBinding;
+exports.resolveObjectLiteralBinding = resolveObjectLiteralBinding;
 exports.resolveMethodOnType = resolveMethodOnType;
 exports.matchCppCallChain = matchCppCallChain;
 exports.matchScopedCallChain = matchScopedCallChain;
@@ -21,9 +58,16 @@ exports.normalizeInferredTypeName = normalizeInferredTypeName;
 exports.clearNameMatcherMemos = clearNameMatcherMemos;
 exports.localReceiverTypePatterns = localReceiverTypePatterns;
 exports.matchMethodCall = matchMethodCall;
+exports.rustFieldTypeName = rustFieldTypeName;
+exports.matchJsStoreBindingCall = matchJsStoreBindingCall;
+exports.isUnresolvedJsMemberCall = isUnresolvedJsMemberCall;
 exports.matchFuzzy = matchFuzzy;
 exports.dumpNameMatcherProfile = dumpNameMatcherProfile;
 exports.matchReference = matchReference;
+const path = __importStar(require("path"));
+const types_1 = require("./types");
+const strip_comments_1 = require("./strip-comments");
+const js_builtins_1 = require("./js-builtins");
 /**
  * Ceiling on how many same-named definitions a FUZZY name-match strategy will
  * score. A name defined more times than this is "ubiquitous" — a method/symbol
@@ -143,14 +187,16 @@ function pickClosestFileNode(candidates, ref) {
  */
 const LANGUAGE_FAMILY = {
     java: 'jvm', kotlin: 'jvm', scala: 'jvm',
-    swift: 'apple', objc: 'apple',
+    swift: 'native', objc: 'native',
     // ArkTS is a TS superset — every HarmonyOS project mixes `.ets` UI with
     // `.ts` logic modules, so refs must cross freely between them.
     typescript: 'web', tsx: 'web', javascript: 'web', jsx: 'web', arkts: 'web',
-    c: 'c', cpp: 'c',
+    c: 'native', cpp: 'native',
     // Razor/Blazor markup names C# types — same family so `@model Foo` /
     // `<MyComponent/>` resolve to their `.cs` class through the cross-family gate.
-    csharp: 'dotnet', razor: 'dotnet',
+    csharp: 'dotnet', razor: 'dotnet', vbnet: 'dotnet',
+    svelte: 'web', vue: 'web', astro: 'web',
+    cfml: 'cfml', cfscript: 'cfml',
 };
 function sameLanguageFamily(a, b) {
     if (a === b)
@@ -158,62 +204,324 @@ function sameLanguageFamily(a, b) {
     const fa = LANGUAGE_FAMILY[a];
     return fa !== undefined && fa === LANGUAGE_FAMILY[b];
 }
-/**
- * True when `lang` belongs to a known multi-language family (jvm/apple/web/c).
- * Languages not listed (php, python, go, ruby, rust, dart, …) and config
- * formats (yaml/xml/blade) form their own singleton families and return
- * `false` — used to leave config↔code framework bridges (whose config side is
- * never a known programming-language family) out of the cross-family gate.
- */
-function isKnownLanguageFamily(lang) {
-    return LANGUAGE_FAMILY[lang] !== undefined;
+/** Config/markup transitions stay open; every other code language has a family. */
+const CODE_FAMILY = {
+    ...LANGUAGE_FAMILY,
+    python: 'python', go: 'go', rust: 'rust', php: 'php', ruby: 'ruby', dart: 'dart',
+    lua: 'lua', luau: 'lua', r: 'r', erlang: 'erlang', pascal: 'pascal', solidity: 'solidity',
+    nix: 'nix', cobol: 'cobol',
+};
+function crossesCodeBoundary(a, b) {
+    return CODE_FAMILY[a] !== undefined && CODE_FAMILY[b] !== undefined &&
+        CODE_FAMILY[a] !== CODE_FAMILY[b];
 }
 /**
- * True when `a` and `b` are two DIFFERENT *known* language families — the
- * signature of a coincidental cross-language name collision (a TS `import
- * React` matching a Swift `import React`, a C++ `#include "X.h"` matching a
- * same-named ObjC header on another platform). The both-*known* test is
- * deliberately weaker than {@link sameLanguageFamily}'s negation: a
- * single-file-component language that carries its own tag (`vue`/`svelte`)
- * importing a `.ts` module, or any singleton-family language (php/go/ruby/…),
- * returns `false` here and is left alone.
+ * Cross-family name matches need a framework export or an actual ABI boundary,
+ * not merely a native caller. ABI evidence is scoped to the named free function.
  */
-function crossesKnownFamily(a, b) {
-    return isKnownLanguageFamily(a) && isKnownLanguageFamily(b) && !sameLanguageFamily(a, b);
+function hasBridgeEvidence(candidate, ref, context) {
+    if (ref.referenceKind !== 'calls')
+        return false;
+    // Expo's extractor creates explicit JS exports, resolved by the ordinary
+    // name matcher rather than a framework resolve() branch.
+    if (CODE_FAMILY[ref.language] === 'web' && candidate.id.startsWith('expo-module:') &&
+        candidate.isExported && (candidate.language === 'swift' || candidate.language === 'kotlin'))
+        return true;
+    if (candidate.kind !== 'function')
+        return false;
+    const name = candidate.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    if (CODE_FAMILY[ref.language] === 'native') {
+        const source = context.readFile(candidate.filePath);
+        if (!source)
+            return false;
+        if (candidate.language === 'go') {
+            const declaration = source.split('\n').slice(Math.max(0, candidate.startLine - 2), candidate.endLine).join('\n');
+            return /\bimport\s+(?:\(\s*)?"C"/.test((0, strip_comments_1.stripCommentsForRegex)(source, 'go')) &&
+                new RegExp('^//export ' + name + '\\r?\\nfunc ' + name + '\\s*\\(', 'm').test(declaration);
+        }
+        if (candidate.language === 'rust') {
+            const declaration = source.split('\n').slice(candidate.startLine - 1, candidate.endLine).join('\n');
+            return new RegExp('\\bpub\\s+extern\\s+"C"\\s+fn\\s+' + name + '\\b')
+                .test((0, strip_comments_1.stripCommentsForRegex)(declaration, 'rust'));
+        }
+    }
+    if (candidate.language === 'c' || candidate.language === 'cpp') {
+        const source = context.readFile(ref.filePath);
+        if (!source)
+            return false;
+        if (ref.language === 'go') {
+            return /\bimport\s+(?:\(\s*)?"C"/.test((0, strip_comments_1.stripCommentsForRegex)(source, 'go')) &&
+                ref.referenceName === 'C.' + candidate.name;
+        }
+        if (ref.language === 'rust') {
+            return new RegExp('extern\\s+"C"\\s*\\{[^}]*\\bfn\\s+' + name + '\\s*\\(')
+                .test((0, strip_comments_1.stripCommentsForRegex)(source, 'rust'));
+        }
+    }
+    return false;
 }
 /**
- * Drop cross-language candidates from a name lookup. Two regimes:
- *  - `references` (type-usage): a type named in language X resolves to a
- *    SAME-family type, never a coincidentally same-named symbol in another
- *    language (the Android `BatteryManager` system class vs a JS one). Strict
- *    same-family filter — cross-language communication is `calls`, not refs.
- *  - `imports` (import binding): an `import`/`#include` never crosses two
- *    KNOWN families (TS `import React` ↮ Swift `import React`). Weaker
- *    both-known filter so `.vue`/`.svelte` (own tag) importing `.ts` survives.
+ * Per-context memo: node id → its language, for gateLanguageMatch. Matches
+ * land on ~5 refs per target on vscode, and each check otherwise fetched the
+ * whole node (a point read + row decode past the query layer's small cache)
+ * only to read one field. Nodes are fixed within a resolution pass; the memo
+ * drops with clearNameMatcherMemos.
  */
-function applyLanguageGate(candidates, ref) {
-    if (ref.referenceKind === 'references' || ref.referenceKind === 'function_ref') {
-        return candidates.filter((c) => sameLanguageFamily(c.language, ref.language));
+const TARGET_LANGUAGE = new WeakMap();
+/** Reject the chosen result without shrinking a pool or trying a replacement. */
+function gateLanguageMatch(result, ref, context) {
+    if (!result)
+        return result;
+    // No code family on the reference's side: no target can cross a boundary.
+    if (CODE_FAMILY[ref.language] === undefined)
+        return result;
+    if (context.getNodeById) {
+        let languages = TARGET_LANGUAGE.get(context);
+        if (!languages) {
+            languages = new Map();
+            TARGET_LANGUAGE.set(context, languages);
+        }
+        let language = languages.get(result.targetNodeId);
+        if (language === undefined) {
+            const node = context.getNodeById(result.targetNodeId);
+            if (node) {
+                language = node.language;
+                if (languages.size >= 400_000)
+                    languages.clear();
+                languages.set(result.targetNodeId, language);
+            }
+        }
+        if (language !== undefined) {
+            if (!crossesCodeBoundary(ref.language, language))
+                return result;
+            const target = context.getNodeById(result.targetNodeId);
+            return target && !hasBridgeEvidence(target, ref, context) ? null : result;
+        }
+    }
+    const target = context.getNodeById?.(result.targetNodeId) ??
+        context.getNodesByName(ref.referenceName).find((n) => n.id === result.targetNodeId);
+    if (target && crossesCodeBoundary(ref.language, target.language) &&
+        !hasBridgeEvidence(target, ref, context))
+        return null;
+    return result;
+}
+/** Member values retain their receiver; never break ties by file order (#1820). */
+function matchMemberFunctionRef(ref, context) {
+    const dot = ref.referenceName.lastIndexOf('.');
+    const receiver = ref.referenceName.slice(0, dot);
+    const member = ref.referenceName.slice(dot + 1);
+    const result = (nodes, confidence = 0.9) => {
+        const pool = nodes.filter(n => sameLanguageFamily(n.language, ref.language));
+        const target = pool.length === 1 ? pool[0] : undefined;
+        return target && (target.kind === 'function' || target.kind === 'method') &&
+            target.id !== ref.fromNodeId && !isPythonProperty(target, context)
+            ? { original: ref, targetNodeId: target.id, confidence, resolvedBy: 'function-ref' }
+            : null;
+    };
+    const imports = context.getImportMappings(ref.filePath, ref.language);
+    // An import is authoritative even when it points outside the project.
+    if (imports.some(i => i.localName === receiver.split('.')[0])) {
+        if (ref.language === 'python') {
+            const cls = pythonRefClass(receiver, ref, context);
+            if (cls)
+                return result(pythonMembers(cls, member, ref, context));
+        }
+        const imported = context.resolveImport?.(ref);
+        const node = imported && context.getNodeById?.(imported.targetNodeId);
+        return node ? result(context.getNodesByQualifiedName(node.qualifiedName).filter(n => n.filePath === node.filePath)) : null;
+    }
+    if (ref.language === 'go') {
+        if (receiver.includes('.'))
+            return matchGoFieldChainCall(receiver, member, ref, context);
+        const type = inferLocalReceiverType(receiver, ref, context);
+        if (type)
+            return resolveMethodOnType(type, member, ref, context, 0.9, 'function-ref');
+        const types = context.getNodesByName(receiver).filter(n => n.language === 'go' && (n.kind === 'struct' || n.kind === 'interface'));
+        if (types.length)
+            return types.length === 1 ? resolveMethodOnType(receiver, member, ref, context, 0.9, 'function-ref') : null;
     }
-    if (ref.referenceKind === 'imports') {
-        return candidates.filter((c) => !crossesKnownFamily(c.language, ref.language));
+    else {
+        const owner = context.getNodesInFile(ref.filePath).filter(n => n.kind === 'class' && n.startLine <= ref.line && n.endLine >= ref.line)
+            .sort((a, b) => b.startLine - a.startLine)[0];
+        let type = null;
+        if (receiver === 'self' || receiver === 'cls') {
+            return owner ? result(pythonMembers(owner, member, ref, context)) : null;
+        }
+        if (/^(self|cls)\.\w+$/.test(receiver)) {
+            if (!owner)
+                return null;
+            type = pythonFieldType(receiver, owner, ref, context);
+        }
+        else {
+            type = pythonLocalType(receiver, ref, context);
+        }
+        // A type name used directly (`Store.fetch`) is scoped just like an annotation.
+        if (!type && /^[A-Z]\w*$/.test(receiver))
+            type = receiver;
+        if (type && type !== 'object' && type !== 'Any') {
+            const cls = pythonRefClass(type, ref, context);
+            if (!cls)
+                return null;
+            const members = pythonMembers(cls, member, ref, context);
+            if (members.length)
+                return result(members);
+            // A base-typed field can hold a subclass-only method (the reported case).
+            // Keep only descendants of THAT base; unrelated same-name methods cannot win.
+            const candidates = context.getNodesByName(member).filter(n => n.kind === 'method' && n.language === 'python');
+            const descendants = candidates.filter(n => {
+                const parent = context.getNodesInFile(n.filePath).find(c => c.kind === 'class' && n.qualifiedName === `${c.qualifiedName}::${member}`);
+                return parent && pythonDerivesFrom(parent, cls, ref, context);
+            });
+            return result(descendants, 0.8);
+        }
+    }
+    // Unknown receivers retain the old unique-or-drop discipline, across ALL
+    // files. Tests and abstract-looking bodies are candidates too.
+    return result(context.getNodesByName(member), 0.8);
+}
+function pythonRefClass(name, ref, context) {
+    const imports = context.getImportMappings(ref.filePath, 'python');
+    if (imports.some(i => i.localName === name.split('.')[0])) {
+        const hit = context.resolveImport?.({ ...ref, referenceName: name, referenceKind: 'references' });
+        const node = hit && context.getNodeById?.(hit.targetNodeId);
+        return node?.kind === 'class' && context.getNodesByQualifiedName(node.qualifiedName)
+            .filter(n => n.kind === 'class' && n.filePath === node.filePath).length === 1 ? node : null;
     }
-    return candidates;
+    const classes = context.getNodesByName(name).filter(n => n.kind === 'class' && n.filePath === ref.filePath);
+    return classes.length === 1 ? classes[0] : null;
+}
+function pythonBases(cls, ref, context) {
+    const line = context.getFileLines?.(cls.filePath)?.[cls.startLine - 1]
+        ?? context.readFile(cls.filePath)?.split('\n')[cls.startLine - 1] ?? '';
+    const bases = line.match(/^\s*class\s+\w+\s*\(([^)]*)\)/)?.[1];
+    return (bases?.split(',') ?? []).flatMap(name => {
+        const base = pythonRefClass(name.trim(), { ...ref, filePath: cls.filePath }, context);
+        return base ? [base] : [];
+    });
+}
+function pythonDerivesFrom(cls, base, ref, context, seen = new Set()) {
+    if (seen.has(cls.id) || seen.size >= 16)
+        return false;
+    seen.add(cls.id);
+    return pythonBases(cls, ref, context).some(p => p.id === base.id || pythonDerivesFrom(p, base, ref, context, seen));
+}
+function pythonMembers(cls, member, ref, context, seen = new Set()) {
+    if (seen.has(cls.id) || seen.size >= 16)
+        return [];
+    seen.add(cls.id);
+    // Instance assignments also shadow methods, even though they are not nodes.
+    const body = pythonMemberLines(cls.filePath, context).slice(cls.startLine - 1, cls.endLine).join('\n');
+    if (new RegExp(`^\\s*(?:(?:self|cls)\\.)?${member}\\s*(?:=|:)`, 'm').test(body))
+        return [cls];
+    const own = context.getNodesByQualifiedName(`${cls.qualifiedName}::${member}`).filter(n => n.filePath === cls.filePath);
+    if (own.length)
+        return own;
+    return [...new Map(pythonBases(cls, ref, context).flatMap(p => pythonMembers(p, member, ref, context, seen)).map(n => [n.id, n])).values()];
+}
+function isPythonProperty(node, context) {
+    if (node.language !== 'python' || node.kind !== 'method')
+        return false;
+    const lines = context.getFileLines?.(node.filePath) ?? context.readFile(node.filePath)?.split('\n') ?? [];
+    for (let i = node.startLine - 2; i >= 0 && lines[i].trim().startsWith('@'); i--) {
+        if (/^\s*@(?:property|(?:functools\.)?cached_property)\s*$/.test(lines[i]))
+            return true;
+    }
+    return false;
+}
+const PYTHON_MEMBER_LINES = new WeakMap();
+function pythonMemberLines(filePath, context) {
+    let files = PYTHON_MEMBER_LINES.get(context);
+    if (!files) {
+        files = new Map();
+        PYTHON_MEMBER_LINES.set(context, files);
+    }
+    let lines = files.get(filePath);
+    if (!lines) {
+        lines = (0, strip_comments_1.stripCommentsForRegex)(context.readFile(filePath) ?? '', 'python').split('\n');
+        files.set(filePath, lines);
+    }
+    return lines;
+}
+function pythonLocalType(receiver, ref, context) {
+    if (!/^\w+$/.test(receiver))
+        return null;
+    const caller = context.getNodeById?.(ref.fromNodeId);
+    const lines = pythonMemberLines(ref.filePath, context);
+    const declaration = new RegExp(`^\\s*${receiver}\\s*(?::\\s*["']?([\\w.]+)["']?)?\\s*=\\s*(.*)$`);
+    const annotation = new RegExp(`^\\s*${receiver}\\s*:\\s*["']?([\\w.]+)`);
+    for (let i = ref.line - 1; i >= (caller?.startLine ?? 1) - 1; i--) {
+        const line = lines[i] ?? '';
+        const assigned = line.match(declaration);
+        if (assigned)
+            return assigned[1] ?? assigned[2].match(/^([A-Z][\w.]*)\s*\(/)?.[1] ?? '<unknown>';
+        const declared = line.match(annotation)?.[1];
+        if (declared)
+            return declared;
+    }
+    return caller?.signature?.match(new RegExp(`\\b${receiver}\\s*:\\s*["']?([\\w.]+)`))?.[1] ?? null;
+}
+/** Read a field's own annotation/initializer, or a constructor parameter assigned to it. */
+function pythonFieldType(receiver, owner, ref, context) {
+    const lines = pythonMemberLines(ref.filePath, context);
+    const field = receiver.split('.')[1];
+    const assignment = new RegExp(`^\\s*(?:self|cls)\\.${field}\\s*(?::\\s*["']?([\\w.]+)["']?)?\\s*=\\s*(.*)$`);
+    const annotation = new RegExp(`^\\s*(?:(?:self|cls)\\.)?${field}\\s*:\\s*["']?([\\w.]+)`);
+    const methods = context.getNodesInFile(ref.filePath).filter(n => n.kind === 'method' &&
+        n.qualifiedName.startsWith(`${owner.qualifiedName}::`));
+    const types = new Set();
+    for (let i = owner.startLine; i < owner.endLine; i++) {
+        const method = methods.find(n => n.startLine <= i + 1 && n.endLine >= i + 1);
+        if (method && method.name !== '__init__' && method.id !== ref.fromNodeId)
+            continue;
+        if (method?.id === ref.fromNodeId && i + 1 > ref.line)
+            continue;
+        const line = lines[i] ?? '';
+        const declared = !method || /^\s*(?:self|cls)\./.test(line) ? line.match(annotation)?.[1] : undefined;
+        if (declared)
+            types.add(declared);
+        const assigned = line.match(assignment);
+        if (!assigned)
+            continue;
+        if (assigned[1]) {
+            types.add(assigned[1]);
+            continue;
+        }
+        const constructor = assigned[2].match(/^([A-Z][\w.]*)\s*\(/)?.[1];
+        if (constructor) {
+            types.add(constructor);
+            continue;
+        }
+        const param = assigned[2].trim();
+        if (method && /^\w+$/.test(param)) {
+            const signature = method.signature ?? '';
+            const type = signature.match(new RegExp(`\\b${param}\\s*:\\s*["']?([\\w.]+)`))?.[1];
+            if (type)
+                types.add(type);
+        }
+        else {
+            types.add('<unknown>');
+        }
+    }
+    // Conflicting assignments are known-but-ambiguous, never a name-only fallback.
+    return types.size === 1 ? [...types][0] : types.size > 1 ? '<ambiguous>' : null;
 }
 /**
  * Resolve a function-as-value reference (#756) — a function name used as a
  * callback/function-pointer value (`register(handler)`, `o->cb = handler`,
  * `{ .cb = handler }`, `signal(SIGINT, handler)`). The ONLY strategy allowed
  * for `function_ref` refs: exact name, function/method targets only, same
- * language family, same-file first, and cross-file only when the match is
- * UNIQUE. No fuzzy fallback, no qualified-name walking — a wrong callback
- * edge is worse than none.
+ * language family, same-file first for bare names, and unique-only cross-file.
+ * Member values use receiver/type/import scope before a unique-name fallback.
+ * A wrong callback edge is worse than none.
  */
 function matchFunctionRef(ref, context) {
     // `this.<member>` refs are resolved ONLY by the class-scoped resolver in
     // resolveOne (resolveThisMemberFnRef) — never by name matching here.
     if (ref.referenceName.startsWith('this.'))
         return null;
+    if ((ref.language === 'python' || ref.language === 'go') && ref.referenceName.includes('.')) {
+        return matchMemberFunctionRef(ref, context);
+    }
     // In JS/TS/Python a bare identifier can never be a method value (methods
     // are only reachable through a receiver — `this.m` / `self.m` /
     // `Cls.m`), so bare fn-refs match FUNCTIONS only. This also sidesteps the
@@ -343,6 +651,8 @@ function matchFunctionRef(ref, context) {
     }
     return null;
 }
+/** Languages with no nested named functions: nesting in the graph is never a scope. */
+const NO_NESTED_FUNCTIONS = new Set(['c', 'cpp']);
 /**
  * A function nested inside another FUNCTION is only callable from within its
  * container — Python, JS/TS, and every closure language scope it lexically.
@@ -357,6 +667,15 @@ function matchFunctionRef(ref, context) {
 function isLexicallyReachable(candidate, ref, context) {
     if (candidate.kind !== 'function')
         return true;
+    // C and C++ have no nested named functions, so a function the graph shows
+    // inside another is an extraction artifact, not a scope: tree-sitter-c
+    // cannot parse a macro call whose arguments are designated initializers
+    // (betaflight's `RESET_CONFIG(pidProfile_t, pidProfile, .pid = {…})`), and
+    // its error recovery runs the enclosing function_definition to the end of
+    // the file, nesting every function after it. Trusting that nesting rejected
+    // 117 real calls into pid.c on that tree; the functions are reachable.
+    if (NO_NESTED_FUNCTIONS.has(candidate.language))
+        return true;
     const qn = candidate.qualifiedName;
     if (!qn || !qn.includes('::'))
         return true;
@@ -372,6 +691,503 @@ function isLexicallyReachable(candidate, ref, context) {
     return (ref.filePath === candidate.filePath &&
         containers.some((p) => ref.line >= p.startLine && ref.line <= p.endLine));
 }
+/** Languages whose module boundary is `import`/`export` (or CommonJS). */
+const ESM_FAMILY = new Set(['typescript', 'tsx', 'javascript', 'jsx', 'arkts']);
+/**
+ * A line-initial `import` statement — the marker that a JS/TS file is a MODULE
+ * rather than a classic script. Line-anchored and followed by a name, brace,
+ * star or quote, so a dynamic `import(` and the word inside a comment or string
+ * do not match.
+ */
+const HAS_IMPORT_STATEMENT = /^[ \t]*import[\s{*'"]/m;
+/**
+ * Anything the file could offer another file, in every form the extractor's own
+ * `isExported` flag misses. `^export` covers the declaration and later forms
+ * (`export const`, `export { x }`, `export default x`, `export *`); the
+ * CommonJS shapes cover files that never use ESM syntax at all, in both the dot
+ * and the bracket form; and `declare global` contributes names to every file
+ * whether or not the module exports anything of its own. Kept as a source test
+ * rather than a node scan precisely because `isExported` is set only from an
+ * `export_statement` ancestor, so `const x = …; export { x }` and
+ * `module.exports = { x }` both read as unexported on the node.
+ */
+const HAS_ESM_EXPORT = /^[ \t]*export[\s{*]|^[ \t]*declare\s+global\b/m;
+const HAS_CJS_EXPORT = /\bmodule\.exports\b|\bexports\s*[.[]/;
+/**
+ * Per-context memo of "this file is a module that exports nothing", asked once
+ * per candidate FILE rather than once per reference. Derived from file source,
+ * so it drops with the context's file caches — clearNameMatcherMemos deletes it
+ * alongside INFER_SCAN_STATES.
+ */
+const SEALED_MODULES = new WeakMap();
+/**
+ * Whether `filePath` is a JS/TS module that exports NOTHING — an import
+ * statement present, no export of any form. No reference from another file can
+ * reach any binding in such a file, so every one of its symbols is a false
+ * candidate for a cross-file name match.
+ *
+ * This is the general case behind a package name capturing a same-named local:
+ * on `vitejs/vite`, 157 cross-file `imports` refs — every `import { defineConfig
+ * } from 'vite'` in the playground and the create-vite templates — resolved onto
+ * `playground/ssr-html/test-stacktrace.js::vite`, which is `const vite = await
+ * createServer(…)` at module scope in a file with zero exports. The existing
+ * guards cannot see it: `isLexicallyReachable` returns early for any candidate
+ * that is not a `function`, and the bare-import guard correctly declines because
+ * `vite` IS a workspace member, so the specifier really is project-local. What
+ * is wrong is only which node the name lands on.
+ *
+ * Deliberately narrow on three axes, because each is a class this would
+ * otherwise resolve wrongly in the opposite direction:
+ *
+ * - **A classic script is exempt.** Requiring an `import` statement means a
+ *   non-module `.js` file — concatenated globals, a browser `<script>` — keeps
+ *   its cross-file matches, where a top-level binding genuinely is reachable.
+ * - **CommonJS is exempt.** `module.exports` and `exports.x` are matched as
+ *   exports, so a CJS file is never sealed.
+ * - **Other languages are exempt.** Go, Python, Java and the rest have no
+ *   equivalent boundary, and several extractors hardcode `isExported`.
+ */
+function isSealedModule(filePath, context) {
+    let memo = SEALED_MODULES.get(context);
+    if (!memo) {
+        memo = new Map();
+        SEALED_MODULES.set(context, memo);
+    }
+    const hit = memo.get(filePath);
+    if (hit !== undefined)
+        return hit;
+    // CommonJS assignments can execute inside template interpolations, which the
+    // masker blanks. Keep the conservative raw-source exemption for those forms.
+    // Cheapest disqualifiers first: nearly every module exports a node (asked
+    // without reading or decoding the file), and masking the source is only
+    // needed to rule out the ones that don't. (The masker only blanks text, so
+    // no `import` in the source means none in code.)
+    const exportsNode = context.fileHasExportedNode
+        ? context.fileHasExportedNode(filePath)
+        : context.getNodesInFile(filePath).some((n) => n.isExported);
+    const source = exportsNode ? null : context.readFile(filePath);
+    const sealed = !exportsNode && source !== null && source.includes('import') &&
+        !HAS_CJS_EXPORT.test(source) &&
+        (() => {
+            const code = (0, strip_comments_1.blankStringContents)((0, strip_comments_1.stripCommentsForRegex)(source, 'typescript'));
+            return HAS_IMPORT_STATEMENT.test(code) && !HAS_ESM_EXPORT.test(code);
+        })();
+    memo.set(filePath, sealed);
+    return sealed;
+}
+/**
+ * Whether `candidate` can be named by a reference in `ref`'s file at all.
+ * Both name-based strategies validate their chosen candidate. Removing an
+ * unreachable candidate before ranking can promote an unrelated runner-up;
+ * rejecting the chosen target must leave the reference unresolved instead.
+ */
+function isCrossFileReachable(candidate, ref, context) {
+    if (ref.language !== 'markdown' && candidate.language === 'markdown')
+        return false;
+    if (ref.referenceKind === 'calls' && ESM_FAMILY.has(candidate.language) &&
+        (candidate.kind === 'constant' || candidate.kind === 'variable') &&
+        /^=\s*require\s*\(\s*(['"])[^'"]+\.json\1\s*\)\s*;?\s*$/.test(candidate.signature ?? ''))
+        return false;
+    return (candidate.filePath === ref.filePath ||
+        !ESM_FAMILY.has(candidate.language) ||
+        !isSealedModule(candidate.filePath, context));
+}
+/**
+ * Languages in which `visibility: 'private'` on a definition means no other
+ * FILE can name it: a Kotlin `private fun` is file- or class-local, and the
+ * same holds for Java, C#, Swift, Scala, Dart and PHP members.
+ */
+const PRIVATE_IS_FILE_LOCAL = new Set(['kotlin', 'java', 'csharp', 'swift', 'scala', 'dart', 'php']);
+/** Per-context memo: node id → "this C/C++ function is declared `static`". */
+const C_STATIC_MEMO = new WeakMap();
+/**
+ * A C/C++ file that IS a translation unit. A `static` defined here is local
+ * to it. A `static` (typically `static inline`) in a header is a different
+ * thing: the header is textually included, so the function exists in every
+ * unit that includes it and is callable from each — MAVLink's generated
+ * `mavlink_msg_*.h` are nothing but such functions, 4,306 real calls on one
+ * betaflight tree.
+ */
+const C_SOURCE_EXT = /\.(c|cc|cpp|cxx|c\+\+|m|mm)$/i;
+/**
+ * Whether a C/C++ function definition carries the `static` storage class —
+ * read from its first source line(s), since the extractor records no storage
+ * class and the kernel arm would need the same field. `static` on the line
+ * above the name (`static void\nfoo(void)`) is the common alternative layout.
+ */
+function isStaticCFunction(candidate, context) {
+    let memo = C_STATIC_MEMO.get(context);
+    if (!memo) {
+        memo = new Map();
+        C_STATIC_MEMO.set(context, memo);
+    }
+    const hit = memo.get(candidate.id);
+    if (hit !== undefined)
+        return hit;
+    const lines = context.getFileLines?.(candidate.filePath) ?? context.readFile(candidate.filePath)?.split('\n') ?? [];
+    const head = [lines[candidate.startLine - 2] ?? '', lines[candidate.startLine - 1] ?? ''].join('\n');
+    const isStatic = /(^|[\s;}])static\s/.test(head);
+    memo.set(candidate.id, isStatic);
+    return isStatic;
+}
+/** Per-context memo: node id → "this Rust method implements a trait". */
+const RUST_TRAIT_IMPL_MEMO = new WeakMap();
+/**
+ * Whether a Rust method sits in an `impl Trait for Type` block. Such a method
+ * carries no `pub` — the trait decides its visibility — so the extractor
+ * records it as private; it is reachable wherever the trait is. Read from the
+ * nearest enclosing `impl` header above the method, memoised per node.
+ */
+function isRustTraitImplMethod(candidate, context) {
+    if (candidate.kind !== 'method')
+        return false;
+    let memo = RUST_TRAIT_IMPL_MEMO.get(context);
+    if (!memo) {
+        memo = new Map();
+        RUST_TRAIT_IMPL_MEMO.set(context, memo);
+    }
+    const hit = memo.get(candidate.id);
+    if (hit !== undefined)
+        return hit;
+    const lines = context.getFileLines?.(candidate.filePath) ?? context.readFile(candidate.filePath)?.split('\n') ?? [];
+    let isTrait = false;
+    for (let i = candidate.startLine - 2; i >= 0; i--) {
+        const line = lines[i] ?? '';
+        if (/^\s*(pub(\([^)]*\))?\s+)?(unsafe\s+)?impl\b/.test(line)) {
+            isTrait = /\sfor\s/.test(line.replace(/\/\/.*$/, ''));
+            break;
+        }
+        // A top-level item above the method means it was not inside an impl.
+        if (/^(pub(\([^)]*\))?\s+)?(fn|struct|enum|mod|trait|const|static|type)\b/.test(line))
+            break;
+    }
+    memo.set(candidate.id, isTrait);
+    return isTrait;
+}
+/**
+ * The directory a Rust file's private items are visible from: the file's own
+ * module subtree. `src/net.rs` and `src/net/mod.rs` own `src/net/`; a crate
+ * root (`lib.rs` / `main.rs`) owns its directory. A child module reaches its
+ * ancestors' private items (`super::`), a sibling or another crate never does.
+ */
+function rustModuleDir(filePath) {
+    const base = path.posix.basename(filePath);
+    const dir = path.posix.dirname(filePath);
+    if (base === 'mod.rs' || base === 'lib.rs' || base === 'main.rs')
+        return dir;
+    return path.posix.join(dir, base.replace(/\.rs$/, ''));
+}
+/**
+ * Whether `candidate` can be NAMED from a reference in `ref`'s file at all,
+ * given what its language says about the definition's visibility. A
+ * definition the language makes file-local is not a candidate for a
+ * cross-file name match, however well the names agree:
+ *
+ * - **C / C++**: a `static` function defined in a SOURCE file is local to
+ *   that translation unit; one in a header is part of every unit that
+ *   includes it and stays visible. On a 2,109-file betaflight tree 145
+ *   cross-file calls resolved onto a `static` in another `.c` (#1730) —
+ *   `usbd_get_descriptor` onto the `static get_device_descriptor` of
+ *   whichever USB class file ranked first.
+ * - **Kotlin, Java, C#, Swift, Scala, Dart, PHP**: `private` is class- or
+ *   file-local. An Android `editor.apply()` resolved onto an unrelated class's
+ *   `private fun apply`.
+ * - **Go**: an unexported (lowercase) identifier is package-local, and a
+ *   package is a directory. Judged by the name's case: the extractor's
+ *   `isExported` is unset for every Go method.
+ * - **Rust**: a non-`pub` item is visible to its module and that module's
+ *   descendants, never to a sibling module or another crate — `.count()` on
+ *   an iterator resolved onto a `fn count` in a different crate. A method in
+ *   an `impl Trait for Type` block has the trait's visibility, not `private`.
+ * - **JS / TS / ArkTS**: a binding in a module that exports nothing (an
+ *   `import` present, no `export` / CommonJS / `declare global`) is sealed —
+ *   the vite playground's `const vite = await createServer(…)` took 157
+ *   `import { defineConfig } from 'vite'` edges (#1719). Classic scripts,
+ *   CommonJS, later `export { … }`, and ambient globals stay visible.
+ *
+ * Same-file candidates are always visible. Applied by ReferenceResolver to
+ * the target the whole name-matching pipeline settled on, so a rejection ends
+ * the reference unresolved: declining inside matchByExactName instead let the
+ * ref fall through to matchFuzzy, which then committed to a same-language
+ * namesake the ranking had passed over — eight such edges on one tree, all
+ * onto a local `const fail = …` arrow the graph does not hold. matchFuzzy
+ * checks its own survivor as well, since nothing runs after it.
+ */
+function isVisibleAcrossFiles(candidate, ref, context) {
+    if (candidate.filePath === ref.filePath)
+        return true;
+    const lang = candidate.language;
+    if (lang === 'c' || lang === 'cpp') {
+        return (candidate.kind !== 'function' ||
+            !C_SOURCE_EXT.test(candidate.filePath) ||
+            !isStaticCFunction(candidate, context));
+    }
+    if (lang === 'go') {
+        // By the name's first letter, not the extractor's flag: the flag is unset
+        // for every Go method, exported or not.
+        return /^[A-Z]/.test(candidate.name) || path.posix.dirname(candidate.filePath) === path.posix.dirname(ref.filePath);
+    }
+    if (lang === 'rust') {
+        if (candidate.visibility !== 'private')
+            return true;
+        if (isRustTraitImplMethod(candidate, context))
+            return true;
+        const owner = rustModuleDir(candidate.filePath);
+        return ref.filePath.startsWith(owner + '/');
+    }
+    if (PRIVATE_IS_FILE_LOCAL.has(lang))
+        return candidate.visibility !== 'private';
+    // JS/TS/ArkTS sealed modules + markdown/JSON call-target guards (#1719).
+    // Same predicate matchByExactName / matchFuzzy apply to their survivors so a
+    // rejection here cannot fall through to a promoted runner-up.
+    return isCrossFileReachable(candidate, ref, context);
+}
+const JS_FAMILY = new Set(['typescript', 'tsx', 'javascript', 'jsx']);
+/**
+ * Whether a JS/TS `calls` ref is a RECEIVER-LESS call — `serialize(x)`, not
+ * `this.serialize(x)` / `obj.serialize(x)`. The extractor emits `this.m()`
+ * and `super.m()` under the bare method name, so the receiver is read back
+ * from the call site's own line: the text at the ref's column is the call
+ * expression, and it starts with the name itself only when nothing precedes
+ * it. In JS/TS a bare call can never bind to a class method (methods need a
+ * receiver), so a `method` node is not a candidate for it (#1714) — the
+ * enclosing method itself least of all, which the same-file proximity term
+ * used to pick over the module-scope function the call actually means.
+ */
+function isBareJsCall(ref, context) {
+    return JS_FAMILY.has(ref.language) && isReceiverLessCall(ref, context);
+}
+/**
+ * Whether a Go `calls` ref is receiver-less — `relogin(ctx)`, not
+ * `l.relogin(ctx)`. A Go method is only reachable through a value or a method
+ * expression, so a bare call (a func parameter, a local func value, a
+ * package-level function) is never a method, in its own package or in one the
+ * file does not import (#1857). Read from the source line like the JS/TS
+ * check, because `pkg.Factory().Method()` reaches the resolver as a bare
+ * `Method` ref too.
+ */
+function isBareGoCall(ref, context) {
+    return ref.language === 'go' && isReceiverLessCall(ref, context);
+}
+/**
+ * Whether a PHP `calls` ref is a bare function call — `redirect($url)`,
+ * `view('books.show')` — rather than `$this->redirect()` / `$obj->view()` /
+ * `Foo::view()`. PHP has no implicit `$this`: a call written without a
+ * receiver can only be a function, so a method, field or property that shares
+ * the name is never what it calls. Name-matching used to bind BookStack's
+ * every `return redirect(…)` to ApiDocsController::redirect and every
+ * `return view(…)` to a `$view` field.
+ *
+ * PHP refs record the column of the call EXPRESSION — `$this->setPageTitle(`
+ * sits at `$this` — so a bare call is the one whose text at its column is the
+ * name itself (a leading `\` for a fully qualified function is allowed).
+ */
+function isBarePhpCall(ref, context) {
+    if (ref.language !== 'php' || ref.referenceKind !== 'calls')
+        return false;
+    if (!/^\w+$/.test(ref.referenceName))
+        return false;
+    const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1]
+        ?? context.readFile(ref.filePath)?.split('\n')[ref.line - 1];
+    if (line === undefined)
+        return false;
+    const at = line[ref.column] === '\\' ? ref.column + 1 : ref.column;
+    if (!line.startsWith(ref.referenceName, at))
+        return false;
+    CALL_OPENER.lastIndex = at + ref.referenceName.length;
+    if (!CALL_OPENER.test(line))
+        return false;
+    let end = at;
+    while (end > 0 && WHITESPACE.test(line[end - 1]))
+        end--;
+    // `$obj->name(` / `Foo::name(` / `$obj?->name(`, should a column ever land on the name.
+    return !(end > 0 && (line[end - 1] === '>' || line[end - 1] === ':'));
+}
+function isReceiverLessCall(ref, context) {
+    if (ref.referenceKind !== 'calls')
+        return false;
+    if (ref.referenceName.includes('.'))
+        return false;
+    const line = context.getFileLines?.(ref.filePath)?.[ref.line - 1]
+        ?? context.readFile(ref.filePath)?.split('\n')[ref.line - 1];
+    if (line === undefined)
+        return false;
+    // `^<name>\s*[(<]` at the call's column, without compiling a pattern per call.
+    if (!line.startsWith(ref.referenceName, ref.column))
+        return false;
+    CALL_OPENER.lastIndex = ref.column + ref.referenceName.length;
+    if (!CALL_OPENER.test(line))
+        return false;
+    // Nothing but whitespace, an operator or an opener may precede a bare call:
+    // read the text before the column backwards, past trailing whitespace,
+    // instead of end-anchoring a pattern that scans the prefix from its start.
+    let end = Math.min(ref.column, line.length);
+    while (end > 0 && WHITESPACE.test(line[end - 1]))
+        end--;
+    if (end === 0 || !RECEIVER_TAIL_CHAR.test(line[end - 1]))
+        return true;
+    let start = end;
+    while (start > 0 && WORD_CHAR.test(line[start - 1]))
+        start--;
+    return BARE_CALL_KEYWORDS.has(line.slice(start, end));
+}
+/** `\s*[(<]` from a given index (sticky). */
+const CALL_OPENER = /\s*[(<]/y;
+const WHITESPACE = /\s/;
+const WORD_CHAR = /\w/;
+/** A character that ends a receiver: `.`, a word character, `$`, `]` or `)`. */
+const RECEIVER_TAIL_CHAR = /[.\w$\])]/;
+/** Keywords after which a name starts an expression, so the call has no receiver. */
+const BARE_CALL_KEYWORDS = new Set([
+    'return', 'await', 'yield', 'typeof', 'void', 'new', 'else', 'case', 'throw', 'in', 'of', 'instanceof', 'go', 'defer',
+]);
+/** Per-context memo: `file\0name` → "the file binds this name locally". */
+const LOCAL_BINDING_MEMO = new WeakMap();
+const LOCAL_BINDING_SITES = new WeakMap();
+const LOCAL_BINDING_SITES_KEEP = 16;
+const VAR_DECL_SITE = /\b(?:const|let|var)\s/g;
+const FN_DECL_SITE = /\b(?:function|class)\s/g;
+function localBindingSites(filePath, source, context) {
+    let cache = LOCAL_BINDING_SITES.get(context);
+    if (!cache) {
+        cache = new Map();
+        LOCAL_BINDING_SITES.set(context, cache);
+    }
+    let sites = cache.get(filePath);
+    if (!sites) {
+        const offsets = (re) => Array.from(source.matchAll(re), (m) => m.index);
+        const arrows = [];
+        for (let a = source.indexOf('=>'); a !== -1; a = source.indexOf('=>', a + 2))
+            arrows.push(a);
+        sites = { varDecls: offsets(VAR_DECL_SITE), fnDecls: offsets(FN_DECL_SITE), arrows };
+        if (cache.size >= LOCAL_BINDING_SITES_KEEP)
+            cache.delete(cache.keys().next().value);
+        cache.set(filePath, sites);
+    }
+    return sites;
+}
+/** Sticky binding patterns by name — the same names recur file after file. */
+const LOCAL_BINDING_PATTERNS = new Map();
+const LOCAL_BINDING_PATTERNS_CAP = 4096;
+const JS_BINDING_NAME = /^[\w$]+$/;
+const ARROW_HEAD_CHAR = /[\w$.]/;
+const IMPORT_BINDING_VALUE = /^\s*(?:await\s+)?(?:require|import)\s*\(/;
+function localBindingPatterns(name, flags) {
+    const n = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return {
+        // `const { name } = require('./m')` / `= await import('./m')` binds an IMPORT,
+        // not a shadow: the symbol lives in the other file and the call means it.
+        decl: new RegExp('\\b(?:const|let|var)\\s+(?:' + n + '\\b|[{\\[][^;=]*?\\b' + n + '\\b[^;=]*?[}\\]])\\s*(?:=\\s*([^;\\n]*))?', flags),
+        fn: new RegExp('\\b(?:function|class)\\s+' + n + '\\b', flags),
+        // a parameter: every token before the name in the list is itself a
+        // parameter (identifier, optional type, optional default) — so a string
+        // argument containing the word cannot match.
+        // Each earlier parameter has exactly one parse: its first non-space
+        // character after the identifier picks the type (`?`/`:`), default (`=`)
+        // or bare alternative. Written as `(type)?(default)?\s*`, the same
+        // strings split several ways per parameter, and a failing search
+        // backtracked through every combination — 30-40s per name on a vscode
+        // test file whose helper takes nine `name: T = value` parameters.
+        param: new RegExp('\\(\\s*(?:(?:\\.\\.\\.)?[\\w$]+(?:\\s*(?:\\?\\s*)?:[^,()]+|\\s*=[^,()]+|\\s*),\\s*)*' +
+            n + '\\b(?:\\s*\\??\\s*:[^,()]*)?(?:\\s*=[^,()]*)?(?:\\s*,\\s*[^()]*)?\\)\\s*(?::[^=;{]*)?(?:=>|\\{)', flags),
+    };
+}
+/**
+ * Whether a JS/TS file binds `name` itself — as a `const`/`let`/`var`/
+ * `function`/`class` declaration (destructuring included) or as a parameter
+ * of a function or arrow. Such a binding shadows every same-named symbol in
+ * other files, so a bare call to it has no cross-file candidate: the
+ * `resolve` of `new Promise((resolve, reject) => …)`, a spec's
+ * `const transform = await makeTransform()`, a factory's `const now =
+ * options.now || (() => new Date())`. None of these is a node the graph
+ * holds (a parameter, a const bound to a call result), so without this the
+ * matcher hands the call to whichever other file defines the name — and
+ * once methods stop being candidates for a bare call (#1714), the function
+ * that was out-ranked steps in. Read from source, memoised per file+name.
+ */
+function isLocallyBoundJsName(name, filePath, context) {
+    let memo = LOCAL_BINDING_MEMO.get(context);
+    if (!memo) {
+        memo = new Map();
+        LOCAL_BINDING_MEMO.set(context, memo);
+    }
+    const key = filePath + '\0' + name;
+    const hit = memo.get(key);
+    if (hit !== undefined)
+        return hit;
+    const source = context.readFile(filePath) ?? '';
+    const bound = JS_BINDING_NAME.test(name)
+        ? bindsAtSites(source, name, localBindingSites(filePath, source, context))
+        : bindsAnywhere(source, name);
+    memo.set(key, bound);
+    return bound;
+}
+/** isLocallyBoundJsName's patterns, searched through the whole source. */
+function bindsAnywhere(source, name) {
+    const { decl, fn, param } = localBindingPatterns(name, 'g');
+    for (const m of source.matchAll(decl)) {
+        if (!IMPORT_BINDING_VALUE.test(m[1] ?? ''))
+            return true;
+    }
+    const n = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return fn.test(source) || param.test(source) || new RegExp('(?:^|[^\\w$.])' + n + '\\s*=>').test(source);
+}
+/**
+ * bindsAnywhere for a plain identifier, tried only where a match can start:
+ * a declaration at its keyword (in order, resuming past each match exactly as
+ * the global search does), a parameter at the `(` its list opens with — the
+ * last `(` before an occurrence of the name, with no `)` between, since no
+ * earlier parameter can hold a parenthesis — and `name =>` at each arrow.
+ */
+function bindsAtSites(source, name, sites) {
+    let patterns = LOCAL_BINDING_PATTERNS.get(name);
+    if (!patterns) {
+        patterns = localBindingPatterns(name, 'y');
+        if (LOCAL_BINDING_PATTERNS.size >= LOCAL_BINDING_PATTERNS_CAP) {
+            LOCAL_BINDING_PATTERNS.delete(LOCAL_BINDING_PATTERNS.keys().next().value);
+        }
+        LOCAL_BINDING_PATTERNS.set(name, patterns);
+    }
+    const { decl, fn, param } = patterns;
+    let from = 0;
+    for (const at of sites.varDecls) {
+        if (at < from)
+            continue;
+        decl.lastIndex = at;
+        const m = decl.exec(source);
+        if (!m)
+            continue;
+        from = at + m[0].length;
+        if (!IMPORT_BINDING_VALUE.test(m[1] ?? ''))
+            return true;
+    }
+    for (const at of sites.fnDecls) {
+        fn.lastIndex = at;
+        if (fn.test(source))
+            return true;
+    }
+    let tried = -1;
+    for (let at = source.indexOf(name); at !== -1; at = source.indexOf(name, at + 1)) {
+        const open = at > 0 ? source.lastIndexOf('(', at - 1) : -1;
+        if (open < 0 || open === tried || source.lastIndexOf(')', at - 1) > open)
+            continue;
+        tried = open;
+        param.lastIndex = open;
+        if (param.test(source))
+            return true;
+    }
+    // `name =>`: the name ends where the whitespace before the arrow starts.
+    for (const arrow of sites.arrows) {
+        let end = arrow;
+        while (end > 0 && WHITESPACE.test(source[end - 1]))
+            end--;
+        const start = end - name.length;
+        if (start >= 0 && source.startsWith(name, start) && (start === 0 || !ARROW_HEAD_CHAR.test(source[start - 1]))) {
+            return true;
+        }
+    }
+    return false;
+}
 /**
  * Try to resolve a reference by exact name match
  */
@@ -385,15 +1201,65 @@ function matchByExactName(ref, context) {
     // unresolved import refs each scored K same-named import candidates through
     // findBestMatch — O(K²) per package, the dominant cost of "Resolving refs" on
     // large import-heavy (front-end + back-end) repos (#915).
-    const candidates = applyLanguageGate(context.getNodesByName(ref.referenceName), ref)
-        .filter((n) => n.kind !== 'import')
+    const bareJs = isBareJsCall(ref, context);
+    const bareGo = isBareGoCall(ref, context);
+    const barePhp = isBarePhpCall(ref, context);
+    if (bareJs) {
+        const storeAction = matchJsStoreBindingCall(ref, context);
+        if (storeAction)
+            return storeAction;
+    }
+    // Every rule below judges one candidate on its own, so they run as ONE pass,
+    // the kind/language checks before the ones that read source: a common name
+    // has thousands of same-named nodes, and a chain of filters copied that
+    // list once per rule for every reference.
+    const valueRef = ref.referenceKind === 'references' || ref.referenceKind === 'function_ref';
+    const importRef = ref.referenceKind === 'imports';
+    const inheritanceRef = (0, types_1.isInheritanceRef)(ref);
+    const sameName = context.getNodesByName(ref.referenceName);
+    // `NAME(...)` where NAME is a function-like macro somewhere in the project is
+    // an expansion or a call to a same-named function — never the macro itself
+    // (#1839), and never a type that happens to share the name (#2070: expat's
+    // `PREFIX(scanRef)(…)` bound to an unrelated `struct PREFIX`). Keep
+    // upstream's language gate on the chosen result.
+    const cMacroCall = ref.referenceKind === 'calls' && (ref.language === 'c' || ref.language === 'cpp') &&
+        sameName.some((n) => n.kind === 'constant' && types_1.CPP_DEFINE_SIGNATURE.test(n.signature ?? ''));
+    const candidates = sameName.filter((n) => !(cMacroCall && n.kind !== 'function' && n.kind !== 'method') &&
+        // Type/value references retain same-family eligibility: a native namesake
+        // must not hide the actual web type. Calls still gate only the winner.
+        (!valueRef || sameLanguageFamily(n.language, ref.language)) &&
+        n.kind !== 'import' &&
+        // A receiver-less JS/TS or Go call cannot reach a method (#1714, #1857).
+        !((bareJs || bareGo) && n.kind === 'method') &&
+        // A bare PHP call is a function call: nothing else is callable without a receiver.
+        !(barePhp && n.kind !== 'function') &&
+        // An `extends`/`implements` ref names a supertype, so anything that can't
+        // BE one is not a candidate at all. This is eligibility, not
+        // ranking: kind is only a scoring bonus below (and none is awarded for
+        // inheritance refs), so without this a same-named `enum_member` outranked
+        // the real `trait`, and as the sole candidate was adopted outright by the
+        // single-match shortcut. Restricting the pool BEFORE ranking lets the
+        // legitimate supertype win instead of merely dropping the false edge.
+        (!inheritanceRef || (0, types_1.isSupertypeTarget)(n)) &&
+        // Likewise for `imports`: a member that only exists inside a type is not
+        // importable, so it is not a candidate. Without this a `path`/`id`/`url`
+        // import resolved to some interface's same-named property.
+        (!importRef || (0, types_1.isImportableKind)(n.kind)) &&
         // Nested locals are only reachable from inside their container (#1230).
-        .filter((n) => isLexicallyReachable(n, ref, context));
+        isLexicallyReachable(n, ref, context) &&
+        // Preserve import ranking; calls reject the winner without promoting another.
+        (!importRef || n.filePath === ref.filePath ||
+            !ESM_FAMILY.has(n.language) || !isSealedModule(n.filePath, context)) &&
+        // A name the file binds itself (a parameter, a const) shadows every other
+        // file's symbol of that name, so a bare call has no cross-file candidate.
+        !(bareJs && n.filePath !== ref.filePath && isLocallyBoundJsName(ref.referenceName, ref.filePath, context)));
     if (candidates.length === 0) {
         return null;
     }
     // If only one match, use it — but penalize cross-language matches
     if (candidates.length === 1) {
+        if (!isCrossFileReachable(candidates[0], ref, context))
+            return null;
         const isCrossLanguage = candidates[0].language !== ref.language;
         return {
             original: ref,
@@ -412,7 +1278,7 @@ function matchByExactName(ref, context) {
     }
     // Multiple matches - try to narrow down
     const bestMatch = findBestMatch(ref, candidates, context);
-    if (bestMatch) {
+    if (bestMatch && isCrossFileReachable(bestMatch, ref, context)) {
         // Lower confidence when the match is from a distant/unrelated module
         const proximity = computePathProximity(ref.filePath, bestMatch.filePath);
         const confidence = proximity >= 30 ? 0.7 : 0.4;
@@ -467,6 +1333,32 @@ function matchByQualifiedName(ref, context) {
             };
         }
     }
+    // Erlang qualified refs (#1610): every erlang function's qualifiedName
+    // carries its arity (`mod::f/2`), and refs carry the call-site arity when it
+    // is statically known.
+    if (ref.language === 'erlang' && ref.referenceName.includes('::')) {
+        // A ref WITH arity that missed the exact lookup names an arity that isn't
+        // defined (or a module out of repo). Never fall through to the partial
+        // match — its "last segment" would be the arity digits — and never settle
+        // for a sibling arity: silent beats wrong.
+        if (/\/\d{1,3}$/.test(ref.referenceName))
+            return null;
+        // An arity-LESS qualified ref (dynamic MFA whose args list wasn't a
+        // static literal): resolve only when the module defines exactly ONE arity
+        // of that function; several arities with no signal is a guess.
+        const base = ref.referenceName.slice(ref.referenceName.lastIndexOf('::') + 2);
+        const prefix = `${ref.referenceName}/`;
+        const arityCands = keepForRef(context.getNodesByName(base)).filter((n) => n.qualifiedName.startsWith(prefix) && /^\d{1,3}$/.test(n.qualifiedName.slice(prefix.length)));
+        if (arityCands.length === 1) {
+            return {
+                original: ref,
+                targetNodeId: arityCands[0].id,
+                confidence: 0.85,
+                resolvedBy: 'qualified-name',
+            };
+        }
+        return null;
+    }
     // Try partial qualified name match — again preferring the call site's own
     // file when more than one symbol's qualifiedName ends with the reference.
     const parts = ref.referenceName.split(/[:.]/);
@@ -486,6 +1378,11 @@ function matchByQualifiedName(ref, context) {
     }
     return null;
 }
+/** A node a `Receiver.method()` call can name as the method's owning type. */
+function isMethodOwnerKind(n) {
+    return n.kind === 'class' || n.kind === 'struct' || n.kind === 'union' || n.kind === 'interface' ||
+        (n.language === 'scala' && n.kind === 'module');
+}
 /**
  * When a symbol name is ambiguous across files, prefer the candidate(s) declared
  * in the call site's own file, keeping the rest in their original order (#1079).
@@ -507,6 +1404,223 @@ function preferCallSiteFile(nodes, callSiteFile) {
     }
     return same.length ? [...same, ...other] : nodes;
 }
+/**
+ * Languages whose object literals declare callable members — `export const
+ * api = { call() {…}, get: () => {…} }` used as a namespace (#1573).
+ */
+const OBJECT_LITERAL_LANGUAGES = new Set(['typescript', 'tsx', 'javascript', 'jsx', 'arkts']);
+/** True when `inner`'s source range lies within `outer`'s (lines, then columns on a shared line). */
+function rangeWithin(inner, outer) {
+    const innerEnd = inner.endLine ?? inner.startLine;
+    const outerEnd = outer.endLine ?? outer.startLine;
+    if (inner.startLine < outer.startLine || innerEnd > outerEnd)
+        return false;
+    if (inner.startLine === outer.startLine && inner.startColumn < outer.startColumn)
+        return false;
+    if (innerEnd === outerEnd && inner.endColumn > outer.endColumn)
+        return false;
+    return true;
+}
+function sameRange(a, b) {
+    return (a.startLine === b.startLine &&
+        a.startColumn === b.startColumn &&
+        (a.endLine ?? a.startLine) === (b.endLine ?? b.startLine) &&
+        a.endColumn === b.endColumn);
+}
+/**
+ * Resolve `container.member` where `container` is a VALUE holding an object
+ * literal — `export const api = { call() {…}, get: () => {…} }` used as the
+ * module's namespace (#1573). The members are extracted as plain functions
+ * with BARE qualified names inside the constant's source extent (there is no
+ * `api::call`), so neither the `Container::member` lookup the class-shaped
+ * kinds use (#825) nor the declared-type inference for singleton instances
+ * (#1292) can reach them, and every such call resolved to nothing — or, via
+ * an import, to the constant itself. This looks the member up by CONTAINMENT:
+ * a node named `member` whose range lies inside the container's, in the
+ * container's own file. A helper declared inside a member's body is not a
+ * member and is skipped; nothing else in the file can donate a match. Calls
+ * take callable kinds only; other references accept value members too.
+ */
+function resolveObjectLiteralMember(container, member, ref, context, confidence, resolvedBy) {
+    if (container.kind !== 'constant' && container.kind !== 'variable')
+        return null;
+    if (!OBJECT_LITERAL_LANGUAGES.has(container.language))
+        return null;
+    if (!sameLanguageFamily(container.language, ref.language))
+        return null;
+    const inFile = context.getNodesInFile(container.filePath);
+    const callable = (n) => n.kind === 'function' || n.kind === 'method';
+    const valueMember = (n) => callable(n) || n.kind === 'property' || n.kind === 'variable' || n.kind === 'constant';
+    const accepts = ref.referenceKind === 'calls' ? callable : valueMember;
+    const inside = inFile.filter((n) => n.id !== container.id && rangeWithin(n, container));
+    const property = objectLiteralProperty(container, member, context);
+    if (property === null || property?.binding)
+        return null;
+    let candidates = inside.filter((n) => n.name === member && accepts(n) && (!property || property.contains(n)));
+    if (candidates.length === 0)
+        return null;
+    // Drop a candidate nested inside ANOTHER callable's body within the literal
+    // (`{ run() { const call = () => {}; } }` — `call` is `run`'s local, not a
+    // member). Strict containment: an identically-ranged sibling node for the
+    // same member (a property node over an arrow function) is not a body.
+    const bodies = inside.filter(callable);
+    candidates = candidates.filter((c) => !bodies.some((b) => b.id !== c.id && !sameRange(b, c) && rangeWithin(c, b)));
+    if (candidates.length === 0)
+        return null;
+    // Several survivors (a property AND a function for one arrow member, say):
+    // a callable first, then the earliest in source order.
+    candidates.sort((a, b) => {
+        const ca = callable(a) ? 0 : 1;
+        const cb = callable(b) ? 0 : 1;
+        if (ca !== cb)
+            return ca - cb;
+        return a.startLine - b.startLine || a.startColumn - b.startColumn;
+    });
+    return {
+        original: ref,
+        targetNodeId: candidates[0].id,
+        confidence,
+        resolvedBy,
+    };
+}
+/**
+ * The binding an object-literal member names when it is a shorthand property
+ * (`{ getUser }`) or a pair whose value is a bare identifier (`{ getUser:
+ * fetchUser }`) — the usual way an API module assembles its namespace from
+ * standalone functions (#1932). Only the literal's own members count: a member
+ * of a nested object, a word inside a member's body, a comment or a string
+ * never donates one. Null when the member is absent, or when its value is not
+ * a bare identifier (`{ fn: 1 }` names nothing).
+ */
+function objectLiteralMemberBinding(container, member, context) {
+    return objectLiteralProperty(container, member, context)?.binding ?? null;
+}
+/** The last own property wins; an unknown spread/computed key invalidates earlier evidence. */
+function objectLiteralProperty(container, member, context) {
+    const lines = context.getFileLines?.(container.filePath) ?? context.readFile(container.filePath)?.split('\n');
+    if (!lines)
+        return undefined;
+    const extentLines = lines.slice(container.startLine - 1, container.endLine);
+    if (!extentLines.length)
+        return undefined;
+    extentLines[extentLines.length - 1] = extentLines[extentLines.length - 1].slice(0, container.endColumn);
+    extentLines[0] = extentLines[0].slice(container.startColumn);
+    const extent = (0, strip_comments_1.stripCommentsForRegex)(extentLines.join('\n'), 'typescript');
+    const code = (0, strip_comments_1.blankStringContents)(extent);
+    // Start at THIS declarator, including its columns, never a sibling on the same line.
+    const open = /^[^=]*=\s*(?:(?:Object\.(?:freeze|seal)\s*)?\(\s*)*\{/.exec(code);
+    if (!open)
+        return undefined;
+    const members = [];
+    let depth = 0;
+    let start = open[0].length;
+    for (let i = start; i < code.length; i++) {
+        const ch = code[i];
+        if (ch === '{' || ch === '(' || ch === '[')
+            depth++;
+        else if (ch === ')' || ch === ']')
+            depth--;
+        else if (ch === '}') {
+            if (depth === 0) {
+                members.push({ start, end: i });
+                break;
+            }
+            depth--;
+        }
+        else if (ch === ',' && depth === 0) {
+            members.push({ start, end: i });
+            start = i + 1;
+        }
+    }
+    let selected = null;
+    for (const part of members) {
+        const text = extent.slice(part.start, part.end).trim();
+        if (/^(?:\.\.\.|\[)/.test(text)) {
+            selected = null;
+            continue;
+        }
+        const key = /^(?:(?:async|get|set)\s+)?\*?\s*(?:([A-Za-z_$][\w$]*)|['"]([^'"\\]*)['"])(?=\s*(?:[:(<,=]|$))/.exec(text);
+        if ((key?.[1] ?? key?.[2]) !== member)
+            continue;
+        const value = text.slice(key[0].length).trim();
+        const binding = value === '' ? member : /^:\s*([A-Za-z_$][\w$]*)$/.exec(value)?.[1] ?? null;
+        selected = { ...part, binding };
+    }
+    if (!selected)
+        return null;
+    const offset = (node) => {
+        let result = node.startColumn - container.startColumn;
+        for (let line = container.startLine; line < node.startLine; line++)
+            result += lines[line - 1].length + 1;
+        return result;
+    };
+    const property = selected;
+    return { binding: property.binding, contains: (node) => offset(node) >= property.start && offset(node) < property.end };
+}
+/**
+ * Shared lexical lookup for namespace-object aliases (#1932): `api.getUser()` where
+ * `api` is `const api = { getUser }` (or `{ getUser: fetchUser }`) in the
+ * object's own file. The member's function is declared OUTSIDE the literal, so
+ * containment (`resolveObjectLiteralMember`) finds nothing. Follow the binding
+ * the member names — a symbol of this file, else one of its imports — unless a
+ * parameter or nearer declaration shadows that name where the literal is
+ * written (the edge would then name the wrong function).
+ */
+function resolveObjectLiteralBinding(container, member, ref, context) {
+    const binding = objectLiteralMemberBinding(container, member, context);
+    if (!binding)
+        return null;
+    const at = { ...ref, filePath: container.filePath, language: container.language,
+        fromNodeId: container.id, line: container.startLine, column: container.startColumn };
+    const inFile = context.getNodesInFile(container.filePath);
+    if (inFile.some((n) => (n.kind === 'function' || n.kind === 'method') &&
+        rangeWithin(container, n) && n.signature &&
+        hasParameterBinding(`${n.signature} {`, binding.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))))
+        return null;
+    const lines = context.getFileLines?.(container.filePath) ?? context.readFile(container.filePath)?.split('\n');
+    if (!lines)
+        return null;
+    const code = (0, strip_comments_1.blankStringContents)((0, strip_comments_1.stripCommentsForRegex)(lines.join('\n'), 'typescript'));
+    const offsets = [0];
+    for (let i = 0; i < code.length; i++)
+        if (code[i] === '\n')
+            offsets.push(i + 1);
+    const scopeAt = (node) => {
+        const end = (offsets[node.startLine - 1] ?? code.length) + node.startColumn;
+        const scope = [];
+        for (let i = 0; i < end; i++) {
+            if (code[i] === '{')
+                scope.push(i);
+            else if (code[i] === '}')
+                scope.pop();
+        }
+        return scope;
+    };
+    const scope = scopeAt(container);
+    const callable = (n) => n.kind === 'function' || n.kind === 'method' || n.kind === 'class';
+    const accepts = ref.referenceKind === 'calls'
+        ? callable
+        : (n) => callable(n) || n.kind === 'constant' || n.kind === 'variable' || n.kind === 'component';
+    const locals = inFile
+        .filter((n) => n.name === binding && n.id !== container.id &&
+        ['function', 'class', 'constant', 'variable', 'component'].includes(n.kind))
+        .map((node) => ({ node, scope: scopeAt(node) }))
+        .filter((entry) => entry.scope.every((position, i) => scope[i] === position))
+        .sort((a, b) => b.scope.length - a.scope.length);
+    // Select the lexical binding BEFORE checking callability: a nearer value
+    // shadows an outer function even if that value cannot be called.
+    const local = locals[0]?.node;
+    if (local)
+        return accepts(local)
+            ? { original: ref, targetNodeId: local.id, confidence: 0.85, resolvedBy: 'instance-method' }
+            : null;
+    const imported = context.resolveImport?.({ ...at, referenceName: binding });
+    const target = imported ? context.getNodeById?.(imported.targetNodeId) : null;
+    if (target && accepts(target)) {
+        return { original: ref, targetNodeId: target.id, confidence: 0.85, resolvedBy: 'instance-method' };
+    }
+    return null;
+}
 // Exported for the precedence unit tests (#1079): they assert the
 // preferredFqn → same-file → matches[0] ordering directly.
 function resolveMethodOnType(typeName, methodName, ref, context, confidence, resolvedBy, 
@@ -542,7 +1656,7 @@ depth = 0) {
         for (const m of methodCandidates) {
             if (m.kind !== 'method')
                 continue;
-            if (m.language !== ref.language)
+            if (!sameLanguageFamily(m.language, ref.language))
                 continue;
             const qn = m.qualifiedName;
             if (qn === want || qn.endsWith(`::${want}`)) {
@@ -597,6 +1711,8 @@ depth = 0) {
     // block, so Java/Kotlin import disambiguation — whose target is intentionally
     // in ANOTHER file (#314) — is unaffected: that block returns early whenever
     // an import FQN pins the class.
+    if (ref.referenceKind === 'function_ref' && matches.length !== 1)
+        return null;
     const ordered = preferCallSiteFile(matches, ref.filePath);
     return {
         original: ref,
@@ -736,12 +1852,12 @@ function lookupCalleeReturnType(callee, ref, context) {
     }
     return candidates.find((n) => n.kind === 'function')?.returnType ?? null;
 }
-/** Does the graph contain a class/struct named `name`'s last segment? */
+/** Does the graph contain an aggregate type named `name`'s last segment? */
 function cppClassExists(name, ref, context) {
     const last = cppLastSegment(name);
     return context
         .getNodesByName(last)
-        .some((n) => (n.kind === 'class' || n.kind === 'struct') && n.language === ref.language);
+        .some((n) => (n.kind === 'class' || n.kind === 'struct' || n.kind === 'union') && n.language === ref.language);
 }
 /**
  * Infer the class produced by a C++ call/construction expression, using return
@@ -1065,6 +2181,8 @@ function normalizeInferredTypeName(raw) {
 const PATTERN_MEMO = new Map();
 const PATTERN_MEMO_CAP = 8192;
 const INFER_SCAN_STATES = new WeakMap();
+const AWAITED_TYPE_MEMO = new WeakMap();
+const AWAITED_FILES = new WeakMap();
 function getInferScanStates(context) {
     let m = INFER_SCAN_STATES.get(context);
     if (!m) {
@@ -1076,6 +2194,19 @@ function getInferScanStates(context) {
 /** Drop the per-context scan states (see ReferenceResolver.clearCaches). */
 function clearNameMatcherMemos(context) {
     INFER_SCAN_STATES.delete(context);
+    PYTHON_MEMBER_LINES.delete(context);
+    AWAITED_TYPE_MEMO.delete(context);
+    AWAITED_FILES.delete(context);
+    C_STATIC_MEMO.delete(context);
+    RUST_TRAIT_IMPL_MEMO.delete(context);
+    SEALED_MODULES.delete(context);
+    LOCAL_BINDING_MEMO.delete(context);
+    LOCAL_BINDING_SITES.delete(context);
+    SELECTOR_NAMES.delete(context);
+    GET_STATE_FILES.delete(context);
+    TS_FIELD_DECL_MEMO.delete(context);
+    TS_CLASS_LINES.delete(context);
+    TARGET_LANGUAGE.delete(context);
 }
 function memoPatterns(key, build) {
     const hit = PATTERN_MEMO.get(key);
@@ -1114,6 +2245,12 @@ function buildLocalReceiverTypePatterns(language, r) {
         case 'python':
             return [
                 new RegExp(`\\b${r}\\b\\s*=\\s*([A-Z][\\w.]*)\\s*\\(`), // lg = Logger(...)
+                // A quoted forward reference (`lg: "Logger"`, `lg: 'pkg.Logger'`) is the
+                // same annotation — and what every file under `from __future__ import
+                // annotations` or with a not-yet-defined class writes. The unquoted
+                // pattern below stopped at the quote and read no type at all, so the
+                // call produced no edge (#1684). Tried first: it is the stricter shape.
+                new RegExp(`\\b${r}\\b\\s*:\\s*["']([A-Z][\\w.]*)["']`), // lg: "Logger"
                 new RegExp(`\\b${r}\\b\\s*:\\s*([A-Z][\\w.]*)`), // lg: Logger  (PEP 526)
             ];
         case 'java':
@@ -1410,6 +2547,191 @@ function inferLocalReceiverType(receiverName, ref, context) {
     }
     return null;
 }
+/** Infer only a visible awaited binding and its actual local/imported callee.
+ * The signature already carries the return annotation in both extractors, so
+ * multiline declarations and neighboring declarations cannot donate a type.
+ * `null` means no awaited evidence; a null NAME means an awaited receiver whose
+ * type is unknown, which must not fall back to an unrelated method name. */
+function inferEsmAwaitedCallType(receiverName, ref, context) {
+    if (!/^[A-Za-z_$][\w$]*$/.test(receiverName))
+        return null;
+    let files = AWAITED_FILES.get(context);
+    if (!files) {
+        files = new Map();
+        AWAITED_FILES.set(context, files);
+    }
+    let file = files.get(ref.filePath);
+    if (file === undefined) {
+        const source = context.readFile(ref.filePath) ?? '';
+        file = null;
+        // Raw eligibility is cheap; sanitize and index scopes only when a ref
+        // actually uses one of these names. Comments cannot donate a binding:
+        // the names are checked again after sanitizing on the first real lookup.
+        const names = new Set([...source.matchAll(/\b(?:const|let|var)\s+([\w$]+)\s*=\s*await\s+[\w$]+\s*\(/g)].map(m => m[1]));
+        if (names.size)
+            file = { code: source, ready: false, names, offsets: [], scopes: [], declarations: new Map() };
+        if (files.size >= 256)
+            files.delete(files.keys().next().value);
+        files.set(ref.filePath, file);
+    }
+    if (!file?.names.has(receiverName))
+        return null;
+    if (!file.ready) {
+        const code = (0, strip_comments_1.blankStringContents)((0, strip_comments_1.stripCommentsForRegex)(file.code, 'typescript'));
+        const names = new Set([...code.matchAll(/\b(?:const|let|var)\s+([\w$]+)\s*=\s*await\s+[\w$]+\s*\(/g)].map(m => m[1]));
+        const offsets = [0];
+        const scopes = [{ start: -1, end: code.length, parent: -1 }];
+        const stack = [0];
+        for (let i = 0; i < code.length; i++) {
+            if (code[i] === '\n')
+                offsets.push(i + 1);
+            if (code[i] === '{') {
+                scopes.push({ start: i, end: code.length, parent: stack[stack.length - 1] });
+                stack.push(scopes.length - 1);
+            }
+            else if (code[i] === '}' && stack.length > 1)
+                scopes[stack.pop()].end = i;
+        }
+        const declarations = new Map();
+        for (const m of code.matchAll(/\b(?:const|let|var)\s+([\w$]+)\s*=\s*/g)) {
+            if (!names.has(m[1]))
+                continue;
+            const entries = declarations.get(m[1]) ?? [];
+            entries.push({ index: m.index, length: m[0].length });
+            declarations.set(m[1], entries);
+        }
+        Object.assign(file, { code, ready: true, names, offsets, scopes, declarations });
+        if (!names.has(receiverName))
+            return null;
+    }
+    let memo = AWAITED_TYPE_MEMO.get(context);
+    if (!memo) {
+        memo = new Map();
+        AWAITED_TYPE_MEMO.set(context, memo);
+    }
+    const key = `${ref.filePath}|${ref.line}|${ref.column}|${receiverName}`;
+    if (memo.has(key))
+        return memo.get(key);
+    const result = resolveAwaitedCallType(receiverName, file, ref, context);
+    if (memo.size >= PATTERN_MEMO_CAP)
+        memo.delete(memo.keys().next().value);
+    memo.set(key, result);
+    return result;
+}
+function resolveAwaitedCallType(receiverName, file, ref, context) {
+    const unknown = { name: null, filePath: ref.filePath };
+    const end = (file.offsets[ref.line - 1] ?? file.code.length) + ref.column;
+    const code = file.code.slice(0, end);
+    const escaped = receiverName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    // Locate scopes in the precomputed brace tree. Rescanning the entire file
+    // for every candidate binding made large test files quadratic in refs.
+    const scopeAt = (offset) => {
+        let lo = 0, hi = file.scopes.length;
+        while (lo + 1 < hi) {
+            const mid = (lo + hi) >>> 1;
+            if (file.scopes[mid].start < offset)
+                lo = mid;
+            else
+                hi = mid;
+        }
+        while (lo > 0 && file.scopes[lo].end < offset)
+            lo = file.scopes[lo].parent;
+        return lo;
+    };
+    const visibleAt = (declaration, use) => {
+        const ancestor = scopeAt(declaration);
+        for (let scope = scopeAt(use); scope >= 0; scope = file.scopes[scope].parent)
+            if (scope === ancestor)
+                return true;
+        return false;
+    };
+    const binding = [...(file.declarations.get(receiverName) ?? [])].reverse()
+        .find(m => m.index < end && visibleAt(m.index, end));
+    if (!binding)
+        return null;
+    const init = code.slice(binding.index + binding.length);
+    if (!/^await\b/.test(init))
+        return null;
+    // Only a bare call result, not a following member/index/conditional expression.
+    const call = /^await\s+([A-Za-z_$][\w$]*)\s*\(/.exec(init);
+    if (!call)
+        return null;
+    let depth = 1, callEnd = call[0].length;
+    for (; callEnd < init.length && depth; callEnd++) {
+        if (init[callEnd] === '(')
+            depth++;
+        else if (init[callEnd] === ')')
+            depth--;
+    }
+    if (depth)
+        return unknown;
+    const tail = init.slice(callEnd);
+    // A following property/index/call is not the callee's annotated value.
+    if (!/^[ \t]*(?:;|\r?\n(?![ \t]*[.(\[?]))/.test(tail))
+        return unknown;
+    const rest = tail;
+    if (new RegExp(`\\b(?:const|let|var|function|class)\\s+(?:${escaped}\\b|\\{[^}]*\\b${escaped}\\b)`).test(rest) ||
+        new RegExp(`\\b${escaped}\\s*=(?!=)`).test(rest) || hasParameterBinding(rest, escaped))
+        return unknown;
+    const bindingLine = file.code.slice(0, binding.index).split('\n').length;
+    const bindingRef = { ...ref, line: bindingLine, column: binding.index - file.offsets[bindingLine - 1] };
+    const callee = call[1];
+    const calleeEscaped = callee.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    if (context.getNodesInFile(ref.filePath).some(n => (n.kind === 'function' || n.kind === 'method') && n.startLine <= bindingLine && n.endLine >= bindingLine &&
+        n.signature && hasParameterBinding(`${n.signature} {`, calleeEscaped)))
+        return unknown;
+    const imported = context.getImportMappings(ref.filePath, ref.language).some(m => m.localName === callee);
+    let declaring;
+    if (imported) {
+        if (importShadowedAt(callee, bindingRef, context))
+            return unknown;
+        const resolved = context.resolveImport?.({ ...bindingRef, referenceName: callee, referenceKind: 'calls' });
+        declaring = resolved ? context.getNodeById?.(resolved.targetNodeId) ?? undefined : undefined;
+    }
+    else {
+        const local = context.getNodesByName(callee).filter(n => n.kind === 'function' &&
+            n.filePath === ref.filePath && ESM_FAMILY.has(n.language) && isLexicallyReachable(n, bindingRef, context));
+        if (local.length === 1)
+            declaring = local[0];
+    }
+    if (!declaring || declaring.kind !== 'function' || !declaring.signature)
+        return unknown;
+    if (!imported) {
+        const beforeBinding = code.slice(0, binding.index);
+        const shadows = new RegExp(`\\b(?:const|let|var)\\s+${calleeEscaped}\\b`, 'g');
+        for (const shadow of beforeBinding.matchAll(shadows)) {
+            if (!visibleAt(shadow.index, binding.index))
+                continue;
+            // A typed arrow function may itself be the declared local factory.
+            const line = file.code.slice(0, shadow.index).split('\n').length;
+            if (line !== declaring.startLine || shadow.index - file.offsets[line - 1] > declaring.startColumn)
+                return unknown;
+        }
+    }
+    const signature = declaring.signature;
+    const annotation = signature.slice(signature.lastIndexOf(')') + 1).match(/^\s*:\s*([\s\S]+)$/)?.[1]?.trim();
+    if (!annotation)
+        return unknown;
+    // Do not turn unions, arrays, object/function types, or conditional types into
+    // a project class. Await recursively unwraps promises, but this narrow path
+    // accepts a single named Promise<T> layer only.
+    const returned = annotation.match(/^Promise\s*<\s*([\w$]+)\s*>$/)?.[1] ?? annotation;
+    if (!/^[A-Za-z_$][\w$]*$/.test(returned))
+        return unknown;
+    if (js_builtins_1.TS_PRIMITIVE_TYPES.has(returned))
+        return { name: returned, filePath: declaring.filePath };
+    const typeRef = { ...bindingRef, fromNodeId: declaring.id, filePath: declaring.filePath,
+        language: declaring.language, line: declaring.startLine, column: declaring.startColumn,
+        referenceName: returned, referenceKind: 'references' };
+    const typeImport = context.getImportMappings(declaring.filePath, declaring.language).some(m => m.localName === returned);
+    const resolved = typeImport ? context.resolveImport?.(typeRef) : null;
+    const typeNode = resolved ? context.getNodeById?.(resolved.targetNodeId) :
+        context.getNodesByName(returned).find(n => n.filePath === declaring.filePath &&
+            ESM_FAMILY.has(n.language) && (n.kind === 'class' || n.kind === 'interface'));
+    if (!typeNode || (typeNode.kind !== 'class' && typeNode.kind !== 'interface'))
+        return unknown;
+    return { name: typeNode.name, filePath: typeNode.filePath };
+}
 /**
  * Patterns that recover a PHP class property's declared type for a
  * `$this->prop` receiver. Deliberately NOT localReceiverTypePatterns: only
@@ -1547,6 +2869,15 @@ function matchMethodCall(ref, context) {
             return null;
         return resolveMethodOnType(inferredType, phpMethodName, ref, context, 0.9, 'instance-method', importedFqnOf(inferredType, ref, context));
     }
+    // A TS/JS call through an ES private field of the enclosing class —
+    // `this.#items.add()`, emitted as `this.#items.add` (#1987) — resolves
+    // exactly like `this.<field>` below (#1496). `#` is outside dotMatch's
+    // receiver class, so the shape is matched here.
+    if (ref.language === 'typescript' || ref.language === 'javascript' || ref.language === 'tsx' || ref.language === 'jsx') {
+        const privateField = ref.referenceName.match(/^this\.(#[\w$]+)\.(\w+)$/);
+        if (privateField)
+            return matchTsThisFieldCall(privateField[1], privateField[2], ref, context);
+    }
     const match = dotMatch || colonMatch || luaColonMatch || rDollarMatch;
     if (!match) {
         return null;
@@ -1561,9 +2892,16 @@ function matchMethodCall(ref, context) {
     // shared source-based inferrer. resolveMethodOnType validates the method
     // exists on the inferred type, so a mis-inference produces no edge.
     if (inferableReceiver) {
-        const inferredType = nmTimedT('mc-infer', ref, () => ref.language === 'cpp'
+        let inferredType = nmTimedT('mc-infer', ref, () => ref.language === 'cpp'
             ? inferCppReceiverType(objectOrClass, ref, context)
             : inferLocalReceiverType(objectOrClass, ref, context));
+        const awaited = !inferredType && ESM_FAMILY.has(ref.language)
+            ? inferEsmAwaitedCallType(objectOrClass, ref, context) : null;
+        if (awaited) {
+            if (!awaited.name || js_builtins_1.TS_PRIMITIVE_TYPES.has(awaited.name))
+                return null;
+            inferredType = awaited.name;
+        }
         if (inferredType) {
             // Java/Kotlin: when two classes share the simple name, the file's import
             // pins WHICH one (#314). Other languages disambiguate by call-site file.
@@ -1572,10 +2910,29 @@ function matchMethodCall(ref, context) {
                     .getImportMappings(ref.filePath, ref.language)
                     .find((i) => i.localName === inferredType)?.source
                 : undefined;
-            const typedMatch = nmTimedT('mc-rmot', ref, () => resolveMethodOnType(inferredType, methodName, ref, context, 0.9, 'instance-method', importedFqn));
+            const typedMatch = nmTimedT('mc-rmot', ref, () => resolveMethodOnType(inferredType, methodName, awaited ? { ...ref, filePath: awaited.filePath } : ref, context, 0.9, 'instance-method', importedFqn));
             if (typedMatch) {
+                if (awaited) {
+                    const target = context.getNodeById?.(typedMatch.targetNodeId);
+                    if (!target || (target.qualifiedName.startsWith(`${inferredType}::`) && target.filePath !== awaited.filePath))
+                        return null;
+                    return { ...typedMatch, original: ref };
+                }
                 return typedMatch;
             }
+            if (awaited)
+                return null;
+            // A known JS/TS builtin receiver is external when it has no project
+            // method (#1566). Inference already strips generics (`Map<K, V>` →
+            // `Map`); do not let Strategy 3 guess an unrelated `get`/`set`/`has`.
+            // Keep the validated match above for a project type shadowing a builtin.
+            // A primitive receiver joins the builtins here: `listed.split()` on a
+            // `string` is the built-in method, and Strategy 3 would otherwise hand
+            // it whichever project class happens to declare a lone `split` (#1840).
+            if (ESM_FAMILY.has(ref.language) &&
+                (js_builtins_1.JS_BUILT_INS.has(inferredType) || js_builtins_1.TS_PRIMITIVE_TYPES.has(inferredType))) {
+                return null;
+            }
         }
     }
     // Go 2-hop field chain `base.field.Method` (#1276): the base's type comes
@@ -1592,6 +2949,39 @@ function matchMethodCall(ref, context) {
     if (ref.language === 'go' && dotMatch && objectOrClass.includes('.')) {
         return matchGoFieldChainCall(objectOrClass, methodName, ref, context);
     }
+    // Rust call through a field of the enclosing type — `self.inner.run()`,
+    // emitted as `self.inner.run` (#1585). Same discipline as the Go branch
+    // above, and EXCLUSIVE for the same reason: validated field-type inference
+    // or nothing. Letting this shape reach the bare-name strategies below is
+    // how `self.inner.run()` resolved to a same-named method on an unrelated
+    // type — or to the calling method itself, a self-edge the source doesn't
+    // contain — whenever the field's type was external or merely shared a
+    // method name with something nearby.
+    if (ref.language === 'rust' && dotMatch && objectOrClass.startsWith('self.')) {
+        return matchRustSelfFieldCall(objectOrClass.slice('self.'.length), methodName, ref, context);
+    }
+    // Rust call on the enclosing type itself — `self.reset()`, emitted as
+    // `self.reset` (#1861). Same discipline as the field branch above, and
+    // EXCLUSIVE for the same reason: the owner is written on the `impl` line and
+    // carried in the calling method's qualified name, so it is not a guess.
+    // Letting this shape reach the bare-name strategies below is how
+    // `self.reset()` resolved to a same-named method on an unrelated type
+    // whenever that type's method happened to sit nearer the call site.
+    if (ref.language === 'rust' && dotMatch && objectOrClass === 'self') {
+        return matchRustSelfCall(methodName, ref, context);
+    }
+    // TS/JS call through a field of the enclosing class — `this.mailer.send()`,
+    // emitted as `this.mailer.send` (#1496). Same discipline as the Rust branch
+    // above, and EXCLUSIVE for the same reason: the field's declared type off
+    // the class's own declaration, validated by resolveMethodOnType, or nothing.
+    // Letting the bare name through is how `this.mailer.send()` inside
+    // `Notifier.send()` resolved to the calling method itself — a self-edge the
+    // source does not contain — whenever the two shared a name.
+    if ((ref.language === 'typescript' || ref.language === 'javascript' || ref.language === 'tsx' || ref.language === 'jsx') &&
+        dotMatch &&
+        objectOrClass.startsWith('this.')) {
+        return matchTsThisFieldCall(objectOrClass.slice('this.'.length), methodName, ref, context);
+    }
     // Java/Kotlin: receiver may be a field whose name doesn't match the type by
     // Java naming convention (`userbo` → class `UserBO`, abbreviated). Look up
     // the field in the enclosing class to get its declared type, then resolve
@@ -1611,59 +3001,85 @@ function matchMethodCall(ref, context) {
             }
         }
     }
+    // Object-literal namespace receiver (#1573): `api.call()` where `api` is a
+    // same-file `const api = { call() {…}, get: () => {…} }`. Its members are
+    // plain functions with bare names inside the constant's extent — no
+    // `Container::member` qualified name — so none of the class-shaped
+    // strategies below can see them (Strategy 3 only considers `method`
+    // kinds) and the call resolved to nothing at all. Same file only: a
+    // cross-file use reaches the same helper through the import path.
+    if (dotMatch && !objectOrClass.includes('.') && OBJECT_LITERAL_LANGUAGES.has(ref.language)) {
+        const literalMatch = nmTimedT('mc-literal', ref, () => {
+            // Same-file holders only, so the call-site-first ordering is moot.
+            const holders = context.getNodesByName(objectOrClass).filter((n) => (n.kind === 'constant' || n.kind === 'variable') && n.filePath === ref.filePath);
+            for (const holder of holders) {
+                const hit = resolveObjectLiteralMember(holder, methodName, ref, context, 0.85, 'instance-method') ??
+                    resolveObjectLiteralBinding(holder, methodName, ref, context);
+                if (hit)
+                    return hit;
+            }
+            return null;
+        });
+        if (literalMatch)
+            return literalMatch;
+    }
     // Strategy 1: Direct class name match (existing logic). When the receiver
     // names a class that exists in several files (`Logger.log()` / `Logger::log()`
     // with a `Logger` in both `a/` and `b/`), try the class in the call site's
     // own file first — otherwise the first-indexed class wins and a call in `b/`
     // resolves to `a/`'s method (#1079).
     const strat1 = nmTimedT('mc-class', ref, () => {
-        const classCandidates = preferCallSiteFile(context.getNodesByName(objectOrClass), ref.filePath);
+        const classCandidates = preferCallSiteFile(context.getNodesByName(objectOrClass).filter(isMethodOwnerKind), ref.filePath);
         for (const classNode of classCandidates) {
-            if (classNode.kind === 'class' || classNode.kind === 'struct' || classNode.kind === 'interface') {
-                // Skip cross-language class matches
-                if (classNode.language !== ref.language)
-                    continue;
-                const nodesInFile = context.getNodesInFile(classNode.filePath);
-                const methodNode = nodesInFile.find((n) => n.kind === 'method' &&
-                    n.name === methodName &&
-                    n.qualifiedName.includes(classNode.name));
-                if (methodNode) {
-                    return {
-                        original: ref,
-                        targetNodeId: methodNode.id,
-                        confidence: 0.85,
-                        resolvedBy: 'qualified-name',
-                    };
-                }
+            // Skip cross-language class matches
+            if (classNode.language !== ref.language)
+                continue;
+            const nodesInFile = context.getNodesInFile(classNode.filePath);
+            const methodNode = nodesInFile.find((n) => n.kind === 'method' &&
+                n.name === methodName &&
+                n.qualifiedName.includes(classNode.name));
+            if (methodNode) {
+                return {
+                    original: ref,
+                    targetNodeId: methodNode.id,
+                    confidence: 0.85,
+                    resolvedBy: 'qualified-name',
+                };
             }
         }
         return null;
     });
     if (strat1)
         return strat1;
+    // Built-in method names need a validated receiver (#1987). Typed, imported,
+    // object-literal and direct class receivers have had their chance above;
+    // capitalization, word overlap or a unique method name are not evidence
+    // that `list.map()` / `cache.get()` calls a project class.
+    if (ref.referenceKind === 'calls' && JS_FAMILY.has(ref.language) &&
+        objectOrClass !== 'this' && objectOrClass !== 'super' &&
+        js_builtins_1.JS_BUILTIN_METHODS.has(methodName))
+        return null;
     // Strategy 2: Instance variable receiver - try capitalized form to find class
     // e.g., "permissionEngine" → look for classes containing "PermissionEngine"
     const capitalizedReceiver = objectOrClass.charAt(0).toUpperCase() + objectOrClass.slice(1);
     if (capitalizedReceiver !== objectOrClass) {
         const strat2 = nmTimedT('mc-capital', ref, () => {
-            const fuzzyClassCandidates = preferCallSiteFile(context.getNodesByName(capitalizedReceiver), ref.filePath);
+            const fuzzyClassCandidates = preferCallSiteFile(context.getNodesByName(capitalizedReceiver).filter(isMethodOwnerKind), ref.filePath);
             for (const classNode of fuzzyClassCandidates) {
-                if (classNode.kind === 'class' || classNode.kind === 'struct' || classNode.kind === 'interface') {
-                    // Skip cross-language class matches
-                    if (classNode.language !== ref.language)
-                        continue;
-                    const nodesInFile = context.getNodesInFile(classNode.filePath);
-                    const methodNode = nodesInFile.find((n) => n.kind === 'method' &&
-                        n.name === methodName &&
-                        n.qualifiedName.includes(classNode.name));
-                    if (methodNode) {
-                        return {
-                            original: ref,
-                            targetNodeId: methodNode.id,
-                            confidence: 0.8,
-                            resolvedBy: 'instance-method',
-                        };
-                    }
+                // Skip cross-language class matches
+                if (classNode.language !== ref.language)
+                    continue;
+                const nodesInFile = context.getNodesInFile(classNode.filePath);
+                const methodNode = nodesInFile.find((n) => n.kind === 'method' &&
+                    n.name === methodName &&
+                    n.qualifiedName.includes(classNode.name));
+                if (methodNode) {
+                    return {
+                        original: ref,
+                        targetNodeId: methodNode.id,
+                        confidence: 0.8,
+                        resolvedBy: 'instance-method',
+                    };
                 }
             }
             return null;
@@ -1814,6 +3230,641 @@ function matchGoFieldChainCall(receiverChain, methodName, ref, context) {
     }
     return null;
 }
+// Rust primitives and the prelude's own types: a field of one of these never
+// names a project type, so a `self.<field>.<method>()` on it stays unresolved.
+const RUST_NON_PROJECT_FIELD_TYPES = new Set([
+    'bool', 'char', 'str', 'String',
+    'i8', 'i16', 'i32', 'i64', 'i128', 'isize',
+    'u8', 'u16', 'u32', 'u64', 'u128', 'usize',
+    'f32', 'f64',
+    'Self', 'self',
+]);
+/**
+ * Reduce a Rust field's declared type text to the simple name of the type a
+ * method call on that field auto-derefs to, or null when there is none we can
+ * name. Only the layers Rust's method-call auto-deref looks through are
+ * unwrapped: references (`&`, `&'a mut`) and the owning smart pointers
+ * (`Box`, `Rc`, `Arc`) — `self.inner.run()` with `inner: Box<Inner>` calls
+ * `Inner::run`. Containers that do NOT auto-deref to their parameter
+ * (`Option<Inner>`, `Vec<Inner>`, `Mutex<Inner>`, `RefCell<Inner>`) keep their
+ * own name and, having no project node, resolve to nothing — `self.items.push()`
+ * must never become `Inner::push`. A trait object (`Box<dyn Source>`) yields
+ * the trait, whose method node the interface-impl synthesizer fans out. A
+ * generic parameter (`T`), a primitive, a tuple / array / raw pointer / fn
+ * type, or a non-identifier yields null.
+ */
+function rustFieldTypeName(raw) {
+    let t = raw.trim();
+    for (;;) {
+        const before = t;
+        t = t.replace(/^&\s*(?:'\w+\s+)?(?:mut\s+)?/, '');
+        t = t.replace(/^(?:Box|Rc|Arc)\s*<\s*/, '');
+        t = t.replace(/^(?:dyn|impl)\s+/, '');
+        if (t === before)
+            break;
+    }
+    // Drop generic args, the closing `>`s of unwrapped pointers, and trait-object
+    // bounds (`dyn Source + Send`); keep the last path segment.
+    t = t.replace(/[<>+].*$/, '').trim();
+    const seg = t.split('::').filter(Boolean).pop();
+    if (!seg || !/^[A-Za-z_]\w*$/.test(seg))
+        return null;
+    if (RUST_NON_PROJECT_FIELD_TYPES.has(seg))
+        return null;
+    if (/^[A-Z]$/.test(seg))
+        return null; // bare single-letter generic parameter
+    return seg;
+}
+/**
+ * `self.method()` in Rust — the method on the type the call sits inside.
+ *
+ * The owner is the calling method's qualified-name prefix (`Target::run` →
+ * `Target`), which is where the `impl` block's type ends up. A free function
+ * has no `self`, so a caller whose qualified name carries no owner declines.
+ * Exactly one candidate must belong to that owner: a project with two `impl`
+ * blocks for the same type is normal, two same-named methods on it is not, and
+ * guessing between them is the failure this replaces.
+ */
+function matchRustSelfCall(methodName, ref, context) {
+    const caller = context.getNodeById?.(ref.fromNodeId);
+    if (!caller?.qualifiedName)
+        return null;
+    const sep = caller.qualifiedName.lastIndexOf('::');
+    if (sep <= 0)
+        return null; // a free fn has no `self`
+    const owner = caller.qualifiedName.slice(0, sep);
+    let owned = context
+        .getNodesByQualifiedName(`${owner}::${methodName}`)
+        .filter((n) => n.kind === 'method' &&
+        n.language === 'rust' &&
+        n.qualifiedName === `${owner}::${methodName}`);
+    // Rust's extracted qualified names omit module paths. Two modules can
+    // each declare `Target`; matching just `Target::reset` does not establish
+    // ownership. In that case require a single owner declaration in the
+    // caller's file and a method in that file. Otherwise leave it unresolved.
+    // A unique owner still permits ordinary impl blocks split across files.
+    const owners = context.getNodesByQualifiedName(owner).filter((n) => n.language === 'rust' && ['struct', 'enum', 'union', 'trait', 'class'].includes(n.kind));
+    if (owners.length > 1) {
+        if (owners.filter((n) => n.filePath === caller.filePath).length !== 1)
+            return null;
+        owned = owned.filter((n) => n.filePath === caller.filePath);
+    }
+    if (owned.length !== 1)
+        return null;
+    return {
+        original: ref,
+        targetNodeId: owned[0].id,
+        confidence: 0.9,
+        resolvedBy: 'qualified-name',
+    };
+}
+/**
+ * Resolve a Rust call through a field of the enclosing type —
+ * `self.inner.run()`, emitted by the extractor as `self.inner.run` (#1585).
+ * Mirrors the Go 2-hop precedent above (#1276): the owner type is the calling
+ * method's qualified-name prefix (`Outer::run` → `Outer`), the field's declared
+ * type comes from the owner struct's OWN declaration lines, and the method is
+ * resolved AND VALIDATED on that type by resolveMethodOnType. The caller
+ * treats this branch as exclusive for `self.<field>` receivers: a field whose
+ * type is external (`std::vec::IntoIter`, `regex::Regex`), a generic
+ * parameter, or not declared where we can see it yields null and the ref stays
+ * unresolved. Rust struct fields are not graph nodes, so the declaration text
+ * is the only place the type lives.
+ */
+function matchRustSelfFieldCall(field, methodName, ref, context) {
+    // The extractor only ever emits a single field hop; anything else is not ours.
+    if (!field || field.includes('.'))
+        return null;
+    const caller = context.getNodeById?.(ref.fromNodeId);
+    if (!caller)
+        return null;
+    const sep = caller.qualifiedName.lastIndexOf('::');
+    if (sep <= 0)
+        return null; // a free fn has no `self`
+    const owner = caller.qualifiedName.slice(0, sep).split('::').pop();
+    if (!owner)
+        return null;
+    const owners = preferCallSiteFile(context.getNodesByName(owner), ref.filePath).filter((n) => (n.kind === 'struct' || n.kind === 'union' || n.kind === 'class') &&
+        n.language === 'rust');
+    const fieldEsc = field.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    // `pub inner: Inner,` / `inner: Box<dyn Source>,` / `pub(crate) inner: T }` —
+    // the type text runs to the field separator. A comma inside generic args
+    // (`HashMap<K, V>`) truncates the capture, which rustFieldTypeName then
+    // reduces to the container's own name — exactly the non-deref case it
+    // refuses anyway.
+    const fieldRe = new RegExp(`\\b${fieldEsc}\\s*:\\s*([^,{}]+)`);
+    for (const s of owners) {
+        const source = context.readFile(s.filePath);
+        if (!source)
+            continue;
+        // Only the struct's own declaration lines, comment-stripped line by line —
+        // same discipline as the Go helper: prose or a same-named identifier
+        // elsewhere in the file can never donate a type.
+        const declLines = source.split('\n').slice(Math.max(0, s.startLine - 1), s.endLine);
+        for (const rawLine of declLines) {
+            const line = rawLine.replace(/\/\/.*$/, '').replace(/\/\*.*?\*\//g, '');
+            const m = line.match(fieldRe);
+            if (!m || !m[1])
+                continue;
+            const fieldType = rustFieldTypeName(m[1]);
+            // The field is declared here; whether or not its type names a project
+            // symbol, this owner is the answer — no other same-named struct applies.
+            if (!fieldType)
+                return null;
+            return resolveMethodOnType(fieldType, methodName, ref, context, 0.85, 'instance-method');
+        }
+    }
+    return null;
+}
+/**
+ * Per-context memo for matchTsThisFieldCall's declaration scan: `classId\0field`
+ * → the first line of the class that declares the field (as `: typeof X`,
+ * `: X`, or `= new X`, tried in that order per line) with its captured type,
+ * or null. The scan depends only on the class and the field, but ran for every
+ * `this.<field>.<method>()` call — re-splitting the file and compiling three
+ * patterns each time, a third of all method-call matching on vscode. Derived
+ * from file source: drops with clearNameMatcherMemos.
+ */
+const TS_FIELD_DECL_MEMO = new WeakMap();
+/** The last few classes' declarations — calls arrive file by file. */
+const TS_CLASS_LINES = new WeakMap();
+const TS_CLASS_LINES_KEEP = 32;
+function tsClassDecl(cls, context) {
+    let cache = TS_CLASS_LINES.get(context);
+    if (!cache) {
+        cache = new Map();
+        TS_CLASS_LINES.set(context, cache);
+    }
+    const hit = cache.get(cls.id);
+    if (hit !== undefined)
+        return hit;
+    const source = context.readFile(cls.filePath);
+    const decl = source
+        ? {
+            lines: source
+                .split('\n')
+                .slice(Math.max(0, cls.startLine - 1), cls.endLine)
+                .map((rawLine) => rawLine.replace(/\/\/.*$/, '').replace(/\/\*.*?\*\//g, '')),
+            lookups: 0,
+            linesByToken: null,
+        }
+        : null;
+    if (cache.size >= TS_CLASS_LINES_KEEP)
+        cache.delete(cache.keys().next().value);
+    cache.set(cls.id, decl);
+    return decl;
+}
+const TS_FIELD_TOKEN = /^[\w$#]+$/;
+const TS_LINE_TOKEN = /[\w$#]+/g;
+const TS_TOKEN_CHAR = /[\w$#]/;
+/**
+ * tsFieldPatterns with the field spelled `[\w$#]+`, tried sticky at a whole-
+ * token occurrence of the field. There the run consumes exactly the field (a
+ * shorter prefix cannot continue: every pattern needs `\s`, `?`, `!`, `:` or
+ * `=` next), so each matches exactly where the field's own pattern would —
+ * without compiling three patterns for every field of every class.
+ */
+const TS_FIELD_PATTERNS_AT = [
+    { re: /(?<![\w$#])[\w$#]+\b\s*[?!]?\s*:\s*(?:readonly\s+)?typeof\s+([A-Za-z_$][\w.$]*)/y, valueType: true },
+    { re: /(?<![\w$#])[\w$#]+\b\s*[?!]?\s*:\s*(?:readonly\s+)?([A-Za-z_$][\w.$]*)/y, valueType: false },
+    { re: /(?<![\w$#])[\w$#]+\b\s*=\s*new\s+([A-Za-z_$][\w.$]*)/y, valueType: false },
+];
+/** The first declaration of `field` on one line, as `line.match` of its patterns in order would find it. */
+function tsFieldOnLine(line, field) {
+    let at = null;
+    for (let i = line.indexOf(field); i !== -1; i = line.indexOf(field, i + 1)) {
+        const end = i + field.length;
+        if ((i > 0 && TS_TOKEN_CHAR.test(line[i - 1])) || (end < line.length && TS_TOKEN_CHAR.test(line[end])))
+            continue;
+        (at ??= []).push(i);
+    }
+    if (!at)
+        return null;
+    for (const { re, valueType } of TS_FIELD_PATTERNS_AT) {
+        for (const i of at) {
+            re.lastIndex = i;
+            const m = re.exec(line);
+            if (m && m[1])
+                return { valueType, type: m[1] };
+        }
+    }
+    return null;
+}
+/** Indices of the class lines holding `token` as a whole `[\w$#]` run, ascending. */
+function tsClassLinesWithToken(decl, token) {
+    if (!decl.linesByToken) {
+        const index = new Map();
+        for (let i = 0; i < decl.lines.length; i++) {
+            for (const m of decl.lines[i].matchAll(TS_LINE_TOKEN)) {
+                const rows = index.get(m[0]);
+                if (!rows)
+                    index.set(m[0], [i]);
+                else if (rows[rows.length - 1] !== i)
+                    rows.push(i);
+            }
+        }
+        decl.linesByToken = index;
+    }
+    return decl.linesByToken.get(token) ?? [];
+}
+/** Compiled declaration patterns by field name — fields recur across classes. */
+const TS_FIELD_PATTERNS = new Map();
+const TS_FIELD_PATTERNS_CAP = 4096;
+function tsFieldPatterns(field) {
+    const hit = TS_FIELD_PATTERNS.get(field);
+    if (hit)
+        return hit;
+    const fieldEsc = field.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    // A word boundary cannot open a private name; it also lets a public
+    // `items` match `#items`. Keep the two field namespaces distinct (#1987).
+    const fieldStart = '(?<![\\w$#])';
+    const patterns = [
+        // `storage: typeof DraftHubStorage` — the type OF a value: an object
+        // literal used as a namespace. Its members are bare-named functions inside
+        // the constant's extent (#1573), so they are found by containment, not by
+        // `Type::method`. Tried first: the declared-type pattern below would
+        // otherwise capture the word `typeof`.
+        {
+            re: new RegExp(`${fieldStart}${fieldEsc}\\b\\s*[?!]?\\s*:\\s*(?:readonly\\s+)?typeof\\s+([A-Za-z_$][\\w.$]*)`),
+            valueType: true,
+        },
+        // `private readonly mailer?: Mailer` — a class field or a constructor
+        // parameter property; the capture stops at `<`, `[` or `|`, so a generic
+        // or union type yields its head and resolveMethodOnType decides.
+        {
+            re: new RegExp(`${fieldStart}${fieldEsc}\\b\\s*[?!]?\\s*:\\s*(?:readonly\\s+)?([A-Za-z_$][\\w.$]*)`),
+            valueType: false,
+        },
+        // `mailer = new Mailer()` / `this.mailer = new Mailer()`
+        { re: new RegExp(`${fieldStart}${fieldEsc}\\b\\s*=\\s*new\\s+([A-Za-z_$][\\w.$]*)`), valueType: false },
+    ];
+    if (TS_FIELD_PATTERNS.size >= TS_FIELD_PATTERNS_CAP)
+        TS_FIELD_PATTERNS.delete(TS_FIELD_PATTERNS.keys().next().value);
+    TS_FIELD_PATTERNS.set(field, patterns);
+    return patterns;
+}
+function tsFieldDeclaration(cls, field, context) {
+    let memo = TS_FIELD_DECL_MEMO.get(context);
+    if (!memo) {
+        memo = new Map();
+        TS_FIELD_DECL_MEMO.set(context, memo);
+    }
+    const key = cls.id + '\0' + field;
+    const hit = memo.get(key);
+    if (hit !== undefined)
+        return hit;
+    let found = null;
+    const decl = tsClassDecl(cls, context);
+    if (decl && TS_FIELD_TOKEN.test(field)) {
+        // Every pattern needs the field as a whole `[\w$#]` run — the lookbehind
+        // bars one before it, and nothing after it but `\s`, `?`, `!`, `:` or `=`
+        // can continue a match — so only lines holding that token can match. A
+        // class asked about several fields is indexed by token once.
+        const rows = ++decl.lookups > 1 ? tsClassLinesWithToken(decl, field) : null;
+        const count = rows ? rows.length : decl.lines.length;
+        for (let k = 0; k < count && !found; k++) {
+            const line = decl.lines[rows ? rows[k] : k];
+            // Every pattern spells the field literally, so only a line that contains
+            // it can match — and most of a class's lines never mention a given field.
+            if (line.includes(field))
+                found = tsFieldOnLine(line, field);
+        }
+    }
+    else if (decl) {
+        const patterns = tsFieldPatterns(field);
+        scan: for (const line of decl.lines) {
+            if (!line.includes(field))
+                continue;
+            for (const { re, valueType } of patterns) {
+                const m = line.match(re);
+                if (!m || !m[1])
+                    continue;
+                found = { valueType, type: m[1] };
+                break scan;
+            }
+        }
+    }
+    memo.set(key, found);
+    return found;
+}
+/**
+ * Resolve a TS/JS `this.<field>.<method>()` call (#1496) through the field's
+ * declared type, read off the ENCLOSING class's own declaration lines:
+ * a field or constructor-parameter property (`private mailer: Mailer`,
+ * `mailer?: Mailer`, `readonly mailer: Mailer`) or an initializer
+ * (`mailer = new Mailer()`, `this.mailer = new Mailer()`). The method is then
+ * VALIDATED on that type by resolveMethodOnType. Null — never a bare-name
+ * fallback — when the field is not declared there or its type is external,
+ * a builtin (`this.items.push()`) or not spelled out.
+ */
+function matchTsThisFieldCall(field, methodName, ref, context) {
+    if (!field || field.includes('.'))
+        return null;
+    const caller = context.getNodeById?.(ref.fromNodeId);
+    if (!caller)
+        return null;
+    const sep = caller.qualifiedName.lastIndexOf('::');
+    if (sep <= 0)
+        return null; // not inside a class
+    const owner = caller.qualifiedName.slice(0, sep).split('::').pop();
+    if (!owner)
+        return null;
+    const owners = preferCallSiteFile(context.getNodesByName(owner), ref.filePath).filter((n) => (n.kind === 'class' || n.kind === 'component') && sameLanguageFamily(n.language, ref.language));
+    for (const cls of owners) {
+        const decl = tsFieldDeclaration(cls, field, context);
+        if (!decl)
+            continue;
+        if (decl.valueType) {
+            // The value's declaration may live in another file (it is imported);
+            // the call site's file is preferred when several share the name.
+            const holderName = decl.type.split('.').pop();
+            const holders = preferCallSiteFile(context.getNodesByName(holderName), ref.filePath).filter((n) => (n.kind === 'constant' || n.kind === 'variable') && sameLanguageFamily(n.language, ref.language));
+            for (const holder of holders) {
+                const hit = resolveObjectLiteralMember(holder, methodName, ref, context, 0.85, 'instance-method');
+                if (hit)
+                    return hit;
+            }
+            return null;
+        }
+        // `ns.Mailer` → `Mailer`; a primitive or builtin names no project type.
+        const typeName = decl.type.split('.').pop();
+        if (!/^[A-Z]/.test(typeName))
+            return null;
+        // Two apps in one repo may each declare a `UserService`. The bare-name
+        // path this replaces broke that tie by directory proximity, so keep the
+        // same signal: among the type's declarations of the method, prefer the
+        // one closest to the call site's directory (its own app), never index
+        // order. resolveMethodOnType still answers the single-declaration and
+        // supertype cases.
+        const declared = context
+            .getNodesByName(methodName)
+            .filter((n) => n.kind === 'method' &&
+            sameLanguageFamily(n.language, ref.language) &&
+            (n.qualifiedName === `${typeName}::${methodName}` || n.qualifiedName.endsWith(`::${typeName}::${methodName}`)));
+        if (declared.length > 1) {
+            const callDirs = ref.filePath.split('/').slice(0, -1);
+            const shared = (fp) => {
+                const dirs = fp.split('/').slice(0, -1);
+                let i = 0;
+                while (i < dirs.length && i < callDirs.length && dirs[i] === callDirs[i])
+                    i++;
+                return i;
+            };
+            const nearest = [...declared].sort((a, b) => shared(b.filePath) - shared(a.filePath) || a.filePath.localeCompare(b.filePath))[0];
+            return { original: ref, targetNodeId: nearest.id, confidence: 0.85, resolvedBy: 'instance-method' };
+        }
+        return resolveMethodOnType(typeName, methodName, ref, context, 0.85, 'instance-method');
+    }
+    return null;
+}
+/**
+ * The one fallback a TS/JS/Python call-receiver chain keeps (#1683): a STORE
+ * ACCESSOR. Zustand's `get()` inside the store factory and
+ * `useStore.getState()` outside it hand back the store whose actions are
+ * indexed as functions (#1573). JS/TS resolves the member within that store;
+ * the existing Python fallback still requires a unique callable. Nothing else
+ * qualifies: a chain rooted in a project value still says nothing about what
+ * the inner call RETURNS — `db.prepare(sql).all()` would bind to any project
+ * function named `all` — so it resolves to nothing, exactly like a chain
+ * rooted in a parameter (`d.setdefault(k, []).append(v)`).
+ */
+function matchStoreAccessorChain(ref, context) {
+    const m = ref.referenceName.match(/^([\w$.]+)\(\)\.(\w+)$/);
+    if (!m || !m[1] || !m[2])
+        return null;
+    const inner = m[1];
+    const method = m[2];
+    if (!(inner === 'get' || inner === 'getState' || inner.endsWith('.getState')))
+        return null;
+    if (JS_FAMILY.has(ref.language)) {
+        return resolveStoreAction(inner, method, ref, context);
+    }
+    const callables = context
+        .getNodesByName(method)
+        .filter((n) => (n.kind === 'function' || n.kind === 'method') && sameLanguageFamily(n.language, ref.language) && n.id !== ref.fromNodeId);
+    if (callables.length !== 1)
+        return null;
+    return { original: ref, targetNodeId: callables[0].id, confidence: 0.6, resolvedBy: 'exact-match' };
+}
+/** Resolve the implementation inside the identified store, not a namesake or
+ * an interface signature elsewhere in the project. Import resolution already
+ * follows aliases/barrels; containment already excludes nested action locals. */
+function resolveStoreAction(inner, member, ref, context, selector = false) {
+    let holders;
+    if (inner === 'get' || inner === 'getState') {
+        const caller = context.getNodeById?.(ref.fromNodeId);
+        if (!caller)
+            return null;
+        holders = context.getNodesInFile(ref.filePath).filter((n) => {
+            if ((n.kind !== 'constant' && n.kind !== 'variable') || !rangeWithin(caller, n))
+                return false;
+            const source = context.readFile(n.filePath)?.split('\n').slice(n.startLine - 1, caller.startLine).join('\n') ?? '';
+            // The accessor must actually be a parameter of the enclosing factory.
+            return new RegExp(`\\(\\s*[\\w$]+\\s*,\\s*${inner}\\s*(?:,\\s*[\\w$]+\\s*)?\\)\\s*=>`).test(source);
+        });
+    }
+    else {
+        const name = inner.slice(0, -'.getState'.length);
+        if (!/^[\w$]+$/.test(name))
+            return null;
+        const imported = context.resolveImport?.({ ...ref, referenceName: name, referenceKind: 'references' });
+        const node = imported && context.getNodeById?.(imported.targetNodeId);
+        if (node && importShadowedAt(name, ref, context))
+            return null;
+        holders = node ? [node] : context.getNodesByName(name).filter((n) => n.filePath === ref.filePath && isLexicallyReachable(n, ref, context));
+    }
+    if (holders.length !== 1)
+        return null;
+    const holder = holders[0];
+    if (selector) {
+        // Only a Zustand hook promises to return the selector's result. An
+        // arbitrary function accepting that callback is not a store binding.
+        const text = context.readFile(holder.filePath)?.split('\n').slice(holder.startLine - 1, holder.endLine).join('\n') ?? '';
+        const escaped = holder.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const factory = new RegExp(`\\b(?:const|let)\\s+${escaped}\\s*=\\s*([\\w$]+)\\s*[<(]`).exec(text)?.[1];
+        if (!factory || !context.getImportMappings(holder.filePath, holder.language).some(m => m.localName === factory && m.source === 'zustand' && (m.exportedName === 'create' || m.isDefault)))
+            return null;
+    }
+    return resolveObjectLiteralMember(holder, member, ref, context, 0.9, 'instance-method');
+}
+// Eligibility is a file property, not a call-site property. Cache both answers
+// within the same stable-source window as the resolver's file cache; sync drops
+// it via clearNameMatcherMemos. Keep only booleans, FIFO-capped like PATTERN_MEMO
+// to avoid per-hit LRU churn. Eviction merely repeats the source scan.
+const GET_STATE_FILES = new WeakMap();
+const GET_STATE_FILES_CAP = 8192;
+/** A const destructuring is a bound reference, so it is eligible even though
+ * arbitrary locally-bound bare calls must never guess a cross-file target. */
+function matchDestructuredStoreCall(ref, context) {
+    let files = GET_STATE_FILES.get(context);
+    if (!files) {
+        files = new Map();
+        GET_STATE_FILES.set(context, files);
+    }
+    let eligible = files.get(ref.filePath);
+    let source;
+    if (eligible === undefined) {
+        source = context.readFile(ref.filePath);
+        eligible = source?.includes('.getState') ?? false;
+        if (files.size >= GET_STATE_FILES_CAP) {
+            const oldest = files.keys().next().value;
+            if (oldest !== undefined)
+                files.delete(oldest);
+        }
+        files.set(ref.filePath, eligible);
+    }
+    if (!eligible)
+        return null;
+    source ??= context.readFile(ref.filePath);
+    if (!source)
+        return null;
+    const lines = source.split('\n');
+    const start = enclosingScopeStartLine(ref, context) - 1;
+    const before = lines.slice(start, ref.line - 1).concat(lines[ref.line - 1].slice(0, ref.column)).join('\n');
+    const code = (0, strip_comments_1.blankStringContents)((0, strip_comments_1.stripCommentsForRegex)(before, 'typescript'));
+    const name = ref.referenceName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const binding = /\bconst\s*\{([^{}]*)\}\s*=\s*([\w$]+)\.getState\s*\(\s*\)/g;
+    // Compare block identities, not just nesting depth: a binding in a sibling
+    // or already-closed block is not in scope at this call.
+    const stackAt = (end) => {
+        const stack = [];
+        for (let i = 0; i < end; i++) {
+            if (code[i] === '{')
+                stack.push(i);
+            else if (code[i] === '}')
+                stack.pop();
+        }
+        return stack;
+    };
+    const callScope = stackAt(code.length);
+    for (const m of [...code.matchAll(binding)].reverse()) {
+        // Plain named bindings only; defaults, rest and computed keys need their
+        // own value tracing rather than a same-name guess.
+        if (!m[1].split(',').some(part => part.trim() === ref.referenceName))
+            continue;
+        const scope = stackAt(m.index);
+        if (!scope.every((pos, i) => callScope[i] === pos))
+            continue;
+        const rest = code.slice(m.index + m[0].length);
+        // Keep the guard when another declaration shadows the captured const.
+        if (new RegExp(`\\b(?:const|let|var|function|class)\\s+(?:${name}\\b|\\{[^}]*\\b${name}\\b)`).test(rest))
+            return null;
+        return resolveStoreAction(`${m[2]}.getState`, ref.referenceName, ref, context);
+    }
+    return null;
+}
+/** Bound action names need not have a same-named definition (selectors may
+ * rename them). The resolver's symbol-existence prefilter must allow them. */
+function matchJsStoreBindingCall(ref, context) {
+    if (!isBareJsCall(ref, context))
+        return null;
+    return matchDestructuredStoreCall(ref, context) ?? matchSelectedStoreCall(ref, context);
+}
+/** A qualified untyped chain is useful source evidence, not permission to
+ * infer a property type. Framework resolution runs before this guard. */
+function isUnresolvedJsMemberCall(ref) {
+    return ref.referenceKind === 'calls' && JS_FAMILY.has(ref.language) &&
+        !/^(?:this|window)\./.test(ref.referenceName) &&
+        /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*){2,}$/.test(ref.referenceName);
+}
+const SELECTOR_NAMES = new WeakMap();
+/** A selector returns the named action from one identified store. Keep the
+ * lexical block identity so closures may capture it but sibling scopes and
+ * shadowing parameters/declarations cannot donate a binding. */
+function matchSelectedStoreCall(ref, context) {
+    const source = context.readFile(ref.filePath);
+    if (!source?.includes('=>'))
+        return null;
+    let files = SELECTOR_NAMES.get(context);
+    if (!files) {
+        files = new Map();
+        SELECTOR_NAMES.set(context, files);
+    }
+    let names = files.get(ref.filePath);
+    if (!names) {
+        names = new Set([...source.matchAll(/\bconst\s+([\w$]+)\s*=\s*[\w$]+\s*\(\s*(?:\(\s*[\w$]+\s*\)|[\w$]+)\s*=>/g)].map(m => m[1]));
+        files.set(ref.filePath, names);
+    }
+    if (!names.has(ref.referenceName))
+        return null;
+    const name = ref.referenceName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const lines = source.split('\n');
+    const before = lines.slice(0, ref.line - 1).concat(lines[ref.line - 1].slice(0, ref.column)).join('\n');
+    const code = (0, strip_comments_1.blankStringContents)((0, strip_comments_1.stripCommentsForRegex)(before, 'typescript'));
+    const binding = new RegExp(`\\bconst\\s+${name}\\s*=\\s*([\\w$]+)\\s*\\(\\s*(?:\\(\\s*([\\w$]+)\\s*\\)|([\\w$]+))\\s*=>\\s*([\\w$]+)\\.([\\w$]+)\\s*\\)`, 'g');
+    const stackAt = (end) => {
+        const stack = [];
+        for (let i = 0; i < end; i++) {
+            if (code[i] === '{')
+                stack.push(i);
+            else if (code[i] === '}')
+                stack.pop();
+        }
+        return stack;
+    };
+    const callScope = stackAt(code.length);
+    for (const m of [...code.matchAll(binding)].reverse()) {
+        if ((m[2] ?? m[3]) !== m[4])
+            continue;
+        if (!stackAt(m.index).every((pos, i) => callScope[i] === pos))
+            continue;
+        const rest = code.slice(m.index + m[0].length);
+        if (new RegExp(`\\b(?:const|let|var|function|class)\\s+(?:${name}\\b|\\{[^}]*\\b${name}\\b)`).test(rest) ||
+            hasParameterBinding(rest, name))
+            return null;
+        return resolveStoreAction(`${m[1]}.getState`, m[5], ref, context, true);
+    }
+    return null;
+}
+/** Import resolution names the module binding; a nearer parameter or block
+ * declaration can shadow that binding at this particular call site. */
+function importShadowedAt(name, ref, context) {
+    const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    for (const fn of context.getNodesInFile(ref.filePath)) {
+        if ((fn.kind === 'function' || fn.kind === 'method') && fn.startLine <= ref.line && fn.endLine >= ref.line &&
+            fn.signature && hasParameterBinding(`${fn.signature} {`, escaped))
+            return true;
+    }
+    const lines = (context.readFile(ref.filePath) ?? '').split('\n');
+    const before = lines.slice(0, ref.line - 1).concat(lines[ref.line - 1]?.slice(0, ref.column) ?? '').join('\n');
+    const code = (0, strip_comments_1.blankStringContents)((0, strip_comments_1.stripCommentsForRegex)(before, 'typescript'));
+    const stackAt = (end) => {
+        const stack = [];
+        for (let i = 0; i < end; i++) {
+            if (code[i] === '{')
+                stack.push(i);
+            else if (code[i] === '}')
+                stack.pop();
+        }
+        return stack;
+    };
+    const scope = stackAt(code.length);
+    const declarations = new RegExp(`\\b(?:const|let|var|function|class)\\s+(?:${escaped}\\b|\\{[^}]*\\b${escaped}\\b)`, 'g');
+    return [...code.matchAll(declarations)].some(m => stackAt(m.index).every((p, i) => scope[i] === p));
+}
+/** Balanced parameter lists also cover function-typed parameters, whose own
+ * parentheses must not make the outer shadow invisible. Conservative when a
+ * parameter's type mentions the same name: leave that call unresolved. */
+function hasParameterBinding(code, escapedName) {
+    const name = new RegExp(`\\b${escapedName}\\b`);
+    if (new RegExp(`\\b${escapedName}\\s*=>`).test(code))
+        return true;
+    for (let i = 0; i < code.length; i++) {
+        if (code[i] !== '(' || /\b(?:if|while|for|switch|with)\s*$/.test(code.slice(0, i)))
+            continue;
+        let depth = 1, j = i + 1;
+        for (; j < code.length && depth; j++) {
+            if (code[j] === '(')
+                depth++;
+            else if (code[j] === ')')
+                depth--;
+        }
+        if (depth === 0 && name.test(code.slice(i + 1, j - 1)) &&
+            /^\s*(?::[^=;{]*)?(?:=>|\{)/.test(code.slice(j)))
+            return true;
+    }
+    return false;
+}
 /**
  * Split a camelCase or PascalCase string into words.
  */
@@ -1912,6 +3963,7 @@ function findBestMatch(ref, candidates, _context) {
         if (ref.referenceKind === 'instantiates') {
             if (candidate.kind === 'class' ||
                 candidate.kind === 'struct' ||
+                candidate.kind === 'union' ||
                 candidate.kind === 'interface') {
                 score += 25;
             }
@@ -1952,11 +4004,38 @@ function matchFuzzy(ref, context) {
     const candidates = context.getNodesByLowerName(lowerName);
     // Filter to callable kinds only (function, method, class)
     const callableKinds = new Set(['function', 'method', 'class']);
-    const callableCandidates = applyLanguageGate(candidates.filter((n) => callableKinds.has(n.kind)), ref);
+    const callableCandidates = candidates.filter((n) => callableKinds.has(n.kind))
+        .filter((n) => (ref.referenceKind !== 'references' && ref.referenceKind !== 'function_ref') ||
+        sameLanguageFamily(n.language, ref.language));
     // Prefer same-language matches
     const sameLanguageCandidates = callableCandidates.filter(n => n.language === ref.language);
     const finalCandidates = sameLanguageCandidates.length > 0 ? sameLanguageCandidates : callableCandidates;
-    if (finalCandidates.length === 1) {
+    // Both post-pipeline visibility guards (#1745 language-local + #1719 sealed
+    // module). The sealed-module test rejects the survivor and never filters the
+    // set that produced it: removing a sealed candidate from a crowd would leave
+    // a lone one and manufacture a 0.5 guess out of an ambiguity fuzzy declines.
+    // Also decline a bare JS/TS call whose only survivor is a method or a
+    // cross-file name the file already binds locally (#1714).
+    // A function nested inside another function is only callable from inside
+    // its container (#1230), so a builtin method call (`res.text()`) whose only
+    // same-named project symbol is some file's closure must decline (#1708).
+    // The check sits on the ONE candidate this strategy would commit to, not on
+    // the candidate set: filtering the unreachable ones out of a crowd would
+    // leave a single survivor and hand it every call of that name — on vite,
+    // `import { resolve } from 'node:path'` in a dozen playground configs onto
+    // the one reachable `resolve` method (#1709). Reachability may reject a
+    // unique guess; it must never manufacture one.
+    if (finalCandidates.length === 1 &&
+        isVisibleAcrossFiles(finalCandidates[0], ref, context) &&
+        isCrossFileReachable(finalCandidates[0], ref, context) &&
+        !(isBareJsCall(ref, context) &&
+            (finalCandidates[0].kind === 'method' ||
+                (finalCandidates[0].filePath !== ref.filePath && isLocallyBoundJsName(ref.referenceName, ref.filePath, context)))) &&
+        !(finalCandidates[0].kind === 'method' && isBareGoCall(ref, context)) &&
+        // A bare PHP call is a function call (case-insensitive, so fuzzy may find
+        // one) — never the class `View` for `view(…)`, never a method.
+        !(finalCandidates[0].kind !== 'function' && isBarePhpCall(ref, context)) &&
+        isLexicallyReachable(finalCandidates[0], ref, context)) {
         const isCrossLanguage = finalCandidates[0].language !== ref.language;
         return {
             original: ref,
@@ -2012,6 +4091,9 @@ function dumpNameMatcherProfile(label) {
     }
 }
 function matchReference(ref, context) {
+    return gateLanguageMatch(matchReferenceInner(ref, context), ref, context);
+}
+function matchReferenceInner(ref, context) {
     // Function-as-value refs (#756) resolve ONLY through the dedicated matcher —
     // never the fuzzy/qualified fallthrough below (a wrong callback edge is
     // worse than none).
@@ -2069,6 +4151,48 @@ function matchReference(ref, context) {
             resolvedBy: 'exact-match',
         };
     }
+    // Erlang call/fun refs carry the call-site arity (`f/1` — #1610) because
+    // arity is part of the function's identity and every erlang function's
+    // qualifiedName carries it (`mod::f/1`). Resolve ONLY to a definition of
+    // that exact arity: the call site's own file first (a local call targets its
+    // own module by language semantics; `-import`ed functions ride the
+    // cross-file branch), and when no definition of that arity exists anywhere,
+    // resolve to NOTHING rather than a sibling arity — the real target may be
+    // macro-generated or out of repo, and a wrong-arity edge is worse than none.
+    if (ref.language === 'erlang' &&
+        !ref.referenceName.includes('::') &&
+        (ref.referenceKind === 'calls' || ref.referenceKind === 'references')) {
+        const am = /^(.+)\/(\d{1,3})$/.exec(ref.referenceName);
+        if (am) {
+            // endsWith is length-anchored, so `/1` cannot match `…/11`.
+            const arityTail = `/${am[2]}`;
+            const candidates = context
+                .getNodesByName(am[1])
+                .filter((n) => n.language === 'erlang' && n.kind === 'function' && n.qualifiedName.endsWith(arityTail));
+            if (candidates.length > 0) {
+                const sameFile = candidates.find((n) => n.filePath === ref.filePath);
+                if (sameFile) {
+                    return { original: ref, targetNodeId: sameFile.id, confidence: 0.95, resolvedBy: 'exact-match' };
+                }
+                if (candidates.length === 1) {
+                    return { original: ref, targetNodeId: candidates[0].id, confidence: 0.8, resolvedBy: 'exact-match' };
+                }
+                const best = findBestMatch(ref, candidates, context);
+                if (best) {
+                    const proximity = computePathProximity(ref.filePath, best.filePath);
+                    return {
+                        original: ref,
+                        targetNodeId: best.id,
+                        confidence: proximity >= 30 ? 0.7 : 0.4,
+                        resolvedBy: 'exact-match',
+                    };
+                }
+            }
+            return null;
+        }
+    }
+    if (isUnresolvedJsMemberCall(ref))
+        return null;
     // Try strategies in order of confidence
     let result;
     // 0. File path match (e.g., "snippets/drawer-menu.liquid" → file node)
@@ -2116,6 +4240,16 @@ function matchReference(ref, context) {
         if (result)
             return result;
     }
+    // A call-receiver chain the extractor encoded as `<inner>().<method>` for a
+    // language with no chain resolver above (TS/JS, Python — #1683) is a
+    // receiver whose type is unknown. Nothing below may guess for it: the
+    // method-call pattern rejects the parens, exact name never matches, but the
+    // fuzzy strategy splits on `.` and would hand `make().run` to any `run` —
+    // the fabricated edge the encoding exists to prevent.
+    if (ref.referenceName.includes('().') &&
+        (ref.language === 'typescript' || ref.language === 'javascript' || ref.language === 'tsx' || ref.language === 'jsx' || ref.language === 'python')) {
+        return nmTimed('storeAccessorChain', ref, () => matchStoreAccessorChain(ref, context));
+    }
     // 2. Method call pattern
     result = nmTimed('methodCall', ref, () => matchMethodCall(ref, context));
     if (result)