From 255972283c08c05b276a473a51bf168eba616223 Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Wed, 28 Oct 2026 12:56:07 -0600
Subject: [PATCH 01/30] fix(resolve): port upstream's lone same-file match
 confidence (cde4cd74)

A lone same-file definition chosen by findBestMatch scored by directory
proximity (0.7/0.4), losing to a framework's naming guess in another
file. is_decisive_same_file_match scores it 0.9 when it is the only
same-file candidate, is not the caller itself, and, as a member, belongs
to an owner the caller is inside.

Ports upstream cde4cd74 (#1938). same-file-match-confidence: 7/7.
---
 codegraph-kernel/src/resolve/names.rs | 57 ++++++++++++++++++++++++++-
 1 file changed, 56 insertions(+), 1 deletion(-)

diff --git a/codegraph-kernel/src/resolve/names.rs b/codegraph-kernel/src/resolve/names.rs
index d8652be24..87be01270 100644
--- a/codegraph-kernel/src/resolve/names.rs
+++ b/codegraph-kernel/src/resolve/names.rs
@@ -950,15 +950,70 @@ impl KernelResolver {
         }
         if self.is_cross_file_reachable(&best, r)? {
             let proximity = compute_path_proximity(&r.file_path, &best.file_path);
+            let confidence = if self.is_decisive_same_file_match(&best, r, &candidates)? {
+                0.9
+            } else if proximity >= 30 {
+                0.7
+            } else {
+                0.4
+            };
             return Ok(Some(KCand {
                 node: best,
-                confidence: if proximity >= 30 { 0.7 } else { 0.4 },
+                confidence,
                 resolved_by: "exact-match",
             }));
         }
         Ok(None)
     }
 
+    /// Whether `findBestMatch` picked `best` because it is THE definition in
+    /// the call site's own file, so the edge deserves a same-file confidence
+    /// rather than the directory-proximity one. Proximity measures shared
+    /// folders, so a same-file match in a shallow path scored 0.4 like a guess
+    /// across unrelated modules. Decisive only when:
+    /// - `best` is the ONLY same-file candidate — several are separated by
+    ///   line distance, which is not evidence;
+    /// - a member of a type, module or namespace belongs to one the caller is
+    ///   inside — a bare call does not reach a sibling class's method just
+    ///   because it is written in that file. A method's owner is always such a
+    ///   scope; another kind's is judged when the file declares it as anything
+    ///   but a function; and
+    /// - `best` is not the caller itself.
+    ///
+    /// (name-matcher.ts isDecisiveSameFileMatch, upstream cde4cd74.)
+    fn is_decisive_same_file_match(
+        &self,
+        best: &Arc<KNode>,
+        r: &ResolveRefIn,
+        candidates: &[Arc<KNode>],
+    ) -> Res<bool> {
+        if best.file_path != r.file_path || best.id == r.from_node_id {
+            return Ok(false);
+        }
+        if candidates.iter().any(|c| c.id != best.id && c.file_path == r.file_path) {
+            return Ok(false);
+        }
+        let sep = best.qualified_name.rfind("::").unwrap_or(0);
+        if sep == 0 {
+            return Ok(best.kind != "method");
+        }
+        let owner = &best.qualified_name[..sep];
+        if best.kind != "method" {
+            let declared = self.nodes_in_file(&best.file_path)?;
+            if declared
+                .iter()
+                .filter(|n| n.qualified_name == owner)
+                .all(|n| n.kind == "function" || n.kind == "method")
+            {
+                return Ok(true);
+            }
+        }
+        let Some(from) = self.node_by_id(&r.from_node_id)? else {
+            return Ok(false);
+        };
+        Ok(from.qualified_name == owner || from.qualified_name.starts_with(&format!("{owner}::")))
+    }
+
     /// The candidates a PHP `$this->m()` / `self::m()` / `parent::m()` call
     /// allows: methods of the class hierarchy around the call site
     /// (matchByExactName / matchFuzzy, name-matcher.ts).

From 54c134f1c45155aab95221317b1d7c975e9997e8 Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Wed, 28 Oct 2026 12:56:07 -0600
Subject: [PATCH 02/30] chore(resolve): dump the kernel profile at close(), not
 only at drop

The resolver is not dropped before process exit on the CLI index path, so
CODEGRAPH_KERNEL_PROF=1 accumulated timings that never printed. close()
is the deterministic teardown point.
---
 codegraph-kernel/src/resolve/mod.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/codegraph-kernel/src/resolve/mod.rs b/codegraph-kernel/src/resolve/mod.rs
index ad22ab441..8684e19ea 100644
--- a/codegraph-kernel/src/resolve/mod.rs
+++ b/codegraph-kernel/src/resolve/mod.rs
@@ -1049,6 +1049,7 @@ impl KernelResolver {
     #[cfg_attr(feature = "addon", napi)]
     pub fn close(&mut self) {
         self.debug_stats("close");
+        prof_dump("close");
         self.release_conn();
         self.table.take();
         self.file_cache.clear();

From 4f0b844ce5773fab48772bd26642fe1ab8694e9c Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Wed, 28 Oct 2026 12:58:28 -0600
Subject: [PATCH 03/30] test(ts): assert the fork's native error-tree path for
 export type *
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Upstream's kernel defers a file whose parse tree has errors, so the test
expected tryKernelExtract to return null. The fork's tsjs walker extracts
the recovered tree natively (cba92567) and keeps the re-export signature
as written — assert that contract instead.
---
 __tests__/ts-export-type-star.test.ts | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/__tests__/ts-export-type-star.test.ts b/__tests__/ts-export-type-star.test.ts
index 4c43299bb..69c9e4407 100644
--- a/__tests__/ts-export-type-star.test.ts
+++ b/__tests__/ts-export-type-star.test.ts
@@ -159,12 +159,19 @@ describe('a type-only star re-export parses in both engines', () => {
     }
   }
 
-  it.runIf(kernelAvailable)('keeps a re-export as written in a file the kernel hands to the wasm parser', () => {
-    // `export const = ;` is an error, so the kernel defers the whole file.
+  it.runIf(kernelAvailable)('keeps a re-export as written in a file with parse errors', () => {
+    // `export const = ;` is an error. Upstream's kernel defers such a file to
+    // the wasm parser; the fork's extracts the recovered native tree and flags
+    // it not-parsed-clean, so this path asserts the signature survives instead
+    // of the defer.
     const source = 'export type * from "./types.js";\nexport const = ;\n';
     delete process.env.CODEGRAPH_KERNEL;
     process.env.CODEGRAPH_KERNEL_LANGS = 'all';
-    expect(tryKernelExtract('src/broken.ts', source, 'typescript')).toBeNull();
+    const kernelResult = tryKernelExtract('src/broken.ts', source, 'typescript');
+    expect(kernelResult).not.toBeNull();
+    expect(kernelResult?.nodes.filter((n) => n.kind === 'import').map((n) => n.signature)).toEqual([
+      'export type * from "./types.js";',
+    ]);
     const result = extractFromSource('src/broken.ts', source, 'typescript');
     expect(result.nodes.filter((n) => n.kind === 'import').map((n) => n.signature)).toEqual([
       'export type * from "./types.js";',

From 2f0c7087e2db5ff025e4985f3213bd10bedf076d Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Wed, 28 Oct 2026 13:00:12 -0600
Subject: [PATCH 04/30] fix(resolve): port upstream's indexed import-path
 spelling (8651990a)

An alias, workspace or direct-path join kept a specifier's lexical
spelling, so `@/widgets/Chart/` probed `Chart//index.tsx` and
`src/widgets/./Chart` probed `./` segments no files row is keyed by.
probe_extensions now spells each candidate as the index keys it for the
ES-module family; other languages keep the path as found.

Ports upstream 8651990a (#2792). import-path-spelling: 5/5.
---
 codegraph-kernel/src/resolve/imports.rs | 30 ++++++++++++++++++++++---
 1 file changed, 27 insertions(+), 3 deletions(-)

diff --git a/codegraph-kernel/src/resolve/imports.rs b/codegraph-kernel/src/resolve/imports.rs
index cb1f7f23a..22437224a 100644
--- a/codegraph-kernel/src/resolve/imports.rs
+++ b/codegraph-kernel/src/resolve/imports.rs
@@ -181,15 +181,20 @@ impl KernelResolver {
 
     /// The first existing file among `base` + each of the language's
     /// extensions, then `base` itself, then the source an emitted `.js`/`.d.ts`
-    /// path was compiled from.
+    /// path was compiled from — each spelled as the index keys it
+    /// (indexedSpelling, upstream 8651990a / #2577).
     pub(super) fn probe_extensions(&self, base: &str, language: &str) -> Option<String> {
         extension_resolution(language)
             .iter()
             .filter(|ext| !base.is_empty() || ext.starts_with('/'))
             .map(|ext| if base.is_empty() { ext.trim_start_matches('/').to_string() } else { format!("{base}{ext}") })
+            .map(|candidate| indexed_spelling(&candidate, language))
             .find(|candidate| self.file_exists(candidate))
-            .or_else(|| self.file_exists(base).then(|| base.to_string()))
-            .or_else(|| self.find_source_for_emitted(base, language))
+            .or_else(|| {
+                let as_is = indexed_spelling(base, language);
+                self.file_exists(&as_is).then_some(as_is)
+            })
+            .or_else(|| self.find_source_for_emitted(&indexed_spelling(base, language), language))
     }
 
     /// resolveAliasedImport (import-resolver.ts): tsconfig paths → workspace
@@ -1763,6 +1768,25 @@ fn plain_import_names(line: &str, source: &str) -> Option<bool> {
     Some(clause.split(',').any(|name| name.trim() == source))
 }
 
+/// indexedSpelling (import-resolver.ts, upstream 8651990a / #2577): a path as
+/// the index keys its files. The alias, workspace and direct-path branches
+/// join an import specifier as written, so `@/widgets/Chart/` made
+/// `src/widgets/Chart//index.tsx` and `src/widgets/./Chart` made
+/// `src/widgets/./Chart/index.tsx` — spellings no file node or `files` row is
+/// keyed by. An ES-module specifier is read lexically, so `.` and empty
+/// segments drop and `..` folds; a trailing slash still names a folder. Other
+/// languages keep the path as found — a C include's `a/../b.h` follows the
+/// folder `a` on disk, symlinks included.
+fn indexed_spelling(file_path: &str, language: &str) -> String {
+    let dirty = file_path.contains("//")
+        || file_path.split('/').any(|seg| seg == "." || seg == "..");
+    if is_esm_import_language(language) && dirty {
+        pos_normalize(file_path)
+    } else {
+        file_path.to_string()
+    }
+}
+
 #[cfg(test)]
 mod plain_import_tests {
     use super::plain_import_names;

From ee5b5c1ab5bb640051204ceea109e2867af03ed2 Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Wed, 28 Oct 2026 13:30:11 -0600
Subject: [PATCH 05/30] fix(resolve): port upstream's Dart library-privacy rule
 (f7820b58)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A Dart `_name` is private to its library — the library file and every
file its `part` directives name — not to its file. private_is_file_local
drops `dart`; is_visible_across_files gets the dart arm (a private
candidate is seen only from a file of its own library); and the
exact-name pre-pick filter declines a private candidate another library
declares so the caller's own library's declaration wins.

Ports upstream f7820b58 (#2832). dart-part-privacy: 10/12 — the two
remaining failures resolve a typed receiver's private method through
resolve_method_on_type's member path, whose visibility gate still needs
tracing (upstream's dart arm at name-matcher.ts ~13147 /
preferOwnDartLibrary is the next suspect).
---
 codegraph-kernel/src/resolve/names.rs  | 12 ++++++++++++
 codegraph-kernel/src/resolve/tables.rs |  5 +++--
 2 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/codegraph-kernel/src/resolve/names.rs b/codegraph-kernel/src/resolve/names.rs
index 87be01270..24569a7f2 100644
--- a/codegraph-kernel/src/resolve/names.rs
+++ b/codegraph-kernel/src/resolve/names.rs
@@ -375,6 +375,14 @@ impl KernelResolver {
         if lang == "go" {
             return Ok(go_name_visible(candidate, r));
         }
+        // A Dart `_name` is its library's, which spans the library file and
+        // its parts: riverpod_generator's `class Counter extends _$Counter`
+        // names the class it wrote into `main.g.dart` (upstream f7820b58).
+        if lang == "dart" {
+            return Ok(candidate.visibility.as_deref() != Some("private")
+                || (r.language == "dart"
+                    && self.dart_same_library(&r.file_path, &candidate.file_path)));
+        }
         if lang == "rust" {
             if candidate.visibility.as_deref() != Some("private") {
                 return Ok(true);
@@ -784,6 +792,10 @@ impl KernelResolver {
                 // tsdb's `[]*memSeries` is head.go's, not `tsdb/agent`'s, which scored the
                 // same by directory proximity and was then vetoed as invisible.
                 && (n.language != "go" || go_name_visible(&n, r))
+                // A Dart `_name` another library declares: the reference's
+                // own library's declaration wins instead of the namesake
+                // picked and then declined (upstream f7820b58 / #2466).
+                && !(r.language == "dart" && n.language == "dart" && n.visibility.as_deref() == Some("private") && n.file_path != r.file_path && !self.dart_same_library(&r.file_path, &n.file_path))
                 && !(matches!(r.language.as_str(),"lua"|"luau") && r.reference_kind=="calls" && !r.reference_name.contains(['.',':']) && n.kind=="method")
                 && !(r.language=="python" && r.reference_kind=="calls" && n.file_path!=r.file_path && self.is_receiver_less_call(r)? && self.python_locally_bound(&r.reference_name,r)? && !self.python_fixture_reachable(&n,&r.file_path)) {
                 kept.push(n);
diff --git a/codegraph-kernel/src/resolve/tables.rs b/codegraph-kernel/src/resolve/tables.rs
index e34a7ce77..32368bc74 100644
--- a/codegraph-kernel/src/resolve/tables.rs
+++ b/codegraph-kernel/src/resolve/tables.rs
@@ -696,9 +696,10 @@ pub(super) fn is_importable_kind(kind: &str) -> bool {
     !matches!(kind, "property" | "field" | "method" | "enum_member" | "parameter")
 }
 
-/// PRIVATE_IS_FILE_LOCAL (name-matcher.ts).
+/// PRIVATE_IS_FILE_LOCAL (name-matcher.ts). A Dart `_name` is its library's,
+/// which can span several files: see is_visible_across_files (f7820b58).
 pub(super) fn private_is_file_local(lang: &str) -> bool {
-    matches!(lang, "kotlin" | "java" | "csharp" | "swift" | "scala" | "dart" | "php")
+    matches!(lang, "kotlin" | "java" | "csharp" | "swift" | "scala" | "php")
 }
 
 /// NO_NESTED_FUNCTIONS (name-matcher.ts).

From 593c3aeb7b4b995d8a2b44e5db17383bd06937e3 Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Wed, 28 Oct 2026 13:53:54 -0600
Subject: [PATCH 06/30] fix(resolve): vet every strategy's pick through
 is_visible_across_files

finish() applied name_post_guard but not the file/library-locality veto
resolveOne's nameResult gets at index.ts:1867, so typed-receiver picks
(instance-method) linked private members of another library. With the
dart arm in place this completes f7820b58: dart-part-privacy 12/12.
---
 codegraph-kernel/src/resolve/pipeline.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/codegraph-kernel/src/resolve/pipeline.rs b/codegraph-kernel/src/resolve/pipeline.rs
index b4237a37d..ff7c40435 100644
--- a/codegraph-kernel/src/resolve/pipeline.rs
+++ b/codegraph-kernel/src/resolve/pipeline.rs
@@ -1192,6 +1192,10 @@ if super::lang_scope::is_dart_member_read(r) {
         // package-level value in another file is not an unknown package name.
         if r.language == "go" && !is_binding_receiver_call(r) && self.go_written_qualifier(r)?.is_some() && self.go_ref_qualifier(r)?.is_none() { return Ok(ResolveOutcome::unresolved()); }
         if !self.name_post_guard(&winner,r)? { return Ok(ResolveOutcome::unresolved()); }
+        // A definition its language makes file- or library-local cannot be
+        // what a name in another file means, whichever strategy chose it —
+        // name-matcher.ts isVisibleAcrossFiles at index.ts:1867 (#1730).
+        if !self.is_visible_across_files(&winner.node, r)? { return Ok(ResolveOutcome::unresolved()); }
         if winner.node.id == r.from_node_id && is_inheritance_ref(&r.reference_kind) {
             let Some(other) = self.other_supertype_named(r)? else { return Ok(ResolveOutcome::unresolved()); }; winner=other;
         }

From 4d65256c1436ded41b44b7d180eb1573bdaacbbf Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Wed, 28 Oct 2026 14:19:55 -0600
Subject: [PATCH 07/30] fix(library): indexFiles keeps other writers out until
 its files are stored
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The file lock was released as soon as indexing started — the promise
returned unawaited, the try ended, the finally let the lock go. Awaited,
the lock now holds until the files are stored, as indexAll and sync hold
it (upstream 865ddf4a / #2845).
---
 src/codegraph.ts | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/codegraph.ts b/src/codegraph.ts
index 7fb507b06..21bce07e1 100644
--- a/src/codegraph.ts
+++ b/src/codegraph.ts
@@ -946,7 +946,11 @@ export class CodeGraph {
         return { success: false, filesIndexed: 0, filesSkipped: 0, filesErrored: 0, nodesCreated: 0, edgesCreated: 0, errors: [{ message: 'Could not acquire file lock - another process may be indexing', severity: 'error' as const }], durationMs: 0 };
       }
       try {
-        return this.orchestrator.indexFiles(filePaths);
+        // Awaited, so the write lock is held until the files are stored, as
+        // indexAll and sync hold it: returned unawaited, the promise left the
+        // `try` at once and the `finally` let the lock go as soon as indexing
+        // started, so another process could write meanwhile (#2845).
+        return await this.orchestrator.indexFiles(filePaths);
       } finally {
         this.fileLock.release();
       }

From 5d6d997ea8d2ba3eefa32507be12f4b818da8f76 Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Wed, 28 Oct 2026 14:20:50 -0600
Subject: [PATCH 08/30] fix(resolve): let a framework own a reference past the
 name strategies

settleKernelOutcome merged kernel candidates beside the frameworks', so a
project namesake could answer a call Nuxt's navigateTo owns (upstream
58eb57a3 / #2826). With ownsReference set, the frameworks' best answer
wins or the ref stays unresolved.
---
 src/resolution/index.ts | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/resolution/index.ts b/src/resolution/index.ts
index f556037d0..acf3775df 100644
--- a/src/resolution/index.ts
+++ b/src/resolution/index.ts
@@ -1461,6 +1461,14 @@ export class ReferenceResolver {
         candidates.push(result);
       }
     }
+    // A reference a framework answers alone ends with the frameworks' answer
+    // (see FrameworkResolver.ownsReference): Nuxt's `navigateTo(x)` with a
+    // destination no route serves is no namesake's call.
+    if (this.frameworksFor(ref.language).some((f) => f.ownsReference?.(ref, this.context))) {
+      if (candidates.length === 0) return this.applyResolveTail(null, ref);
+      const owned = candidates.reduce((best, curr) => (curr.confidence > best.confidence ? curr : best));
+      return this.applyResolveTail(this.gateTargetKind(owned, ref), ref);
+    }
     // The kernel's ≥0.9 import verdict outranks <0.9 framework candidates —
     // resolveOneInner early-returns it and discards them. A verdict reported
     // without a candidate list is likewise already the merged winner.

From 35ecabf764a0e5248fb36d5bd894c0cd84658cb3 Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Wed, 28 Oct 2026 14:22:18 -0600
Subject: [PATCH 09/30] =?UTF-8?q?test(vue):=20assert=20the=20fork=20contra?=
 =?UTF-8?q?ct=20for=20tsx=20blocks=20=E2=80=94=20grammar=20always=20compil?=
 =?UTF-8?q?ed=20in?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Upstream's test asserted wasm-preload sets (9ee6718a / #2824); the fork
has no wasm loader, so a tsx <script> can never lack its grammar. The
block-mapping half was already fixed in sfcScriptLanguage.
---
 __tests__/vue-tsx-script.test.ts | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/__tests__/vue-tsx-script.test.ts b/__tests__/vue-tsx-script.test.ts
index d20d1ccae..c84ab98a2 100644
--- a/__tests__/vue-tsx-script.test.ts
+++ b/__tests__/vue-tsx-script.test.ts
@@ -19,7 +19,7 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import CodeGraph from '../src/index';
-import { readGrammarWasmBytes } from '../src/extraction/grammars';
+import { hasTreeSitterGrammar } from '../src/extraction/grammars';
 import { syntaxRegionsFor } from '../src/extraction/syntax-tokens';
 import type { Node } from '../src/types';
 
@@ -128,9 +128,15 @@ describe('Vue <script lang="tsx">', () => {
     expect(named(graph.getNodesInFile('src/Legacy.vue'), 'function', 'sum')).toBeDefined();
   });
 
-  it('loads the TSX grammar for a Vue project, and not for a Svelte one', async () => {
-    expect(Object.keys(await readGrammarWasmBytes(['vue'])).sort()).toEqual(['javascript', 'tsx', 'typescript']);
-    expect(Object.keys(await readGrammarWasmBytes(['svelte'])).sort()).toEqual(['javascript', 'typescript']);
+  it('reads a Vue tsx block with the TSX grammar, which the kernel always carries', async () => {
+    // Upstream preloads wasm grammars per project and had to add TSX to Vue's
+    // set; the fork's kernel compiles every grammar in, so the contract is
+    // that TSX parses — the indexing tests above then prove a .vue project's
+    // tsx block never lacks a grammar.
+    expect(hasTreeSitterGrammar('tsx')).toBe(true);
+    const graph = await indexProject();
+    expect(errorsOf(graph, 'src/Title.vue')).toEqual([]);
+    expect(errorsOf(graph, 'src/Card.vue')).toEqual([]);
   });
 
   it('is highlighted in the viewer with the grammar it was indexed with', () => {

From 4783ec029808bc9239d4a76e16a9bdf11fa1482d Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Wed, 28 Oct 2026 14:38:00 -0600
Subject: [PATCH 10/30] fix(resolve): finish() visibility guard on the final
 node, name picks only
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two corrections to the finish() is_visible_across_files port:

- Run it on the node after supertype/overload/alias retargets, the way
  upstream vets the target matchReference reports — a pre-forward object
  property or import alias is not the node upstream inspects.
- Vet only name-matcher picks: upstream's guard sits inside the
  matchReference arm, so import, file-path and framework results never
  reach it. An import pick's alias forward can legitimately land on an
  unexported module member (export const api = { run: right }).

Also ports the Rust arm upstream added for typed receivers: a method a
trait declares carries no pub of its own — reached through a typed
receiver it is the trait's (rust_trait_of + rust_typed_refs, marking
rust_written_call exits). Fixes the rust-* regressions the guard exposed
(rust-typed-receivers, rust-receiver-chains, rust-generic-bound-paths,
rust-method-value-types, rust-self-field-types, rust-wrapped-self-calls)
while keeping dart-part-privacy 12/12.

Remaining exposed failures are import-binding port debt, not guard bugs:
items$.getState().inc (import-type-modifier) and styled(Disclosure)
(function-ref-project-imports) resolve upstream through the import path
the kernel does not fully carry.
---
 codegraph-kernel/src/resolve/mod.rs        |  8 ++++
 codegraph-kernel/src/resolve/names.rs      | 47 ++++++++++++++++++++++
 codegraph-kernel/src/resolve/pipeline.rs   | 20 +++++++--
 codegraph-kernel/src/resolve/rust_types.rs |  9 ++++-
 4 files changed, 79 insertions(+), 5 deletions(-)

diff --git a/codegraph-kernel/src/resolve/mod.rs b/codegraph-kernel/src/resolve/mod.rs
index 8684e19ea..4ce6e65e8 100644
--- a/codegraph-kernel/src/resolve/mod.rs
+++ b/codegraph-kernel/src/resolve/mod.rs
@@ -681,6 +681,12 @@ pub struct KernelResolver {
     /// cppProjectScopeNames: every name a C or C++ qualifier may start with in this project.
     cpp_scope_names: Option<Rc<HashSet<String>>>,
     rust_trait_memo: HashMap<String, bool>,
+    /// RUST_TYPED_REFS (name-matcher.ts): refs a Rust typed-receiver path
+    /// resolved, by row id — a trait-declared method such a ref lands on is
+    /// the trait's, not a name guess.
+    rust_typed_refs: HashSet<i64>,
+    /// rustTraitOf, by method id → the enclosing trait node's id.
+    rust_trait_of_memo: HashMap<String, Option<String>>,
     /// javaSupertypesOf, by type name.
     java_supers_memo: HashMap<String, Rc<Vec<String>>>,
     /// phpSupertypeQns, by declaration id.
@@ -946,6 +952,8 @@ impl KernelResolver {
             cpp_macro_arguments_memo: HashMap::new(),
             cpp_scope_names: None,
             rust_trait_memo: HashMap::new(),
+            rust_typed_refs: HashSet::new(),
+            rust_trait_of_memo: HashMap::new(),
             java_supers_memo: HashMap::new(),
             php_supers_memo: HashMap::new(),
             vb: vbnet::VbMemo::default(),
diff --git a/codegraph-kernel/src/resolve/names.rs b/codegraph-kernel/src/resolve/names.rs
index 24569a7f2..112829bf8 100644
--- a/codegraph-kernel/src/resolve/names.rs
+++ b/codegraph-kernel/src/resolve/names.rs
@@ -304,6 +304,41 @@ impl KernelResolver {
         Ok(is_trait)
     }
 
+    /// Mark that a Rust typed-receiver path resolved `r` (RUST_TYPED_REFS).
+    pub(super) fn mark_rust_typed(&mut self, r: &ResolveRefIn) {
+        if let Some(id) = r.row_id {
+            self.rust_typed_refs.insert(id);
+        }
+    }
+
+    /// rustTraitOf (name-matcher.ts): the `trait` node `Owner::method`'s
+    /// owner names when it encloses the method's lines, else None.
+    pub(super) fn rust_trait_of(&mut self, candidate: &KNode) -> Res<Option<Arc<KNode>>> {
+        if let Some(hit) = self.rust_trait_of_memo.get(&candidate.id) {
+            return Ok(match hit {
+                Some(id) => self.node_by_id(id)?,
+                None => None,
+            });
+        }
+        let owner = candidate
+            .qualified_name
+            .rsplit_once("::")
+            .map(|(q, _)| q.rsplit("::").next().unwrap_or(""))
+            .unwrap_or("");
+        let found = if owner.is_empty() {
+            None
+        } else {
+            self.nodes_in_file(&candidate.file_path)?.iter().find(|n| {
+                n.kind == "trait" && n.name == owner
+                    && n.start_line <= candidate.start_line
+                    && n.end_line >= candidate.start_line
+            }).cloned()
+        };
+        self.rust_trait_of_memo
+            .insert(candidate.id.clone(), found.as_ref().map(|t| t.id.clone()));
+        Ok(found)
+    }
+
     /// isCrossFileReachable (name-matcher.ts).
     pub(super) fn is_cross_file_reachable(&mut self, candidate: &KNode, r: &ResolveRefIn) -> Res<bool> {
         if r.language != "markdown"
@@ -390,6 +425,18 @@ impl KernelResolver {
             if self.is_rust_trait_impl_method(candidate)? {
                 return Ok(true);
             }
+            // A method a trait declares carries no `pub` of its own: it is
+            // the trait's, reached through a value whose type the call's
+            // receiver declares (rust_written_call marks the ref typed). A
+            // guess by its name alone stays out.
+            if candidate.kind == "method"
+                && r.row_id.is_some_and(|id| self.rust_typed_refs.contains(&id))
+                && self
+                    .rust_trait_of(candidate)?
+                    .is_none_or(|t| t.visibility.as_deref() != Some("private"))
+            {
+                return Ok(true);
+            }
             let owner = rust_module_dir(&candidate.file_path);
             return Ok(r.file_path.starts_with(&format!("{}/", owner)));
         }
diff --git a/codegraph-kernel/src/resolve/pipeline.rs b/codegraph-kernel/src/resolve/pipeline.rs
index ff7c40435..ae1177508 100644
--- a/codegraph-kernel/src/resolve/pipeline.rs
+++ b/codegraph-kernel/src/resolve/pipeline.rs
@@ -1192,10 +1192,6 @@ if super::lang_scope::is_dart_member_read(r) {
         // package-level value in another file is not an unknown package name.
         if r.language == "go" && !is_binding_receiver_call(r) && self.go_written_qualifier(r)?.is_some() && self.go_ref_qualifier(r)?.is_none() { return Ok(ResolveOutcome::unresolved()); }
         if !self.name_post_guard(&winner,r)? { return Ok(ResolveOutcome::unresolved()); }
-        // A definition its language makes file- or library-local cannot be
-        // what a name in another file means, whichever strategy chose it —
-        // name-matcher.ts isVisibleAcrossFiles at index.ts:1867 (#1730).
-        if !self.is_visible_across_files(&winner.node, r)? { return Ok(ResolveOutcome::unresolved()); }
         if winner.node.id == r.from_node_id && is_inheritance_ref(&r.reference_kind) {
             let Some(other) = self.other_supertype_named(r)? else { return Ok(ResolveOutcome::unresolved()); }; winner=other;
         }
@@ -1228,6 +1224,22 @@ if r.language == "dart" && r.reference_kind == "references"
                 }
             }
         }
+        // A definition its language makes file- or library-local cannot be
+        // what a name in another file means, whichever strategy chose it —
+        // name-matcher.ts isVisibleAcrossFiles at index.ts:1867 (#1730), run
+        // on the node after supertype/overload/alias retargets the way
+        // upstream vets the target matchReference reports. Only a name-match
+        // pick is vetted: upstream's import, file-path and framework results
+        // never reach that guard, and an import pick's alias forward can
+        // legitimately land on an unexported module member.
+        if !matches!(winner.resolved_by, "import" | "framework" | "file-path")
+            && !self.is_visible_across_files(&winner.node, r)?
+        {
+            if std::env::var_os("CODEGRAPH_KERNEL_DEBUG_VIS").is_some() {
+                eprintln!("[vis-veto] {} {:?} via={} -> {}:{} {}:{}", r.reference_name, r.reference_kind, winner.resolved_by, winner.node.id, winner.node.kind, winner.node.file_path, winner.node.start_line);
+            }
+            return Ok(ResolveOutcome::unresolved());
+        }
         Ok(ResolveOutcome::resolved(
             &winner.node,
             winner.confidence,
diff --git a/codegraph-kernel/src/resolve/rust_types.rs b/codegraph-kernel/src/resolve/rust_types.rs
index 0a811164d..fcbd8a5bd 100644
--- a/codegraph-kernel/src/resolve/rust_types.rs
+++ b/codegraph-kernel/src/resolve/rust_types.rs
@@ -1729,6 +1729,7 @@ impl KernelResolver {
         // chain arm types each link's return by name instead.
         if call_chain_re().is_match(&r.reference_name) {
             if let Some(hit) = self.match_call_chain(r)? {
+                self.mark_rust_typed(r);
                 return Ok(Some(Some(hit)));
             }
         }
@@ -1793,7 +1794,10 @@ impl KernelResolver {
                 }
                 if base.kind() == "call_expression" && base.child_by_field_name("function")
                     .is_some_and(|f| matches!(f.kind(), "scoped_identifier" | "generic_function")) {
-                    if let Some(hit) = self.match_call_chain(r)? { return Ok(Some(Some(hit))); }
+                    if let Some(hit) = self.match_call_chain(r)? {
+                        self.mark_rust_typed(r);
+                        return Ok(Some(Some(hit)));
+                    }
                 }
                 return Ok(Some(None));
             }
@@ -1866,6 +1870,9 @@ impl KernelResolver {
             }
         }
         let node = self.rust_method_on(&written, &method, r, 0)?;
+        if node.is_some() {
+            self.mark_rust_typed(r);
+        }
         Ok(Some(node.map(|node| KCand {
             node,
             confidence: 0.9,

From f38947fcff30ff7fa54436794fd6252053d237f2 Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Wed, 28 Oct 2026 15:27:22 -0600
Subject: [PATCH 11/30] feat(kernel): port Go value-type inference,
 indexed/chained/package-value call arms

Port goReceiverChainType/goElementOf/goPackageValueType semantics
tree-natively into the kernel: package-level var/const typing, indexed
and chained receiver calls, and declared-type terminal vetoes for
literals/outside types. Bound-receiver misses are terminal unless the
receiver is an asserted local the index cannot type (upstream
strategy-3 passthrough). TS gateTargetKind gains the missing upstream
arms (import self-edge, Go extends qualification, dot-imported
supertypes) and goBareTypeDir for type-position targets.
---
 codegraph-kernel/src/resolve/fields.rs      | 198 +++++++++-
 codegraph-kernel/src/resolve/go_asserted.rs | 119 ++++--
 codegraph-kernel/src/resolve/go_value.rs    | 384 ++++++++++++++++++++
 codegraph-kernel/src/resolve/method_call.rs |  65 +++-
 codegraph-kernel/src/resolve/mod.rs         |  16 +
 codegraph-kernel/src/resolve/names.rs       |   2 +-
 codegraph-kernel/src/resolve/pipeline.rs    |  15 +-
 src/resolution/go-type-visibility.ts        |  86 ++++-
 src/resolution/index.ts                     |  17 +-
 9 files changed, 864 insertions(+), 38 deletions(-)
 create mode 100644 codegraph-kernel/src/resolve/go_value.rs

diff --git a/codegraph-kernel/src/resolve/fields.rs b/codegraph-kernel/src/resolve/fields.rs
index b6bf6326a..57f773357 100644
--- a/codegraph-kernel/src/resolve/fields.rs
+++ b/codegraph-kernel/src/resolve/fields.rs
@@ -60,7 +60,10 @@ impl KernelResolver {
                     continue;
                 };
                 // The package directory that declares the field's type: the
-                // imported package for `pkg.Type`, else the struct's own.
+                // imported package for `pkg.Type`; for a bare name the
+                // struct's own package or one its file dot-imports — none of
+                // the project's for a name only an outside package can give
+                // the file.
                 let pkg_dir = if raw_type.contains('.') {
                     let pkg = raw_type.split('.').next().unwrap_or("");
                     match self.go_imported_package_dir(&s.file_path, pkg)? {
@@ -68,7 +71,10 @@ impl KernelResolver {
                         None => continue,
                     }
                 } else {
-                    pos_dirname(&s.file_path).to_string()
+                    match self.go_bare_type_dir(&raw_type, &s.file_path)? {
+                        Some(dir) => dir,
+                        None => continue,
+                    }
                 };
                 let Some(field_type) = raw_type.split('.').next_back() else {
                     continue;
@@ -81,6 +87,14 @@ impl KernelResolver {
                 {
                     continue;
                 }
+                // Nor is an alias of an outside type (`ctx Ctx` with
+                // `type Ctx = context.Context`): read in the struct's file.
+                if matches!(
+                    self.go_written_type(&raw_type, &r.clone().at(&s))?,
+                    Some(super::go_asserted::GoAsserted::Outside)
+                ) {
+                    continue;
+                }
                 if let Some(c) = self.go_method_in_package(field_type, method, &pkg_dir, r)? {
                     return Ok(Some(c));
                 }
@@ -89,6 +103,160 @@ impl KernelResolver {
         Ok(None)
     }
 
+    /// goDotImports (name-matcher.ts): the project package directories
+    /// `file_path` dot-imports (`import . "…"`), whether a dot import lies
+    /// outside the project's modules, and — only when an outside one does —
+    /// the names the file's own `type` declarations use.
+    pub(super) fn go_dot_imports(&mut self, file_path: &str) -> Res<GoDotImports> {
+        if let Some(hit) = self.go_dot_imports_memo.get(file_path) {
+            return Ok(hit.clone());
+        }
+        let mut found = GoDotImports::default();
+        if std::env::var_os("CODEGRAPH_KERNEL_DEBUG_GO").is_some() {
+            eprintln!("[go-dots] {file_path} imports: {:?}", self.import_mappings(file_path)?.iter().map(|i| format!("{}={}", i.local_name, i.source)).collect::<Vec<_>>());
+        }
+        for import in self.import_mappings(file_path)?.iter().filter(|i| i.local_name == ".") {
+            if let Some(dir) = self.go_package_dir(&import.source, file_path) {
+                found.dirs.push(dir);
+            } else if !import.source.starts_with('.') && !import.source.contains("/internal/") {
+                found.outside = true;
+            }
+        }
+        if found.outside {
+            let mut types = HashSet::new();
+            if let Some(lines) = self.read_file(file_path) {
+                for line in lines.iter() {
+                    for m in re!(r"(?:^|[^\w.])type\s+([A-Za-z_]\w*)").captures_iter(&strip_line_comments(line)) {
+                        types.insert(m[1].to_string());
+                    }
+                }
+            }
+            found.types = types;
+        }
+        self.go_dot_imports_memo.insert(file_path.to_string(), found.clone());
+        Ok(found)
+    }
+
+    /// goPackageTypes (name-matcher.ts): the Go type declarations named
+    /// `name` in the package at `dir`.
+    pub(super) fn go_package_types(&mut self, name: &str, dir: &str) -> Res<Vec<Arc<KNode>>> {
+        Ok(self.nodes_by_name(name)?.iter()
+            .filter(|n| n.language == "go"
+                && matches!(n.kind.as_str(), "struct" | "interface" | "type_alias")
+                && pos_dirname(&n.file_path) == dir)
+            .cloned().collect())
+    }
+
+    /// goBareTypeDir (name-matcher.ts): the package directory Go reads a
+    /// bare type name from — the file's own package, else a package of the
+    /// project the file dot-imports that declares it. `None` for an
+    /// exported name only a package from outside the project can give the
+    /// file (`. "github.com/onsi/gomega"`): no type of the project's. The
+    /// file's own package when no package declares the name — a type the
+    /// index doesn't hold, like one a function declares.
+    pub(super) fn go_bare_type_dir(&mut self, name: &str, file_path: &str) -> Res<Option<String>> {
+        let own = pos_dirname(file_path).to_string();
+        let dots = self.go_dot_imports(file_path)?;
+        if std::env::var_os("CODEGRAPH_KERNEL_DEBUG_GO").is_some() {
+            eprintln!("[go-bare] {name} in {file_path}: own={own} dirs={:?} outside={} types={:?}", dots.dirs, dots.outside, dots.types);
+        }
+        if (dots.dirs.is_empty() && !dots.outside) || !self.go_package_types(name, &own)?.is_empty() {
+            return Ok(Some(own));
+        }
+        for dir in &dots.dirs {
+            if !self.go_package_types(name, dir)?.is_empty() {
+                return Ok(Some(dir.clone()));
+            }
+        }
+        if !dots.outside || !re!(r"^[A-Z]\w*$").is_match(name) {
+            return Ok(Some(own));
+        }
+        Ok(dots.types.contains(name).then_some(own))
+    }
+
+    /// goAliasTarget (name-matcher.ts): the project type a `type X = T`
+    /// declaration names — `Null` when X is no project type's (a builtin or
+    /// a type from outside the modules), `Unknown` when the node is no alias
+    /// or its target can't be read.
+    pub(super) fn go_alias_target(&mut self, type_node: &KNode) -> Res<GoAliasTarget> {
+        if type_node.kind != "type_alias" {
+            return Ok(GoAliasTarget::Unknown);
+        }
+        if let Some(hit) = self.go_alias_target_memo.get(&type_node.id) {
+            return Ok(hit.clone());
+        }
+        let Some(lines) = self.read_file(&type_node.file_path) else {
+            return Ok(GoAliasTarget::Unknown);
+        };
+        // From the alias's name, where the node starts, to the end of its type.
+        let decl = lines.iter()
+            .skip((type_node.start_line - 1).max(0) as usize)
+            .take((type_node.end_line - type_node.start_line + 1).max(0) as usize)
+            .enumerate()
+            .map(|(i, l)| {
+                let s = if i == 0 { &l[type_node.start_column.max(0) as usize..] } else { l.as_str() };
+                strip_line_comments(s).to_string()
+            })
+            .collect::<Vec<_>>()
+            .join(" ");
+        let decl = re!(r"/\*.*?\*/").replace_all(&decl, "");
+        // `Name =` or `Name[T any] =`; a defined type has no `=` there.
+        let head = re!(r"^\s*[A-Za-z_]\w*\s*(?:\[[^\]]*\])?\s*=").captures(&decl);
+        let target = match head {
+            None => GoAliasTarget::Unknown,
+            Some(head) => {
+                let m = re!(r"^\s*(?:\*\s*)?([A-Za-z_]\w*)(?:\s*\.\s*([A-Za-z_]\w*))?\s*(?:\[.*\])?\s*;?\s*$")
+                    .captures(&decl[head.get(0).unwrap().end()..]);
+                match m {
+                    None => GoAliasTarget::Null,
+                    Some(m) => {
+                        let (bare, name) = match m.get(2) {
+                            Some(second) => (false, second.as_str().to_string()),
+                            None => (true, m[1].to_string()),
+                        };
+                        let pkg_dir = if bare {
+                            self.go_bare_type_dir(&name, &type_node.file_path)?
+                        } else {
+                            self.go_imported_package_dir(&type_node.file_path, &m[1])?
+                        };
+                        match pkg_dir {
+                            Some(dir) if !bare || !GO_BUILTIN_FIELD_TYPES.contains(name.as_str()) => {
+                                GoAliasTarget::Target(name, dir)
+                            }
+                            _ => GoAliasTarget::Null,
+                        }
+                    }
+                }
+            }
+        };
+        self.go_alias_target_memo.insert(type_node.id.clone(), target.clone());
+        Ok(target)
+    }
+
+    /// goDotImportedSupertype (name-matcher.ts): what a Go embedding written
+    /// bare (`*Manager`) names — the type of the package the file
+    /// dot-imports that declares it, not another package's namesake, and
+    /// nothing for a name only a package from outside the project can give
+    /// the file. `None` vetoes the pick; `Some` gives the node to use,
+    /// which may be `cand` unchanged.
+    pub(super) fn go_dot_imported_supertype(&mut self, cand: &Arc<KNode>, r: &ResolveRefIn) -> Res<Option<Arc<KNode>>> {
+        if !re!(r"^[A-Za-z_]\w*$").is_match(&r.reference_name) {
+            return Ok(Some(cand.clone()));
+        }
+        let own = pos_dirname(&r.file_path).to_string();
+        let Some(dir) = self.go_bare_type_dir(&r.reference_name, &r.file_path)? else {
+            return Ok(None);
+        };
+        if dir == own || self.go_written_qualifier(r)?.is_some() {
+            return Ok(Some(cand.clone()));
+        }
+        if pos_dirname(&cand.file_path) == dir {
+            return Ok(Some(cand.clone()));
+        }
+        let types = self.go_package_types(&r.reference_name, &dir)?;
+        Ok(prefer_call_site_file(types, &r.file_path).into_iter().next().or_else(|| Some(cand.clone())))
+    }
+
     /// The module directory of the package `file_path` imports as `pkg`:
     /// `None` when `pkg` is no import there or names a package outside the
     /// module.
@@ -161,7 +329,9 @@ impl KernelResolver {
             return Ok(self.go_imported_package_dir(file, pkg)?
                 .map(|dir| (name.to_string(), dir)));
         }
-        Ok(Some((named.to_string(), pos_dirname(file).to_string())))
+        // A bare type name reads from the file's own package or one it
+        // dot-imports (goBareTypeDir): `None` when it can't be told.
+        Ok(self.go_bare_type_dir(named, file)?.map(|dir| (named.to_string(), dir)))
     }
 
     /// A named term in an interface is a supertype only if its declaration
@@ -1524,6 +1694,28 @@ fn ts_array_suffix_re() -> Rc<Regex> {
     re!(r"^\s*(?:<[^;=(){}<>]*(?:<[^;=(){}<>]*>[^;=(){}<>]*)*>)?\s*\[\s*\]")
 }
 
+/// goDotImports' answer (name-matcher.ts).
+#[derive(Clone, Default)]
+pub(super) struct GoDotImports {
+    pub(super) dirs: Vec<String>,
+    pub(super) outside: bool,
+    pub(super) types: HashSet<String>,
+}
+
+/// goAliasTarget's answer (name-matcher.ts).
+#[derive(Clone)]
+pub(super) enum GoAliasTarget {
+    /// A project type the alias names (`name`, package `dir`). Carried for
+    /// the callers that follow an alias to its type (the unread-file and
+    /// indexed-receiver Go ports); the alias-outside check only reads Null.
+    #[allow(dead_code)]
+    Target(String, String),
+    /// No project type — a builtin or a type from outside the modules.
+    Null,
+    /// Not a type alias, or its target can't be read.
+    Unknown,
+}
+
 /// A TypeScript class-field declaration found by `ts_field_decl`.
 pub(super) struct TsFieldDecl {
     /// The declared type text (`Mailer`, `ns.Mailer`, the `typeof` operand).
diff --git a/codegraph-kernel/src/resolve/go_asserted.rs b/codegraph-kernel/src/resolve/go_asserted.rs
index 2641b80f5..be37c127c 100644
--- a/codegraph-kernel/src/resolve/go_asserted.rs
+++ b/codegraph-kernel/src/resolve/go_asserted.rs
@@ -13,6 +13,7 @@
 //! name some other way and is left to the other receiver inference.
 
 use super::*;
+use super::fields::GoAliasTarget;
 use tree_sitter::Node as TsNode;
 
 /// What a Go type written at a call site names.
@@ -183,15 +184,30 @@ impl KernelResolver {
                 Some(_) => return Ok(None),
             }
         } else {
-            let mut dirs = vec![pos_dirname(&r.file_path).to_string()];
-            for import in self.import_mappings(&r.file_path)?.iter().filter(|i| i.local_name == ".") {
-                if let Some(dir) = self.go_package_dir(&import.source, &r.file_path) { dirs.push(dir); }
-            }
-            match dirs.into_iter().find(|d| declared.contains(d)) {
-                Some(dir) => dir,
-                None => return Ok(GO_BUILTIN_FIELD_TYPES.contains(name.as_str()).then_some(GoAsserted::Outside)),
+            let Some(dir) = self.go_bare_type_dir(&name, &r.file_path)? else {
+                return Ok(Some(GoAsserted::Outside));
+            };
+            if !declared.contains(&dir) {
+                return Ok(GO_BUILTIN_FIELD_TYPES.contains(name.as_str()).then_some(GoAsserted::Outside));
             }
+            dir
         };
+        // An alias of a type from outside the project (`type Ctx =
+        // context.Context`) has that type's methods, none the project
+        // declares. Every declaration an outside alias means none here.
+        let types = self.go_package_types(&name, &dir)?;
+        if !types.is_empty() {
+            let mut all_outside_alias = true;
+            for t in &types {
+                if !matches!(self.go_alias_target(t)?, GoAliasTarget::Null) {
+                    all_outside_alias = false;
+                    break;
+                }
+            }
+            if all_outside_alias {
+                return Ok(Some(GoAsserted::Outside));
+            }
+        }
         Ok(Some(GoAsserted::Project { name, dir }))
     }
 
@@ -203,32 +219,81 @@ impl KernelResolver {
     }
 
     /// The verdict for `receiver.method` when the receiver is an asserted
-    /// local: the method the asserted type has, or nothing. `None`: not an
-    /// asserted local; the other strategies decide.
+    /// local: the method the asserted type has, or nothing — a miss and a
+    /// type the index cannot read are both terminal; the fork never guesses
+    /// a callee for an asserted receiver by name. `None`: not an asserted
+    /// local; the other strategies decide.
     pub(super) fn go_asserted_member(&mut self, receiver: &str, method: &str, r: &ResolveRefIn) -> Res<Option<Option<KCand>>> {
-        Ok(match self.go_asserted_local(receiver, r)? {
-            None => None,
-            Some(GoAsserted::Outside) => Some(None),
-            Some(GoAsserted::Project { name, dir }) => Some(self.go_method_in_package(&name, method, &dir, r)?),
-        })
+        let Some(written) = self.go_asserted_local_type(receiver, r) else { return Ok(None); };
+        Ok(Some(match self.go_written_type(&written, r)? {
+            Some(GoAsserted::Outside) => None,
+            Some(GoAsserted::Project { name, dir }) => self.go_method_in_package(&name, method, &dir, r)?,
+            None => {
+                // An exported type the file declares — `type T interface`
+                // inside the function — is no index node; its call goes to
+                // the name strategies, as before. A literal, an unexported
+                // or an unknown name stays refused: the fork never guesses
+                // a callee for an asserted receiver it cannot type.
+                let bare = written.trim_start_matches('*').rsplit('.').next().unwrap_or("");
+                let local = Self::go_named_type(&written).is_some()
+                    && bare.chars().next().is_some_and(|c| c.is_uppercase())
+                    && self.go_bare_type_dir(bare, &r.file_path)?.is_some();
+                if local { self.go_mc_untyped_local = true; return Ok(None); }
+                None
+            }
+        }))
     }
 }
 
 /// An actual lexical declaration, including the name's position for reading
 /// its initializer. Used by func-field synthesis through the native bridge.
 fn local_declaration_in<'a>(scope: TsNode<'a>, name: &str, site: usize, text: &str) -> Option<(TsNode<'a>, Option<String>)> {
-    fn names<'a>(decl: TsNode<'a>, name: &str, text: &str) -> Option<(TsNode<'a>, Option<String>)> {
-        let mut cursor = decl.walk();
-        let target = decl.children_by_field_name("name", &mut cursor).find(|n| text_of(*n, text) == name)?;
-        Some((target, decl.child_by_field_name("type").map(|t| text_of(t, text).to_string())))
+    /// `x := &pkg.T{…}`, `x := T{…}`, `x := new(T)` and `var x = &T{…}`
+    /// write their type in the value; other right-hand sides say nothing.
+    /// `k` is the name's place among the declaration's names — the value
+    /// list's same place is its initializer.
+    fn value_type<'a>(value: Option<TsNode<'a>>, k: usize, text: &'a str) -> Option<String> {
+        let mut v = value?;
+        if v.kind() == "expression_list" {
+            v = if v.named_child_count() > k { v.named_child(k)? } else { v.named_child(v.named_child_count() - 1)? };
+        }
+        while v.kind() == "parenthesized_expression" {
+            v = v.named_child(0)?;
+        }
+        if v.kind() == "unary_expression" {
+            if text.get(v.start_byte()..v.start_byte() + 1)? != "&" { return None; }
+            v = v.named_child(0)?;
+        }
+        match v.kind() {
+            "composite_literal" => v.child_by_field_name("type").map(|t| text_of(t, text).to_string()),
+            // A type switch's `x := v.(type)` binds a per-clause type the
+            // declaration does not spell: unreadable, never a project type.
+            "type_assertion_expression" => Some(match v.child_by_field_name("type") {
+                Some(t) if text_of(t, text) != "type" => text_of(t, text).to_string(),
+                _ => "<type>".to_string(),
+            }),
+            "call_expression" => {
+                let function = v.child_by_field_name("function")?;
+                if function.kind() != "identifier" || !matches!(text_of(function, text), "new" | "make") { return None; }
+                v.child_by_field_name("arguments")?.named_child(0).map(|t| text_of(t, text).to_string())
+            }
+            _ => None,
+        }
     }
     fn statement<'a>(stmt: TsNode<'a>, name: &str, text: &str) -> Option<(TsNode<'a>, Option<String>)> {
         match stmt.kind() {
             "short_var_declaration" | "range_clause" => {
-                let target = identifiers(stmt.child_by_field_name("left")?).into_iter().find(|n| text_of(*n, text) == name)?;
-                Some((target, None))
+                let names = identifiers(stmt.child_by_field_name("left")?);
+                let (k, target) = names.iter().enumerate().find(|(_, n)| text_of(**n, text) == name).map(|(k, n)| (k, *n))?;
+                Some((target, value_type(stmt.child_by_field_name("right"), k, text)))
+            }
+            "var_spec" | "const_spec" | "parameter_declaration" | "variadic_parameter_declaration" => {
+                let mut c = stmt.walk();
+                let names: Vec<_> = stmt.children_by_field_name("name", &mut c).collect();
+                let (k, target) = names.iter().enumerate().find(|(_, n)| text_of(**n, text) == name).map(|(k, n)| (k, *n))?;
+                let declared = stmt.child_by_field_name("type").map(|t| text_of(t, text).to_string());
+                Some((target, declared.or_else(|| value_type(stmt.child_by_field_name("value"), k, text))))
             }
-            "var_spec" | "const_spec" | "parameter_declaration" | "variadic_parameter_declaration" => names(stmt, name, text),
             "var_declaration" | "const_declaration" | "var_spec_list" | "parameter_list" => {
                 let mut c = stmt.walk();
                 stmt.named_children(&mut c).filter_map(|s| statement(s, name, text)).last()
@@ -243,7 +308,17 @@ fn local_declaration_in<'a>(scope: TsNode<'a>, name: &str, site: usize, text: &s
         }
         "if_statement" | "expression_switch_statement" | "type_switch_statement" | "for_statement" => {
             if let Some(alias) = scope.child_by_field_name("alias").filter(|n| n.end_byte() <= site) {
-                if let Some(target) = identifiers(alias).into_iter().find(|n| text_of(*n, text) == name) { return Some((target,None)); }
+                let decl = if alias.kind() == "short_var_declaration" { Some(alias) } else {
+                    let mut c = alias.walk();
+                    let mut it = alias.named_children(&mut c);
+                    it.find(|n| n.kind() == "short_var_declaration")
+                };
+                if let Some(d) = decl {
+                    let names = identifiers(d.child_by_field_name("left")?);
+                    if let Some((k, target)) = names.iter().enumerate().find(|(_, n)| text_of(**n, text) == name).map(|(k, n)| (k, *n)) {
+                        return Some((target, value_type(d.child_by_field_name("right"), k, text)));
+                    }
+                }
             }
             let mut c=scope.walk();
             for child in scope.named_children(&mut c).filter(|n| n.end_byte() <= site) {
diff --git a/codegraph-kernel/src/resolve/go_value.rs b/codegraph-kernel/src/resolve/go_value.rs
new file mode 100644
index 000000000..cd68028c1
--- /dev/null
+++ b/codegraph-kernel/src/resolve/go_value.rs
@@ -0,0 +1,384 @@
+//! Go package-value typing and expression-typed call arms — the tree-native
+//! ports of name-matcher.ts `matchGoPackageValueCall`, `matchGoIndexedCall`
+//! and `matchGoChainedCall` (`goPackageValueType`/`goValueType`/
+//! `goNamedType`/`goReceiverChainType` semantics).
+
+use super::go_asserted::GoAsserted;
+use super::*;
+use tree_sitter::Node as TsNode;
+
+/// What a package-level var/const's declaration says its type is
+/// (`goPackageValueType`): `Written` the spec spells or its value reads,
+/// `Outside` one an outside package hands out, `Unknown` nothing readable.
+enum GoPkgValue {
+    Written(String),
+    Outside,
+    Unknown,
+}
+
+impl KernelResolver {
+    /// goNamedType — `*?ident(.ident)?[type-args]?` reduced to `ident` or
+    /// `pkg.ident`; anything else (a literal like `[]T`, `map[K]V`) is no
+    /// named type.
+    pub(super) fn go_named_type(written: &str) -> Option<String> {
+        static NAMED: LazyLock<Regex> = LazyLock::new(|| {
+            Regex::new(r"^\*?\s*([A-Za-z_]\w*)\s*(?:\.\s*([A-Za-z_]\w*))?\s*(?:\[[\s\S]*\])?$").unwrap()
+        });
+        let cap = NAMED.captures(written.trim())?;
+        Some(match cap.get(2) {
+            Some(second) => format!("{}.{}", &cap[1], second.as_str()),
+            None => cap[1].to_string(),
+        })
+    }
+
+    /// isGoOutsidePackage — `pkg` names an import of `file` whose package is
+    /// no project directory.
+    pub(super) fn go_is_outside_package(&mut self, pkg: &str, file: &str) -> Res<bool> {
+        Ok(self.import_mappings(file)?.iter().any(|i| i.local_name == pkg)
+            && self.go_imported_package_dir(file, pkg)?.is_none())
+    }
+
+    /// goPackageValueType — the type a package-level `var`/`const` node's
+    /// spec writes: an explicit `var x T`, the spec a `const` group member
+    /// repeats, or the type a composite literal / conversion value gives.
+    fn go_package_value_type(&mut self, n: &KNode) -> Res<GoPkgValue> {
+        let Some(file) = self.read_file(&n.file_path) else { return Ok(GoPkgValue::Unknown); };
+        static SPEC: LazyLock<Regex> = LazyLock::new(|| {
+            Regex::new(r"^\s*(?:(?:var|const)\s*(?:\(\s*)?)?([A-Za-z_]\w*(?:\s*,\s*[A-Za-z_]\w*)*)(.*)$").unwrap()
+        });
+        let start = (n.start_line - 1).max(0) as usize;
+        let mut i = start as i64;
+        while i >= 0 && start as i64 - i < 200 {
+            let raw = file.text().lines().nth(i as usize).unwrap_or("").to_string();
+            i -= 1;
+            let line = strip_line_comments(&raw);
+            let own = i as usize + 1 == start;
+            if !own && (line.trim().is_empty() || line.trim_start().starts_with("/*") || line.trim_start().starts_with('*')) {
+                continue;
+            }
+            let Some(cap) = SPEC.captures(&line) else { return Ok(GoPkgValue::Unknown); };
+            if own && !cap[1].split(',').map(str::trim).any(|x| x == n.name) {
+                return Ok(GoPkgValue::Unknown);
+            }
+            let rest = cap[2].trim();
+            if rest.is_empty() {
+                // A constant alone in its group repeats the spec above it.
+                if n.kind != "constant" || line.trim_start().starts_with("var") || line.trim_start().starts_with("const") {
+                    return Ok(GoPkgValue::Unknown);
+                }
+                continue;
+            }
+            let eq = rest.find('=').filter(|&p| !rest[p + 1..].starts_with('='));
+            let written = match eq {
+                Some(p) => rest[..p].trim(),
+                None => rest,
+            };
+            if written.chars().any(|c| matches!(c, ':' | '"' | '\'' | '`')) {
+                return Ok(GoPkgValue::Unknown);
+            }
+            if !written.is_empty() {
+                return Ok(GoPkgValue::Written(written.to_string()));
+            }
+            let Some(p) = eq else { return Ok(GoPkgValue::Unknown); };
+            return self.go_value_type(&rest[p + 1..], &n.file_path);
+        }
+        Ok(GoPkgValue::Unknown)
+    }
+
+    /// goValueType — the type a declaration value gives: a composite
+    /// literal's (`&Registry{}`, `pkg.T{…}`) or a conversion's (`Role("x")`,
+    /// `pkg.T(x)`). Outside for what an outside package hands out.
+    fn go_value_type(&mut self, value: &str, file: &str) -> Res<GoPkgValue> {
+        static VAL: LazyLock<Regex> = LazyLock::new(|| {
+            Regex::new(r"^\s*&?\s*(?:([A-Za-z_]\w*)\s*\.\s*)?([A-Za-z_]\w*)\s*(?:\[[^\]\n]*\]\s*)?([({])").unwrap()
+        });
+        let Some(cap) = VAL.captures(value) else { return Ok(GoPkgValue::Unknown); };
+        let qualifier = cap.get(1).map(|m| m.as_str());
+        let name = cap[2].to_string();
+        let open = cap[3].to_string();
+        if let Some(q) = qualifier {
+            if self.go_is_outside_package(q, file)? {
+                return Ok(GoPkgValue::Outside);
+            }
+        }
+        let written = match qualifier {
+            Some(q) => format!("{q}.{name}"),
+            None => name.clone(),
+        };
+        if open == "{" {
+            return Ok(if GO_BUILTIN_FIELD_TYPES.contains(name.as_str()) || matches!(name.as_str(), "any" | "error") {
+                GoPkgValue::Outside
+            } else {
+                GoPkgValue::Written(written)
+            });
+        }
+        // A call is a conversion when it names a type of its package.
+        let dir = match qualifier {
+            Some(q) => self.go_imported_package_dir(file, q)?,
+            None => self.go_bare_type_dir(&name, file)?,
+        };
+        Ok(match dir {
+            Some(dir) if !self.go_package_types(&name, &dir)?.is_empty() => GoPkgValue::Written(written),
+            _ => GoPkgValue::Unknown,
+        })
+    }
+
+    /// matchGoPackageValueCall — `receiver.method` on a package-level
+    /// var/const whose declaration says its type (`var level = Level(2)`).
+    /// `Some(verdict)` claims the ref; `verdict=None` is a terminal miss on
+    /// an outside type. `None` leaves the other strategies to decide.
+    pub(super) fn match_go_package_value_call(
+        &mut self,
+        receiver: &str,
+        method: &str,
+        r: &ResolveRefIn,
+    ) -> Res<Option<Option<KCand>>> {
+        let dir = pos_dirname(&r.file_path);
+        let decls: Vec<Arc<KNode>> = self
+            .nodes_by_name(receiver)?
+            .iter()
+            .filter(|n| {
+                n.language == "go"
+                    && matches!(n.kind.as_str(), "variable" | "constant")
+                    && pos_dirname(&n.file_path) == dir
+            })
+            .cloned()
+            .collect();
+        if decls.is_empty() {
+            return Ok(None);
+        }
+        if self.import_mappings(&r.file_path)?.iter().any(|i| i.local_name == receiver) {
+            return Ok(None);
+        }
+        if self
+            .go_local_declaration_at(receiver.to_string(), r.file_path.clone(), r.line, r.column)?
+            .is_some()
+        {
+            return Ok(None);
+        }
+        let pkg = self.go_package_clause(&r.file_path);
+        let mut agreed: Option<String> = None;
+        for d in &decls {
+            if self.go_package_clause(&d.file_path) != pkg {
+                continue;
+            }
+            let written = match self.go_package_value_type(d)? {
+                GoPkgValue::Outside => return Ok(Some(None)),
+                GoPkgValue::Unknown => return Ok(None),
+                GoPkgValue::Written(w) => w.replace(char::is_whitespace, ""),
+            };
+            // Files for other build targets may declare it differently.
+            if agreed.as_deref().is_some_and(|seen| seen != written) {
+                return Ok(None);
+            }
+            agreed = Some(written);
+        }
+        let Some(written) = agreed else { return Ok(None); };
+        let Some(named) = Self::go_named_type(&written) else { return Ok(Some(None)); };
+        let mut site = r.clone();
+        site.file_path = decls[0].file_path.clone();
+        if matches!(self.go_written_type(&written, &site)?, Some(GoAsserted::Outside)) {
+            return Ok(Some(None));
+        }
+        let dot = named.find('.');
+        let name = match dot {
+            Some(p) => named[p + 1..].to_string(),
+            None => named.clone(),
+        };
+        if dot.is_none() && GO_BUILTIN_FIELD_TYPES.contains(name.as_str()) {
+            return Ok(Some(None));
+        }
+        let pkg_dir = match dot {
+            Some(p) => self.go_imported_package_dir(&site.file_path, &named[..p])?,
+            None => self.go_bare_type_dir(&name, &site.file_path)?,
+        };
+        if pkg_dir.is_none() && dot.is_none() {
+            return Ok(Some(None));
+        }
+        let Some(pkg_dir) = pkg_dir else { return Ok(None); };
+        if self.go_package_types(&name, &pkg_dir)?.is_empty() {
+            return Ok(None);
+        }
+        Ok(Some(self.go_method_in_package(&name, method, &pkg_dir, r)?))
+    }
+
+    /// The type an expression's source text spells (`goReceiverChainType`,
+    /// tree-native): `(written, file)`. `None` is unreadable — the other
+    /// strategies decide.
+    fn go_expr_written(&mut self, expr: TsNode, file_text: &str, r: &ResolveRefIn) -> Res<Option<(String, String)>> {
+        let file = r.file_path.clone();
+        match expr.kind() {
+            "parenthesized_expression" => match expr.named_child(0) {
+                Some(inner) => self.go_expr_written(inner, file_text, r),
+                None => Ok(None),
+            },
+            "identifier" => {
+                let name = file_text[expr.byte_range()].to_string();
+                if let Some(decl) =
+                    self.go_local_declaration_at(name.clone(), file.clone(), r.line, r.column)?
+                {
+                    if let Some(t) = decl.declared_type {
+                        return Ok(Some((t, file)));
+                    }
+                    if let Some(w) = self.go_asserted_local_type(&name, r) {
+                        return Ok(Some((w, file)));
+                    }
+                    return Ok(None);
+                }
+                for n in self.nodes_by_name(&name)?.iter().filter(|n| {
+                    n.language == "go"
+                        && matches!(n.kind.as_str(), "variable" | "constant")
+                        && pos_dirname(&n.file_path) == pos_dirname(&file)
+                }) {
+                    if let GoPkgValue::Written(w) = self.go_package_value_type(n)? {
+                        return Ok(Some((w, n.file_path.clone())));
+                    }
+                }
+                Ok(None)
+            }
+            "index_expression" | "slice_expression" => {
+                let Some(operand) = expr.child_by_field_name("operand") else { return Ok(None); };
+                let Some((mut text, at)) = self.go_expr_written(operand, file_text, r)? else {
+                    return Ok(None);
+                };
+                // `x[i]` on `[]T`, `[N]T`, `map[K]V` or `*[N]T` gives T / V.
+                while let Some(rest) = text.strip_prefix('*') {
+                    text = rest.trim_start().to_string();
+                }
+                let text = text.trim_start().to_string();
+                if let Some(rest) = text.strip_prefix("map[") {
+                    return Ok(match rest.find(']') {
+                        Some(p) => Some((rest[p + 1..].trim().to_string(), at)),
+                        None => None,
+                    });
+                }
+                if !text.starts_with('[') {
+                    return Ok(None);
+                }
+                Ok(match text.find(']') {
+                    Some(p) => Some((text[p + 1..].trim().to_string(), at)),
+                    None => None,
+                })
+            }
+            "type_assertion_expression" => Ok(expr
+                .child_by_field_name("type")
+                .map(|t| (file_text[t.byte_range()].trim().to_string(), file))),
+            "composite_literal" => Ok(expr
+                .child_by_field_name("type")
+                .map(|t| (file_text[t.byte_range()].trim().to_string(), file))),
+            "unary_expression" => {
+                let op = expr.child(0).map(|n| &file_text[n.byte_range()]).unwrap_or("");
+                let Some(inner) = expr.named_child(0) else { return Ok(None); };
+                let Some((t, at)) = self.go_expr_written(inner, file_text, r)? else { return Ok(None); };
+                Ok(match op {
+                    "*" => t.strip_prefix('*').map(|s| (s.trim().to_string(), at)),
+                    "&" => Some((format!("*{t}"), at)),
+                    _ => None,
+                })
+            }
+            "call_expression" => {
+                let Some(function) = expr.child_by_field_name("function") else { return Ok(None); };
+                if function.kind() == "identifier" {
+                    let callee = &file_text[function.byte_range()];
+                    if matches!(callee, "new" | "make") {
+                        return Ok(expr
+                            .child_by_field_name("arguments")
+                            .and_then(|a| a.named_child(0))
+                            .map(|t| (file_text[t.byte_range()].trim().to_string(), file)));
+                    }
+                    // A conversion names a type of its package.
+                    let dir = self.go_bare_type_dir(callee, &file)?;
+                    if dir.is_some_and(|d| !self.go_package_types(callee, &d).unwrap_or_default().is_empty()) {
+                        return Ok(Some((callee.to_string(), file)));
+                    }
+                }
+                if function.kind() == "selector_expression" {
+                    if let (Some(operand), Some(field)) =
+                        (function.child_by_field_name("operand"), function.child_by_field_name("field"))
+                    {
+                        if operand.kind() == "identifier" {
+                            let q = &file_text[operand.byte_range()];
+                            let callee = &file_text[field.byte_range()];
+                            if self.go_is_outside_package(q, &file)? {
+                                return Ok(None);
+                            }
+                            if let Some(d) = self.go_imported_package_dir(&file, q)? {
+                                if !self.go_package_types(callee, &d)?.is_empty() {
+                                    return Ok(Some((format!("{q}.{callee}"), file)));
+                                }
+                            }
+                        }
+                    }
+                }
+                Ok(None)
+            }
+            _ => Ok(None),
+        }
+    }
+
+    /// The settled type of `expr` where `r` is read: a project type with its
+    /// package, `Outside`, or `None` (unreadable — name matching decides).
+    fn go_expr_type(&mut self, expr: TsNode, file_text: &str, r: &ResolveRefIn) -> Res<Option<GoAsserted>> {
+        let Some((written, at)) = self.go_expr_written(expr, file_text, r)? else { return Ok(None); };
+        let mut site = r.clone();
+        site.file_path = at;
+        self.go_written_type(&written, &site)
+    }
+
+    /// matchGoIndexedCall + matchGoChainedCall — a bare `calls` name whose
+    /// enclosing call selects the method on an index, call, assertion,
+    /// composite or selector receiver: `gs[0].Expect`, `f().M`, `v.(T).M`,
+    /// `x.f.M`. The receiver's type owns the ref: a project type names the
+    /// method (or nothing — terminal), an outside type refuses it, and an
+    /// unreadable one leaves name matching to decide.
+    pub(super) fn match_go_expr_call(&mut self, r: &ResolveRefIn) -> Res<Option<Option<KCand>>> {
+        if r.language != "go" || r.reference_kind != "calls" || r.reference_name.contains('.') {
+            return Ok(None);
+        }
+        let Some(file) = self.read_file(&r.file_path) else { return Ok(None); };
+        let Some(tree) = self.parsed_tree(&file, r) else { return Ok(None); };
+        let mut node = super::iteration::descendant_for_position(
+            tree.root_node(),
+            file.text(),
+            ((r.line - 1).max(0) as usize, r.column.max(0) as usize),
+        );
+        let mut selector = None;
+        loop {
+            if node.kind() == "call_expression" {
+                if let Some(function) = node.child_by_field_name("function") {
+                    if function.kind() == "selector_expression" {
+                        if let Some(field) = function.child_by_field_name("field") {
+                            if &file.text()[field.byte_range()] == r.reference_name {
+                                selector = Some(function);
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            let Some(parent) = node.parent() else { break };
+            if matches!(parent.kind(), "argument_list" | "block" | "source_file") {
+                break;
+            }
+            node = parent;
+        }
+        let Some(selector) = selector else { return Ok(None); };
+        let Some(operand) = selector.child_by_field_name("operand") else { return Ok(None); };
+        let mut operand = operand;
+        while operand.kind() == "parenthesized_expression" {
+            let Some(inner) = operand.named_child(0) else { return Ok(None); };
+            operand = inner;
+        }
+        match operand.kind() {
+            // `x.M` arrives as a dotted ref, never a bare name.
+            "identifier" => Ok(None),
+            _ => Ok(match self.go_expr_type(operand, file.text(), r)? {
+                Some(GoAsserted::Project { name, dir }) => {
+                    Some(self.go_method_in_package(&name, &r.reference_name, &dir, r)?)
+                }
+                Some(GoAsserted::Outside) => Some(None),
+                None => None,
+            }),
+        }
+    }
+}
diff --git a/codegraph-kernel/src/resolve/method_call.rs b/codegraph-kernel/src/resolve/method_call.rs
index 65e4e0351..57f5eb7e7 100644
--- a/codegraph-kernel/src/resolve/method_call.rs
+++ b/codegraph-kernel/src/resolve/method_call.rs
@@ -687,7 +687,35 @@ impl KernelResolver {
 
         if inferable {
             if r.language == "go" {
-                if let Some(verdict) = self.go_asserted_member(&object_or_class, &method_name, r)? { return Ok(verdict); }
+                if let Some(verdict) = self.go_asserted_member(&object_or_class, &method_name, r)? {
+                    if verdict.is_none() { self.go_mc_terminal = true; }
+                    return Ok(verdict);
+                }
+                // A package-level value's spec types its method calls
+                // (`var level = Level(2)` → `level.Label()` on Level).
+                if !object_or_class.contains('.') {
+                    if let Some(verdict) = self.match_go_package_value_call(&object_or_class, &method_name, r)? {
+                        return Ok(verdict);
+                    }
+                    // The declared type settles the call when it is readable:
+                    // a literal (`[]Gomega`) or a type no project package
+                    // declares methods on means no project method answers.
+                    if let Some(decl) = self.go_local_declaration_at(
+                        object_or_class.clone(), r.file_path.clone(), r.line, r.column)?
+                    {
+                        match &decl.declared_type {
+                            Some(text) => {
+                                if Self::go_named_type(text).is_none()
+                                    || matches!(self.go_written_type(text, r)?, Some(super::go_asserted::GoAsserted::Outside))
+                                {
+                                    self.go_mc_terminal = true;
+                                    return Ok(None);
+                                }
+                            }
+                            _ => {}
+                        }
+                    }
+                }
             }
             // A PHP `instanceof` branch narrows the receiver inside its body.
             if let Some(t) = probe!(r, "mc:guarded", self.infer_guarded_receiver(&object_or_class, r)?) {
@@ -803,7 +831,16 @@ if inferred.is_none() && r.language == "dart" {
                     bsite.line = b.line;
                 }
                 let member = self.match_bound_type_member(&t, &method_name, &bsite)?;
-                if member.is_none() && r.language == "kotlin" {
+                if member.is_none() && r.language == "go" {
+                    // A Go standard method name the declared type lacks is no
+                    // other type's (`err.Error()`, `context.Done()`); any
+                    // other name goes on to name matching, as one on a
+                    // receiver of unread type does.
+                    if super::call_shape::is_std_method("go", &method_name) {
+                        self.go_mc_terminal = true;
+                        return Ok(None);
+                    }
+                } else if member.is_none() && r.language == "kotlin" {
                     // An extension function is no member of the receiver's class, and in a
                     // package its qualified name does not say which class it extends.
                     let hit = super::kotlin_receiver::KotlinReceiverHit { ty: t.clone(), site: bsite, heuristic: false };
@@ -814,9 +851,11 @@ if inferred.is_none() && r.language == "dart" {
             }
         }
 
-        // Go 2-hop field chain — exclusive branch.
+        // Go 2-hop field chain — exclusive branch; its miss is terminal.
         if r.language == "go" && dotted && object_or_class.contains('.') {
-            return self.match_go_field_chain_call(&object_or_class, &method_name, r);
+            let hit = self.match_go_field_chain_call(&object_or_class, &method_name, r)?;
+            if hit.is_none() { self.go_mc_terminal = true; }
+            return Ok(hit);
         }
         // rust field/self arms: rust is unmigrated — dead.
         // this.field arms: `this.` receivers are excluded by the claim gate —
@@ -852,6 +891,15 @@ if inferred.is_none() && r.language == "dart" {
         Ok(None)
     }
 
+    /// Whether the bound-receiver miss is a local the index cannot type —
+    /// upstream's strategy-3 name match runs for it (`ctx`, bound from an
+    /// assertion to a type a function declares); every other miss —
+    /// terminal arms included — is refused. Clears both markers either way.
+    fn take_go_mc_untyped(&mut self) -> bool {
+        self.go_mc_terminal = false;
+        std::mem::take(&mut self.go_mc_untyped_local)
+    }
+
     /// matchMethodCall(ref, context, requireReceiverEvidence=false) — the
     /// member-tail arm of matchReference, reached by refs the boundReceiver
     /// claim never took (`this.`/`self.` roots, non-call kinds, deep
@@ -1511,7 +1559,11 @@ if inferred.is_none() && r.language == "dart" {
                     None => None,
                 });
             }
-            return Ok(probe!(r, "brc:match_method_call", self.match_method_call(r)?));
+            let hit = probe!(r, "brc:match_method_call", self.match_method_call(r)?);
+            if hit.is_none() && r.language == "go" && self.take_go_mc_untyped() {
+                return self.match_method_call_free(r);
+            }
+            return Ok(hit);
         }
 
         if binding.as_ref().is_some_and(|b| b.kind == "import") {
@@ -1589,6 +1641,9 @@ if inferred.is_none() && r.language == "dart" {
         if let Some(c) = probe!(r, "brc:match_method_call", self.match_method_call(r)?) {
             return Ok(Some(c));
         }
+        if r.language == "go" && self.take_go_mc_untyped() {
+            return self.match_method_call_free(r);
+        }
         if binding.kind == "param" {
             return Ok(None);
         }
diff --git a/codegraph-kernel/src/resolve/mod.rs b/codegraph-kernel/src/resolve/mod.rs
index 4ce6e65e8..3b2a0c079 100644
--- a/codegraph-kernel/src/resolve/mod.rs
+++ b/codegraph-kernel/src/resolve/mod.rs
@@ -591,6 +591,7 @@ mod fields;
 mod rust_impls;
 mod ts_known;
 mod go_asserted;
+mod go_value;
 mod method_call;
 mod pipeline;
 mod file_refs;
@@ -687,6 +688,17 @@ pub struct KernelResolver {
     rust_typed_refs: HashSet<i64>,
     /// rustTraitOf, by method id → the enclosing trait node's id.
     rust_trait_of_memo: HashMap<String, Option<String>>,
+    /// goDotImports, by file path.
+    go_dot_imports_memo: HashMap<String, fields::GoDotImports>,
+    /// A Go bound-receiver arm proved the receiver has no project method —
+    /// the miss is terminal, not a name-match candidate (`goHasNoProjectMethods`,
+    /// declared-type literals, field-chain and asserted-outside vetoes).
+    go_mc_terminal: bool,
+    /// The receiver is an asserted local whose type a function declares —
+    /// no index type answers, and upstream's strategy-3 name match applies.
+    go_mc_untyped_local: bool,
+    /// goAliasTarget, by type node id.
+    go_alias_target_memo: HashMap<String, fields::GoAliasTarget>,
     /// javaSupertypesOf, by type name.
     java_supers_memo: HashMap<String, Rc<Vec<String>>>,
     /// phpSupertypeQns, by declaration id.
@@ -954,6 +966,10 @@ impl KernelResolver {
             rust_trait_memo: HashMap::new(),
             rust_typed_refs: HashSet::new(),
             rust_trait_of_memo: HashMap::new(),
+            go_dot_imports_memo: HashMap::new(),
+            go_mc_terminal: false,
+            go_mc_untyped_local: false,
+            go_alias_target_memo: HashMap::new(),
             java_supers_memo: HashMap::new(),
             php_supers_memo: HashMap::new(),
             vb: vbnet::VbMemo::default(),
diff --git a/codegraph-kernel/src/resolve/names.rs b/codegraph-kernel/src/resolve/names.rs
index 112829bf8..0e6d18cc7 100644
--- a/codegraph-kernel/src/resolve/names.rs
+++ b/codegraph-kernel/src/resolve/names.rs
@@ -497,7 +497,7 @@ impl KernelResolver {
 
     /// The name in a Go file's `package` clause (the first line that starts
     /// with `package`, outside block comments).
-    fn go_package_clause(&mut self, file: &str) -> Option<String> {
+    pub(super) fn go_package_clause(&mut self, file: &str) -> Option<String> {
         let lines = self.read_file(file)?;
         let mut in_block = false;
         for line in lines.iter() {
diff --git a/codegraph-kernel/src/resolve/pipeline.rs b/codegraph-kernel/src/resolve/pipeline.rs
index ae1177508..3c91cbc79 100644
--- a/codegraph-kernel/src/resolve/pipeline.rs
+++ b/codegraph-kernel/src/resolve/pipeline.rs
@@ -705,8 +705,11 @@ if super::lang_scope::is_dart_member_read(r) {
                 } else if let Some(imp) = self.go_ref_qualifier(r)? {
                     self.go_package_dir(&imp.source, &r.file_path)
                 } else if self.go_written_qualifier(r)?.is_none() {
-                    Some(pos_dirname(&r.file_path).to_string())
+                    self.go_bare_type_dir(name, &r.file_path)?
                 } else { None };
+                if std::env::var_os("CODEGRAPH_KERNEL_DEBUG_GO").is_some() {
+                    eprintln!("[go-gate] {} {} in {} cand={}:{} pkg={:?}", r.reference_name, r.reference_kind, r.file_path, cand.node.kind, cand.node.file_path, package);
+                }
                 if let Some(package) = package {
                     let types: Vec<_> = self.nodes_by_name(name)?.iter()
                         .filter(|n| n.language == "go" && matches!(n.kind.as_str(), "struct" | "interface" | "type_alias")
@@ -734,6 +737,13 @@ if super::lang_scope::is_dart_member_read(r) {
         if self.is_bound_to_out_of_repo_import(r)? {
             return Ok(None);
         }
+        // One embedded bare that only a package the file dot-imports
+        // declares is that package's, not a namesake as near the file
+        // (goDotImportedSupertype).
+        if r.language == "go" {
+            let Some(node) = self.go_dot_imported_supertype(&cand.node, r)? else { return Ok(None); };
+            cand.node = node;
+        }
         Ok(Some(cand))
     }
 
@@ -1064,6 +1074,9 @@ if super::lang_scope::is_dart_member_read(r) {
         if let Some(result) = self.go_assertion_call(r)? {
             return match result { Some(candidate) => self.finish_pre_framework(r, candidate), None => Ok(self.refused()) };
         }
+        if let Some(result) = self.match_go_expr_call(r)? {
+            return match result { Some(candidate) => self.finish_pre_framework(r, candidate), None => Ok(self.refused()) };
+        }
         if let Some(result) = self.cpp_complex_call(r)? {
             return match result { Some(candidate) => self.finish_pre_framework(r, candidate), None => Ok(self.refused()) };
         }
diff --git a/src/resolution/go-type-visibility.ts b/src/resolution/go-type-visibility.ts
index ace101ff5..81aca8a43 100644
--- a/src/resolution/go-type-visibility.ts
+++ b/src/resolution/go-type-visibility.ts
@@ -17,6 +17,83 @@ function preferCallSiteFile(nodes: Node[], file: string): Node[] {
   return [...nodes].sort((a, b) => Number(b.filePath === file) - Number(a.filePath === file));
 }
 export const GO_TYPE_KINDS: ReadonlySet<string> = new Set(['struct', 'interface', 'type_alias']);
+
+/** The project packages a Go file dot-imports, and whether it dot-imports one from outside the project. */
+interface GoDotImports {
+  dirs: string[];
+  outside: boolean;
+  /** The `type` declarations the file's text holds — function-local ones included — read on demand. */
+  types?: Set<string>;
+}
+
+const GO_DOT_IMPORTS = new WeakMap<ResolutionContext, Map<string, GoDotImports>>();
+
+function goDotImports(filePath: string, context: ResolutionContext): GoDotImports {
+  let memo = GO_DOT_IMPORTS.get(context);
+  if (!memo) GO_DOT_IMPORTS.set(context, (memo = new Map()));
+  let found = memo.get(filePath);
+  if (found) return found;
+  found = { dirs: [], outside: false };
+  for (const line of context.getFileLines?.(filePath) ?? context.readFile(filePath)?.split(/\r?\n/) ?? []) {
+    // The imports come before any other declaration.
+    if (/^(?:func|type|var|const)\b/.test(line)) break;
+    const dot = /^\s*(?:import\s+)?\.\s+"([^"]+)"/.exec(line);
+    if (!dot || !context.getGoPackageDir) continue;
+    const dir = context.getGoPackageDir(dot[1]!, filePath);
+    if (dir) found.dirs.push(dir);
+    // A relative or `/internal/` path is the project's own, mapped or not.
+    else if (!dot[1]!.startsWith('.') && !dot[1]!.includes('/internal/')) found.outside = true;
+  }
+  memo.set(filePath, found);
+  return found;
+}
+
+/**
+ * The directory of the package that declares a Go type written bare in
+ * `filePath` (`Controller`, `*Manager`), as Go reads the name: the file's own
+ * package, else a package of the project the file dot-imports that declares
+ * it (harbor's config tests read `Controller` from `. ".../controller/config"`).
+ * Null for an exported name that only a package from outside the project the
+ * file dot-imports can give it (`. "github.com/onsi/gomega"`): no type of the
+ * project's. The file's own package when no package declares the name, as
+ * before: a type the index doesn't hold there, like one a function declares
+ * (ginkgo's `type CompleteSpecContext interface {…}` inside a test), which
+ * hides a dot import's.
+ */
+function goBareTypeDir(name: string, filePath: string, context: ResolutionContext): string | null {
+  const own = goPackageDir(filePath);
+  const dots = goDotImports(filePath, context);
+  if ((dots.dirs.length === 0 && !dots.outside) || goPackageTypes(name, own, context).length > 0) return own;
+  const dir = dots.dirs.find((d) => goPackageTypes(name, d, context).length > 0);
+  if (dir !== undefined) return dir;
+  if (!dots.outside || !/^[A-Z]\w*$/.test(name)) return own;
+  if (!dots.types) {
+    dots.types = new Set();
+    for (const line of context.getFileLines?.(filePath) ?? context.readFile(filePath)?.split(/\r?\n/) ?? []) {
+      for (const m of line.replace(/\/\/.*$/, '').matchAll(/(?:^|[^\w.])type\s+([A-Za-z_]\w*)/g)) dots.types.add(m[1]!);
+    }
+  }
+  return dots.types.has(name) ? own : null;
+}
+
+/**
+ * What a Go embedding written bare (`*Manager`) names when the file's own
+ * package doesn't declare the name: the type of the package the file
+ * dot-imports that does (goBareTypeDir), not another package's namesake name
+ * matching found as near the file, or nothing for a name only a package from
+ * outside the project can give the file. Any other is left as it is.
+ */
+export function goDotImportedSupertype(result: ResolvedRef, ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+  const name = ref.referenceName;
+  if (!/^[A-Za-z_]\w*$/.test(name)) return result;
+  const dir = goBareTypeDir(name, ref.filePath, context);
+  if (dir === goPackageDir(ref.filePath) || goRefQualification(ref, context).written !== undefined) return result;
+  if (dir === null) return null;
+  const target = context.getNodeById?.(result.targetNodeId);
+  if (target && goPackageDir(target.filePath) === dir) return result;
+  return { ...result, targetNodeId: preferCallSiteFile(goPackageTypes(name, dir, context), ref.filePath)[0]!.id };
+}
+
 interface GoQualification {
   /** The package name written before the reference's name, as spelled. */
   written?: string;
@@ -97,12 +174,13 @@ export function goTypePositionTarget(result: ResolvedRef, ref: UnresolvedRef, co
   } else {
     const { written, imported } = goRefQualification(ref, context);
     bare = written === undefined;
-    if (bare) pkgDir = goPackageDir(ref.filePath);
-    else if (imported) pkgDir = context.getGoPackageDir?.(imported.source, ref.filePath) ?? null;
+    if (bare) {
+      pkgDir = goBareTypeDir(name, ref.filePath, context);
+      if (pkgDir === null) return null;
+    } else if (imported) pkgDir = context.getGoPackageDir?.(imported.source, ref.filePath) ?? null;
   }
-  if (pkgDir === '') pkgDir = '.';
   if (isType && (!bare || goPackageDir(target.filePath) === pkgDir)) return result;
-  const types = pkgDir != null ? goPackageTypes(name, pkgDir, context) : [];
+  const types = pkgDir ? goPackageTypes(name, pkgDir, context) : [];
   if (types.length > 0) return { ...result, targetNodeId: preferCallSiteFile(types, ref.filePath)[0]!.id };
   return isType ? result : null;
 }
diff --git a/src/resolution/index.ts b/src/resolution/index.ts
index acf3775df..cb31f61d2 100644
--- a/src/resolution/index.ts
+++ b/src/resolution/index.ts
@@ -32,7 +32,7 @@ import { gateRustScope, clearRustScopeMemos } from './rust-scope';
 import { gateSuperSelfCall } from './super-self';
 import { gatePascalCall } from './pascal-scope';
 import { resurrectRefFromDroppedEdge } from './resurrect-ref';
-import { GO_TYPE_KINDS, isGoBareName, isGoUnknownQualified, goTypePositionTarget } from './go-type-visibility';
+import { GO_TYPE_KINDS, isGoBareName, isGoUnknownQualified, goTypePositionTarget, goDotImportedSupertype } from './go-type-visibility';
 import { ResolverPool, adaptiveEngageEnabled, minRefsForPool, shouldEngageAdaptively } from './resolver-pool';
 import { resolveAliasBinding } from './alias-binding';
 import { detectFrameworksWithSkips, getResolvingFrameworks } from './frameworks';
@@ -3174,9 +3174,14 @@ export class ReferenceResolver {
     }
 
     // An `imports` reference names something importable — never a member that
-    // only exists inside a type.
+    // only exists inside a type, nor its own import statement. A module path
+    // that names no file (`./missing`, `stdio.h`, `pkg.mod`, a C# `using` of
+    // an outside namespace) reaches the statement by its qualified name; as an
+    // edge to itself it is never retried, while a failed ref is retried by the
+    // sync that adds the file it names.
     if (ref.referenceKind === 'imports') {
       const target = this.nodeById(result.targetNodeId);
+      if (target?.kind === 'import' && target.filePath === ref.filePath) return null;
       return target && !isImportableKind(target.kind) ? null : result;
     }
 
@@ -3204,6 +3209,14 @@ export class ReferenceResolver {
       result = { ...result, targetNodeId: type.id };
     }
     if (isBoundToOutOfRepoImport(ref, this.context)) return null;
+    // A Go type embedded through a package (`clientv3.KV`) is that package's.
+    // When the package is none of the file's imports as indexed (clientv3
+    // imported unaliased as `go.etcd.io/etcd/client/v3`), a type found by its
+    // bare name is some other package's namesake.
+    if (ref.language === 'go' && isGoUnknownQualified(ref, this.context)) return null;
+    // One embedded bare that only a package the file dot-imports declares is
+    // that package's, not a namesake as near the file.
+    if (ref.language === 'go') return goDotImportedSupertype(result, ref, this.context);
     return result;
   }
 

From 87b4a3905ecf279298e3ee5bb9e03eb01c1c36db Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Wed, 28 Oct 2026 15:28:52 -0600
Subject: [PATCH 12/30] fix(kernel): resolve Go package-value calls at
 typed-receiver confidence

Upstream's matchGoPackageValueCall resolves at 0.9; the arm inherited
go_method_in_package's 0.85.
---
 codegraph-kernel/src/resolve/go_value.rs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/codegraph-kernel/src/resolve/go_value.rs b/codegraph-kernel/src/resolve/go_value.rs
index cd68028c1..ac5dae18f 100644
--- a/codegraph-kernel/src/resolve/go_value.rs
+++ b/codegraph-kernel/src/resolve/go_value.rs
@@ -199,7 +199,12 @@ impl KernelResolver {
         if self.go_package_types(&name, &pkg_dir)?.is_empty() {
             return Ok(None);
         }
-        Ok(Some(self.go_method_in_package(&name, method, &pkg_dir, r)?))
+        // Upstream resolves the package-value arm at the typed-receiver
+        // confidence, 0.9.
+        Ok(Some(self.go_method_in_package(&name, method, &pkg_dir, r)?.map(|mut c| {
+            c.confidence = 0.9;
+            c
+        })))
     }
 
     /// The type an expression's source text spells (`goReceiverChainType`,

From 0918f20641deaeffe80b1c56a6813555d835a7c9 Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Wed, 28 Oct 2026 15:40:04 -0600
Subject: [PATCH 13/30] feat(kernel): Go element/field/call-result expression
 typing

goElementOf (named slice/map types resolve through their declarations),
goFieldTypeOf (struct field written types), selector-expression and
call-expression result arms in go_expr_written. Param/decl locals the
declaration reader misses fall back to infer_local_receiver_type.
---
 codegraph-kernel/src/resolve/go_value.rs | 190 +++++++++++++++++++++--
 1 file changed, 174 insertions(+), 16 deletions(-)

diff --git a/codegraph-kernel/src/resolve/go_value.rs b/codegraph-kernel/src/resolve/go_value.rs
index ac5dae18f..921fcd576 100644
--- a/codegraph-kernel/src/resolve/go_value.rs
+++ b/codegraph-kernel/src/resolve/go_value.rs
@@ -207,6 +207,111 @@ impl KernelResolver {
         })))
     }
 
+    /// The text after the name in a Go type declaration's node span —
+    /// `[]Item` of `type Items []Item`, `B` of `type A = B`.
+    fn go_type_decl_rhs(&mut self, node: &KNode) -> Option<String> {
+        let lines = self.read_file(&node.file_path)?;
+        let decl = lines.iter()
+            .skip((node.start_line - 1).max(0) as usize)
+            .take((node.end_line - node.start_line + 1).max(0) as usize)
+            .enumerate()
+            .map(|(i, l)| {
+                let s = if i == 0 { &l[node.start_column.max(0) as usize..] } else { l.as_str() };
+                strip_line_comments(s).to_string()
+            })
+            .collect::<Vec<_>>()
+            .join(" ");
+        let decl = re!(r"/\*.*?\*/").replace_all(&decl, "");
+        let m = re!(r"^\s*[A-Za-z_]\w*\s*(?:\[[^\]]*\])?\s*(?:=\s*)?(\S.*)$").captures(&decl)?;
+        Some(m[1].trim().trim_end_matches(';').trim().to_string()).filter(|s| !s.is_empty())
+    }
+
+    /// goElementOf (name-matcher.ts): the element one `x[i]` on a value of
+    /// type `written` gives — `T` of `[]T`/`[N]T`, `V` of `map[K]V`, and of
+    /// a named type what its declaration's element gives. Returns the
+    /// element's written text and the file it is read in.
+    fn go_element_of(&mut self, written: &str, file: &str, depth: u8) -> Res<Option<(String, String)>> {
+        if depth > 4 {
+            return Ok(None);
+        }
+        let text = written.trim().trim_start_matches('*').trim_start().to_string();
+        if let Some(rest) = text.strip_prefix("map[") {
+            return Ok(rest.find(']').map(|p| (rest[p + 1..].trim().to_string(), file.to_string())));
+        }
+        if text.starts_with('[') {
+            return Ok(text.find(']').map(|p| (text[p + 1..].trim().to_string(), file.to_string())));
+        }
+        let Some(named) = Self::go_named_type(&text) else { return Ok(None) };
+        let (name, dir) = match named.find('.') {
+            Some(p) => match self.go_imported_package_dir(file, &named[..p])? {
+                Some(d) => (named[p + 1..].to_string(), d),
+                None => return Ok(None),
+            },
+            None => {
+                if GO_BUILTIN_FIELD_TYPES.contains(named.as_str()) {
+                    return Ok(None);
+                }
+                match self.go_bare_type_dir(&named, file)? {
+                    Some(d) => (named.clone(), d),
+                    None => return Ok(None),
+                }
+            }
+        };
+        for decl in self.go_package_types(&name, &dir)? {
+            if let Some(rhs) = self.go_type_decl_rhs(&decl) {
+                if rhs != text
+                    && (rhs.starts_with('[')
+                        || rhs.starts_with("map[")
+                        || rhs.starts_with('*')
+                        || Self::go_named_type(&rhs).is_some())
+                {
+                    return self.go_element_of(&rhs, &decl.file_path, depth + 1);
+                }
+            }
+        }
+        Ok(None)
+    }
+
+    /// goFieldTypeOf (name-matcher.ts): the type `field` of the Go struct
+    /// `type_name` in `dir` is declared with — the written text, read in the
+    /// struct's own file.
+    fn go_field_type(&mut self, type_name: &str, field: &str, dir: &str) -> Res<Option<(String, String)>> {
+        static FIELD_OF: LazyLock<Affix> = LazyLock::new(|| {
+            Affix::new("", r"\s+(\*?(?:map\[[^\]]+\])?\[?\]?\s*[A-Za-z_][A-Za-z0-9_.]*(?:\[[^\]]*\])?)", true, false, false)
+        });
+        for s in self.go_package_types(type_name, dir)?.iter().filter(|n| n.kind == "struct") {
+            let Some(source) = self.read_file(&s.file_path) else { continue };
+            let start = (s.start_line - 1).max(0) as usize;
+            let end = (s.end_line as usize).min(source.len());
+            for raw in source.get(start..end).unwrap_or_default() {
+                let line = strip_line_comments(raw);
+                if let Some(t) = FIELD_OF.capture(&line, field) {
+                    return Ok(Some((t.trim().to_string(), s.file_path.clone())));
+                }
+            }
+        }
+        Ok(None)
+    }
+
+    /// The first result of a Go call's callee — `*Session` of
+    /// `func New() (*Session, error)`, from its `return_type` or the tail of
+    /// its signature.
+    fn go_call_result(&self, callee: &KNode) -> Option<String> {
+        let raw = callee.return_type.clone().or_else(|| {
+            let s = callee.signature.as_deref()?;
+            let close = s.match_indices(')').map(|(i, _)| i).next_back()?;
+            Some(s[close + 1..].trim().trim_end_matches('{').trim().to_string())
+        })?;
+        let raw = raw.trim();
+        if raw.is_empty() || raw == "error" {
+            return None;
+        }
+        // `(T, error)` and `[]T`/`T` alike reduce to the first result.
+        let inner = raw.strip_prefix('(').and_then(|s| s.strip_suffix(')')).unwrap_or(raw);
+        let first = inner.split(',').next()?.trim();
+        Some(first.to_string()).filter(|s| !s.is_empty() && s != "error")
+    }
+
     /// The type an expression's source text spells (`goReceiverChainType`,
     /// tree-native): `(written, file)`. `None` is unreadable — the other
     /// strategies decide.
@@ -228,8 +333,16 @@ impl KernelResolver {
                     if let Some(w) = self.go_asserted_local_type(&name, r) {
                         return Ok(Some((w, file)));
                     }
+                    if let Some(t) = self.infer_local_receiver_type(&name, r, true)? {
+                        return Ok(Some((t, file)));
+                    }
                     return Ok(None);
                 }
+                // A parameter or `:=` local the declaration reader missed —
+                // the bound-receiver inference still types it.
+                if let Some(t) = self.infer_local_receiver_type(&name, r, true)? {
+                    return Ok(Some((t, file)));
+                }
                 for n in self.nodes_by_name(&name)?.iter().filter(|n| {
                     n.language == "go"
                         && matches!(n.kind.as_str(), "variable" | "constant")
@@ -243,27 +356,33 @@ impl KernelResolver {
             }
             "index_expression" | "slice_expression" => {
                 let Some(operand) = expr.child_by_field_name("operand") else { return Ok(None); };
-                let Some((mut text, at)) = self.go_expr_written(operand, file_text, r)? else {
+                let Some((text, at)) = self.go_expr_written(operand, file_text, r)? else {
                     return Ok(None);
                 };
-                // `x[i]` on `[]T`, `[N]T`, `map[K]V` or `*[N]T` gives T / V.
-                while let Some(rest) = text.strip_prefix('*') {
-                    text = rest.trim_start().to_string();
+                self.go_element_of(&text, &at, 0)
+            }
+            "selector_expression" => {
+                let (Some(op), Some(field)) =
+                    (expr.child_by_field_name("operand"), expr.child_by_field_name("field"))
+                else {
+                    return Ok(None);
+                };
+                if op.kind() != "identifier" {
+                    return Ok(None);
                 }
-                let text = text.trim_start().to_string();
-                if let Some(rest) = text.strip_prefix("map[") {
-                    return Ok(match rest.find(']') {
-                        Some(p) => Some((rest[p + 1..].trim().to_string(), at)),
-                        None => None,
-                    });
+                let base = file_text[op.byte_range()].to_string();
+                let field = file_text[field.byte_range()].to_string();
+                // `pkg.Name` — a qualified type, not a field read.
+                if self.go_imported_package_dir(&file, &base)?.is_some() {
+                    return Ok(Some((format!("{base}.{field}"), file)));
                 }
-                if !text.starts_with('[') {
+                let Some(base_ty) = self.infer_local_receiver_type(&base, r, true)? else {
                     return Ok(None);
-                }
-                Ok(match text.find(']') {
-                    Some(p) => Some((text[p + 1..].trim().to_string(), at)),
-                    None => None,
-                })
+                };
+                let Some((tn, dir)) = self.go_type_package(&base_ty, &file)? else {
+                    return Ok(None);
+                };
+                self.go_field_type(&tn, &field, &dir)
             }
             "type_assertion_expression" => Ok(expr
                 .child_by_field_name("type")
@@ -311,7 +430,46 @@ impl KernelResolver {
                                 if !self.go_package_types(callee, &d)?.is_empty() {
                                     return Ok(Some((format!("{q}.{callee}"), file)));
                                 }
+                                // `pkg.F(…)` — F's first result.
+                                for f in self.nodes_by_name(callee)?.iter().filter(|n| {
+                                    n.language == "go" && n.kind == "function" && pos_dirname(&n.file_path) == d
+                                }) {
+                                    if let Some(t) = self.go_call_result(f) {
+                                        return Ok(Some((t, f.file_path.clone())));
+                                    }
+                                }
+                                return Ok(None);
+                            }
+                            // `m.F(…)` — F's first result, on m's type.
+                            let Some(base_ty) = self.infer_local_receiver_type(q, r, true)? else {
+                                return Ok(None);
+                            };
+                            let Some((tn, dir)) = self.go_type_package(&base_ty, &file)? else {
+                                return Ok(None);
+                            };
+                            for f in self.nodes_by_name(callee)?.iter().filter(|n| {
+                                n.language == "go"
+                                    && n.kind == "method"
+                                    && pos_dirname(&n.file_path) == dir
+                                    && n.qualified_name.contains(&format!("::{tn}"))
+                            }) {
+                                if let Some(t) = self.go_call_result(f) {
+                                    return Ok(Some((t, f.file_path.clone())));
+                                }
                             }
+                            return Ok(None);
+                        }
+                    }
+                }
+                // `f(…)` on a project function — its first result.
+                if function.kind() == "identifier" {
+                    let callee = &file_text[function.byte_range()];
+                    let own = pos_dirname(&file);
+                    for f in self.nodes_by_name(callee)?.iter().filter(|n| {
+                        n.language == "go" && n.kind == "function" && pos_dirname(&n.file_path) == own
+                    }) {
+                        if let Some(t) = self.go_call_result(f) {
+                            return Ok(Some((t, f.file_path.clone())));
                         }
                     }
                 }

From 05909c1c77ac67e2eea52ab2d56cccd55f27b819 Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Wed, 28 Oct 2026 18:24:51 -0600
Subject: [PATCH 14/30] feat(kernel): Go chained/generic receivers, range
 elements, unread-file methods

---
 __tests__/fixtures/golden/payroll-go.dump     |  22 +-
 __tests__/fixtures/golden/tail-langs.dump     |   2 +-
 .../fixtures/golden/torture-multilang.dump    |  36 +-
 codegraph-kernel/src/resolve/fields.rs        |  15 +-
 codegraph-kernel/src/resolve/go_asserted.rs   |  19 +-
 codegraph-kernel/src/resolve/go_value.rs      | 616 +++++++++++++++---
 codegraph-kernel/src/resolve/method_call.rs   | 105 ++-
 codegraph-kernel/src/resolve/mod.rs           |   3 +
 codegraph-kernel/src/resolve/pipeline.rs      |   6 -
 codegraph-kernel/src/resolve/receivers.rs     |  13 +-
 .../src/resolve/resolver_upstream.rs          |  21 +-
 11 files changed, 701 insertions(+), 157 deletions(-)

diff --git a/__tests__/fixtures/golden/payroll-go.dump b/__tests__/fixtures/golden/payroll-go.dump
index 968514cc3..947aac69b 100644
--- a/__tests__/fixtures/golden/payroll-go.dump
+++ b/__tests__/fixtures/golden/payroll-go.dump
@@ -312,7 +312,7 @@
 {"id":"variable:6b7bef84822056845bdabeb41a821f0a","kind":"variable","name":"ErrCycleClosed","qualified_name":"ErrCycleClosed","file_path":"internal/usecase/payroll/cycle.go","language":"go","start_line":16,"end_line":16,"start_column":4,"end_column":58,"docstring":"ErrCycleClosed is returned when a cycle has already been finalized.","signature":"= errors.New(\"payroll cycle is closed\")","visibility":null,"is_exported":1,"is_async":0,"is_static":0,"is_abstract":0,"decorators":null,"type_parameters":null,"return_type":null}
 {"id":"variable:9c3a0c9681a69504be5d3af6ddb5378c","kind":"variable","name":"file_payroll_v1_payroll_proto_goTypes","qualified_name":"file_payroll_v1_payroll_proto_goTypes","file_path":"internal/gen/payrollpb/payroll.pb.go","language":"go","start_line":132,"end_line":137,"start_column":4,"end_column":1,"docstring":null,"signature":"= []any{\n\t(*RunPayrollCycleRequest)(nil),\n\t(*RunPayrollCycleResponse)(nil),\n\t(*Payslip)(nil),\n\t(*Payro...","visibility":null,"is_exported":0,"is_async":0,"is_static":0,"is_abstract":0,"decorators":null,"type_parameters":null,"return_type":null}
 {"id":"variable:baa4aee814b380ae99f1b1829407b106","kind":"variable","name":"ErrNoEmployees","qualified_name":"ErrNoEmployees","file_path":"internal/usecase/payroll/cycle.go","language":"go","start_line":19,"end_line":19,"start_column":4,"end_column":72,"docstring":"ErrNoEmployees is returned when a cycle resolves to an empty roster.","signature":"= errors.New(\"payroll cycle has no active employees\")","visibility":null,"is_exported":1,"is_async":0,"is_static":0,"is_abstract":0,"decorators":null,"type_parameters":null,"return_type":null}
-== edges (657)
+== edges (656)
 {"source":"file:69f63e0581b8138f256b63d2aac60e8a","target":"module:1be454da0953954aef45c525ee8f8b51","kind":"contains","metadata":null,"line":null,"col":null,"provenance":"heuristic"}
 {"source":"file:cmd/payrolld/main.go","target":"function:90eb51f51a3d9a397d4a53f26f2019aa","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"file:cmd/payrolld/main.go","target":"import:0a9ee69fa4c64208200c3bebcbbf0b75","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
@@ -572,8 +572,8 @@
 {"source":"function:0ae098aebe4dbe9d71e324db178702ba","target":"struct:19321b921e8669d1052268136951cb96","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"PayrollCycleRow\"}","line":52,"col":100,"provenance":null}
 {"source":"function:0ae098aebe4dbe9d71e324db178702ba","target":"struct:a7849e2411e6cccc2a1da578922c7004","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"PayrollCycleUpdateRequest\"}","line":52,"col":72,"provenance":null}
 {"source":"function:0e6d6dd34d39c0ac54c9a7084b8d8ca8","target":"struct:44ba5408fc435805ad63b792fae78895","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"EmployeeRow\"}","line":84,"col":33,"provenance":null}
-{"source":"function:0f4c51f6d4475eb21570beb83cf54ff4","target":"struct:13bfc2acbe1de6557e9a28c0be484ffa","kind":"instantiates","metadata":"{\"framework\":\"go\",\"confidence\":0.8,\"resolvedBy\":\"framework\",\"refName\":\"Store\"}","line":19,"col":43,"provenance":null}
-{"source":"function:0f4c51f6d4475eb21570beb83cf54ff4","target":"struct:13bfc2acbe1de6557e9a28c0be484ffa","kind":"references","metadata":"{\"framework\":\"go\",\"confidence\":0.8,\"resolvedBy\":\"framework\",\"refName\":\"Store\"}","line":19,"col":27,"provenance":null}
+{"source":"function:0f4c51f6d4475eb21570beb83cf54ff4","target":"struct:13bfc2acbe1de6557e9a28c0be484ffa","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Store\"}","line":19,"col":43,"provenance":null}
+{"source":"function:0f4c51f6d4475eb21570beb83cf54ff4","target":"struct:13bfc2acbe1de6557e9a28c0be484ffa","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Store\"}","line":19,"col":27,"provenance":null}
 {"source":"function:13c7c9632913a7b5c4cb3853ae46f74a","target":"function:d82ab6b26c7b41b587b8d940d1c57034","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"scanPayslip\"}","line":71,"col":8,"provenance":null}
 {"source":"function:13c7c9632913a7b5c4cb3853ae46f74a","target":"struct:6c93a0c367bc4b0f4392bc71266af6f6","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"PayslipUpdateRequest\"}","line":65,"col":67,"provenance":null}
 {"source":"function:13c7c9632913a7b5c4cb3853ae46f74a","target":"struct:eed7116b6261c410c79b06f6b3a3aebe","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"PayslipRow\"}","line":65,"col":90,"provenance":null}
@@ -635,8 +635,8 @@
 {"source":"function:97d5bc1460c9dc0379c4c2016964d601","target":"struct:141301eeb403e252d3f06decd0665c41","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"TimesheetRow\"}","line":71,"col":34,"provenance":null}
 {"source":"function:9a1275209a1a60e56b21de5aba04f222","target":"function:d82ab6b26c7b41b587b8d940d1c57034","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"scanPayslip\"}","line":61,"col":8,"provenance":null}
 {"source":"function:9a1275209a1a60e56b21de5aba04f222","target":"struct:eed7116b6261c410c79b06f6b3a3aebe","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"PayslipRow\"}","line":59,"col":61,"provenance":null}
-{"source":"function:a2d9b9035f29c64480f1644da96bc32f","target":"struct:33239c589ef83d64d5f6e73c2e021ee6","kind":"instantiates","metadata":"{\"framework\":\"go\",\"confidence\":0.8,\"resolvedBy\":\"framework\",\"refName\":\"Store\"}","line":23,"col":9,"provenance":null}
-{"source":"function:a2d9b9035f29c64480f1644da96bc32f","target":"struct:33239c589ef83d64d5f6e73c2e021ee6","kind":"references","metadata":"{\"framework\":\"go\",\"confidence\":0.8,\"resolvedBy\":\"framework\",\"refName\":\"Store\"}","line":22,"col":12,"provenance":null}
+{"source":"function:a2d9b9035f29c64480f1644da96bc32f","target":"struct:33239c589ef83d64d5f6e73c2e021ee6","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Store\"}","line":23,"col":9,"provenance":null}
+{"source":"function:a2d9b9035f29c64480f1644da96bc32f","target":"struct:33239c589ef83d64d5f6e73c2e021ee6","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Store\"}","line":22,"col":12,"provenance":null}
 {"source":"function:b11ab260a99f087321b978dfbbcbccbb","target":"function:680f46cf762a57779b8a8dbe6de8c989","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"scanContract\"}","line":49,"col":8,"provenance":null}
 {"source":"function:b11ab260a99f087321b978dfbbcbccbb","target":"struct:8ae9f91523a30c90667e8f5ba09c3fc1","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"ContractRow\"}","line":47,"col":62,"provenance":null}
 {"source":"function:b3b725a56ce5377ac34ef157db4d1170","target":"struct:416d70a4ba3bd67a9d4b7114f2abd3a6","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"PayslipDTO\"}","line":40,"col":8,"provenance":null}
@@ -672,7 +672,6 @@
 {"source":"interface:9382b4b7c3b120f81bd0566fb2d74864","target":"method:4df364d0c37da3d10e39207b87a94ca8","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"interface:9382b4b7c3b120f81bd0566fb2d74864","target":"method:a235478f8389c36b95d45a62664c4557","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"interface:a2c04a6e9d1203f224eb044d73e38f03","target":"method:d73f595573e869571a14f1606df5c296","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
-{"source":"method:01c8a961c1fdfb54ea0c32614f905acc","target":"method:1b4f96e5a5a8b2784487acc4f7134ff7","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"instance-method\",\"refName\":\"e.UnpaidLeaveCoversWindow\"}","line":155,"col":5,"provenance":null}
 {"source":"method:01c8a961c1fdfb54ea0c32614f905acc","target":"method:75bdf0b5152e4d85c947a608505c15c1","kind":"calls","metadata":"{\"confidence\":0.85,\"resolvedBy\":\"instance-method\",\"refName\":\"s.store.EmployeesForCycle\"}","line":137,"col":13,"provenance":null}
 {"source":"method:01c8a961c1fdfb54ea0c32614f905acc","target":"struct:4831ac24c172065fee6e46751021f7ba","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"import\",\"refName\":\"Cycle\"}","line":136,"col":63,"provenance":null}
 {"source":"method:01c8a961c1fdfb54ea0c32614f905acc","target":"struct:62563918fc7ed271ca7e2c7b11f2c17a","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"import\",\"refName\":\"Employee\"}","line":136,"col":98,"provenance":null}
@@ -690,7 +689,7 @@
 {"source":"method:18a9696cad4179d634834650c0684f0c","target":"struct:e66f442bcf28c3bd0a3f42fbacb69b2a","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"RunPayrollCycleResponse\"}","line":37,"col":123,"provenance":null}
 {"source":"method:24e3292f2546abebcb9d371572f38e20","target":"struct:f1c05936f2b11591d1f90efa9d981fa7","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"import\",\"refName\":\"Payslip\"}","line":50,"col":76,"provenance":null}
 {"source":"method:2eb01c123ced28db3096d2168949061f","target":"method:412163f69abf5ae22adf9b9141ba79e2","kind":"calls","metadata":"{\"synthesizedBy\":\"interface-impl\",\"via\":\"mustEmbedUnimplementedPayrollServiceServer\",\"registeredAt\":\"internal/gen/payrollpb/payroll_grpc.pb.go:87\"}","line":69,"col":null,"provenance":"heuristic"}
-{"source":"method:3367319bda79cdcf1fefc366ce7322ac","target":"struct:d541b867b240edf388feab5ff2002afd","kind":"instantiates","metadata":"{\"framework\":\"go\",\"confidence\":0.7,\"resolvedBy\":\"framework\",\"refName\":\"Payslip\"}","line":102,"col":41,"provenance":null}
+{"source":"method:3367319bda79cdcf1fefc366ce7322ac","target":"struct:d541b867b240edf388feab5ff2002afd","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Payslip\"}","line":102,"col":41,"provenance":null}
 {"source":"method:3708105303f9a5feb2601fa8f3fe731e","target":"function:5e2796c1fbc4081e6b6f6a4307fe4bc0","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"key\"}","line":45,"col":12,"provenance":null}
 {"source":"method:3708105303f9a5feb2601fa8f3fe731e","target":"struct:f1c05936f2b11591d1f90efa9d981fa7","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"import\",\"refName\":\"Payslip\"}","line":36,"col":57,"provenance":null}
 {"source":"method:3af34007f72fd40aebe0e4504e8228ae","target":"method:24e3292f2546abebcb9d371572f38e20","kind":"calls","metadata":"{\"confidence\":0.85,\"resolvedBy\":\"instance-method\",\"refName\":\"s.store.ListByCycle\"}","line":206,"col":15,"provenance":null}
@@ -724,7 +723,7 @@
 {"source":"method:4df364d0c37da3d10e39207b87a94ca8","target":"method:b90cd7088a55c9068e12a8120b256e13","kind":"calls","metadata":"{\"synthesizedBy\":\"interface-impl\",\"via\":\"RunPayrollCycle\",\"registeredAt\":\"internal/gen/payrollpb/payroll_grpc.pb.go:75\"}","line":66,"col":null,"provenance":"heuristic"}
 {"source":"method:4df364d0c37da3d10e39207b87a94ca8","target":"struct:4325013490f7f7a77604146f5e38c292","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"RunPayrollCycleRequest\"}","line":66,"col":35,"provenance":null}
 {"source":"method:4df364d0c37da3d10e39207b87a94ca8","target":"struct:e66f442bcf28c3bd0a3f42fbacb69b2a","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"RunPayrollCycleResponse\"}","line":66,"col":61,"provenance":null}
-{"source":"method:4f0ac2154c360ad1c55284c03d1f0c73","target":"struct:13bfc2acbe1de6557e9a28c0be484ffa","kind":"references","metadata":"{\"framework\":\"go\",\"confidence\":0.8,\"resolvedBy\":\"framework\",\"refName\":\"Store\"}","line":85,"col":49,"provenance":null}
+{"source":"method:4f0ac2154c360ad1c55284c03d1f0c73","target":"struct:13bfc2acbe1de6557e9a28c0be484ffa","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Store\"}","line":85,"col":49,"provenance":null}
 {"source":"method:4f57884a5e57e13884848a959e466e9d","target":"function:63f3bd99966467470cbabcb097ad36dd","kind":"calls","metadata":"{\"confidence\":0.7,\"resolvedBy\":\"exact-match\",\"refName\":\"ListPayslipsByCycle\"}","line":66,"col":8,"provenance":null}
 {"source":"method:4f57884a5e57e13884848a959e466e9d","target":"struct:eed7116b6261c410c79b06f6b3a3aebe","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"PayslipRow\"}","line":65,"col":76,"provenance":null}
 {"source":"method:578c07e761ce9e31fb80ec2ae5ee7713","target":"struct:4325013490f7f7a77604146f5e38c292","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"RunPayrollCycleRequest\"}","line":47,"col":56,"provenance":null}
@@ -824,7 +823,7 @@
 {"source":"method:e5d8405d7063593214cc4d16d2bbec81","target":"struct:4831ac24c172065fee6e46751021f7ba","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"import\",\"refName\":\"payroll.Cycle\"}","line":67,"col":9,"provenance":null}
 {"source":"method:e5d8405d7063593214cc4d16d2bbec81","target":"struct:4831ac24c172065fee6e46751021f7ba","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"import\",\"refName\":\"payroll.Cycle\"}","line":73,"col":9,"provenance":null}
 {"source":"method:e5d8405d7063593214cc4d16d2bbec81","target":"struct:4831ac24c172065fee6e46751021f7ba","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"import\",\"refName\":\"Cycle\"}","line":65,"col":68,"provenance":null}
-{"source":"method:eba91430ad280a0c070af5c64e79d2d0","target":"struct:d541b867b240edf388feab5ff2002afd","kind":"references","metadata":"{\"framework\":\"go\",\"confidence\":0.7,\"resolvedBy\":\"framework\",\"refName\":\"Payslip\"}","line":62,"col":51,"provenance":null}
+{"source":"method:eba91430ad280a0c070af5c64e79d2d0","target":"struct:d541b867b240edf388feab5ff2002afd","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Payslip\"}","line":62,"col":51,"provenance":null}
 {"source":"method:ed702f7226c3efff6b07f6f5afd73bf8","target":"method:59c25996edd43745355454c918ca737d","kind":"calls","metadata":"{\"confidence\":0.85,\"resolvedBy\":\"instance-method\",\"refName\":\"s.store.SaveCycle\"}","line":196,"col":8,"provenance":null}
 {"source":"method:ed702f7226c3efff6b07f6f5afd73bf8","target":"struct:4831ac24c172065fee6e46751021f7ba","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"import\",\"refName\":\"Cycle\"}","line":193,"col":64,"provenance":null}
 {"source":"method:ee60f0f8c18e9fd703205c637e5b5f8d","target":"function:c68d01c236174f79631f8e8222523fa4","kind":"calls","metadata":"{\"confidence\":0.7,\"resolvedBy\":\"exact-match\",\"refName\":\"ListPayrollCycles\"}","line":81,"col":8,"provenance":null}
@@ -962,7 +961,7 @@
 {"source":"struct:e66f442bcf28c3bd0a3f42fbacb69b2a","target":"method:2f3ad781c22d07dedb06b0a2f536ba18","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"struct:e66f442bcf28c3bd0a3f42fbacb69b2a","target":"method:3f9811f3a17dc661bfba3de069234279","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"struct:e66f442bcf28c3bd0a3f42fbacb69b2a","target":"method:eba91430ad280a0c070af5c64e79d2d0","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
-{"source":"struct:e66f442bcf28c3bd0a3f42fbacb69b2a","target":"struct:d541b867b240edf388feab5ff2002afd","kind":"references","metadata":"{\"framework\":\"go\",\"confidence\":0.7,\"resolvedBy\":\"framework\",\"refName\":\"Payslip\"}","line":57,"col":15,"provenance":null}
+{"source":"struct:e66f442bcf28c3bd0a3f42fbacb69b2a","target":"struct:d541b867b240edf388feab5ff2002afd","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Payslip\"}","line":57,"col":15,"provenance":null}
 {"source":"struct:f1c05936f2b11591d1f90efa9d981fa7","target":"struct:51160f165aa24865c9ffd701638e08de","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Line\"}","line":53,"col":18,"provenance":null}
 {"source":"struct:f221a626c8918bb65aeb52f4f2641203","target":"method:dd6580e3209a7f4efedb099a9bd5576d","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"variable:02a9b4868be4f999189e4d930af29b95","target":"interface:9382b4b7c3b120f81bd0566fb2d74864","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"PayrollServiceServer\",\"refKind\":\"calls\"}","line":97,"col":14,"provenance":null}
@@ -970,7 +969,7 @@
 {"source":"variable:9c3a0c9681a69504be5d3af6ddb5378c","target":"struct:4325013490f7f7a77604146f5e38c292","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"RunPayrollCycleRequest\",\"refKind\":\"calls\"}","line":133,"col":1,"provenance":null}
 {"source":"variable:9c3a0c9681a69504be5d3af6ddb5378c","target":"struct:d541b867b240edf388feab5ff2002afd","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Payslip\",\"refKind\":\"calls\"}","line":135,"col":1,"provenance":null}
 {"source":"variable:9c3a0c9681a69504be5d3af6ddb5378c","target":"struct:e66f442bcf28c3bd0a3f42fbacb69b2a","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"RunPayrollCycleResponse\",\"refKind\":\"calls\"}","line":134,"col":1,"provenance":null}
-== refs (599)
+== refs (600)
 {"from_node_id":"file:cmd/payrolld/main.go","reference_name":"github.com/example/payroll-svc/internal/platform/clock","reference_kind":"imports","line":9,"col":1,"candidates":null,"file_path":"cmd/payrolld/main.go","language":"go","status":"failed","name_tail":"clock"}
 {"from_node_id":"file:cmd/payrolld/main.go","reference_name":"github.com/example/payroll-svc/internal/store/payslipstore","reference_kind":"imports","line":10,"col":1,"candidates":null,"file_path":"cmd/payrolld/main.go","language":"go","status":"failed","name_tail":"payslipstore"}
 {"from_node_id":"file:cmd/payrolld/main.go","reference_name":"github.com/example/payroll-svc/internal/transport/httpapi","reference_kind":"imports","line":11,"col":1,"candidates":null,"file_path":"cmd/payrolld/main.go","language":"go","status":"failed","name_tail":"httpapi"}
@@ -1273,6 +1272,7 @@
 {"from_node_id":"method:01c8a961c1fdfb54ea0c32614f905acc","reference_name":"cycle.ID","reference_kind":"function_ref","line":137,"col":50,"candidates":null,"file_path":"internal/usecase/payroll/cycle.go","language":"go","status":"failed","name_tail":"ID"}
 {"from_node_id":"method:01c8a961c1fdfb54ea0c32614f905acc","reference_name":"cycle.Start","reference_kind":"function_ref","line":152,"col":38,"candidates":null,"file_path":"internal/usecase/payroll/cycle.go","language":"go","status":"failed","name_tail":"Start"}
 {"from_node_id":"method:01c8a961c1fdfb54ea0c32614f905acc","reference_name":"e.Contract.OverlapsWindow","reference_kind":"calls","line":152,"col":6,"candidates":null,"file_path":"internal/usecase/payroll/cycle.go","language":"go","status":"failed","name_tail":"OverlapsWindow","failure_reason":"unknown-receiver"}
+{"from_node_id":"method:01c8a961c1fdfb54ea0c32614f905acc","reference_name":"e.UnpaidLeaveCoversWindow","reference_kind":"calls","line":155,"col":5,"candidates":null,"file_path":"internal/usecase/payroll/cycle.go","language":"go","status":"failed","name_tail":"UnpaidLeaveCoversWindow","failure_reason":"unknown-receiver"}
 {"from_node_id":"method:01c8a961c1fdfb54ea0c32614f905acc","reference_name":"len","reference_kind":"calls","line":147,"col":39,"candidates":null,"file_path":"internal/usecase/payroll/cycle.go","language":"go","status":"failed","name_tail":"len"}
 {"from_node_id":"method:01c8a961c1fdfb54ea0c32614f905acc","reference_name":"len","reference_kind":"calls","line":149,"col":5,"candidates":null,"file_path":"internal/usecase/payroll/cycle.go","language":"go","status":"failed","name_tail":"len"}
 {"from_node_id":"method:01c8a961c1fdfb54ea0c32614f905acc","reference_name":"make","reference_kind":"calls","line":147,"col":11,"candidates":null,"file_path":"internal/usecase/payroll/cycle.go","language":"go","status":"failed","name_tail":"make"}
diff --git a/__tests__/fixtures/golden/tail-langs.dump b/__tests__/fixtures/golden/tail-langs.dump
index 0aa85d678..14f19a41a 100644
--- a/__tests__/fixtures/golden/tail-langs.dump
+++ b/__tests__/fixtures/golden/tail-langs.dump
@@ -263,7 +263,7 @@
 {"source":"method:3e8f1a96504ba0922e3ea15fd67c3af7","target":"method:834675ad82e7c76b57d6b7dbd9c4d007","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"_upper\"}","line":14,"col":68,"provenance":null}
 {"source":"method:6371e3682b7f64f04708b1f642de336e","target":"method:1b92f98530b02ea1c9bfb4530bca5eb7","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"capitalize\"}","line":8,"col":48,"provenance":null}
 {"source":"method:6371e3682b7f64f04708b1f642de336e","target":"method:88abbd176ab3dd1c582009f2f0c8c792","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"logIt\"}","line":9,"col":8,"provenance":null}
-{"source":"method:bab15b615c718a99979e32483e78a2bd","target":"class:8f245e11bfe6a3d101a39ded206566ec","kind":"references","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"Greeter\"}","line":14,"col":39,"provenance":null}
+{"source":"method:bab15b615c718a99979e32483e78a2bd","target":"class:8f245e11bfe6a3d101a39ded206566ec","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Greeter\"}","line":14,"col":39,"provenance":null}
 {"source":"method:bab15b615c718a99979e32483e78a2bd","target":"method:8c9db773f13cb8c0e5a0498432ebc819","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"initWithName:\"}","line":14,"col":37,"provenance":null}
 {"source":"method:bce8c6cce85fec8bd2df9223eaf629de","target":"method:7021a8a0ecfa8d21106abcf10c74a4d3","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"onlyOwner\"}","line":7,"col":52,"provenance":null}
 {"source":"method:c43ae451b29e35763223fd3a5fd1ae22","target":"class:5ed1a9fbfc5fad495850f0cc6ac2970c","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Greeter\"}","line":23,"col":19,"provenance":null}
diff --git a/__tests__/fixtures/golden/torture-multilang.dump b/__tests__/fixtures/golden/torture-multilang.dump
index af86bd28e..53b8bf008 100644
--- a/__tests__/fixtures/golden/torture-multilang.dump
+++ b/__tests__/fixtures/golden/torture-multilang.dump
@@ -2040,7 +2040,7 @@
 {"source":"class:129f932b07791059905bc786775e5dff","target":"method:846b59388a77b469427475c32a0d11a3","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:12b0fc1a5b8916f4876df49d6cd78ad7","target":"method:2482c6a39c7a71c514ac4eda10980efa","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:12b8092ee33506020a2ef69ffb0c942f","target":"method:f93cac5b4e9fd958cce4400d8a1fb21a","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
-{"source":"class:184d52a70ca25ab02246ba53448afd84","target":"trait:09af11c47861285a512e31fce265f12b","kind":"extends","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"Shape\"}","line":88,"col":21,"provenance":null}
+{"source":"class:184d52a70ca25ab02246ba53448afd84","target":"trait:09af11c47861285a512e31fce265f12b","kind":"extends","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Shape\"}","line":88,"col":21,"provenance":null}
 {"source":"class:185f6260a8d5b738c53be0accb2a4e19","target":"method:2ea1f4137a11a0863dc001320a6553d4","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:185f6260a8d5b738c53be0accb2a4e19","target":"method:56abbc29e06f18840ab8e081a5955345","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:185f6260a8d5b738c53be0accb2a4e19","target":"method:7e714128b5b3c81a4e4f571a142197ba","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
@@ -2127,7 +2127,7 @@
 {"source":"class:326854f65c2a15980f69f2865639f179","target":"variable:6adfcec1106f14a610956b32cf60e621","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:339d61243e19865bc9a1abb1bf086ced","target":"class:51e8dab5c341254b6e69fea52526cec0","kind":"extends","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"SealedOp\"}","line":121,"col":33,"provenance":null}
 {"source":"class:341082c7a6943c8178f54be340ac5776","target":"class:02b8749f9f3f54ac2e63b9af5107cd67","kind":"extends","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"OpenBase\"}","line":103,"col":21,"provenance":null}
-{"source":"class:341082c7a6943c8178f54be340ac5776","target":"interface:c81d5cab63db22eb6f15b7c2253d937e","kind":"implements","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"Drawable\",\"refKind\":\"extends\"}","line":103,"col":34,"provenance":null}
+{"source":"class:341082c7a6943c8178f54be340ac5776","target":"interface:c81d5cab63db22eb6f15b7c2253d937e","kind":"implements","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Drawable\",\"refKind\":\"extends\"}","line":103,"col":34,"provenance":null}
 {"source":"class:341082c7a6943c8178f54be340ac5776","target":"method:45a51bb86d639c728b97972d1987b72b","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:341082c7a6943c8178f54be340ac5776","target":"method:6f5a2fd43f38fbf52acfdb0b84cb3b93","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:341082c7a6943c8178f54be340ac5776","target":"method:d0c57c6f9abd19cc5263f4b1c36ba5c9","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
@@ -2165,7 +2165,7 @@
 {"source":"class:4bd83cdfb5b8540fad90ce018af02e21","target":"constant:b3b1efa0122809a96522516575f0cccb","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:4bd83cdfb5b8540fad90ce018af02e21","target":"field:32f596742e8806ab7d3138e43bb9b86b","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:4bd83cdfb5b8540fad90ce018af02e21","target":"field:530469f189a3fea0785da07779d01767","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
-{"source":"class:4bd83cdfb5b8540fad90ce018af02e21","target":"method:5eb14184151e0e35d5705df793db77a4","kind":"calls","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"isReady\"}","line":14,"col":23,"provenance":null}
+{"source":"class:4bd83cdfb5b8540fad90ce018af02e21","target":"method:5eb14184151e0e35d5705df793db77a4","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"isReady\"}","line":14,"col":23,"provenance":null}
 {"source":"class:4bd83cdfb5b8540fad90ce018af02e21","target":"method:5eb14184151e0e35d5705df793db77a4","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:4bd83cdfb5b8540fad90ce018af02e21","target":"method:73b61c8d80bf0af73a67434ab7f4be86","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:4bd83cdfb5b8540fad90ce018af02e21","target":"method:fa3938cdf0d608dc9a8646d21c39961c","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
@@ -2195,7 +2195,7 @@
 {"source":"class:54c0d1e485f298b4f9827706f928657f","target":"method:77e06442f583b8a728ecb572f6730060","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:54c0d1e485f298b4f9827706f928657f","target":"method:a7b6861e2ff780d68310f545ca791d3c","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:54c0d1e485f298b4f9827706f928657f","target":"method:f11a1632c933108942e00d3b2c940adc","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
-{"source":"class:54c0d1e485f298b4f9827706f928657f","target":"trait:f91851c14912462ae9592cb13a51f3b1","kind":"extends","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"Drawable\"}","line":42,"col":86,"provenance":null}
+{"source":"class:54c0d1e485f298b4f9827706f928657f","target":"trait:f91851c14912462ae9592cb13a51f3b1","kind":"extends","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Drawable\"}","line":42,"col":86,"provenance":null}
 {"source":"class:5502ac035e1ca2d56c14e093db0d8cec","target":"constant:918bdd1cc2ff2b2cd79d7560e2a8d3e4","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:5545c7494bbd6c81f0a1d85a3cf99570","target":"class:0939ad4dcc3f8b9686a6f2915ddc27f6","kind":"extends","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"qualified-name\",\"refName\":\"Base\"}","line":73,"col":23,"provenance":null}
 {"source":"class:5545c7494bbd6c81f0a1d85a3cf99570","target":"class:25244cbdbe3e9bc720df9fc4d54fac0a","kind":"extends","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"qualified-name\",\"refName\":\"app::Config\"}","line":73,"col":42,"provenance":null}
@@ -2230,7 +2230,7 @@
 {"source":"class:63dc577067a8afeda1988d7d6845f698","target":"method:4a64a3754cd246ad0a17464408bb4625","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:63dc577067a8afeda1988d7d6845f698","target":"method:ec47a62d06708c1f02fc28a967649234","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:65d5c81c60b7d34bc7538930f2e979ac","target":"method:3d1787adb831782b4a90413dd941412b","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
-{"source":"class:65d5c81c60b7d34bc7538930f2e979ac","target":"trait:f91851c14912462ae9592cb13a51f3b1","kind":"extends","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"Drawable\"}","line":92,"col":41,"provenance":null}
+{"source":"class:65d5c81c60b7d34bc7538930f2e979ac","target":"trait:f91851c14912462ae9592cb13a51f3b1","kind":"extends","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Drawable\"}","line":92,"col":41,"provenance":null}
 {"source":"class:669ed683926cda236e997600e8333886","target":"field:f42ef23569cac66be69e4d9154772969","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:679670ecd455feab2a3da4e81ddddb92","target":"class:ca530cf4e2520283a176c1937131d988","kind":"extends","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"ProviderT\"}","line":53,"col":24,"provenance":null}
 {"source":"class:679670ecd455feab2a3da4e81ddddb92","target":"method:7f480d6918f98c10a04c91362d661b3e","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
@@ -2484,7 +2484,7 @@
 {"source":"class:c70093f83659a119eaf917e29e426544","target":"field:00576f3dd90e6114937e113163da4652","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:c70093f83659a119eaf917e29e426544","target":"field:14b603226804f3f428d49d2f565924f2","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:c70093f83659a119eaf917e29e426544","target":"field:44640a600955ccc0d98ee903194917f8","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
-{"source":"class:c70093f83659a119eaf917e29e426544","target":"interface:de46be0e109ecba28258bf5ab5ad85c2","kind":"implements","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"Shape\"}","line":7,"col":64,"provenance":null}
+{"source":"class:c70093f83659a119eaf917e29e426544","target":"interface:de46be0e109ecba28258bf5ab5ad85c2","kind":"implements","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Shape\"}","line":7,"col":64,"provenance":null}
 {"source":"class:c70093f83659a119eaf917e29e426544","target":"method:2026cf93a3b05afc33179fdef3bd9a2e","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:c70093f83659a119eaf917e29e426544","target":"method:208640df2853621ea9e882dbb7a52d5a","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"class:c70093f83659a119eaf917e29e426544","target":"method:5a848545dc28c551fa3193ddb28d9b17","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
@@ -3929,7 +3929,7 @@
 {"source":"function:112bb390a54043c8ee6b3ee94ba6c956","target":"class:508cb01a02b2ec3d871fa137a11a8863","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Holder\"}","line":15,"col":14,"provenance":null}
 {"source":"function:112bb390a54043c8ee6b3ee94ba6c956","target":"function:1932b46aef9b5a9c946962703eaf2c1c","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"localWithNew\"}","line":18,"col":14,"provenance":null}
 {"source":"function:112bb390a54043c8ee6b3ee94ba6c956","target":"function:1932b46aef9b5a9c946962703eaf2c1c","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
-{"source":"function:112bb390a54043c8ee6b3ee94ba6c956","target":"function:21ca45d9f9601839f9b8698f898ae7d9","kind":"calls","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"localFn\"}","line":13,"col":9,"provenance":null}
+{"source":"function:112bb390a54043c8ee6b3ee94ba6c956","target":"function:21ca45d9f9601839f9b8698f898ae7d9","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"localFn\"}","line":13,"col":9,"provenance":null}
 {"source":"function:112bb390a54043c8ee6b3ee94ba6c956","target":"function:21ca45d9f9601839f9b8698f898ae7d9","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"function:1710f4f05ce5bdd8e1b2662e40746d82","target":"constant:9330a6b515f190e755baa3a37e0d04ba","kind":"references","metadata":"{\"valueRef\":true}","line":null,"col":null,"provenance":null}
 {"source":"function:1932b46aef9b5a9c946962703eaf2c1c","target":"class:508cb01a02b2ec3d871fa137a11a8863","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Holder\"}","line":15,"col":14,"provenance":null}
@@ -3955,15 +3955,15 @@
 {"source":"function:1c731d01deb9c8e7eb2881eaebba9e58","target":"function:9880cd7d8361fedda327ff0eb3eb37df","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"legacyHelper\"}","line":123,"col":11,"provenance":null}
 {"source":"function:1c731d01deb9c8e7eb2881eaebba9e58","target":"function:f54946f3687d20f9751ad94e97e271d7","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"arrow\"}","line":124,"col":17,"provenance":null}
 {"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"class:2160a464a79ffdc55d54ec63926e795a","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"WidgetK\",\"refKind\":\"calls\"}","line":183,"col":12,"provenance":null}
-{"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"class:58dfebdea413c36d40db63cf5abbf568","kind":"references","metadata":"{\"framework\":\"spring\",\"confidence\":0.7,\"resolvedBy\":\"framework\",\"refName\":\"Registry\"}","line":188,"col":4,"provenance":null}
+{"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"class:58dfebdea413c36d40db63cf5abbf568","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Registry\"}","line":188,"col":4,"provenance":null}
 {"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"class:f9fa34d7af7ef38aa701ed9a4fde753e","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"enum:1cf855fc73c828cc6a9624095f50c676","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Color\"}","line":189,"col":4,"provenance":null}
 {"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"function:02ea7e14e3e28772587e5187d6cbde25","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"localFn\"}","line":225,"col":4,"provenance":null}
 {"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"function:02ea7e14e3e28772587e5187d6cbde25","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"function:195bf407247f64b7e9a36cd403bed18e","kind":"calls","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"run\"}","line":205,"col":4,"provenance":null}
 {"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"function:1cb7a6623f4a42c3a29a0ebe06f99a20","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
-{"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"function:88e57afaba7a321e02ac14c23164971f","kind":"calls","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"draw\"}","line":220,"col":16,"provenance":null}
-{"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"function:88e57afaba7a321e02ac14c23164971f","kind":"calls","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"draw\"}","line":223,"col":22,"provenance":null}
+{"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"function:88e57afaba7a321e02ac14c23164971f","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"draw\"}","line":220,"col":16,"provenance":null}
+{"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"function:88e57afaba7a321e02ac14c23164971f","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"draw\"}","line":223,"col":22,"provenance":null}
 {"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"function:88e57afaba7a321e02ac14c23164971f","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"function:a835a780a7ca146cededcd8053765be7","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"`weird name`\"}","line":237,"col":19,"provenance":null}
 {"source":"function:1e94e74590f4532a219d3a0d6e1645f6","target":"function:c062ca02de706ffe85e7dfb2f9586331","kind":"references","metadata":"{\"confidence\":0.95,\"resolvedBy\":\"function-ref\",\"refName\":\"topLevel\",\"refKind\":\"function_ref\",\"fnRef\":true}","line":209,"col":15,"provenance":null}
@@ -4000,7 +4000,7 @@
 {"source":"function:26ac3e78238b037efdce6f5fac049878","target":"class:ca1f1b5975a06b517d843fd576230997","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Report\"}","line":122,"col":25,"provenance":null}
 {"source":"function:26ac3e78238b037efdce6f5fac049878","target":"class:ca1f1b5975a06b517d843fd576230997","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Report\"}","line":124,"col":29,"provenance":null}
 {"source":"function:2cc9a67de84931c83b539237a3d695b9","target":"class:0ea6b25874f3f2740efdf3fe3093b554","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"FieldDelegator\"}","line":255,"col":84,"provenance":null}
-{"source":"function:2f5b0cdb31144b6c7277428960de2a32","target":"function:2dbfb7bd9188675ef862d45c0d8fd93c","kind":"calls","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"local\"}","line":192,"col":7,"provenance":null}
+{"source":"function:2f5b0cdb31144b6c7277428960de2a32","target":"function:2dbfb7bd9188675ef862d45c0d8fd93c","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"local\"}","line":192,"col":7,"provenance":null}
 {"source":"function:2f5b0cdb31144b6c7277428960de2a32","target":"function:2dbfb7bd9188675ef862d45c0d8fd93c","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"function:31667d19df8f0e5cd5dfb03fb205a8d7","target":"function:077abb142cd38f50fd7aeb4958ac54b7","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"register\"}","line":76,"col":10,"provenance":null}
 {"source":"function:31667d19df8f0e5cd5dfb03fb205a8d7","target":"function:112bb390a54043c8ee6b3ee94ba6c956","kind":"references","metadata":"{\"confidence\":0.95,\"resolvedBy\":\"function-ref\",\"refName\":\"hostFn\",\"refKind\":\"function_ref\",\"fnRef\":true}","line":78,"col":28,"provenance":null}
@@ -4108,7 +4108,7 @@
 {"source":"function:a1998a5fcada0a95b1aebb30d3f1222c","target":"class:fa355652331eee519e97b9ef15a61b2d","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"WidgetT\"}","line":94,"col":14,"provenance":null}
 {"source":"function:a1998a5fcada0a95b1aebb30d3f1222c","target":"function:ba9868d0ac07f6aadd40bfb18b1f232e","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"helper\"}","line":67,"col":8,"provenance":null}
 {"source":"function:a1998a5fcada0a95b1aebb30d3f1222c","target":"function:ba9868d0ac07f6aadd40bfb18b1f232e","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"helper\"}","line":83,"col":10,"provenance":null}
-{"source":"function:a1998a5fcada0a95b1aebb30d3f1222c","target":"function:de3e7760a8bf304d54651b74e6589aa3","kind":"calls","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"localFn\"}","line":89,"col":9,"provenance":null}
+{"source":"function:a1998a5fcada0a95b1aebb30d3f1222c","target":"function:de3e7760a8bf304d54651b74e6589aa3","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"localFn\"}","line":89,"col":9,"provenance":null}
 {"source":"function:a1998a5fcada0a95b1aebb30d3f1222c","target":"function:de3e7760a8bf304d54651b74e6589aa3","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"function:a1998a5fcada0a95b1aebb30d3f1222c","target":"method:2ec7b72739446515eb6fa0e9a847d996","kind":"calls","metadata":"{\"confidence\":0.85,\"resolvedBy\":\"qualified-name\",\"refName\":\"WidgetT.named\"}","line":79,"col":15,"provenance":null}
 {"source":"function:a1998a5fcada0a95b1aebb30d3f1222c","target":"method:8073f837979c32f4ea834666de93ff0e","kind":"calls","metadata":"{\"confidence\":0.85,\"resolvedBy\":\"qualified-name\",\"refName\":\"ConfigT.load\"}","line":70,"col":14,"provenance":null}
@@ -4154,7 +4154,7 @@
 {"source":"function:c2971e4b1912de92c9c1e02416630c6b","target":"class:185f6260a8d5b738c53be0accb2a4e19","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"qualified-name\",\"refName\":\"Widget\"}","line":59,"col":2,"provenance":null}
 {"source":"function:c2971e4b1912de92c9c1e02416630c6b","target":"method:7e714128b5b3c81a4e4f571a142197ba","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"qualified-name\",\"refName\":\"Widget::Widget/0\"}","line":59,"col":2,"provenance":null}
 {"source":"function:ca2a58bf9e2fe349053607e85964f54f","target":"class:fa355652331eee519e97b9ef15a61b2d","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"WidgetT\"}","line":56,"col":34,"provenance":null}
-{"source":"function:d06c2607f3378f3f3037272d30c5d24b","target":"function:dd3ddcfaee0976e540855839ddc8e1b0","kind":"calls","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"local\"}","line":174,"col":7,"provenance":null}
+{"source":"function:d06c2607f3378f3f3037272d30c5d24b","target":"function:dd3ddcfaee0976e540855839ddc8e1b0","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"local\"}","line":174,"col":7,"provenance":null}
 {"source":"function:d06c2607f3378f3f3037272d30c5d24b","target":"function:dd3ddcfaee0976e540855839ddc8e1b0","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"function:d1b22ce81e4dcd9f8f6bd5f508ed2535","target":"class:54c0d1e485f298b4f9827706f928657f","kind":"references","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"WidgetS\"}","line":26,"col":15,"provenance":null}
 {"source":"function:d7da4b402ad97a64a1766fcf09e392e0","target":"constant:84e8ca2c7ea91f1d3a3ed700ab7c9298","kind":"references","metadata":"{\"valueRef\":true}","line":null,"col":null,"provenance":null}
@@ -4168,7 +4168,7 @@
 {"source":"function:e611a10f53cb2352067120211e7632b2","target":"class:54c0d1e485f298b4f9827706f928657f","kind":"references","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"WidgetS\"}","line":10,"col":22,"provenance":null}
 {"source":"function:f11355267c15b025e65a025974c2a4d1","target":"constant:4d2266cb0f452fd0233976ec146c28eb","kind":"references","metadata":"{\"valueRef\":true}","line":null,"col":null,"provenance":null}
 {"source":"function:f11355267c15b025e65a025974c2a4d1","target":"constant:7af11b36e8d4ddbbdc72a75e5d163a1f","kind":"references","metadata":"{\"valueRef\":true}","line":null,"col":null,"provenance":null}
-{"source":"function:f42d18d9932ecf98835384d2a581205f","target":"function:e611a10f53cb2352067120211e7632b2","kind":"calls","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"topLevel\"}","line":30,"col":26,"provenance":null}
+{"source":"function:f42d18d9932ecf98835384d2a581205f","target":"function:e611a10f53cb2352067120211e7632b2","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"topLevel\"}","line":30,"col":26,"provenance":null}
 {"source":"function:f54946f3687d20f9751ad94e97e271d7","target":"function:9880cd7d8361fedda327ff0eb3eb37df","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"legacyHelper\"}","line":13,"col":21,"provenance":null}
 {"source":"function:fa31a4bba4af75d85403a627a9e62897","target":"module:3e98a45ef089de69c402c540a05c492e","kind":"references","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"WidgetS\"}","line":108,"col":17,"provenance":null}
 {"source":"function:fa31a4bba4af75d85403a627a9e62897","target":"module:3e98a45ef089de69c402c540a05c492e","kind":"references","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"WidgetS\"}","line":108,"col":29,"provenance":null}
@@ -4215,7 +4215,7 @@
 {"source":"method:1edca63b63663ee826e2349f6d040e1c","target":"method:fc93d61b2caa73e9feea003464e6332d","kind":"calls","metadata":"{\"synthesizedBy\":\"interface-impl\",\"via\":\"render\",\"registeredAt\":\"torture.rs:57\"}","line":42,"col":null,"provenance":"heuristic"}
 {"source":"method:212bbb3d2db529e2eb6e8fdd590a7e89","target":"method:d85e75675c9c25670ba7f631481482f8","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"render\"}","line":59,"col":27,"provenance":null}
 {"source":"method:255fc37070ede2ebf60c5b5f53829c63","target":"method:d0c57c6f9abd19cc5263f4b1c36ba5c9","kind":"calls","metadata":"{\"synthesizedBy\":\"interface-impl\",\"via\":\"draw\",\"registeredAt\":\"torture.kt:106\"}","line":114,"col":null,"provenance":"heuristic"}
-{"source":"method:2596782eaecc1c154a4fdc2334a968a4","target":"enum:2301fa8d1a0b010b91450d59386b4020","kind":"references","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"Http\"}","line":166,"col":13,"provenance":null}
+{"source":"method:2596782eaecc1c154a4fdc2334a968a4","target":"enum:2301fa8d1a0b010b91450d59386b4020","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Http\"}","line":166,"col":13,"provenance":null}
 {"source":"method:2596782eaecc1c154a4fdc2334a968a4","target":"module:bc14df23aa624c6e9abad13ed495709a","kind":"references","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"Registry\"}","line":165,"col":13,"provenance":null}
 {"source":"method:2596782eaecc1c154a4fdc2334a968a4","target":"module:bc14df23aa624c6e9abad13ed495709a","kind":"references","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"Registry\"}","line":168,"col":4,"provenance":null}
 {"source":"method:2596782eaecc1c154a4fdc2334a968a4","target":"module:bc14df23aa624c6e9abad13ed495709a","kind":"references","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"Registry\"}","line":169,"col":12,"provenance":null}
@@ -4296,7 +4296,7 @@
 {"source":"method:62962794279c3c99426ab6031814cfb6","target":"method:df9319e9e35228fc08a4c26bb7cac4dc","kind":"references","metadata":"{\"confidence\":0.95,\"resolvedBy\":\"function-ref\",\"refName\":\"items\",\"refKind\":\"function_ref\",\"fnRef\":true}","line":47,"col":12,"provenance":null}
 {"source":"method:696a13d993cb735ae83777bf41611e4c","target":"class:35d9285764fa4fb28ea1d16db47145a1","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Pair\"}","line":43,"col":24,"provenance":null}
 {"source":"method:696a13d993cb735ae83777bf41611e4c","target":"class:afd19409ef5bc781bca7198f0f8f0f88","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
-{"source":"method:696a13d993cb735ae83777bf41611e4c","target":"class:afd19409ef5bc781bca7198f0f8f0f88","kind":"instantiates","metadata":"{\"framework\":\"spring\",\"confidence\":0.7,\"resolvedBy\":\"framework\",\"refName\":\"Local\"}","line":45,"col":18,"provenance":null}
+{"source":"method:696a13d993cb735ae83777bf41611e4c","target":"class:afd19409ef5bc781bca7198f0f8f0f88","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Local\"}","line":45,"col":18,"provenance":null}
 {"source":"method:696a13d993cb735ae83777bf41611e4c","target":"class:c70093f83659a119eaf917e29e426544","kind":"references","metadata":"{\"framework\":\"spring\",\"confidence\":0.7,\"resolvedBy\":\"framework\",\"refName\":\"Point\"}","line":43,"col":15,"provenance":null}
 {"source":"method:696a13d993cb735ae83777bf41611e4c","target":"constant:f5723290218cacb63dda24a45134f84d","kind":"references","metadata":"{\"valueRef\":true}","line":null,"col":null,"provenance":null}
 {"source":"method:696a13d993cb735ae83777bf41611e4c","target":"method:1d91cdf995f81588bef6345d2c41cab8","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"instance-method\",\"refName\":\"pr.left\"}","line":47,"col":39,"provenance":null}
@@ -4367,7 +4367,7 @@
 {"source":"method:a7103764da0854afee05bc7d100478a4","target":"method:8cc04f699d9a44f457ad849e48334cf2","kind":"calls","metadata":"{\"confidence\":0.85,\"resolvedBy\":\"qualified-name\",\"refName\":\"ProviderT.value\"}","line":47,"col":16,"provenance":null}
 {"source":"method:a7b6861e2ff780d68310f545ca791d3c","target":"module:3e98a45ef089de69c402c540a05c492e","kind":"references","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"WidgetS\"}","line":58,"col":20,"provenance":null}
 {"source":"method:a83a51eab57270a522b9a2b7133e3e55","target":"constant:f3f2f36c072cdfa3d41c0be651e605ce","kind":"references","metadata":"{\"valueRef\":true}","line":null,"col":null,"provenance":null}
-{"source":"method:a83a51eab57270a522b9a2b7133e3e55","target":"module:7b0b21e64c28c40d1a3a9a73109bc603","kind":"references","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"Config\"}","line":12,"col":16,"provenance":null}
+{"source":"method:a83a51eab57270a522b9a2b7133e3e55","target":"module:7b0b21e64c28c40d1a3a9a73109bc603","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Config\"}","line":12,"col":16,"provenance":null}
 {"source":"method:a935b33c83e72d78f5aba957dc6b5362","target":"function:ba9868d0ac07f6aadd40bfb18b1f232e","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"helper\"}","line":55,"col":27,"provenance":null}
 {"source":"method:ac9d754fee3741f21584a0086c577453","target":"struct:0c309a8ed6f33456724d94ba73599e04","kind":"instantiates","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Widget\"}","line":87,"col":8,"provenance":null}
 {"source":"method:ac9d754fee3741f21584a0086c577453","target":"struct:0c309a8ed6f33456724d94ba73599e04","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"qualified-name\",\"refName\":\"Self\"}","line":85,"col":28,"provenance":null}
@@ -4474,7 +4474,7 @@
 {"source":"module:3e98a45ef089de69c402c540a05c492e","target":"method:90c2e7d9608647c254c97e9a9cfea8f0","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"module:3e98a45ef089de69c402c540a05c492e","target":"method:f141417138453a1e069cb41778364534","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"module:50656f4b2dd953684ccf0569354e5f6a","target":"constant:afa8c28eaee270ee74f5cac2a4bac4f9","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
-{"source":"module:62d09c593067cc591a381d4b61d3c7cc","target":"trait:09af11c47861285a512e31fce265f12b","kind":"extends","metadata":"{\"confidence\":0.4,\"resolvedBy\":\"exact-match\",\"refName\":\"Shape\"}","line":87,"col":22,"provenance":null}
+{"source":"module:62d09c593067cc591a381d4b61d3c7cc","target":"trait:09af11c47861285a512e31fce265f12b","kind":"extends","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Shape\"}","line":87,"col":22,"provenance":null}
 {"source":"module:6e9593e56da8abba78b4de05c2093067","target":"method:1dd50f72d18602fd517764d7d7f38d07","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"module:6e9593e56da8abba78b4de05c2093067","target":"method:21bccd402845e4d14582f7b3f06c7f98","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"module:6e9593e56da8abba78b4de05c2093067","target":"method:6d9dc963c222f94eab797e7bbd0151d3","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
diff --git a/codegraph-kernel/src/resolve/fields.rs b/codegraph-kernel/src/resolve/fields.rs
index 57f773357..027c56a8b 100644
--- a/codegraph-kernel/src/resolve/fields.rs
+++ b/codegraph-kernel/src/resolve/fields.rs
@@ -112,9 +112,6 @@ impl KernelResolver {
             return Ok(hit.clone());
         }
         let mut found = GoDotImports::default();
-        if std::env::var_os("CODEGRAPH_KERNEL_DEBUG_GO").is_some() {
-            eprintln!("[go-dots] {file_path} imports: {:?}", self.import_mappings(file_path)?.iter().map(|i| format!("{}={}", i.local_name, i.source)).collect::<Vec<_>>());
-        }
         for import in self.import_mappings(file_path)?.iter().filter(|i| i.local_name == ".") {
             if let Some(dir) = self.go_package_dir(&import.source, file_path) {
                 found.dirs.push(dir);
@@ -157,9 +154,6 @@ impl KernelResolver {
     pub(super) fn go_bare_type_dir(&mut self, name: &str, file_path: &str) -> Res<Option<String>> {
         let own = pos_dirname(file_path).to_string();
         let dots = self.go_dot_imports(file_path)?;
-        if std::env::var_os("CODEGRAPH_KERNEL_DEBUG_GO").is_some() {
-            eprintln!("[go-bare] {name} in {file_path}: own={own} dirs={:?} outside={} types={:?}", dots.dirs, dots.outside, dots.types);
-        }
         if (dots.dirs.is_empty() && !dots.outside) || !self.go_package_types(name, &own)?.is_empty() {
             return Ok(Some(own));
         }
@@ -308,7 +302,14 @@ impl KernelResolver {
             .collect();
         let in_pkg: Vec<Arc<KNode>> =
             named.into_iter().filter(|m| pos_dirname(&m.file_path) == pkg_dir).collect();
-        if in_pkg.is_empty() { return self.go_promoted_method(type_name, method, pkg_dir, r); }
+        if in_pkg.is_empty() {
+            // A file of the package the index couldn't read may declare the
+            // method — the graph's gap is not a promoted method's place.
+            if self.go_unread_file_declares(type_name, method, pkg_dir)? {
+                return Ok(None);
+            }
+            return self.go_promoted_method(type_name, method, pkg_dir, r);
+        }
         if r.reference_kind == "function_ref" && in_pkg.len() != 1 { return Ok(None); }
         let ordered = prefer_call_site_file(in_pkg, &r.file_path);
         Ok(Some(KCand { node: ordered[0].clone(), confidence: 0.85, resolved_by: "instance-method" }))
diff --git a/codegraph-kernel/src/resolve/go_asserted.rs b/codegraph-kernel/src/resolve/go_asserted.rs
index be37c127c..e30c9ba06 100644
--- a/codegraph-kernel/src/resolve/go_asserted.rs
+++ b/codegraph-kernel/src/resolve/go_asserted.rs
@@ -31,7 +31,7 @@ enum Declared {
     Other,
 }
 
-fn text_of<'a>(node: TsNode, text: &'a str) -> &'a str {
+pub(super) fn text_of<'a>(node: TsNode, text: &'a str) -> &'a str {
     &text[node.start_byte()..node.end_byte()]
 }
 
@@ -51,10 +51,10 @@ fn declared_by(names: &[TsNode], values: Option<TsNode>, typed: bool, name: &str
     Some(asserted.map_or(Declared::Other, Declared::Asserted))
 }
 
-fn identifiers<'t>(list: TsNode<'t>) -> Vec<TsNode<'t>> {
-    if list.kind() == "identifier" { return vec![list]; }
+pub(super) fn identifiers<'t>(list: TsNode<'t>) -> Vec<TsNode<'t>> {
+    if matches!(list.kind(), "identifier" | "blank_identifier") { return vec![list]; }
     let mut cursor = list.walk();
-    list.named_children(&mut cursor).filter(|n| n.kind() == "identifier").collect()
+    list.named_children(&mut cursor).filter(|n| matches!(n.kind(), "identifier" | "blank_identifier")).collect()
 }
 
 /// `name`'s declaration among one statement, if the statement declares it.
@@ -171,7 +171,14 @@ impl KernelResolver {
     /// the index cannot tell (a type literal, a type declared inside a
     /// function, a type parameter): the call goes to the other strategies.
     pub(super) fn go_written_type(&mut self, written: &str, r: &ResolveRefIn) -> Res<Option<GoAsserted>> {
-        let Some(hit) = re!(r"^\*?\s*(?:([A-Za-z_]\w*)\s*\.\s*)?([A-Za-z_]\w*)\s*(?:\[[\s\S]*\])?$").captures(written.trim()) else { return Ok(None); };
+        let w = written.trim();
+        // A type the source spells without a named holder — `func() T`,
+        // `struct{…}`, `[]T`, `map[K]V`, `chan T`, `interface{…}` — is no
+        // project type's: terminal, not a name-match cue.
+        if re!(r"^\*?\s*(func\b|struct\b|interface\b|map\s*\[|chan\b|<-|\[)").is_match(w) {
+            return Ok(Some(GoAsserted::Outside));
+        }
+        let Some(hit) = re!(r"^\*?\s*(?:([A-Za-z_]\w*)\s*\.\s*)?([A-Za-z_]\w*)\s*(?:\[[\s\S]*\])?$").captures(w) else { return Ok(None); };
         let qualifier = hit.get(1).map(|m| m.as_str().to_string());
         let name = hit[2].to_string();
         let declared = self.nodes_by_name(&name)?.iter()
@@ -247,7 +254,7 @@ impl KernelResolver {
 
 /// An actual lexical declaration, including the name's position for reading
 /// its initializer. Used by func-field synthesis through the native bridge.
-fn local_declaration_in<'a>(scope: TsNode<'a>, name: &str, site: usize, text: &str) -> Option<(TsNode<'a>, Option<String>)> {
+pub(super) fn local_declaration_in<'a>(scope: TsNode<'a>, name: &str, site: usize, text: &str) -> Option<(TsNode<'a>, Option<String>)> {
     /// `x := &pkg.T{…}`, `x := T{…}`, `x := new(T)` and `var x = &T{…}`
     /// write their type in the value; other right-hand sides say nothing.
     /// `k` is the name's place among the declaration's names — the value
diff --git a/codegraph-kernel/src/resolve/go_value.rs b/codegraph-kernel/src/resolve/go_value.rs
index 921fcd576..814c31abf 100644
--- a/codegraph-kernel/src/resolve/go_value.rs
+++ b/codegraph-kernel/src/resolve/go_value.rs
@@ -89,6 +89,13 @@ impl KernelResolver {
     /// literal's (`&Registry{}`, `pkg.T{…}`) or a conversion's (`Role("x")`,
     /// `pkg.T(x)`). Outside for what an outside package hands out.
     fn go_value_type(&mut self, value: &str, file: &str) -> Res<GoPkgValue> {
+        // A composite literal's own type is its first token: `[]T{…}`,
+        // `map[K]V{…}`, `&pkg.T{…}`.
+        let lead = value.trim_start_matches('&').trim_start();
+        if lead.starts_with('[') || lead.starts_with("map[") {
+            let token: String = lead.chars().take_while(|c| !matches!(c, '{' | '(' | ' ' | '\t')).collect();
+            return Ok(if token.is_empty() { GoPkgValue::Unknown } else { GoPkgValue::Written(token) });
+        }
         static VAL: LazyLock<Regex> = LazyLock::new(|| {
             Regex::new(r"^\s*&?\s*(?:([A-Za-z_]\w*)\s*\.\s*)?([A-Za-z_]\w*)\s*(?:\[[^\]\n]*\]\s*)?([({])").unwrap()
         });
@@ -222,7 +229,9 @@ impl KernelResolver {
             .collect::<Vec<_>>()
             .join(" ");
         let decl = re!(r"/\*.*?\*/").replace_all(&decl, "");
-        let m = re!(r"^\s*[A-Za-z_]\w*\s*(?:\[[^\]]*\])?\s*(?:=\s*)?(\S.*)$").captures(&decl)?;
+        // The name's own `[…]` is generics (`Pair[K,V]` — never empty); a
+        // `[]`/`[N]` prefix is the declared type's own (`Items []Item`).
+        let m = re!(r"^\s*[A-Za-z_]\w*(?:\[[A-Za-z_~][^\]]*\])?\s*(?:=\s*)?(\S[\s\S]*)$").captures(&decl)?;
         Some(m[1].trim().trim_end_matches(';').trim().to_string()).filter(|s| !s.is_empty())
     }
 
@@ -245,15 +254,24 @@ impl KernelResolver {
         let (name, dir) = match named.find('.') {
             Some(p) => match self.go_imported_package_dir(file, &named[..p])? {
                 Some(d) => (named[p + 1..].to_string(), d),
-                None => return Ok(None),
+                None => {
+                    // `pkg.T` whose `pkg` is an import of no project package:
+                    // an outside element — go_written_type vetoes it.
+                    return Ok(if self.import_mappings(file)?.iter().any(|i| i.local_name == named[..p]) {
+                        Some((named.clone(), file.to_string()))
+                    } else {
+                        None
+                    });
+                }
             },
             None => {
+                // A builtin element (`error`) is no project type's either.
                 if GO_BUILTIN_FIELD_TYPES.contains(named.as_str()) {
-                    return Ok(None);
+                    return Ok(Some((named.clone(), file.to_string())));
                 }
                 match self.go_bare_type_dir(&named, file)? {
                     Some(d) => (named.clone(), d),
-                    None => return Ok(None),
+                    None => return Ok(Some((named.clone(), file.to_string()))),
                 }
             }
         };
@@ -277,7 +295,7 @@ impl KernelResolver {
     /// struct's own file.
     fn go_field_type(&mut self, type_name: &str, field: &str, dir: &str) -> Res<Option<(String, String)>> {
         static FIELD_OF: LazyLock<Affix> = LazyLock::new(|| {
-            Affix::new("", r"\s+(\*?(?:map\[[^\]]+\])?\[?\]?\s*[A-Za-z_][A-Za-z0-9_.]*(?:\[[^\]]*\])?)", true, false, false)
+            Affix::new("", r"\s+(\S+)", true, false, false)
         });
         for s in self.go_package_types(type_name, dir)?.iter().filter(|n| n.kind == "struct") {
             let Some(source) = self.read_file(&s.file_path) else { continue };
@@ -288,34 +306,293 @@ impl KernelResolver {
                 if let Some(t) = FIELD_OF.capture(&line, field) {
                     return Ok(Some((t.trim().to_string(), s.file_path.clone())));
                 }
+                // An embedded field spells only its type — `KV` of `struct
+                // { KV; name string }` answers `KV` for the field `KV`.
+                let toks = line.split_whitespace().collect::<Vec<_>>();
+                if let [only, ..] = toks.as_slice() {
+                    if only.trim_start_matches('*').rsplit('.').next() == Some(field) {
+                        return Ok(Some((only.to_string(), s.file_path.clone())));
+                    }
+                }
             }
         }
         Ok(None)
     }
 
-    /// The first result of a Go call's callee — `*Session` of
-    /// `func New() (*Session, error)`, from its `return_type` or the tail of
-    /// its signature.
-    fn go_call_result(&self, callee: &KNode) -> Option<String> {
-        let raw = callee.return_type.clone().or_else(|| {
-            let s = callee.signature.as_deref()?;
-            let close = s.match_indices(')').map(|(i, _)| i).next_back()?;
-            Some(s[close + 1..].trim().trim_end_matches('{').trim().to_string())
-        })?;
+    /// The `index`th result of a Go call's callee — `*Session` of `func
+    /// New() (*Session, error)` at 0, `*Txn` of `func Begin() (int, *Txn)`
+    /// at 1. A result that names the callee's own type parameter reduces to
+    /// its constraint (`func Pick[V Validator](vs []V) V` → `Validator`);
+    /// `any`/an interface literal leaves no named type.
+    pub(super) fn go_call_result_at(&mut self, callee: &KNode, index: usize) -> Option<String> {
+        // `() (int, *Txn)` — the results follow the params' closing `)`.
+        let sig_tail = |c: &KNode| -> Option<String> {
+            let s = c.signature.as_deref()?;
+            let mut depth = 0usize;
+            for (i, ch) in s.char_indices() {
+                match ch {
+                    '(' | '[' | '{' => depth += 1,
+                    ')' | ']' | '}' => {
+                        depth = depth.saturating_sub(1);
+                        if depth == 0 {
+                            return Some(s[i + 1..].trim().trim_end_matches('{').trim().to_string());
+                        }
+                    }
+                    _ => {}
+                }
+            }
+            None
+        };
+        let raw = if index == 0 {
+            callee.return_type.clone().or_else(|| sig_tail(callee))?
+        } else {
+            // `return_type` keeps only the first result.
+            sig_tail(callee).or(callee.return_type.clone())?
+        };
         let raw = raw.trim();
         if raw.is_empty() || raw == "error" {
             return None;
         }
-        // `(T, error)` and `[]T`/`T` alike reduce to the first result.
+        // `(T, error)` and `[]T`/`T` alike reduce to the named result.
         let inner = raw.strip_prefix('(').and_then(|s| s.strip_suffix(')')).unwrap_or(raw);
-        let first = inner.split(',').next()?.trim();
-        Some(first.to_string()).filter(|s| !s.is_empty() && s != "error")
+        let mut depth = 0usize;
+        let mut starts = vec![0usize];
+        let mut commas: Vec<usize> = Vec::new();
+        for (i, c) in inner.char_indices() {
+            match c {
+                '[' | '(' | '{' => depth += 1,
+                ']' | ')' | '}' => depth = depth.saturating_sub(1),
+                ',' if depth == 0 => { commas.push(i); starts.push(i + 1); }
+                _ => {}
+            }
+        }
+        if index >= starts.len() {
+            return None;
+        }
+        let end = commas.get(index).copied().unwrap_or(inner.len());
+        let nth = inner[starts[index]..end].trim();
+        let nth = nth.rsplit(' ').next().unwrap_or(nth).trim();
+        if nth.is_empty() || nth == "error" {
+            return None;
+        }
+        // The result a type parameter spells is its constraint: `V` of
+        // `F[V Validator]` carries Validator's methods, `T` of `F[T any]`
+        // none. The stored signature drops `[…]`, so the declaration line
+        // is read for it.
+        if let Some(source) = self.read_file(&callee.file_path) {
+            if let Some(line) = source.get((callee.start_line - 1).max(0) as usize) {
+                if let Some(tps) = re!(r"func\s+(?:\([^)]*\)\s*)?[A-Za-z_]\w*\s*\[([^\]]+)\]")
+                    .captures(line).map(|m| m[1].to_string())
+                {
+                    // `T1, T2 C` names share C; `K comparable, V any` pairs.
+                    let mut pending: Vec<String> = Vec::new();
+                    for chunk in tps.split(',') {
+                        let toks: Vec<&str> = chunk.split_whitespace().collect();
+                        match toks.as_slice() {
+                            [name] => pending.push(name.to_string()),
+                            [rest @ .., constraint] => {
+                                for n in rest.iter().map(|s| s.trim_end_matches(',')).chain(pending.iter().map(|s| s.as_str())) {
+                                    if n == nth {
+                                        return Some(constraint.to_string());
+                                    }
+                                }
+                                pending.clear();
+                            }
+                            [] => {}
+                        }
+                    }
+                }
+            }
+        }
+        Some(nth.to_string())
+    }
+
+    /// The initializer `names = values` gives the name `name_node`
+    /// declares — its place among the names picks the value among the
+    /// expression list (`in, out := &in.Items, &out.Items`).
+    fn decl_rhs_node<'a>(name_node: TsNode<'a>, name: &str, text: &'a str) -> Option<(TsNode<'a>, usize, bool)> {
+        use super::go_asserted::{identifiers, text_of};
+        let mut owner = name_node.parent()?;
+        if owner.kind() == "expression_list" {
+            owner = owner.parent()?;
+        }
+        let (names, value, range) = match owner.kind() {
+            "short_var_declaration" => {
+                (identifiers(owner.child_by_field_name("left")?), owner.child_by_field_name("right")?, false)
+            }
+            // `for k, v := range coll` — the name's position means key/index
+            // vs element, not a multi-result index.
+            "range_clause" => {
+                (identifiers(owner.child_by_field_name("left")?), owner.child_by_field_name("right")?, true)
+            }
+            "var_spec" | "const_spec" => {
+                let mut c = owner.walk();
+                (
+                    owner.children_by_field_name("name", &mut c).collect::<Vec<_>>(),
+                    owner.child_by_field_name("value")?,
+                    false,
+                )
+            }
+            _ => return None,
+        };
+        let k = names.iter().position(|n| text_of(*n, text) == name)?;
+        if value.kind() == "expression_list" {
+            if value.named_child_count() > k {
+                return Some((value.named_child(k)?, 0, range));
+            }
+            // `a, b := f()` — the call's kth result types b.
+            return Some((value.named_child(value.named_child_count() - 1)?, k, range));
+        }
+        Some((value, k, range))
+    }
+
+    /// The type `for k, v := range coll` binds `k`/`v` at — name position
+    /// 0 takes the index (`int` for a slice, array or `string`) or key
+    /// (`K` of `map[K]V`); position 1 takes the element/value. A `chan`
+    /// range binds only its received value.
+    fn go_range_pick(written: &str, pos: usize) -> String {
+        let w = written.trim().trim_start_matches('*').trim();
+        if let Some(rest) = w.strip_prefix("map[") {
+            if let Some(end) = rest.find(']') {
+                return (if pos == 0 { &rest[..end] } else { rest[end + 1..].trim() }).to_string();
+            }
+        }
+        for p in ["chan ", "<-chan ", "chan<- "] {
+            if let Some(rest) = w.strip_prefix(p) {
+                return rest.trim().to_string();
+            }
+        }
+        if pos == 0 {
+            "int".to_string()
+        } else if w.starts_with('[') {
+            w.find(']').map(|e| w[e + 1..].trim().to_string()).unwrap_or_else(|| w.to_string())
+        } else if w == "string" {
+            "rune".to_string()
+        } else {
+            w.to_string()
+        }
+    }
+
+    /// The type parameter `name`'s constraint in the function enclosing the
+    /// ref — `model.Validator` of `F[T model.Validator]`, the interface
+    /// literal of `F[T interface{ … }]`. `None` when `name` is no type
+    /// parameter of an enclosing declaration.
+    fn go_type_param_constraint(&mut self, name: &str, r: &ResolveRefIn) -> Res<Option<String>> {
+        use super::go_asserted::text_of;
+        let Some(file) = self.read_file(&r.file_path) else { return Ok(None) };
+        let Some(tree) = self.parsed_tree(&file, r) else { return Ok(None) };
+        let mut scope = super::iteration::descendant_for_position(
+            tree.root_node(),
+            file.text(),
+            ((r.line - 1).max(0) as usize, r.column.max(0) as usize),
+        );
+        loop {
+            if matches!(scope.kind(), "function_declaration" | "method_declaration" | "func_literal") {
+                let Some(tps) = scope.child_by_field_name("type_parameters") else { return Ok(None) };
+                let mut c = tps.walk();
+                for decl in tps.named_children(&mut c) {
+                    if decl.kind() != "type_parameter_declaration" {
+                        continue;
+                    }
+                    let mut nc = decl.walk();
+                    let names: Vec<_> = decl.children_by_field_name("name", &mut nc).collect();
+                    if names.iter().any(|n| text_of(*n, file.text()) == name) {
+                        return Ok(decl.child_by_field_name("type").map(|t| text_of(t, file.text()).to_string()));
+                    }
+                }
+                return Ok(None);
+            }
+            let Some(parent) = scope.parent() else { return Ok(None) };
+            scope = parent;
+        }
+    }
+
+    /// The written type a Go local `name` carries at `anchor`'s site —
+    /// declared type, asserted type, its `:=`/`var` initializer's type, or
+    /// a package-level value's. `None` when nothing types it.
+    fn go_named_local_written(
+        &mut self,
+        name: &str,
+        anchor: TsNode,
+        file_text: &str,
+        r: &ResolveRefIn,
+    ) -> Res<Option<(String, String)>> {
+        use super::go_asserted::local_declaration_in;
+        let file = r.file_path.clone();
+        let mut scope = anchor;
+        let found = loop {
+            if let Some(hit) = local_declaration_in(scope, name, anchor.start_byte(), file_text) {
+                break Some(hit);
+            }
+            match scope.parent() {
+                Some(p) => scope = p,
+                None => break None,
+            }
+        };
+        if let Some((target, declared)) = found {
+            if let Some(t) = declared {
+                return Ok(Some((t, file)));
+            }
+            if let Some(w) = self.go_asserted_local_type(name, r) {
+                return Ok(Some((w, file)));
+            }
+            // An untyped `:=`/`var` — read the initializer itself:
+            // `&m.F`, `f()`, `x[i]`, `[]T(v)` all carry a type.
+            if let Some((rhs, pos, range)) = Self::decl_rhs_node(target, name, file_text) {
+                let w = self.go_expr_written_at(rhs, if range { 0 } else { pos }, file_text, r)?
+                    .map(|(t, f)| if range { (Self::go_range_pick(&t, pos), f) } else { (t, f) });
+                if let Some(t) = w {
+                    return Ok(Some(t));
+                }
+            }
+            if let Some(t) = self.infer_local_receiver_type(name, r, true)? {
+                return Ok(Some((t, file)));
+            }
+            return Ok(None);
+        }
+        // A parameter or `:=` local the declaration reader missed —
+        // the bound-receiver inference still types it.
+        if let Some(t) = self.infer_local_receiver_type(name, r, true)? {
+            return Ok(Some((t, file)));
+        }
+        for n in self.nodes_by_name(name)?.iter().filter(|n| {
+            n.language == "go"
+                && matches!(n.kind.as_str(), "variable" | "constant")
+                && pos_dirname(&n.file_path) == pos_dirname(&file)
+        }) {
+            if let GoPkgValue::Written(w) = self.go_package_value_type(n)? {
+                return Ok(Some((w, n.file_path.clone())));
+            }
+        }
+        Ok(None)
+    }
+
+    /// A Go receiver named `name` at `r`'s call site, typed through the
+    /// same scoped local machinery `x[i].M` uses — the line-regex
+    /// infer_local_receiver_type can't see `x := pkg.F().Field` or a
+    /// shadowed name's outer binding.
+    pub(super) fn go_local_receiver_written(&mut self, name: &str, r: &ResolveRefIn) -> Res<Option<(String, String)>> {
+        let Some(file) = self.read_file(&r.file_path) else { return Ok(None) };
+        let Some(tree) = self.parsed_tree(&file, r) else { return Ok(None) };
+        let anchor = super::iteration::descendant_for_position(
+            tree.root_node(),
+            file.text(),
+            ((r.line - 1).max(0) as usize, r.column.max(0) as usize),
+        );
+        let w = self.go_named_local_written(name, anchor, file.text(), r)?;
+        Ok(w)
     }
 
     /// The type an expression's source text spells (`goReceiverChainType`,
     /// tree-native): `(written, file)`. `None` is unreadable — the other
     /// strategies decide.
     fn go_expr_written(&mut self, expr: TsNode, file_text: &str, r: &ResolveRefIn) -> Res<Option<(String, String)>> {
+        self.go_expr_written_at(expr, 0, file_text, r)
+    }
+
+    /// `go_expr_written` whose top-level call takes its `result_idx`th
+    /// result — `_, txn := store.Begin()` types `txn` by the second.
+    fn go_expr_written_at(&mut self, expr: TsNode, result_idx: usize, file_text: &str, r: &ResolveRefIn) -> Res<Option<(String, String)>> {
         let file = r.file_path.clone();
         match expr.kind() {
             "parenthesized_expression" => match expr.named_child(0) {
@@ -324,69 +601,94 @@ impl KernelResolver {
             },
             "identifier" => {
                 let name = file_text[expr.byte_range()].to_string();
-                if let Some(decl) =
-                    self.go_local_declaration_at(name.clone(), file.clone(), r.line, r.column)?
-                {
-                    if let Some(t) = decl.declared_type {
-                        return Ok(Some((t, file)));
-                    }
-                    if let Some(w) = self.go_asserted_local_type(&name, r) {
-                        return Ok(Some((w, file)));
-                    }
-                    if let Some(t) = self.infer_local_receiver_type(&name, r, true)? {
-                        return Ok(Some((t, file)));
-                    }
-                    return Ok(None);
-                }
-                // A parameter or `:=` local the declaration reader missed —
-                // the bound-receiver inference still types it.
-                if let Some(t) = self.infer_local_receiver_type(&name, r, true)? {
-                    return Ok(Some((t, file)));
-                }
-                for n in self.nodes_by_name(&name)?.iter().filter(|n| {
-                    n.language == "go"
-                        && matches!(n.kind.as_str(), "variable" | "constant")
-                        && pos_dirname(&n.file_path) == pos_dirname(&file)
-                }) {
-                    if let GoPkgValue::Written(w) = self.go_package_value_type(n)? {
-                        return Ok(Some((w, n.file_path.clone())));
-                    }
-                }
-                Ok(None)
+                self.go_named_local_written(&name, expr, file_text, r)
             }
-            "index_expression" | "slice_expression" => {
+            "index_expression" => {
                 let Some(operand) = expr.child_by_field_name("operand") else { return Ok(None); };
                 let Some((text, at)) = self.go_expr_written(operand, file_text, r)? else {
                     return Ok(None);
                 };
                 self.go_element_of(&text, &at, 0)
             }
+            "slice_expression" => {
+                // `x[a:b]` keeps the slice's own type — `[]T` stays `[]T`, a
+                // named `Items` stays `Items`; `[N]T` cuts to `[]T`.
+                let Some(operand) = expr.child_by_field_name("operand") else { return Ok(None); };
+                let Some((text, at)) = self.go_expr_written(operand, file_text, r)? else {
+                    return Ok(None);
+                };
+                let trimmed = text.trim_start_matches('*').trim_start();
+                Ok(Some(if trimmed.starts_with('[') && trimmed[1..].chars().next().is_some_and(|c| c.is_ascii_digit()) {
+                    let p = trimmed.find(']').unwrap_or(1);
+                    (format!("[]{}", trimmed[p + 1..].trim()), at)
+                } else {
+                    (trimmed.to_string(), at)
+                }))
+            }
             "selector_expression" => {
                 let (Some(op), Some(field)) =
                     (expr.child_by_field_name("operand"), expr.child_by_field_name("field"))
                 else {
                     return Ok(None);
                 };
-                if op.kind() != "identifier" {
-                    return Ok(None);
-                }
-                let base = file_text[op.byte_range()].to_string();
                 let field = file_text[field.byte_range()].to_string();
-                // `pkg.Name` — a qualified type, not a field read.
-                if self.go_imported_package_dir(&file, &base)?.is_some() {
-                    return Ok(Some((format!("{base}.{field}"), file)));
+                if op.kind() == "identifier" {
+                    let base = file_text[op.byte_range()].to_string();
+                    // `pkg.Name` — a qualified type, not a field read.
+                    if self.go_imported_package_dir(&file, &base)?.is_some() {
+                        return Ok(Some((format!("{base}.{field}"), file)));
+                    }
+                    let Some((base_ty, base_at)) = self.go_expr_written(op, file_text, r)? else {
+                        return Ok(None);
+                    };
+                    // A literal type's package can't be named — the text
+                    // itself settles the read (Outside), never a name cue.
+                    let Some((tn, dir)) = self.go_type_package(&base_ty, &base_at)? else {
+                        return Ok(Some((base_ty, base_at)));
+                    };
+                    return self.go_field_type(&tn, &field, &dir);
                 }
-                let Some(base_ty) = self.infer_local_receiver_type(&base, r, true)? else {
+                // `f().F`, `x[0].F`, `(a).F` — the field the operand's type
+                // declares.
+                let Some((w, at)) = self.go_expr_written(op, file_text, r)? else {
                     return Ok(None);
                 };
-                let Some((tn, dir)) = self.go_type_package(&base_ty, &file)? else {
-                    return Ok(None);
+                let Some((tn, dir)) = self.go_type_package(&w, &at)? else {
+                    return Ok(Some((w, at)));
                 };
                 self.go_field_type(&tn, &field, &dir)
             }
             "type_assertion_expression" => Ok(expr
                 .child_by_field_name("type")
                 .map(|t| (file_text[t.byte_range()].trim().to_string(), file))),
+            "type_conversion_expression" => {
+                let Some(t) = expr.child_by_field_name("type") else { return Ok(None) };
+                let text = file_text[t.byte_range()].trim().to_string();
+                // `F[T](x)` parses as a conversion; when its type names a
+                // function rather than a declared type it is a generic call
+                // — the callee's result types it, not the "converted" name.
+                if let Some(named) = Self::go_named_type(&text) {
+                    let (q, name) = named.split_once('.')
+                        .map(|(a, b)| (Some(a.to_string()), b.to_string()))
+                        .unwrap_or((None, named));
+                    let dir = match &q {
+                        Some(q) => self.go_imported_package_dir(&file, q)?,
+                        None => Some(pos_dirname(&file).to_string()),
+                    };
+                    if let Some(d) = dir {
+                        if self.go_package_types(&name, &d)?.is_empty() {
+                            for f in self.nodes_by_name(&name)?.iter().filter(|n| {
+                                n.language == "go" && n.kind == "function" && pos_dirname(&n.file_path) == d
+                            }) {
+                                if let Some(t) = self.go_call_result_at(f, result_idx) {
+                                    return Ok(Some((t, f.file_path.clone())));
+                                }
+                            }
+                        }
+                    }
+                }
+                Ok(Some((text, file)))
+            }
             "composite_literal" => Ok(expr
                 .child_by_field_name("type")
                 .map(|t| (file_text[t.byte_range()].trim().to_string(), file))),
@@ -402,6 +704,59 @@ impl KernelResolver {
             }
             "call_expression" => {
                 let Some(function) = expr.child_by_field_name("function") else { return Ok(None); };
+                // `F[T](x)` — the callee sits under the instantiation as a
+                // qualified_type/type_identifier, not the expression
+                // grammar's selector/identifier shapes.
+                let function = if function.kind() == "type_instantiation_expression" {
+                    function.child_by_field_name("type").unwrap_or(function)
+                } else {
+                    function
+                };
+                if function.kind() == "qualified_type" {
+                    let q = function.child_by_field_name("package").map(|n| file_text[n.byte_range()].to_string());
+                    let callee = function.child_by_field_name("name").map(|n| file_text[n.byte_range()].to_string());
+                    if let (Some(q), Some(callee)) = (q, callee) {
+                        if self.go_is_outside_package(&q, &file)? {
+                            return Ok(None);
+                        }
+                        if let Some(d) = self.go_imported_package_dir(&file, &q)? {
+                            if !self.go_package_types(&callee, &d)?.is_empty() {
+                                return Ok(Some((format!("{q}.{callee}"), file)));
+                            }
+                            for f in self.nodes_by_name(&callee)?.iter().filter(|n| {
+                                n.language == "go" && n.kind == "function" && pos_dirname(&n.file_path) == d
+                            }) {
+                                if let Some(t) = self.go_call_result_at(f, result_idx) {
+                                    return Ok(Some((t, f.file_path.clone())));
+                                }
+                            }
+                        }
+                        return Ok(None);
+                    }
+                }
+                if function.kind() == "type_identifier" {
+                    let callee = &file_text[function.byte_range()];
+                    let own = pos_dirname(&file);
+                    for f in self.nodes_by_name(callee)?.iter().filter(|n| {
+                        n.language == "go" && n.kind == "function" && pos_dirname(&n.file_path) == own
+                    }) {
+                        if let Some(t) = self.go_call_result_at(f, result_idx) {
+                            return Ok(Some((t, f.file_path.clone())));
+                        }
+                    }
+                    return Ok(None);
+                }
+                // A conversion spells its result type where a call spells a
+                // name: `[]T(x)`, `Pair[A,B](x)`, `map[K]V(x)`, `(*T)(x)`.
+                if matches!(
+                    function.kind(),
+                    "slice_type" | "map_type" | "pointer_type" | "generic_type" | "array_type"
+                ) {
+                    return Ok(Some((file_text[function.byte_range()].trim().to_string(), file)));
+                }
+                if function.kind() == "parenthesized_expression" {
+                    return Ok(function.named_child(0).map(|t| (file_text[t.byte_range()].trim().to_string(), file)));
+                }
                 if function.kind() == "identifier" {
                     let callee = &file_text[function.byte_range()];
                     if matches!(callee, "new" | "make") {
@@ -430,45 +785,76 @@ impl KernelResolver {
                                 if !self.go_package_types(callee, &d)?.is_empty() {
                                     return Ok(Some((format!("{q}.{callee}"), file)));
                                 }
-                                // `pkg.F(…)` — F's first result.
+                                // `pkg.F(…)` — F's result.
                                 for f in self.nodes_by_name(callee)?.iter().filter(|n| {
                                     n.language == "go" && n.kind == "function" && pos_dirname(&n.file_path) == d
                                 }) {
-                                    if let Some(t) = self.go_call_result(f) {
+                                    if let Some(t) = self.go_call_result_at(f, result_idx) {
                                         return Ok(Some((t, f.file_path.clone())));
                                     }
                                 }
                                 return Ok(None);
                             }
                             // `m.F(…)` — F's first result, on m's type.
-                            let Some(base_ty) = self.infer_local_receiver_type(q, r, true)? else {
+                            let Some((base_ty, base_at)) = self.go_expr_written(operand, file_text, r)? else {
                                 return Ok(None);
                             };
-                            let Some((tn, dir)) = self.go_type_package(&base_ty, &file)? else {
-                                return Ok(None);
+                            let Some((tn, dir)) = self.go_type_package(&base_ty, &base_at)? else {
+                                return Ok(Some((base_ty, base_at)));
                             };
+                            let want = format!("{tn}::{callee}");
+                            let suffix = format!("::{want}");
                             for f in self.nodes_by_name(callee)?.iter().filter(|n| {
                                 n.language == "go"
                                     && n.kind == "method"
                                     && pos_dirname(&n.file_path) == dir
-                                    && n.qualified_name.contains(&format!("::{tn}"))
+                                    && (n.qualified_name == want
+                                        || n.qualified_name.ends_with(&suffix))
                             }) {
-                                if let Some(t) = self.go_call_result(f) {
+                                if let Some(t) = self.go_call_result_at(f, result_idx) {
                                     return Ok(Some((t, f.file_path.clone())));
                                 }
                             }
+                            // `h.get()` — a field of func type called as a
+                            // callee: its type is no named method holder's.
+                            if let Some((ft, at)) = self.go_field_type(&tn, callee, &dir)? {
+                                return Ok(Some((ft, at)));
+                            }
+                            return Ok(None);
+                        }
+                        // `f().G(…)`, `x[0].G(…)` — the method's first
+                        // result on the operand's type.
+                        let callee = file_text[field.byte_range()].to_string();
+                        let Some((w, at)) = self.go_expr_written(operand, file_text, r)? else {
                             return Ok(None);
+                        };
+                        let Some((tn, dir)) = self.go_type_package(&w, &at)? else {
+                            return Ok(Some((w, at)));
+                        };
+                        let want = format!("{tn}::{callee}");
+                        let suffix = format!("::{want}");
+                        for f in self.nodes_by_name(&callee)?.iter().filter(|n| {
+                            n.language == "go"
+                                && n.kind == "method"
+                                && pos_dirname(&n.file_path) == dir
+                                && (n.qualified_name == want
+                                    || n.qualified_name.ends_with(&suffix))
+                        }) {
+                            if let Some(t) = self.go_call_result_at(f, result_idx) {
+                                return Ok(Some((t, f.file_path.clone())));
+                            }
                         }
+                        return Ok(None);
                     }
                 }
-                // `f(…)` on a project function — its first result.
+                // `f(…)` on a project function — its result.
                 if function.kind() == "identifier" {
                     let callee = &file_text[function.byte_range()];
                     let own = pos_dirname(&file);
                     for f in self.nodes_by_name(callee)?.iter().filter(|n| {
                         n.language == "go" && n.kind == "function" && pos_dirname(&n.file_path) == own
                     }) {
-                        if let Some(t) = self.go_call_result(f) {
+                        if let Some(t) = self.go_call_result_at(f, result_idx) {
                             return Ok(Some((t, f.file_path.clone())));
                         }
                     }
@@ -479,10 +865,89 @@ impl KernelResolver {
         }
     }
 
+    /// Whether a `.go` file of package `dir` that the index read nothing
+    /// from declares `type::method` — or itself can't be read (its methods
+    /// are then unknowable): kubernetes' oversized generated.pb.go. The
+    /// method the graph is missing is not the one an embedded type has.
+    pub(super) fn go_unread_file_declares(&mut self, type_name: &str, method: &str, dir: &str) -> Res<bool> {
+        let files = self.sorted_files().unwrap_or_default();
+        let mut unread: Vec<String> = files
+            .iter()
+            .filter(|f| {
+                f.ends_with(".go") && !f.ends_with("_test.go") && pos_dirname(f) == dir && self.known_file(f)
+            })
+            .filter(|f| self.nodes_in_file(f).map(|l| l.is_empty()).unwrap_or(true))
+            .cloned()
+            .collect();
+        // A path the index never recorded still sits on disk.
+        if let Ok(rd) = std::fs::read_dir(pos_resolve(&self.root_abs, dir)) {
+            for e in rd.flatten() {
+                let name = e.file_name().to_string_lossy().to_string();
+                if !name.ends_with(".go") || name.ends_with("_test.go") {
+                    continue;
+                }
+                let f = if dir.is_empty() { name.clone() } else { format!("{dir}/{name}") };
+                if !unread.contains(&f) && self.nodes_in_file(&f).map(|l| l.is_empty()).unwrap_or(true) {
+                    unread.push(f);
+                }
+            }
+        }
+        for f in unread {
+            let ms = self.go_unread_file_methods(&f)?;
+            match ms {
+                None => return Ok(true),
+                Some(ms) if ms.contains(&format!("{type_name}::{method}")) => return Ok(true),
+                _ => {}
+            }
+        }
+        Ok(false)
+    }
+
+    /// `Type::Method` names a file the index couldn't read declares, from
+    /// its text (`goUnreadFileMethods`). `None` when the file can't be read.
+    fn go_unread_file_methods(&mut self, f: &str) -> Res<Option<std::collections::HashSet<String>>> {
+        if let Some(hit) = self.go_unread_methods_memo.get(f) {
+            return Ok(hit.clone());
+        }
+        // GO_UNREAD_SCAN_BYTES — the sweep reads far past the indexer's 1
+        // MB cap, which is exactly why these files are unread.
+        const GO_UNREAD_SCAN_BYTES: u64 = 32 * 1024 * 1024;
+        let path = pos_resolve(&self.root_abs, f);
+        let methods = (|| {
+            let meta = std::fs::metadata(&path).ok()?;
+            if !meta.is_file() || meta.len() > GO_UNREAD_SCAN_BYTES {
+                return None;
+            }
+            let raw = std::fs::read(&path).ok()?;
+            let text = String::from_utf8(raw).unwrap_or_else(|e| String::from_utf8_lossy(e.as_bytes()).into_owned());
+            let mut set = std::collections::HashSet::new();
+            let re = re!(r"(?m)^func\s*\(\s*(?:[A-Za-z_]\w*\s+)?\*?\s*([A-Za-z_]\w*)\s*(?:\[[^\]\n]*\])?\s*\)\s*([A-Za-z_]\w*)\s*[\[(]");
+            for m in re.captures_iter(&text) {
+                set.insert(format!("{}::{}", &m[1], &m[2]));
+            }
+            Some(set)
+        })();
+        self.go_unread_methods_memo.insert(f.to_string(), methods.clone());
+        Ok(methods)
+    }
+
     /// The settled type of `expr` where `r` is read: a project type with its
     /// package, `Outside`, or `None` (unreadable — name matching decides).
     fn go_expr_type(&mut self, expr: TsNode, file_text: &str, r: &ResolveRefIn) -> Res<Option<GoAsserted>> {
         let Some((written, at)) = self.go_expr_written(expr, file_text, r)? else { return Ok(None); };
+        // A type parameter is its constraint, never the package's namesake
+        // type: `F[T interface{…}]` → literal (nothing to read), `F[T
+        // model.Validator]` → the constraint's type.
+        if let Some(named) = Self::go_named_type(&written) {
+            if !named.contains('.') {
+                if let Some(constraint) = self.go_type_param_constraint(&named, r)? {
+                    return match Self::go_named_type(&constraint) {
+                        Some(_) => self.go_written_type(&constraint, r),
+                        None => Ok(Some(GoAsserted::Outside)),
+                    };
+                }
+            }
+        }
         let mut site = r.clone();
         site.file_path = at;
         self.go_written_type(&written, &site)
@@ -511,7 +976,7 @@ impl KernelResolver {
                 if let Some(function) = node.child_by_field_name("function") {
                     if function.kind() == "selector_expression" {
                         if let Some(field) = function.child_by_field_name("field") {
-                            if &file.text()[field.byte_range()] == r.reference_name {
+                            if file.text()[field.byte_range()] == r.reference_name {
                                 selector = Some(function);
                                 break;
                             }
@@ -535,13 +1000,16 @@ impl KernelResolver {
         match operand.kind() {
             // `x.M` arrives as a dotted ref, never a bare name.
             "identifier" => Ok(None),
-            _ => Ok(match self.go_expr_type(operand, file.text(), r)? {
-                Some(GoAsserted::Project { name, dir }) => {
-                    Some(self.go_method_in_package(&name, &r.reference_name, &dir, r)?)
-                }
-                Some(GoAsserted::Outside) => Some(None),
-                None => None,
-            }),
+            _ => {
+                let ty = self.go_expr_type(operand, file.text(), r)?;
+                Ok(match ty {
+                    Some(GoAsserted::Project { name, dir }) => {
+                        Some(self.go_method_in_package(&name, &r.reference_name, &dir, r)?)
+                    }
+                    Some(GoAsserted::Outside) => Some(None),
+                    None => None,
+                })
+            }
         }
     }
 }
diff --git a/codegraph-kernel/src/resolve/method_call.rs b/codegraph-kernel/src/resolve/method_call.rs
index 57f5eb7e7..4593c8e9c 100644
--- a/codegraph-kernel/src/resolve/method_call.rs
+++ b/codegraph-kernel/src/resolve/method_call.rs
@@ -628,6 +628,20 @@ impl KernelResolver {
         }
 
         // `this.#field.method` keeps its ES private field (#1987).
+        // A Go composite literal's written type carries its type arguments
+        // (`Box[int]{}.Size` arrives as `Box[int].Size`, `lib.List[int]{}.Len`
+        // as `lib.List[int].Len`); an indexed receiver arrives bare, so a
+        // bracketed receiver here is always an instantiation.
+        if r.language == "go" {
+            if let Some(m) = re!(r"^([A-Za-z0-9_.]+\[[^\]]*\])\.([A-Za-z0-9_]+)$").captures(&r.reference_name) {
+                return Ok(McShape::Parsed {
+                    receiver: m[1].to_string(),
+                    method: m[2].to_string(),
+                    inferable: true,
+                    dotted: true,
+                });
+            }
+        }
         let dot_re = re!(r"^((?:this\.#)?[A-Za-z0-9_.]+)\.([A-Za-z0-9_]+:?(?:[A-Za-z0-9_]+:)*)$");
         // A JS/TS method name may carry `$`, which `\w` doesn't: an RxJS-style
         // `this.organizationService.organizations$()`, vscode's RPC
@@ -687,6 +701,14 @@ impl KernelResolver {
 
         if inferable {
             if r.language == "go" {
+                // `Box[int]`/`lib.List[int]` is the written type of the
+                // composite literal the call selects on — the type's method
+                // answers, or nothing does; no local inference applies.
+                if let Some(base) = object_or_class.strip_suffix(']').and_then(|s| s.split('[').next()) {
+                    if re!(r"^\*?[A-Za-z_]\w*(\.[A-Za-z_]\w*)?$").is_match(base) {
+                        return self.go_method_on_declared_type(base, &r.file_path, &method_name, r);
+                    }
+                }
                 if let Some(verdict) = self.go_asserted_member(&object_or_class, &method_name, r)? {
                     if verdict.is_none() { self.go_mc_terminal = true; }
                     return Ok(verdict);
@@ -703,16 +725,13 @@ impl KernelResolver {
                     if let Some(decl) = self.go_local_declaration_at(
                         object_or_class.clone(), r.file_path.clone(), r.line, r.column)?
                     {
-                        match &decl.declared_type {
-                            Some(text) => {
-                                if Self::go_named_type(text).is_none()
-                                    || matches!(self.go_written_type(text, r)?, Some(super::go_asserted::GoAsserted::Outside))
-                                {
-                                    self.go_mc_terminal = true;
-                                    return Ok(None);
-                                }
+                        if let Some(text) = &decl.declared_type {
+                            if Self::go_named_type(text).is_none()
+                                || matches!(self.go_written_type(text, r)?, Some(super::go_asserted::GoAsserted::Outside))
+                            {
+                                self.go_mc_terminal = true;
+                                return Ok(None);
                             }
-                            _ => {}
                         }
                     }
                 }
@@ -754,6 +773,7 @@ impl KernelResolver {
             }
             // TS passes requireReceiverEvidence (=true) as preserveQualifiedName
             // to both inferrers here — qualified names stay intact.
+            let mut go_type_file: Option<String> = None;
             let mut inferred = if matches!(r.language.as_str(), "java" | "kotlin" | "csharp") && self.explicit_this_receiver(&object_or_class, &method_name, r) {
                 self.infer_declared_member_receiver_type(&format!("this.{object_or_class}"), r)?
             } else if r.language == "cpp" {
@@ -761,7 +781,18 @@ impl KernelResolver {
             } else if r.language == "python" && object_or_class.contains('.') {
                 None
             } else {
-                probe!(r, "mc:infer-local", self.infer_local_receiver_type(&object_or_class, &site, true)?)
+                let local = if r.language == "go" && !object_or_class.contains('.') {
+                    match self.go_local_receiver_written(&object_or_class, r)? {
+                        Some((t, f)) => { go_type_file = Some(f); Some(t) }
+                        None => None,
+                    }
+                } else {
+                    None
+                };
+                probe!(r, "mc:infer-local", match local {
+                    Some(_) => Ok(local),
+                    None => self.infer_local_receiver_type(&object_or_class, &site, true),
+                }?)
             };
             if r.language == "objc" && inferred.is_none() {
                 inferred = self.objc_member_receiver_type(&object_or_class, r)?;
@@ -830,6 +861,12 @@ if inferred.is_none() && r.language == "dart" {
                 if let Some(b) = &binding {
                     bsite.line = b.line;
                 }
+                // A Go type the written source read names the file that
+                // knows its package (`model := query.Query().Session` —
+                // Session lives in query/, not the call's).
+                if let Some(f) = &go_type_file {
+                    bsite.file_path = f.clone();
+                }
                 let member = self.match_bound_type_member(&t, &method_name, &bsite)?;
                 if member.is_none() && r.language == "go" {
                     // A Go standard method name the declared type lacks is no
@@ -933,6 +970,7 @@ if inferred.is_none() && r.language == "dart" {
             // inferrers run at the ref's own site with qualified names
             // normalized (preserveQualifiedName=false).
             let cpp_alias = if r.language == "cpp" { self.cpp_receiver_alias(&object_or_class, r)? } else { None };
+            let mut go_type_file: Option<String> = None;
             let inferred = if let Some(alias) = &cpp_alias {
                 match &alias.raw {
                     Some(raw) => match self.cpp_type_owner(raw, &alias.site, 0, false)? {
@@ -945,6 +983,11 @@ if inferred.is_none() && r.language == "dart" {
                 self.infer_cpp_receiver_type(&object_or_class, r, 0, false)?
             } else if r.language == "python" && object_or_class.contains('.') {
                 None
+            } else if r.language == "go" && !object_or_class.contains('.') {
+                match self.go_local_receiver_written(&object_or_class, r)? {
+                    Some((t, f)) => { go_type_file = Some(f); Some(t) }
+                    None => self.infer_local_receiver_type(&object_or_class, r, true)?,
+                }
             } else {
                 self.infer_local_receiver_type(&object_or_class, r, r.language == "go")?
             };
@@ -1027,9 +1070,10 @@ if inferred.is_none() && r.language == "dart" {
                     }
                 }
                 // An awaited type resolves from the file that declares it,
-                // and a hit on that type itself must live there.
+                // and a hit on that type itself must live there. A Go type
+                // the written source read names that file the same way.
                 let mut site = r.clone();
-                if let Some(f) = &awaited_file {
+                if let Some(f) = awaited_file.as_ref().or(go_type_file.as_ref()) {
                     site.file_path = f.clone();
                 }
                 match self.resolve_method_on_type(
@@ -1545,15 +1589,24 @@ if inferred.is_none() && r.language == "dart" {
                 if (r.language == "java" || r.language == "kotlin" || r.language == "python") && self.resolve_bound_type(root, r, 0)?.is_some() {
                     return if receiver == root { self.match_bound_type_member(root, method, r) } else { self.enum_constant_call(receiver, method, r) };
                 }
-                return Ok(match self.resolve_via_import_member(r)? {
-                    Some(c) => {
-                        if matches!(
-                            c.node.kind.as_str(),
-                            "function" | "method" | "class" | "component"
-                        ) {
-                            Some(c)
-                        } else {
-                            None
+                let via_import = self.resolve_via_import_member(r)?.filter(|c| {
+                    matches!(
+                        c.node.kind.as_str(),
+                        "function" | "method" | "class" | "component"
+                    )
+                });
+                return Ok(match via_import {
+                    Some(c) => Some(c),
+                    // A Go `pkg.Type{}.M`/`pkg.Type[args]{}.M` keeps the
+                    // composite literal's written type — `pkg.Type`'s method
+                    // or nothing.
+                    None if r.language == "go" => {
+                        match re!(r"^([A-Za-z_]\w*\.[A-Za-z_]\w*)\[[^\]]*\]$")
+                            .captures(receiver)
+                            .or_else(|| re!(r"^([A-Za-z_]\w*\.[A-Za-z_]\w*)$").captures(receiver))
+                        {
+                            Some(m) => self.go_method_on_declared_type(&m[1], &r.file_path, method, r)?,
+                            None => None,
                         }
                     }
                     None => None,
@@ -1570,6 +1623,16 @@ if inferred.is_none() && r.language == "dart" {
             // The import resolver descends one member — a deeper receiver
             // must not mistake the first member for the call.
             if receiver.contains('.') {
+                // A Go `pkg.Type{}.M`/`pkg.Type[args]{}.M` keeps the
+                // literal's written type — `pkg.Type`'s method or nothing.
+                if r.language == "go" {
+                    if let Some(m) = re!(r"^([A-Za-z_]\w*\.[A-Za-z_]\w*)\[[^\]]*\]$")
+                        .captures(receiver)
+                        .or_else(|| re!(r"^([A-Za-z_]\w*\.[A-Za-z_]\w*)$").captures(receiver))
+                    {
+                        return self.go_method_on_declared_type(&m[1], &r.file_path, method, r);
+                    }
+                }
                 return Ok(None);
             }
             return Ok(match self.resolve_via_import_member(r)? {
diff --git a/codegraph-kernel/src/resolve/mod.rs b/codegraph-kernel/src/resolve/mod.rs
index 3b2a0c079..dc3817d4e 100644
--- a/codegraph-kernel/src/resolve/mod.rs
+++ b/codegraph-kernel/src/resolve/mod.rs
@@ -699,6 +699,8 @@ pub struct KernelResolver {
     go_mc_untyped_local: bool,
     /// goAliasTarget, by type node id.
     go_alias_target_memo: HashMap<String, fields::GoAliasTarget>,
+    /// goUnreadFileMethods, by file path: `None` when the file can't be read.
+    go_unread_methods_memo: HashMap<String, Option<HashSet<String>>>,
     /// javaSupertypesOf, by type name.
     java_supers_memo: HashMap<String, Rc<Vec<String>>>,
     /// phpSupertypeQns, by declaration id.
@@ -970,6 +972,7 @@ impl KernelResolver {
             go_mc_terminal: false,
             go_mc_untyped_local: false,
             go_alias_target_memo: HashMap::new(),
+            go_unread_methods_memo: HashMap::new(),
             java_supers_memo: HashMap::new(),
             php_supers_memo: HashMap::new(),
             vb: vbnet::VbMemo::default(),
diff --git a/codegraph-kernel/src/resolve/pipeline.rs b/codegraph-kernel/src/resolve/pipeline.rs
index 3c91cbc79..4859a7b90 100644
--- a/codegraph-kernel/src/resolve/pipeline.rs
+++ b/codegraph-kernel/src/resolve/pipeline.rs
@@ -707,9 +707,6 @@ if super::lang_scope::is_dart_member_read(r) {
                 } else if self.go_written_qualifier(r)?.is_none() {
                     self.go_bare_type_dir(name, &r.file_path)?
                 } else { None };
-                if std::env::var_os("CODEGRAPH_KERNEL_DEBUG_GO").is_some() {
-                    eprintln!("[go-gate] {} {} in {} cand={}:{} pkg={:?}", r.reference_name, r.reference_kind, r.file_path, cand.node.kind, cand.node.file_path, package);
-                }
                 if let Some(package) = package {
                     let types: Vec<_> = self.nodes_by_name(name)?.iter()
                         .filter(|n| n.language == "go" && matches!(n.kind.as_str(), "struct" | "interface" | "type_alias")
@@ -1248,9 +1245,6 @@ if r.language == "dart" && r.reference_kind == "references"
         if !matches!(winner.resolved_by, "import" | "framework" | "file-path")
             && !self.is_visible_across_files(&winner.node, r)?
         {
-            if std::env::var_os("CODEGRAPH_KERNEL_DEBUG_VIS").is_some() {
-                eprintln!("[vis-veto] {} {:?} via={} -> {}:{} {}:{}", r.reference_name, r.reference_kind, winner.resolved_by, winner.node.id, winner.node.kind, winner.node.file_path, winner.node.start_line);
-            }
             return Ok(ResolveOutcome::unresolved());
         }
         Ok(ResolveOutcome::resolved(
diff --git a/codegraph-kernel/src/resolve/receivers.rs b/codegraph-kernel/src/resolve/receivers.rs
index 28c053019..f6efcd70f 100644
--- a/codegraph-kernel/src/resolve/receivers.rs
+++ b/codegraph-kernel/src/resolve/receivers.rs
@@ -903,7 +903,7 @@ fn go_bare_result(
         }
         if let Some(id) = binding.node_id.as_deref() {
             let Some(node) = self.node_by_id(id)? else { return Ok(None) };
-            return Ok(go_result_from_node(&node).map(|ty| (ty, node)));
+            return Ok(go_result_from_node(self, &node).map(|ty| (ty, node)));
         }
         return Ok(None);
     }
@@ -915,7 +915,7 @@ fn go_bare_result(
             && pos_dirname(&n.file_path) == dir)
         .cloned().collect();
     let [node] = nodes.as_slice() else { return Ok(None) };
-    Ok(go_result_from_node(node).map(|ty| (ty, node.clone())))
+    Ok(go_result_from_node(self, node).map(|ty| (ty, node.clone())))
 }
 
     /// cppClassExists — an aggregate type with this last `::` segment exists.
@@ -1088,7 +1088,7 @@ fn go_bare_result(
                 && pos_dirname(&n.file_path) == dir)
             .cloned().collect();
         let [callee] = nodes.as_slice() else { return Ok(None) };
-        let Some(raw) = go_result_from_node(callee) else { return Ok(None) };
+        let Some(raw) = go_result_from_node(self, callee) else { return Ok(None) };
         self.go_method_on_declared_type(&raw, &callee.file_path, method, r)
     }
 
@@ -1218,9 +1218,12 @@ pub(super) fn pick_closest_jvm_candidate(candidates: &[Arc<KNode>], from_path: &
     best.clone()
 }
 
-fn go_result_from_node(node: &KNode) -> Option<String> {
+fn go_result_from_node(resolver: &mut KernelResolver, node: &KNode) -> Option<String> {
     if node.kind == "function" {
-        return node.return_type.clone().filter(|ty| !ty.is_empty());
+        // The result a type parameter spells is its constraint: `V` of
+        // `F[V Validator]` carries Validator's methods, `T` of `F[T any]`
+        // none — go_call_result_at reads the declaration for it.
+        return resolver.go_call_result_at(node, 0);
     }
     if !matches!(node.kind.as_str(), "variable" | "constant") {
         return None;
diff --git a/codegraph-kernel/src/resolve/resolver_upstream.rs b/codegraph-kernel/src/resolve/resolver_upstream.rs
index 439cc470d..7c5e7e760 100644
--- a/codegraph-kernel/src/resolve/resolver_upstream.rs
+++ b/codegraph-kernel/src/resolve/resolver_upstream.rs
@@ -574,13 +574,18 @@ impl KernelResolver {
         if r.language != "go" || r.reference_kind == "imports" {
             return Ok(None);
         }
-        if let Some((root, _)) = r.reference_name.split_once('.') {
-            if !re!(r"^[A-Za-z_]\w*$").is_match(root) || self.is_shadowed_import(root, r)? { return Ok(None); }
-            if !self.import_mappings(&r.file_path)?.iter().any(|m| m.local_name == root)
-                && self.nodes_by_name(root)?.iter().any(|n| n.language == "go"
-                    && matches!(n.kind.as_str(), "struct" | "interface" | "type_alias")
-                    && pos_dirname(&n.file_path) == pos_dirname(&r.file_path)) { return Ok(None); }
-            return Ok(Some(root.to_string()));
+        if let Some((root, rest)) = r.reference_name.split_once('.') {
+            // The root qualifies the leaf only in a `pkg.Name` ref — in
+            // `pkg.Type[args].M` or `pkg.F().M` it qualifies the receiver,
+            // not the method.
+            if re!(r"^[A-Za-z_]\w*$").is_match(rest) {
+                if !re!(r"^[A-Za-z_]\w*$").is_match(root) || self.is_shadowed_import(root, r)? { return Ok(None); }
+                if !self.import_mappings(&r.file_path)?.iter().any(|m| m.local_name == root)
+                    && self.nodes_by_name(root)?.iter().any(|n| n.language == "go"
+                        && matches!(n.kind.as_str(), "struct" | "interface" | "type_alias")
+                        && pos_dirname(&n.file_path) == pos_dirname(&r.file_path)) { return Ok(None); }
+                return Ok(Some(root.to_string()));
+            }
         }
         let name = r.reference_name.rsplit('.').next().unwrap_or(&r.reference_name);
         if !re!(r"^[A-Za-z_]\w*$").is_match(name) {
@@ -611,7 +616,7 @@ impl KernelResolver {
     }
 
     pub(super) fn go_ref_qualifier(&mut self, r: &ResolveRefIn) -> Res<Option<KImport>> {
-        let Some(root) = self.go_written_qualifier(r)? else { return Ok(None); };
+        let Some(root) = self.go_written_qualifier(r)? else { return Ok(None) };
         Ok(self.import_mappings(&r.file_path)?.iter().find(|imp| imp.local_name == root).cloned())
     }
 

From 4b727b659662aa9960d0bc920d16f03467b6c878 Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Wed, 28 Oct 2026 21:50:29 -0600
Subject: [PATCH 15/30] feat(kernel): Go build-constraint twins, external test
 packages, conversion refs (#2581)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Port upstream 800e582d's three Go semantics into the kernel:

- A `pkg.Type(…)` conversion resolves its type through the import
  member arm — the kind filter now accepts Go exported member kinds
  (struct/interface/type_alias/variable/constant), which the TS
  edge-kind rewrite then turns into a `references` edge.
- `go_name_visible` is clause-aware: files sharing a directory but
  declaring different package clauses (`a` vs `a_test`) see each
  other's bare top-level names only through an import — qualified,
  or bare after a dot import and exported.
- New `go_build.rs` ports `goFileConstraint`/`preferGoBuildTwin`:
  `//go:build` and `// +build` expressions plus `_GOOS`/`_GOARCH`
  filename suffixes evaluate against the ordered GO_BUILD_TARGETS;
  a resolved target with constrained twins retargets to the twin
  the reference's own file builds with, and `go_pick_twin` collapses
  multi-candidate package members the import arm couldn't pick.

Also fixes the fork's `go-type-visibility.ts`: module-root packages
spell their dir `''` (matching `getGoPackageDir` and kernel
`pos_dirname`), so `goTypePositionTarget` retargets a namesake
function to the module-root type.
---
 __tests__/fixtures/golden/payroll-go.dump   |   6 +-
 codegraph-kernel/src/resolve/go_build.rs    | 457 ++++++++++++++++++++
 codegraph-kernel/src/resolve/imports.rs     |   5 +
 codegraph-kernel/src/resolve/method_call.rs |   8 +-
 codegraph-kernel/src/resolve/mod.rs         |  13 +-
 codegraph-kernel/src/resolve/names.rs       |  38 +-
 codegraph-kernel/src/resolve/pipeline.rs    |  23 +-
 src/resolution/go-type-visibility.ts        |   5 +-
 8 files changed, 534 insertions(+), 21 deletions(-)
 create mode 100644 codegraph-kernel/src/resolve/go_build.rs

diff --git a/__tests__/fixtures/golden/payroll-go.dump b/__tests__/fixtures/golden/payroll-go.dump
index 947aac69b..7012d043d 100644
--- a/__tests__/fixtures/golden/payroll-go.dump
+++ b/__tests__/fixtures/golden/payroll-go.dump
@@ -312,7 +312,7 @@
 {"id":"variable:6b7bef84822056845bdabeb41a821f0a","kind":"variable","name":"ErrCycleClosed","qualified_name":"ErrCycleClosed","file_path":"internal/usecase/payroll/cycle.go","language":"go","start_line":16,"end_line":16,"start_column":4,"end_column":58,"docstring":"ErrCycleClosed is returned when a cycle has already been finalized.","signature":"= errors.New(\"payroll cycle is closed\")","visibility":null,"is_exported":1,"is_async":0,"is_static":0,"is_abstract":0,"decorators":null,"type_parameters":null,"return_type":null}
 {"id":"variable:9c3a0c9681a69504be5d3af6ddb5378c","kind":"variable","name":"file_payroll_v1_payroll_proto_goTypes","qualified_name":"file_payroll_v1_payroll_proto_goTypes","file_path":"internal/gen/payrollpb/payroll.pb.go","language":"go","start_line":132,"end_line":137,"start_column":4,"end_column":1,"docstring":null,"signature":"= []any{\n\t(*RunPayrollCycleRequest)(nil),\n\t(*RunPayrollCycleResponse)(nil),\n\t(*Payslip)(nil),\n\t(*Payro...","visibility":null,"is_exported":0,"is_async":0,"is_static":0,"is_abstract":0,"decorators":null,"type_parameters":null,"return_type":null}
 {"id":"variable:baa4aee814b380ae99f1b1829407b106","kind":"variable","name":"ErrNoEmployees","qualified_name":"ErrNoEmployees","file_path":"internal/usecase/payroll/cycle.go","language":"go","start_line":19,"end_line":19,"start_column":4,"end_column":72,"docstring":"ErrNoEmployees is returned when a cycle resolves to an empty roster.","signature":"= errors.New(\"payroll cycle has no active employees\")","visibility":null,"is_exported":1,"is_async":0,"is_static":0,"is_abstract":0,"decorators":null,"type_parameters":null,"return_type":null}
-== edges (656)
+== edges (657)
 {"source":"file:69f63e0581b8138f256b63d2aac60e8a","target":"module:1be454da0953954aef45c525ee8f8b51","kind":"contains","metadata":null,"line":null,"col":null,"provenance":"heuristic"}
 {"source":"file:cmd/payrolld/main.go","target":"function:90eb51f51a3d9a397d4a53f26f2019aa","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"file:cmd/payrolld/main.go","target":"import:0a9ee69fa4c64208200c3bebcbbf0b75","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
@@ -672,6 +672,7 @@
 {"source":"interface:9382b4b7c3b120f81bd0566fb2d74864","target":"method:4df364d0c37da3d10e39207b87a94ca8","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"interface:9382b4b7c3b120f81bd0566fb2d74864","target":"method:a235478f8389c36b95d45a62664c4557","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
 {"source":"interface:a2c04a6e9d1203f224eb044d73e38f03","target":"method:d73f595573e869571a14f1606df5c296","kind":"contains","metadata":null,"line":null,"col":null,"provenance":null}
+{"source":"method:01c8a961c1fdfb54ea0c32614f905acc","target":"method:1b4f96e5a5a8b2784487acc4f7134ff7","kind":"calls","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"instance-method\",\"refName\":\"e.UnpaidLeaveCoversWindow\"}","line":155,"col":5,"provenance":null}
 {"source":"method:01c8a961c1fdfb54ea0c32614f905acc","target":"method:75bdf0b5152e4d85c947a608505c15c1","kind":"calls","metadata":"{\"confidence\":0.85,\"resolvedBy\":\"instance-method\",\"refName\":\"s.store.EmployeesForCycle\"}","line":137,"col":13,"provenance":null}
 {"source":"method:01c8a961c1fdfb54ea0c32614f905acc","target":"struct:4831ac24c172065fee6e46751021f7ba","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"import\",\"refName\":\"Cycle\"}","line":136,"col":63,"provenance":null}
 {"source":"method:01c8a961c1fdfb54ea0c32614f905acc","target":"struct:62563918fc7ed271ca7e2c7b11f2c17a","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"import\",\"refName\":\"Employee\"}","line":136,"col":98,"provenance":null}
@@ -969,7 +970,7 @@
 {"source":"variable:9c3a0c9681a69504be5d3af6ddb5378c","target":"struct:4325013490f7f7a77604146f5e38c292","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"RunPayrollCycleRequest\",\"refKind\":\"calls\"}","line":133,"col":1,"provenance":null}
 {"source":"variable:9c3a0c9681a69504be5d3af6ddb5378c","target":"struct:d541b867b240edf388feab5ff2002afd","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"Payslip\",\"refKind\":\"calls\"}","line":135,"col":1,"provenance":null}
 {"source":"variable:9c3a0c9681a69504be5d3af6ddb5378c","target":"struct:e66f442bcf28c3bd0a3f42fbacb69b2a","kind":"references","metadata":"{\"confidence\":0.9,\"resolvedBy\":\"exact-match\",\"refName\":\"RunPayrollCycleResponse\",\"refKind\":\"calls\"}","line":134,"col":1,"provenance":null}
-== refs (600)
+== refs (599)
 {"from_node_id":"file:cmd/payrolld/main.go","reference_name":"github.com/example/payroll-svc/internal/platform/clock","reference_kind":"imports","line":9,"col":1,"candidates":null,"file_path":"cmd/payrolld/main.go","language":"go","status":"failed","name_tail":"clock"}
 {"from_node_id":"file:cmd/payrolld/main.go","reference_name":"github.com/example/payroll-svc/internal/store/payslipstore","reference_kind":"imports","line":10,"col":1,"candidates":null,"file_path":"cmd/payrolld/main.go","language":"go","status":"failed","name_tail":"payslipstore"}
 {"from_node_id":"file:cmd/payrolld/main.go","reference_name":"github.com/example/payroll-svc/internal/transport/httpapi","reference_kind":"imports","line":11,"col":1,"candidates":null,"file_path":"cmd/payrolld/main.go","language":"go","status":"failed","name_tail":"httpapi"}
@@ -1272,7 +1273,6 @@
 {"from_node_id":"method:01c8a961c1fdfb54ea0c32614f905acc","reference_name":"cycle.ID","reference_kind":"function_ref","line":137,"col":50,"candidates":null,"file_path":"internal/usecase/payroll/cycle.go","language":"go","status":"failed","name_tail":"ID"}
 {"from_node_id":"method:01c8a961c1fdfb54ea0c32614f905acc","reference_name":"cycle.Start","reference_kind":"function_ref","line":152,"col":38,"candidates":null,"file_path":"internal/usecase/payroll/cycle.go","language":"go","status":"failed","name_tail":"Start"}
 {"from_node_id":"method:01c8a961c1fdfb54ea0c32614f905acc","reference_name":"e.Contract.OverlapsWindow","reference_kind":"calls","line":152,"col":6,"candidates":null,"file_path":"internal/usecase/payroll/cycle.go","language":"go","status":"failed","name_tail":"OverlapsWindow","failure_reason":"unknown-receiver"}
-{"from_node_id":"method:01c8a961c1fdfb54ea0c32614f905acc","reference_name":"e.UnpaidLeaveCoversWindow","reference_kind":"calls","line":155,"col":5,"candidates":null,"file_path":"internal/usecase/payroll/cycle.go","language":"go","status":"failed","name_tail":"UnpaidLeaveCoversWindow","failure_reason":"unknown-receiver"}
 {"from_node_id":"method:01c8a961c1fdfb54ea0c32614f905acc","reference_name":"len","reference_kind":"calls","line":147,"col":39,"candidates":null,"file_path":"internal/usecase/payroll/cycle.go","language":"go","status":"failed","name_tail":"len"}
 {"from_node_id":"method:01c8a961c1fdfb54ea0c32614f905acc","reference_name":"len","reference_kind":"calls","line":149,"col":5,"candidates":null,"file_path":"internal/usecase/payroll/cycle.go","language":"go","status":"failed","name_tail":"len"}
 {"from_node_id":"method:01c8a961c1fdfb54ea0c32614f905acc","reference_name":"make","reference_kind":"calls","line":147,"col":11,"candidates":null,"file_path":"internal/usecase/payroll/cycle.go","language":"go","status":"failed","name_tail":"make"}
diff --git a/codegraph-kernel/src/resolve/go_build.rs b/codegraph-kernel/src/resolve/go_build.rs
new file mode 100644
index 000000000..46fe3d300
--- /dev/null
+++ b/codegraph-kernel/src/resolve/go_build.rs
@@ -0,0 +1,457 @@
+//! preferGoBuildTwin and goFileConstraint (name-matcher.ts, #2581): a name a
+//! Go package defines once per build target resolves to the definition that
+//! builds for the most typical target the reference's own file builds for.
+
+use super::*;
+
+/// The operating systems and architectures go/build reads from a file name
+/// (its syslist).
+const GO_KNOWN_OS: &[&str] = &[
+    "aix", "android", "darwin", "dragonfly", "freebsd", "hurd", "illumos", "ios", "js", "linux",
+    "nacl", "netbsd", "openbsd", "plan9", "solaris", "wasip1", "windows", "zos",
+];
+const GO_KNOWN_ARCH: &[&str] = &[
+    "386", "amd64", "amd64p32", "arm", "armbe", "arm64", "arm64be", "loong64", "mips", "mipsle",
+    "mips64", "mips64le", "mips64p32", "mips64p32le", "ppc", "ppc64", "ppc64le", "riscv", "riscv64",
+    "s390", "s390x", "sparc", "sparc64", "wasm",
+];
+/// The systems the `unix` build tag holds for.
+const GO_UNIX_OS: &[&str] = &[
+    "aix", "android", "darwin", "dragonfly", "freebsd", "hurd", "illumos", "ios", "linux", "netbsd",
+    "openbsd", "solaris",
+];
+
+#[derive(Clone, Copy)]
+pub(super) struct GoTarget {
+    goos: &'static str,
+    goarch: &'static str,
+}
+
+/// GO_BUILD_TARGETS: the targets a Go name with build-constrained twins is
+/// read for, the most typical first: a Linux server, a Mac, Windows, then
+/// every other system on its usual architecture and Linux on every other
+/// architecture.
+fn go_build_targets() -> &'static [GoTarget] {
+    static TARGETS: std::sync::OnceLock<Vec<GoTarget>> = std::sync::OnceLock::new();
+    TARGETS.get_or_init(|| {
+        let usual = |goos: &str| match goos {
+            "js" | "wasip1" => "wasm",
+            "ios" | "android" => "arm64",
+            "aix" => "ppc64",
+            "zos" => "s390x",
+            "hurd" => "386",
+            _ => "amd64",
+        };
+        let mut targets = vec![
+            GoTarget { goos: "linux", goarch: "amd64" },
+            GoTarget { goos: "darwin", goarch: "arm64" },
+            GoTarget { goos: "windows", goarch: "amd64" },
+            GoTarget { goos: "linux", goarch: "arm64" },
+            GoTarget { goos: "darwin", goarch: "amd64" },
+            GoTarget { goos: "freebsd", goarch: "amd64" },
+        ];
+        for goos in GO_KNOWN_OS {
+            let goarch = usual(goos);
+            if !targets.iter().any(|t| t.goos == *goos && t.goarch == goarch) {
+                targets.push(GoTarget { goos, goarch });
+            }
+        }
+        for goarch in GO_KNOWN_ARCH {
+            if !targets.iter().any(|t| t.goos == "linux" && t.goarch == *goarch) {
+                targets.push(GoTarget { goos: "linux", goarch });
+            }
+        }
+        targets
+    })
+}
+
+/// goBuildTagHolds: whether a build tag holds for a target, as the go command
+/// sets them by default: the system and architecture (`android` is also
+/// `linux`, `ios` `darwin`, `illumos` `solaris`), `unix` on a Unix system, the
+/// `gc` compiler, cgo, and every `go1.N` release. Any other tag is unset.
+fn go_tag_holds(tag: &str, t: &GoTarget) -> bool {
+    if tag == t.goos || tag == t.goarch {
+        return true;
+    }
+    match tag {
+        "unix" => GO_UNIX_OS.contains(&t.goos),
+        "linux" => t.goos == "android",
+        "darwin" => t.goos == "ios",
+        "solaris" => t.goos == "illumos",
+        "gc" => true,
+        "cgo" => t.goos != "js" && t.goos != "wasip1",
+        _ => tag
+            .strip_prefix("go1.")
+            .is_some_and(|v| !v.is_empty() && v.bytes().all(|b| b.is_ascii_digit())),
+    }
+}
+
+/// A parsed build expression: a `//go:build` line, a `// +build` line, or a
+/// file-name suffix as a test of a target.
+enum BuildExpr {
+    Tag(String),
+    Not(Box<BuildExpr>),
+    And(Box<BuildExpr>, Box<BuildExpr>),
+    Or(Box<BuildExpr>, Box<BuildExpr>),
+}
+
+impl BuildExpr {
+    fn holds(&self, t: &GoTarget) -> bool {
+        match self {
+            Self::Tag(s) => go_tag_holds(s, t),
+            Self::Not(e) => !e.holds(t),
+            Self::And(a, b) => a.holds(t) && b.holds(t),
+            Self::Or(a, b) => a.holds(t) || b.holds(t),
+        }
+    }
+}
+
+fn build_tokens(text: &str) -> Vec<String> {
+    let b = text.as_bytes();
+    let mut out = Vec::new();
+    let mut i = 0;
+    while i < b.len() {
+        if b[i].is_ascii_whitespace() {
+            i += 1;
+            continue;
+        }
+        if b[i..].starts_with(b"&&") || b[i..].starts_with(b"||") {
+            out.push(text[i..i + 2].to_string());
+            i += 2;
+            continue;
+        }
+        if matches!(b[i], b'(' | b')' | b'!') {
+            out.push(text[i..i + 1].to_string());
+            i += 1;
+            continue;
+        }
+        let start = i;
+        while i < b.len() && (b[i].is_ascii_alphanumeric() || b[i] == b'_' || b[i] == b'.') {
+            i += 1;
+        }
+        if i > start {
+            out.push(text[start..i].to_string());
+            continue;
+        }
+        // The upstream `\S` catch-all: a stray token the parser then rejects.
+        out.push(text[i..i + 1].to_string());
+        i += 1;
+    }
+    out
+}
+
+fn parse_or(toks: &[String], i: &mut usize) -> Option<BuildExpr> {
+    let mut left = parse_and(toks, i)?;
+    while toks.get(*i).is_some_and(|t| t == "||") {
+        *i += 1;
+        left = BuildExpr::Or(Box::new(left), Box::new(parse_and(toks, i)?));
+    }
+    Some(left)
+}
+
+fn parse_and(toks: &[String], i: &mut usize) -> Option<BuildExpr> {
+    let mut left = parse_not(toks, i)?;
+    while toks.get(*i).is_some_and(|t| t == "&&") {
+        *i += 1;
+        left = BuildExpr::And(Box::new(left), Box::new(parse_not(toks, i)?));
+    }
+    Some(left)
+}
+
+fn parse_not(toks: &[String], i: &mut usize) -> Option<BuildExpr> {
+    let tok = toks.get(*i)?;
+    *i += 1;
+    match tok.as_str() {
+        "!" => Some(BuildExpr::Not(Box::new(parse_not(toks, i)?))),
+        "(" => {
+            let inner = parse_or(toks, i)?;
+            if toks.get(*i).is_some_and(|t| t == ")") {
+                *i += 1;
+                Some(inner)
+            } else {
+                None
+            }
+        }
+        w if !w.is_empty() && w.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_' || b == b'.') => {
+            Some(BuildExpr::Tag(w.to_string()))
+        }
+        _ => None,
+    }
+}
+
+/// goParseBuildExpr: a `//go:build` expression (`unix && !(linux || darwin)`)
+/// as a test of a target, or None when it can't be read.
+fn go_parse_build_expr(text: &str) -> Option<BuildExpr> {
+    let toks = build_tokens(text);
+    let mut i = 0;
+    let expr = parse_or(&toks, &mut i)?;
+    (i == toks.len()).then_some(expr)
+}
+
+/// goParsePlusBuild: a legacy `// +build` line's options (`linux,amd64
+/// darwin`, `!plan9`) as a test of a target, or None when it can't be read.
+fn go_parse_plus_build(text: &str) -> Option<BuildExpr> {
+    let options: Option<Vec<Vec<(bool, String)>>> = text
+        .split_whitespace()
+        .map(|option| {
+            option
+                .split(',')
+                .map(|term| {
+                    let (neg, tag) = term
+                        .strip_prefix('!')
+                        .map_or((false, term), |t| (true, t));
+                    (!tag.is_empty()
+                        && tag.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_' || b == b'.'))
+                    .then(|| (neg, tag.to_string()))
+                })
+                .collect()
+        })
+        .collect();
+    let mut options = options?.into_iter();
+    let first = options.next()?;
+    let mut acc = plus_option(first);
+    for option in options {
+        acc = BuildExpr::Or(Box::new(acc), Box::new(plus_option(option)));
+    }
+    Some(acc)
+}
+
+fn plus_option(terms: Vec<(bool, String)>) -> BuildExpr {
+    let mut terms = terms.into_iter().map(|(neg, tag)| {
+        let e = BuildExpr::Tag(tag);
+        if neg {
+            BuildExpr::Not(Box::new(e))
+        } else {
+            e
+        }
+    });
+    let mut acc = terms.next().unwrap();
+    for term in terms {
+        acc = BuildExpr::And(Box::new(acc), Box::new(term));
+    }
+    acc
+}
+
+/// goFileConstraint's answer: every part must hold for the file to build.
+pub(super) struct GoFileConstraint {
+    parts: Vec<BuildExpr>,
+}
+
+impl GoFileConstraint {
+    pub(super) fn holds(&self, t: &GoTarget) -> bool {
+        self.parts.iter().all(|p| p.holds(t))
+    }
+}
+
+impl KernelResolver {
+    /// goFileConstraint: the targets a Go file builds for, as go/build reads
+    /// them: a `_linux`, `_amd64` or `_windows_arm64` suffix on its name
+    /// (before `_test`), and the `//go:build` line above its package clause,
+    /// or the legacy `// +build` lines when it has none. None for a file that
+    /// builds everywhere, or whose constraint can't be read.
+    pub(super) fn go_file_constraint(&mut self, file: &str) -> Option<Rc<GoFileConstraint>> {
+        if let Some(hit) = self.go_build_constraint_memo.get(file) {
+            return hit.clone();
+        }
+        let mut parts: Vec<BuildExpr> = Vec::new();
+        // go/build ignores what comes before the name's first `_`, so
+        // `linux.go` names no system.
+        let base = file
+            .rsplit('/')
+            .next()
+            .unwrap_or(file)
+            .split('.')
+            .next()
+            .unwrap_or("");
+        if let Some(u) = base.find('_') {
+            let mut suffix: Vec<&str> = base[u + 1..].split('_').collect();
+            if suffix.last() == Some(&"test") {
+                suffix.pop();
+            }
+            let last = suffix.last().copied();
+            let prev = suffix.len().checked_sub(2).map(|i| suffix[i]);
+            if let (Some(p), Some(l)) = (prev, last) {
+                if GO_KNOWN_OS.contains(&p) && GO_KNOWN_ARCH.contains(&l) {
+                    parts.push(BuildExpr::And(
+                        Box::new(BuildExpr::Tag(p.to_string())),
+                        Box::new(BuildExpr::Tag(l.to_string())),
+                    ));
+                } else if GO_KNOWN_OS.contains(&l) || GO_KNOWN_ARCH.contains(&l) {
+                    parts.push(BuildExpr::Tag(l.to_string()));
+                }
+            } else if let Some(l) = last {
+                if GO_KNOWN_OS.contains(&l) || GO_KNOWN_ARCH.contains(&l) {
+                    parts.push(BuildExpr::Tag(l.to_string()));
+                }
+            }
+        }
+        // The constraint comes before the package clause, after only blank
+        // lines and line comments.
+        let mut go_build: Option<String> = None;
+        let mut plus_build: Vec<String> = Vec::new();
+        if let Some(lines) = self.read_file(file) {
+            for line in lines.iter().take(200) {
+                let text = line
+                    .as_str()
+                    .strip_prefix('\u{feff}')
+                    .unwrap_or(line.as_str())
+                    .trim();
+                if text.is_empty() {
+                    continue;
+                }
+                if !text.starts_with("//") {
+                    break;
+                }
+                if go_build.is_none() {
+                    if let Some(c) = re!(r"^//go:build\s+(.*)$").captures(text) {
+                        go_build = Some(c[1].to_string());
+                    }
+                }
+                if let Some(c) = re!(r"^//\s*\+build\s+(.*)$").captures(text) {
+                    plus_build.push(c[1].to_string());
+                }
+            }
+        }
+        let mut readable = true;
+        if let Some(g) = go_build {
+            match go_parse_build_expr(&g) {
+                Some(e) => parts.push(e),
+                None => readable = false,
+            }
+        } else {
+            for p in &plus_build {
+                match go_parse_plus_build(p) {
+                    Some(e) => parts.push(e),
+                    None => readable = false,
+                }
+            }
+        }
+        let constraint = if !readable || parts.is_empty() {
+            None
+        } else {
+            Some(Rc::new(GoFileConstraint { parts }))
+        };
+        self.go_build_constraint_memo.insert(file.to_string(), constraint.clone());
+        constraint
+    }
+
+    /// The twins of `target`: same name, kind and qualified name in the same
+    /// package (directory and clause), defined in different build files.
+    fn go_build_twins(&mut self, target: &KNode) -> Res<Rc<Vec<Arc<KNode>>>> {
+        if let Some(hit) = self.go_build_twins_memo.get(&target.id) {
+            return Ok(hit.clone());
+        }
+        let dir = pos_dirname(&target.file_path);
+        let clause = self.go_package_clause(&target.file_path);
+        let list = self.nodes_by_name(&target.name)?;
+        let mut twins = Vec::new();
+        for n in list.iter() {
+            if n.language == "go"
+                && n.kind == target.kind
+                && n.qualified_name == target.qualified_name
+                && pos_dirname(&n.file_path) == dir
+                && self.go_package_clause(&n.file_path) == clause
+            {
+                twins.push(n.clone());
+            }
+        }
+        let twins = Rc::new(twins);
+        self.go_build_twins_memo.insert(target.id.clone(), twins.clone());
+        Ok(twins)
+    }
+
+    /// The twin the reference's file builds with, among candidates no
+    /// resolution arm could collapse to one: same walk preferGoBuildTwin
+    /// runs — the most typical target the reference's file builds for whose
+    /// build admits exactly one. None when no target singles one out.
+    pub(super) fn go_pick_twin(
+        &mut self,
+        cands: &[Arc<KNode>],
+        r: &ResolveRefIn,
+    ) -> Res<Option<Arc<KNode>>> {
+        let own = self.go_file_constraint(&r.file_path);
+        for t in go_build_targets() {
+            if let Some(c) = &own {
+                if !c.holds(t) {
+                    continue;
+                }
+            }
+            let mut built: Vec<Arc<KNode>> = Vec::new();
+            for n in cands {
+                if self
+                    .go_file_constraint(&n.file_path)
+                    .map(|c| c.holds(t))
+                    .unwrap_or(true)
+                {
+                    built.push(n.clone());
+                }
+            }
+            if built.len() == 1 {
+                return Ok(Some(built.remove(0)));
+            }
+            if built.len() > 1 {
+                return Ok(None);
+            }
+        }
+        Ok(None)
+    }
+
+    /// preferGoBuildTwin: the definition Go builds, of a name its package
+    /// defines more than once for different targets — `sep` in `sep_unix.go`
+    /// (`//go:build unix`) and `sep_other.go` (`//go:build !unix`). The
+    /// definition kept is the one that builds for the most typical target the
+    /// reference's own file builds for: Linux on amd64 first, then a Mac,
+    /// then Windows and the rest (GO_BUILD_TARGETS), so a file that only
+    /// builds for Windows reaches the Windows definition. The result stands
+    /// when no twin builds for those targets, or two do (#2581).
+    pub(super) fn prefer_go_build_twin(
+        &mut self,
+        mut outcome: ResolveOutcome,
+        r: &ResolveRefIn,
+    ) -> Res<ResolveOutcome> {
+        if r.language != "go" || outcome.status != "resolved" {
+            return Ok(outcome);
+        }
+        let Some(tid) = outcome.target_node_id.clone() else {
+            return Ok(outcome);
+        };
+        let Some(target) = self.node_by_id(&tid)? else {
+            return Ok(outcome);
+        };
+        // A file that builds everywhere can have no twin: the package would
+        // declare the name twice.
+        if target.language != "go" || self.go_file_constraint(&target.file_path).is_none() {
+            return Ok(outcome);
+        }
+        let twins = self.go_build_twins(&target)?;
+        if twins.len() < 2 {
+            return Ok(outcome);
+        }
+        let own = self.go_file_constraint(&r.file_path);
+        for t in go_build_targets() {
+            if let Some(c) = &own {
+                if !c.holds(t) {
+                    continue;
+                }
+            }
+            let mut built: Vec<Arc<KNode>> = Vec::new();
+            for n in twins.iter() {
+                if self
+                    .go_file_constraint(&n.file_path)
+                    .map(|c| c.holds(t))
+                    .unwrap_or(true)
+                {
+                    built.push(n.clone());
+                }
+            }
+            if built.len() == 1 {
+                outcome.target_node_id = Some(built[0].id.clone());
+                return Ok(outcome);
+            }
+            if built.len() > 1 {
+                return Ok(outcome);
+            }
+        }
+        Ok(outcome)
+    }
+}
diff --git a/codegraph-kernel/src/resolve/imports.rs b/codegraph-kernel/src/resolve/imports.rs
index 22437224a..f2ed9c177 100644
--- a/codegraph-kernel/src/resolve/imports.rs
+++ b/codegraph-kernel/src/resolve/imports.rs
@@ -1569,6 +1569,11 @@ impl KernelResolver {
             if let [node] = nodes.as_slice() {
                 return Ok(Some(KCand { node: node.clone(), confidence: 0.9, resolved_by: "import" }));
             }
+            // A name the package defines once per build target: the twin the
+            // reference's file builds with, or nothing (#2581).
+            if let Some(node) = self.go_pick_twin(&nodes, r)? {
+                return Ok(Some(KCand { node, confidence: 0.9, resolved_by: "import" }));
+            }
         }
         Ok(None)
     }
diff --git a/codegraph-kernel/src/resolve/method_call.rs b/codegraph-kernel/src/resolve/method_call.rs
index 4593c8e9c..437c610bd 100644
--- a/codegraph-kernel/src/resolve/method_call.rs
+++ b/codegraph-kernel/src/resolve/method_call.rs
@@ -1590,7 +1590,13 @@ if inferred.is_none() && r.language == "dart" {
                     return if receiver == root { self.match_bound_type_member(root, method, r) } else { self.enum_constant_call(receiver, method, r) };
                 }
                 let via_import = self.resolve_via_import_member(r)?.filter(|c| {
-                    matches!(
+                    // A Go `pkg.Name` can name any exported package member —
+                    // `pkg.Type(…)` conversions included; edge-kind rewriting
+                    // decides calls-vs-references downstream.
+                    let go_member = r.language == "go"
+                        && matches!(c.node.kind.as_str(),
+                            "struct" | "interface" | "type_alias" | "variable" | "constant");
+                    go_member || matches!(
                         c.node.kind.as_str(),
                         "function" | "method" | "class" | "component"
                     )
diff --git a/codegraph-kernel/src/resolve/mod.rs b/codegraph-kernel/src/resolve/mod.rs
index dc3817d4e..df308205a 100644
--- a/codegraph-kernel/src/resolve/mod.rs
+++ b/codegraph-kernel/src/resolve/mod.rs
@@ -591,6 +591,7 @@ mod fields;
 mod rust_impls;
 mod ts_known;
 mod go_asserted;
+mod go_build;
 mod go_value;
 mod method_call;
 mod pipeline;
@@ -701,6 +702,11 @@ pub struct KernelResolver {
     go_alias_target_memo: HashMap<String, fields::GoAliasTarget>,
     /// goUnreadFileMethods, by file path: `None` when the file can't be read.
     go_unread_methods_memo: HashMap<String, Option<HashSet<String>>>,
+    /// goFileConstraint, by file path: `None` builds everywhere or can't be
+    /// read.
+    go_build_constraint_memo: HashMap<String, Option<Rc<go_build::GoFileConstraint>>>,
+    /// preferGoBuildTwin's same-package same-name pool, by target node id.
+    go_build_twins_memo: HashMap<String, Rc<Vec<Arc<KNode>>>>,
     /// javaSupertypesOf, by type name.
     java_supers_memo: HashMap<String, Rc<Vec<String>>>,
     /// phpSupertypeQns, by declaration id.
@@ -973,6 +979,8 @@ impl KernelResolver {
             go_mc_untyped_local: false,
             go_alias_target_memo: HashMap::new(),
             go_unread_methods_memo: HashMap::new(),
+            go_build_constraint_memo: HashMap::new(),
+            go_build_twins_memo: HashMap::new(),
             java_supers_memo: HashMap::new(),
             php_supers_memo: HashMap::new(),
             vb: vbnet::VbMemo::default(),
@@ -1356,7 +1364,10 @@ impl KernelResolver {
             });
             out.push(match hit {
                 Ok(c) => match c {
-                    Some(c) => ResolveOutcome::resolved(&c.node, c.confidence, c.resolved_by, true, None),
+                    Some(c) => {
+                        let outcome = ResolveOutcome::resolved(&c.node, c.confidence, c.resolved_by, true, None);
+                        if r.language == "go" { self.prefer_go_build_twin(outcome, &r)? } else { outcome }
+                    }
                     None => ResolveOutcome::unresolved(),
                 },
                 Err(Halt::Napi(e)) => return Err(e),
diff --git a/codegraph-kernel/src/resolve/names.rs b/codegraph-kernel/src/resolve/names.rs
index 0e6d18cc7..00b0131c1 100644
--- a/codegraph-kernel/src/resolve/names.rs
+++ b/codegraph-kernel/src/resolve/names.rs
@@ -408,7 +408,7 @@ impl KernelResolver {
             return Ok(false);
         }
         if lang == "go" {
-            return Ok(go_name_visible(candidate, r));
+            return self.go_name_visible(candidate, r);
         }
         // A Dart `_name` is its library's, which spans the library file and
         // its parts: riverpod_generator's `class Counter extends _$Counter`
@@ -519,6 +519,32 @@ impl KernelResolver {
         None
     }
 
+    /// isGoNameVisible (name-matcher.ts): by the name's first letter, not the
+    /// extractor's flag (unset for every Go method, exported or not); an
+    /// unexported name is its own package's. A package is its directory AND
+    /// package clause: `a_test` files beside `a` files are a package of their
+    /// own whose bare top-level names reach `a` only through an import —
+    /// qualified, or bare after a dot import and exported (#2581).
+    pub(super) fn go_name_visible(&mut self, candidate: &KNode, r: &ResolveRefIn) -> Res<bool> {
+        let dir = pos_dirname(&candidate.file_path);
+        if dir != pos_dirname(&r.file_path) {
+            return Ok(candidate.name.chars().next().is_some_and(|c| c.is_ascii_uppercase()));
+        }
+        if candidate.file_path == r.file_path
+            || matches!(candidate.kind.as_str(), "method" | "property" | "field" | "enum_member")
+            || r.reference_name.contains('.')
+        {
+            return Ok(true);
+        }
+        let own = self.go_package_clause(&r.file_path);
+        let theirs = self.go_package_clause(&candidate.file_path);
+        if own.is_none() || theirs.is_none() || own == theirs {
+            return Ok(true);
+        }
+        Ok(candidate.name.chars().next().is_some_and(|c| c.is_ascii_uppercase())
+            && self.go_dot_imports(&r.file_path)?.dirs.iter().any(|d| *d == dir))
+    }
+
     /// isBarePhpCall (name-matcher.ts): a PHP `calls` ref written without a
     /// receiver — `redirect($url)`, `view('books.show')` — rather than
     /// `$this->redirect()` / `Foo::view()`. PHP has no implicit `$this`, so
@@ -838,7 +864,7 @@ impl KernelResolver {
                 // And a Go name that isn't exported, only its own package's: prometheus
                 // tsdb's `[]*memSeries` is head.go's, not `tsdb/agent`'s, which scored the
                 // same by directory proximity and was then vetoed as invisible.
-                && (n.language != "go" || go_name_visible(&n, r))
+                && (n.language != "go" || self.go_name_visible(&n, r)?)
                 // A Dart `_name` another library declares: the reference's
                 // own library's declaration wins instead of the namesake
                 // picked and then declined (upstream f7820b58 / #2466).
@@ -2103,11 +2129,3 @@ mod js_unit_tests {
         s.chars().map(char::len_utf16).sum()
     }
 }
-
-/// isGoNameVisible (name-matcher.ts): by the name's first letter, not the
-/// extractor's flag (unset for every Go method, exported or not); an
-/// unexported name is its own package's directory's.
-fn go_name_visible(candidate: &KNode, r: &ResolveRefIn) -> bool {
-    candidate.name.chars().next().is_some_and(|c| c.is_ascii_uppercase())
-        || pos_dirname(&candidate.file_path) == pos_dirname(&r.file_path)
-}
diff --git a/codegraph-kernel/src/resolve/pipeline.rs b/codegraph-kernel/src/resolve/pipeline.rs
index 4859a7b90..aff53129f 100644
--- a/codegraph-kernel/src/resolve/pipeline.rs
+++ b/codegraph-kernel/src/resolve/pipeline.rs
@@ -708,10 +708,19 @@ if super::lang_scope::is_dart_member_read(r) {
                     self.go_bare_type_dir(name, &r.file_path)?
                 } else { None };
                 if let Some(package) = package {
-                    let types: Vec<_> = self.nodes_by_name(name)?.iter()
-                        .filter(|n| n.language == "go" && matches!(n.kind.as_str(), "struct" | "interface" | "type_alias")
-                            && pos_dirname(&n.file_path) == package)
-                        .cloned().collect();
+                    // The package is its directory AND clause: `a_test`'s
+                    // type position cannot name `a`'s fixture (#2581).
+                    let list = self.nodes_by_name(name)?;
+                    let mut types: Vec<_> = Vec::new();
+                    for n in list.iter() {
+                        if n.language == "go"
+                            && matches!(n.kind.as_str(), "struct" | "interface" | "type_alias")
+                            && pos_dirname(&n.file_path) == package
+                            && self.go_name_visible(n, r)?
+                        {
+                            types.push(n.clone());
+                        }
+                    }
                     if let Some(target) = prefer_call_site_file(types, &r.file_path).first() {
                         cand.node = target.clone();
                     } else { return Ok(None); }
@@ -907,6 +916,12 @@ if super::lang_scope::is_dart_member_read(r) {
         if let Some(attribute) = attribute {
             if !attribute.type_from.is_empty() { outcome.type_from = Some(attribute.type_from); }
         }
+        // A Go name its package defines under complementary build
+        // constraints resolves to the twin the reference's file builds with
+        // (preferGoBuildTwin, #2581).
+        if r.language == "go" {
+            outcome = self.prefer_go_build_twin(outcome, r)?;
+        }
         Ok(outcome)
     }
 
diff --git a/src/resolution/go-type-visibility.ts b/src/resolution/go-type-visibility.ts
index 81aca8a43..04a8942b5 100644
--- a/src/resolution/go-type-visibility.ts
+++ b/src/resolution/go-type-visibility.ts
@@ -5,7 +5,7 @@ import type { ImportMapping, ResolutionContext, ResolvedRef, UnresolvedRef } fro
 function lineAt(ref: UnresolvedRef, context: ResolutionContext): string | undefined {
   return context.getFileLines?.(ref.filePath)?.[ref.line - 1] ?? context.readFile(ref.filePath)?.split(/\r?\n/)[ref.line - 1];
 }
-function goPackageDir(file: string): string { return path.posix.dirname(file.replace(/\\/g, '/')); }
+function goPackageDir(file: string): string { const dir = path.posix.dirname(file.replace(/\\/g, '/')); return dir === '.' ? '' : dir; }
 function goImportPackageDir(name: string, file: string, context: ResolutionContext): string | null | undefined {
   const imp = context.getImportMappings(file, 'go').find((m) => m.localName === name);
   return imp ? context.getGoPackageDir?.(imp.source, file) ?? null : undefined;
@@ -180,7 +180,8 @@ export function goTypePositionTarget(result: ResolvedRef, ref: UnresolvedRef, co
     } else if (imported) pkgDir = context.getGoPackageDir?.(imported.source, ref.filePath) ?? null;
   }
   if (isType && (!bare || goPackageDir(target.filePath) === pkgDir)) return result;
-  const types = pkgDir ? goPackageTypes(name, pkgDir, context) : [];
+  // `''` is a real directory — a module's root package — not a miss.
+  const types = pkgDir !== null && pkgDir !== undefined ? goPackageTypes(name, pkgDir, context) : [];
   if (types.length > 0) return { ...result, targetNodeId: preferCallSiteFile(types, ref.filePath)[0]!.id };
   return isType ? result : null;
 }

From 9885426bd2ec4e30dae79ba79cc2a2bab4732bd6 Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Wed, 28 Oct 2026 22:06:09 -0600
Subject: [PATCH 16/30] feat(kernel): VB.NET namespace receivers, overload
 pick, head members (#2762)

Port upstream dbb6aa9b: VbReceiver gains a namespace arm
(vb_known_namespaces/vb_namespace_around/vb_namespace_named/
vb_types_in_namespace/vb_module_member_in) so reads like
Billing.Invoice.MaxLines and Acme.Billing.Invoice.MaxLines link the
type or Module member the namespace declares; vb_takes_no_arguments +
vb_runnable_overload pick the overload VB.NET runs when a method is
named without parentheses (Me.Load, Optional/ParamArray, a ctor's
Me.New never resolves to itself); vb_head_member + vb_with_head link a
bare member before the dot (Button1.Text) when no local or parameter
shadows it, gated by foreign-Module and outside-namesake checks.
vb_receiver_type's member search is extracted as vb_member_around.
---
 codegraph-kernel/src/resolve/vbnet/calls.rs   | 223 +++++++++++-
 .../src/resolve/vbnet/receivers.rs            |  44 +--
 codegraph-kernel/src/resolve/vbnet/types.rs   | 329 ++++++++++++++++++
 3 files changed, 552 insertions(+), 44 deletions(-)

diff --git a/codegraph-kernel/src/resolve/vbnet/calls.rs b/codegraph-kernel/src/resolve/vbnet/calls.rs
index 6ba4a87c7..d9ecb914d 100644
--- a/codegraph-kernel/src/resolve/vbnet/calls.rs
+++ b/codegraph-kernel/src/resolve/vbnet/calls.rs
@@ -5,13 +5,23 @@ struct VbReceiver {
     typed: Option<VbType>,
     through_type: bool,
     color_color: bool,
+    namespace: Option<Rc<Vec<String>>>,
+}
+
+impl VbReceiver {
+    fn owned(owners: Vec<Arc<KNode>>, typed: Option<VbType>, through_type: bool, color_color: bool) -> Self {
+        VbReceiver { owners, typed, through_type, color_color, namespace: None }
+    }
+    fn ns(namespace: Rc<Vec<String>>) -> Self {
+        VbReceiver { owners: vec![], typed: None, through_type: false, color_color: false, namespace: Some(namespace) }
+    }
 }
 
 
 impl KernelResolver {
     fn vb_value_receiver(&mut self, typed: Option<VbType>) -> Res<Option<VbReceiver>> {
         let Some(t) = typed.filter(|t| vb_key(t) != "object") else { return Ok(None); };
-        Ok(self.vb_owners(&t)?.map(|owners| VbReceiver { owners, typed: Some(t), through_type: false, color_color: false }))
+        Ok(self.vb_owners(&t)?.map(|owners| VbReceiver::owned(owners, Some(t), false, false)))
     }
     fn vb_path_receiver(&mut self, head: &str, links: &[&str], r: &ResolveRefIn) -> Res<Option<VbReceiver>> {
         let mut at = if head.starts_with('{') {
@@ -25,50 +35,229 @@ impl KernelResolver {
                     let base = self.vb_supers(&own)?.into_iter().find(|(_, implemented)| !implemented).map(|(t, _)| t);
                     self.vb_value_receiver(base)?
                 }
-                Some(own) => Some(VbReceiver { typed: Some(vb_simple(&own.name, r)), owners: vec![own], through_type: false, color_color: false }),
+                Some(own) => Some(VbReceiver::owned(vec![own.clone()], Some(vb_simple(&own.name, r)), false, false)),
                 None => None,
             }
         } else {
             let name = head.trim_matches(['[', ']']);
             let bound = self.vb_receiver_type(name, r, 0)?;
             let written = match &bound { None => Some(vb_simple(name, r)), Some(Some(t)) if !t.array && t.name.eq_ignore_ascii_case(name) => Some(t.clone()), _ => None };
-            if let Some(written) = written {
-                let (owners, ambiguous) = self.vb_types_at(&written, true)?;
-                (!ambiguous && !owners.is_empty()).then_some(VbReceiver { owners, typed: None, through_type: true, color_color: bound.is_some() })
-            } else { self.vb_value_receiver(bound.flatten())? }
+            match written {
+                Some(written) => {
+                    let (owners, ambiguous) = self.vb_types_at(&written, true)?;
+                    if ambiguous {
+                        None
+                    } else if !owners.is_empty() {
+                        Some(VbReceiver::owned(owners, None, true, bound.is_some()))
+                    } else {
+                        match bound.is_none() {
+                            true => self.vb_namespace_named(name, r)?.map(VbReceiver::ns),
+                            false => None,
+                        }
+                    }
+                }
+                None => self.vb_value_receiver(bound.flatten())?,
+            }
         };
         for link in links {
             let Some(prior) = at else { return Ok(None); };
             let name = link.trim_matches(['[', ']']);
+            if let Some(ns) = prior.namespace {
+                let types = self.vb_types_in_namespace(&ns, name, r)?;
+                at = match types {
+                    None => return Ok(None),
+                    Some(types) if !types.is_empty() => Some(VbReceiver::owned(types, None, true, false)),
+                    Some(_) => {
+                        let mut nested = (*ns).clone();
+                        nested.push(name.to_ascii_lowercase());
+                        if self.vb_known_namespaces()?.contains(&nested.join(".")) {
+                            Some(VbReceiver::ns(Rc::new(nested)))
+                        } else {
+                            let member = self.vb_module_member_in(&ns, name, r)?;
+                            let Some(member) = member else { return Ok(None); };
+                            let typed = self.vb_member_type(&VbMember { node: member, args: HashMap::new() })?;
+                            self.vb_value_receiver(typed)?
+                        }
+                    }
+                };
+                continue;
+            }
+            if prior.owners.is_empty() { return Ok(None); }
             let found = self.vb_member_on(&prior.owners, name, r, true, prior.typed.as_ref(), true)?
                 .or(self.vb_member_on(&prior.owners, &format!("[{name}]"), r, true, prior.typed.as_ref(), true)?);
             let Some(found) = found else { return Ok(None); };
             at = if vb_like_kind(&found.node.kind) {
-                prior.through_type.then_some(VbReceiver { owners: vec![found.node], typed: None, through_type: true, color_color: false })
+                prior.through_type.then_some(VbReceiver::owned(vec![found.node], None, true, false))
             } else { let typed = self.vb_member_type(&found)?; self.vb_value_receiver(typed)? };
         }
         Ok(at)
     }
+    /// The overload VB.NET runs where a method is named without parentheses,
+    /// unless `AddressOf`/`NameOf` only names it.
+    fn vb_run(&mut self, member: Arc<KNode>, named: bool, r: &ResolveRefIn) -> Res<Option<Arc<KNode>>> {
+        if member.kind != "method" || named {
+            return Ok(Some(member));
+        }
+        self.vb_runnable_overload(member, r)
+    }
+    /// The field, property or Module variable a bare name before the dot
+    /// reads as well, where VB.NET binds the name to one (`Button1` in
+    /// `Button1.Text`). Null for a parameter or local of that name, for `Me`,
+    /// `MyBase` and `{T}`, for a `With` block's name, and for an outside
+    /// namesake (`Responser As Responser`).
+    fn vb_head_member(&mut self, head: &str, r: &ResolveRefIn) -> Res<Option<Arc<KNode>>> {
+        if head.starts_with('{') || re!(r"(?i)^(Me|MyClass|MyBase)$").is_match(head) {
+            return Ok(None);
+        }
+        let name = head.trim_matches(['[', ']']);
+        let Some(line) = self.read_file(&r.file_path).and_then(|f| f.get((r.line - 1).max(0) as usize).cloned()) else {
+            return Ok(None);
+        };
+        let mut byte = super::names::js_unit_to_byte(&line, r.column.max(0) as usize).min(line.len());
+        let bracketed = line.as_bytes().get(byte) == Some(&b'[');
+        if bracketed {
+            byte += 1;
+        }
+        if line.len() < byte + name.len() || !line[byte..byte + name.len()].eq_ignore_ascii_case(name) {
+            return Ok(None);
+        }
+        byte += name.len();
+        if bracketed {
+            if line.as_bytes().get(byte) != Some(&b']') {
+                return Ok(None);
+            }
+            byte += 1;
+        }
+        while matches!(line.as_bytes().get(byte), Some(b' ' | b'\t')) {
+            byte += 1;
+        }
+        if line.as_bytes().get(byte) != Some(&b'.') {
+            return Ok(None);
+        }
+        if self.vb_local_bound(name, r)? {
+            return Ok(None);
+        }
+        let Some(found) = self.vb_member_around(name, r)? else {
+            return Ok(None);
+        };
+        let member = found.node;
+        if !vb_value_kind(&member.kind) || member.id == r.from_node_id {
+            return Ok(None);
+        }
+        // Another project's Module is one this code can't name without a reference to it.
+        let foreign = self.vb_project(&member.file_path) != self.vb_project(&r.file_path);
+        if foreign {
+            if let Some(qn) = vb_parent_qn(&member) {
+                let module = self
+                    .nodes_by_qualified_name(qn)?
+                    .iter()
+                    .any(|n| self.vb_module(n));
+                if module {
+                    return Ok(None);
+                }
+            }
+        }
+        if self.vb_is_outside_namesake(&member, &found.args)? {
+            return Ok(None);
+        }
+        Ok(Some(member))
+    }
+    /// withHead: the bare-name member before the dot is linked beside what is
+    /// read through it — alone when nothing reads through it, and never when
+    /// the read calls the member.
+    fn vb_with_head(&mut self, read: Option<VbHit>, head: &str, links: &[&str], r: &ResolveRefIn) -> Res<Option<VbHit>> {
+        let head_member = if links.is_empty() {
+            self.vb_head_member(head, r)?
+        } else {
+            None
+        };
+        Ok(match (head_member, read) {
+            (None, read) => read,
+            (Some(head), None) => Some(VbHit {
+                candidate: KCand { node: head, confidence: 0.9, resolved_by: "instance-method" },
+                edge_kind: None,
+                also: vec![],
+            }),
+            (Some(head), Some(mut read)) => {
+                if read.edge_kind.as_deref() != Some("calls") {
+                    read.also.push(head.id.clone());
+                }
+                Some(read)
+            }
+        })
+    }
     fn vb_member_read(&mut self, head: &str, links: &[&str], name: &str, r: &ResolveRefIn) -> Res<Option<VbHit>> {
         let Some(at) = self.vb_path_receiver(head, links, r)? else { return Ok(None); };
         let name = name.trim_matches(['[', ']']);
-        let found = self.vb_member_on(&at.owners, name, r, true, at.typed.as_ref(), true)?
-            .or(self.vb_member_on(&at.owners, &format!("[{name}]"), r, true, at.typed.as_ref(), true)?);
+        let line = self.read_file(&r.file_path).and_then(|f| f.get((r.line - 1).max(0) as usize).cloned()).unwrap_or_default();
+        let named = re!(r"(?i)\b(?:AddressOf\s+|NameOf\s*\(\s*)$").is_match(super::names::js_prefix(&line, r.column.max(0) as usize));
+        if let Some(ns) = &at.namespace {
+            // A type, or a Module's member, read through its namespace.
+            let types = self.vb_types_in_namespace(ns, name, r)?;
+            let target = match types {
+                Some(types) => match types.into_iter().next() {
+                    Some(first) => Some(first),
+                    None => match self.vb_module_member_in(ns, name, r)? {
+                        Some(member) => self.vb_run(member, named, r)?,
+                        None => None,
+                    },
+                },
+                None => None,
+            };
+            let Some(target) = target.filter(|t| t.id != r.from_node_id) else {
+                return Ok(None);
+            };
+            return Ok(Some(VbHit {
+                candidate: KCand {
+                    node: target.clone(),
+                    confidence: if target.kind == "method" { 0.85 } else { 0.9 },
+                    resolved_by: "qualified-name",
+                },
+                edge_kind: (target.kind == "method" && !named).then(|| "calls".to_string()),
+                also: vec![],
+            }));
+        }
+        if at.owners.is_empty() {
+            return self.vb_with_head(None, head, links, r);
+        }
+        if !at.through_type {
+            // The member the name means: the nearest the type declares or inherits.
+            let found = self.vb_member_on(&at.owners, name, r, true, at.typed.as_ref(), false)?
+                .or(self.vb_member_on(&at.owners, &format!("[{name}]"), r, true, at.typed.as_ref(), false)?);
+            let member = match found {
+                Some(found) => self.vb_run(found.node, named, r)?,
+                None => None,
+            };
+            let hit = member.filter(|m| m.id != r.from_node_id).map(|member| {
+                VbHit {
+                    candidate: KCand { node: member.clone(), confidence: 0.9, resolved_by: "instance-method" },
+                    edge_kind: (member.kind == "method" && !named).then(|| "calls".to_string()),
+                    also: vec![],
+                }
+            });
+            return self.vb_with_head(hit, head, links, r);
+        }
+        let found = self.vb_member_on(&at.owners, name, r, true, None, true)?
+            .or(self.vb_member_on(&at.owners, &format!("[{name}]"), r, true, None, true)?);
         let Some(mut found) = found else { return Ok(None); };
-        if found.node.id == r.from_node_id { return Ok(None); }
-        if !at.through_type && !matches!(found.node.kind.as_str(), "method" | "field" | "property" | "constant" | "variable") { return Ok(None); }
-        if at.through_type && !found.node.is_static {
+        if !found.node.is_static {
             if let Some(shared) = self.nodes_by_qualified_name(&found.node.qualified_name)?.iter().find(|n| n.is_static && n.file_path == found.node.file_path && n.id != r.from_node_id) { found.node = shared.clone(); }
         }
+        found.node = self.vb_run(found.node.clone(), named, r)?.unwrap_or(found.node);
         let constant = self.read_file(&found.node.file_path).and_then(|f| f.get((found.node.start_line - 1).max(0) as usize).cloned())
             .is_some_and(|line| re!(r"(?i)^\s*(?:(?:Public|Private|Protected|Friend|Shadows)\s+)*Const\b").is_match(&line));
         let shared = found.node.is_static || constant || matches!(found.node.kind.as_str(), "constant" | "enum_member") || at.owners.iter().any(|n| self.vb_module(n));
-        let through_value = !at.through_type || at.color_color && !shared;
-        let line = self.read_file(&r.file_path).and_then(|f| f.get((r.line - 1).max(0) as usize).cloned()).unwrap_or_default();
-        let named = re!(r"(?i)\b(?:AddressOf\s+|NameOf\s*\(\s*)$").is_match(super::names::js_prefix(&line, r.column.max(0) as usize));
+        if at.color_color && !shared {
+            return self.vb_with_head(Some(VbHit {
+                candidate: KCand { node: found.node.clone(), confidence: 0.9, resolved_by: "instance-method" },
+                edge_kind: (found.node.kind == "method" && !named).then(|| "calls".to_string()),
+                also: vec![],
+            }), head, links, r);
+        }
         let edge_kind = (found.node.kind == "method" && !named).then(|| "calls".to_string());
-        if through_value || found.node.kind == "method" || !links.is_empty() {
-            return Ok(Some(VbHit { candidate: KCand { node: found.node, confidence: if through_value { 0.9 } else { 0.85 }, resolved_by: if through_value { "instance-method" } else { "qualified-name" } }, edge_kind, also: vec![] }));
+        if found.node.kind == "method" || !links.is_empty() {
+            let confidence = if found.node.kind == "method" { 0.85 } else { 0.9 };
+            return Ok(Some(VbHit { candidate: KCand { node: found.node, confidence, resolved_by: "qualified-name" }, edge_kind, also: vec![] }));
         }
         self.vb_read_through(found.node, &at.owners, r, 0.9, edge_kind.as_deref())
     }
diff --git a/codegraph-kernel/src/resolve/vbnet/receivers.rs b/codegraph-kernel/src/resolve/vbnet/receivers.rs
index 6a453118c..0669df11f 100644
--- a/codegraph-kernel/src/resolve/vbnet/receivers.rs
+++ b/codegraph-kernel/src/resolve/vbnet/receivers.rs
@@ -320,36 +320,26 @@ impl KernelResolver {
             };
             return Ok(Some(ty));
         }
-        for owner in self.vb_around(&r.file_path, r.line)? {
-            for ancestor in self.vb_ancestry(&owner)? {
-                if let Some(node) = self
-                    .vb_members(&ancestor.node, name)?
-                    .into_iter()
-                    .find(|n| vb_value_kind(&n.kind) || n.kind == "method")
-                {
-                    return self
-                        .vb_member_type(&VbMember {
-                            node,
-                            args: ancestor.args,
-                        })
-                        .map(Some);
-                }
-            }
-        }
-        if let Some(node) = self
-            .vb_module_members(name, r)?
-            .into_iter()
-            .find(|n| vb_value_kind(&n.kind) || n.kind == "method")
-        {
-            return self
-                .vb_member_type(&VbMember {
-                    node,
-                    args: HashMap::new(),
-                })
-                .map(Some);
+        if let Some(member) = self.vb_member_around(name, r)? {
+            return self.vb_member_type(&member).map(Some);
         }
         Ok(None)
     }
+    /// localBinding: whether a parameter or local of `name` is in scope at the
+    /// reference — a member of that name is hidden where one is.
+    pub(in crate::resolve) fn vb_local_bound(&mut self, name: &str, r: &ResolveRefIn) -> Res<bool> {
+        let start = self.vb_scope_start(r)?;
+        let lines = self.vb_lines(&r.file_path);
+        for i in (start.max(1) as usize - 1..(r.line.max(0) as usize).min(lines.len())).rev() {
+            if self
+                .vb_binding_on(&lines[i], name, &r.file_path, i as i64 + 1)?
+                .is_some()
+            {
+                return Ok(true);
+            }
+        }
+        Ok(false)
+    }
     pub(in crate::resolve) fn vb_owners(&mut self, t: &VbType) -> Res<Option<Vec<Arc<KNode>>>> {
         if t.array || vb_builtin(t) {
             return Ok(Some(vec![]));
diff --git a/codegraph-kernel/src/resolve/vbnet/types.rs b/codegraph-kernel/src/resolve/vbnet/types.rs
index a7a57409f..d10ce1613 100644
--- a/codegraph-kernel/src/resolve/vbnet/types.rs
+++ b/codegraph-kernel/src/resolve/vbnet/types.rs
@@ -26,6 +26,11 @@ pub(in crate::resolve) struct VbMemo {
     pub(in crate::resolve) code: HashMap<String, Rc<Vec<String>>>,
     pub(in crate::resolve) projects: HashMap<String, Option<String>>,
     pub(in crate::resolve) headers: HashMap<String, Rc<VbHeader>>,
+    pub(in crate::resolve) namespaces: Option<Rc<HashSet<String>>>,
+    pub(in crate::resolve) ns_around: HashMap<(String, i64), Rc<Vec<String>>>,
+    pub(in crate::resolve) ns_named: HashMap<String, Option<Rc<Vec<String>>>>,
+    pub(in crate::resolve) no_args: HashMap<String, bool>,
+    pub(in crate::resolve) namesakes: HashMap<String, bool>,
 }
 #[derive(Clone)]
 pub(in crate::resolve) enum VbBinding {
@@ -733,4 +738,328 @@ impl KernelResolver {
         }
         Ok(None)
     }
+    /// knownNamespaces: every full namespace name the project's VB.NET code
+    /// declares (root namespaces included), lowercased and dot-joined.
+    pub(in crate::resolve) fn vb_known_namespaces(&mut self) -> Res<Rc<HashSet<String>>> {
+        if let Some(hit) = &self.vb.namespaces {
+            return Ok(hit.clone());
+        }
+        let mut known = HashSet::new();
+        let mut add = |segments: &[String]| {
+            for i in 1..=segments.len() {
+                known.insert(segments[..i].join("."));
+            }
+        };
+        let namespaces: Vec<Arc<KNode>> = self
+            .table()?
+            .nodes
+            .iter()
+            .filter(|n| n.language == "vbnet" && n.kind == "namespace")
+            .cloned()
+            .collect();
+        for n in &namespaces {
+            add(&self.vb_full(n));
+        }
+        let files: Vec<String> = self
+            .table()?
+            .by_file
+            .keys()
+            .filter(|f| f.to_ascii_lowercase().ends_with(".vb"))
+            .cloned()
+            .collect();
+        for file in files {
+            add(&self.vb_header(&file).root);
+        }
+        let out = Rc::new(known);
+        self.vb.namespaces = Some(out.clone());
+        Ok(out)
+    }
+    /// namespaceAround: the full segments of the namespace a line sits in —
+    /// the project's root namespace, then the `Namespace` block around it.
+    pub(in crate::resolve) fn vb_namespace_around(&mut self, file: &str, line: i64) -> Res<Rc<Vec<String>>> {
+        let key = (file.to_string(), line);
+        if let Some(hit) = self.vb.ns_around.get(&key) {
+            return Ok(hit.clone());
+        }
+        let root = self.vb_header(file).root.clone();
+        let around = self.vb_around(file, line)?;
+        let outer = around.last();
+        let out = match outer.and_then(|n| n.qualified_name.find("::").map(|cut| n.qualified_name[..cut].to_ascii_lowercase())) {
+            Some(head)
+                if self
+                    .nodes_in_file(file)?
+                    .iter()
+                    .any(|n| n.kind == "namespace" && n.qualified_name.eq_ignore_ascii_case(&head)) =>
+            {
+                let mut v = root;
+                v.extend(head.split('.').map(str::to_string));
+                v
+            }
+            _ => root,
+        };
+        let out = Rc::new(out);
+        self.vb.ns_around.insert(key, out.clone());
+        Ok(out)
+    }
+    /// namespaceNamed: the full segments of the namespace a first path segment
+    /// names where it is written — nested inside the namespaces around the
+    /// read, innermost first, else inside an imported one. None when the name
+    /// is no namespace there.
+    pub(in crate::resolve) fn vb_namespace_named(
+        &mut self,
+        name: &str,
+        r: &ResolveRefIn,
+    ) -> Res<Option<Rc<Vec<String>>>> {
+        let lower = name.to_ascii_lowercase();
+        let key = format!("{}:{}:{lower}", r.file_path, r.line);
+        if let Some(hit) = self.vb.ns_named.get(&key) {
+            return Ok(hit.clone());
+        }
+        let known = self.vb_known_namespaces()?;
+        let around = self.vb_namespace_around(&r.file_path, r.line)?;
+        let mut out = None;
+        for i in (0..=around.len()).rev() {
+            let mut candidate = around[..i].to_vec();
+            candidate.push(lower.clone());
+            if known.contains(&candidate.join(".")) {
+                out = Some(candidate);
+                break;
+            }
+        }
+        if out.is_none() {
+            for imported in self.vb_header(&r.file_path).imports.clone() {
+                let mut candidate: Vec<String> = imported.split('.').map(str::to_string).collect();
+                candidate.push(lower.clone());
+                if known.contains(&candidate.join(".")) {
+                    out = Some(candidate);
+                    break;
+                }
+            }
+        }
+        let out = out.map(Rc::new);
+        self.vb.ns_named.insert(key, out.clone());
+        Ok(out)
+    }
+    /// typesInNamespace: the project types named `name` declared directly in
+    /// namespace `ns` (full segments) — the caller's project's when it has
+    /// one, and None when that leaves two different types.
+    pub(in crate::resolve) fn vb_types_in_namespace(
+        &mut self,
+        ns: &[String],
+        name: &str,
+        r: &ResolveRefIn,
+    ) -> Res<Option<Vec<Arc<KNode>>>> {
+        let key = ns.join(".");
+        let mut found: Vec<Arc<KNode>> = Vec::new();
+        for n in self.nodes_by_lower_name(name)?.iter() {
+            if n.language != "vbnet" || !(vb_type_kind(&n.kind) || n.kind == "enum") {
+                continue;
+            }
+            let full = self.vb_full(n);
+            if full[..full.len() - 1].join(".") == key {
+                found.push(n.clone());
+            }
+        }
+        let own: Vec<_> = found
+            .iter()
+            .filter(|n| self.vb_same_project(&n.file_path, &r.file_path))
+            .cloned()
+            .collect();
+        if !own.is_empty() {
+            found = own;
+        }
+        let mut distinct = HashSet::new();
+        for n in &found {
+            distinct.insert((
+                self.vb_project(&n.file_path),
+                n.qualified_name.to_ascii_lowercase(),
+            ));
+        }
+        if distinct.len() > 1 {
+            return Ok(None);
+        }
+        found.sort_by_key(|n| n.file_path != r.file_path);
+        Ok(Some(found))
+    }
+    /// moduleMemberIn: a member named `name` of a `Module` declared directly
+    /// in namespace `ns`, which VB.NET reads through the namespace.
+    pub(in crate::resolve) fn vb_module_member_in(
+        &mut self,
+        ns: &[String],
+        name: &str,
+        r: &ResolveRefIn,
+    ) -> Res<Option<Arc<KNode>>> {
+        let key = ns.join(".");
+        for n in self.vb_module_members(name, r)?.iter() {
+            if !(vb_value_kind(&n.kind) || n.kind == "method") {
+                continue;
+            }
+            let full = self.vb_full(n);
+            if full.len() >= 2 && full[..full.len() - 2].join(".") == key {
+                return Ok(Some(n.clone()));
+            }
+        }
+        Ok(None)
+    }
+    /// memberAround: the field, property, function or Module member a
+    /// receiver-less `name` reads where a call is (upstream memberAround).
+    pub(in crate::resolve) fn vb_member_around(
+        &mut self,
+        name: &str,
+        r: &ResolveRefIn,
+    ) -> Res<Option<VbMember>> {
+        for owner in self.vb_around(&r.file_path, r.line)? {
+            for ancestor in self.vb_ancestry(&owner)? {
+                if let Some(node) = self
+                    .vb_members(&ancestor.node, name)?
+                    .into_iter()
+                    .find(|n| vb_value_kind(&n.kind) || n.kind == "method")
+                {
+                    return Ok(Some(VbMember {
+                        node,
+                        args: ancestor.args,
+                    }));
+                }
+            }
+        }
+        if let Some(node) = self
+            .vb_module_members(name, r)?
+            .into_iter()
+            .find(|n| vb_value_kind(&n.kind) || n.kind == "method")
+        {
+            return Ok(Some(VbMember {
+                node,
+                args: HashMap::new(),
+            }));
+        }
+        Ok(None)
+    }
+    /// takesNoArguments: whether VB.NET can call a method with no arguments —
+    /// it declares no parameter, or only `Optional` ones and a `ParamArray`.
+    /// Read from its declaration; true when that can't be read.
+    pub(in crate::resolve) fn vb_takes_no_arguments(&mut self, n: &KNode) -> Res<bool> {
+        if let Some(hit) = self.vb.no_args.get(&n.id) {
+            return Ok(*hit);
+        }
+        let code = self
+            .vb_lines(&n.file_path)
+            .iter()
+            .skip((n.start_line - 1).max(0) as usize)
+            .take(7)
+            .cloned()
+            .collect::<Vec<_>>()
+            .join(" ");
+        let name = regex::escape(n.name.trim_matches(['[', ']']));
+        let head = Self::cached_regex(&format!(
+            r"(?i)\b(?:Sub|Function)\s+(\[?{name}\]?)(?:[^\w$%&!#@]|$)"
+        ))?
+        .captures(&code);
+        let mut none = true;
+        if let Some(head) = head {
+            let mut at = head.get(1).unwrap().end();
+            if re!(r"(?i)^\s*\(\s*Of\b").is_match(&code[at..]) {
+                // `Function Parse(Of T)(text As String)`: the type parameters come first.
+                at = code[at..]
+                    .find('(')
+                    .and_then(|i| vb_close(&code, at + i))
+                    .map_or(0, |close| close + 1);
+            }
+            let open = (at > 0).then(|| re!(r"^\s*\(").find(&code[at..])).flatten();
+            let params = open.and_then(|m| {
+                let open_at = at + m.end() - 1;
+                vb_close(&code, open_at).map(|close| vb_args(&code[open_at + 1..close]))
+            });
+            none = params.is_none_or(|params| {
+                params.iter().all(|p| {
+                    let param = re!(r"<[^<>]*>").replace_all(p, "");
+                    let param = param.trim_start_matches([' ', '\t', '_']);
+                    param.is_empty()
+                        || re!(r"(?i)^(?:(?:ByVal|ByRef)\s+)*(?:Optional|ParamArray)\b")
+                            .is_match(param)
+                })
+            });
+        }
+        self.vb.no_args.insert(n.id.clone(), none);
+        Ok(none)
+    }
+    /// runnableOverload: the overload of `member` VB.NET runs where a
+    /// reference names it without parentheses — one that takes no arguments,
+    /// and never the member the reference is in. `member` itself when the
+    /// overloads don't tell; None when the only one is the containing member.
+    pub(in crate::resolve) fn vb_runnable_overload(
+        &mut self,
+        member: Arc<KNode>,
+        r: &ResolveRefIn,
+    ) -> Res<Option<Arc<KNode>>> {
+        let owner = match vb_parent_qn(&member) {
+            Some(qn) => self
+                .nodes_by_qualified_name(qn)?
+                .iter()
+                .find(|n| n.language == "vbnet" && vb_type_kind(&n.kind))
+                .cloned(),
+            None => None,
+        };
+        let project = self.vb_project(&member.file_path);
+        let overloads: Vec<Arc<KNode>> = match owner {
+            Some(owner) => self
+                .vb_members(&owner, &member.name)?
+                .into_iter()
+                .filter(|n| {
+                    n.kind == "method" && self.vb_project(&n.file_path) == project
+                })
+                .collect(),
+            None => vec![],
+        };
+        let others: Vec<_> = overloads
+            .into_iter()
+            .filter(|n| n.id != r.from_node_id)
+            .collect();
+        if others.is_empty() {
+            return Ok((member.id != r.from_node_id).then_some(member));
+        }
+        let mut runnable = Vec::new();
+        for n in &others {
+            if self.vb_takes_no_arguments(n)? {
+                runnable.push(n.clone());
+            }
+        }
+        let pool = if runnable.is_empty() { &others } else { &runnable };
+        Ok(Some(
+            pool.iter()
+                .find(|n| n.id == member.id)
+                .cloned()
+                .unwrap_or_else(|| pool[0].clone()),
+        ))
+    }
+    /// isOutsideNamesake: a member declared as a type of its own name that
+    /// isn't one of the project's (`Responser As Responser`), or naming two —
+    /// a read through its name may be one through that type.
+    pub(in crate::resolve) fn vb_is_outside_namesake(
+        &mut self,
+        member: &Arc<KNode>,
+        args: &HashMap<String, VbType>,
+    ) -> Res<bool> {
+        if args.is_empty() {
+            if let Some(hit) = self.vb.namesakes.get(&member.id) {
+                return Ok(*hit);
+            }
+        }
+        let declared = self.vb_member_type(&VbMember {
+            node: member.clone(),
+            args: args.clone(),
+        })?;
+        let mut namesake = false;
+        if let Some(d) = declared.filter(|d| {
+            !d.array
+                && d.name
+                    .eq_ignore_ascii_case(member.name.trim_matches(['[', ']']))
+        }) {
+            let (owners, ambiguous) = self.vb_types_at(&d, true)?;
+            namesake = ambiguous || owners.is_empty();
+        }
+        if args.is_empty() {
+            self.vb.namesakes.insert(member.id.clone(), namesake);
+        }
+        Ok(namesake)
+    }
 }

From db9b06729319870bda3eff4b8a750d73063366ca Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Wed, 28 Oct 2026 22:15:20 -0600
Subject: [PATCH 17/30] feat(kernel): workspace package entries, path deps,
 manifest-edit sync (#2502, #2456)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Port e8ddc4e2's declared-entry import resolution into the kernel and its
sync-side invalidation into codegraph.ts.

Kernel (napi config grows entriesByDir + scopedByName):
- resolve_workspace_import takes from_file; workspace_import_targets tries
  declared entries first — exports (exact, wildcard, fallback arrays,
  nested conditions), then source/module/main/types/typings in order —
  then an indexed direct probe, then emitted→source mapping, then the
  direct probe as last resort. Path deps (file:/link:/portal:) resolve
  scoped by the importer's nearest manifest, before global names;
  longest package name wins.
- imports.rs gains longest_package_name/match_workspace_package/
  declared_workspace_entries/indexed_target/built_source_of plus
  WorkspaceTargets/exported_targets/built_sources_of; prefilter passes
  the importing file through.

TS sync side (upstream index.ts port):
- resolver: refreshWorkspacePackages/getWorkspaceFingerprint/
  workspacePackageDirOf; a moved map closes the kernel since the config
  is construction-time.
- codegraph.ts: js_workspace_fingerprint metadata stamped at index and
  re-checked on full reconcile; a moved fingerprint re-opens every
  ESM-language ref for the orphan sweep. reopenReferencesThroughAddedFiles
  gets packageDirOf so a late-appearing declared entry re-links importers.
- loader.ts KernelWorkspaceIn + serialization gain the two new maps.

workspace-package-entries: 26/26. Regression sweep: 146/147, the one
failure a pre-existing tracked bucket (7180fd06 #2788).
---
 codegraph-kernel/src/resolve/imports.rs    | 251 +++++++++++++++++++--
 codegraph-kernel/src/resolve/mod.rs        |  62 +++++
 codegraph-kernel/src/resolve/node_table.rs |  12 +
 codegraph-kernel/src/resolve/prefilter.rs  |   4 +-
 src/codegraph.ts                           |  47 +++-
 src/extraction/kernel/loader.ts            |  18 ++
 src/resolution/index.ts                    |  44 +++-
 7 files changed, 417 insertions(+), 21 deletions(-)

diff --git a/codegraph-kernel/src/resolve/imports.rs b/codegraph-kernel/src/resolve/imports.rs
index f2ed9c177..ad63e8c0e 100644
--- a/codegraph-kernel/src/resolve/imports.rs
+++ b/codegraph-kernel/src/resolve/imports.rs
@@ -34,7 +34,7 @@ impl KernelResolver {
         if import_path.starts_with('.') {
             return false;
         }
-        if self.workspaces.is_some() && self.resolve_workspace_import(import_path).is_some() {
+        if self.workspaces.is_some() && self.resolve_workspace_import(import_path, from_file).is_some() {
             return false;
         }
         if is_esm_import_language(language) {
@@ -79,27 +79,52 @@ impl KernelResolver {
         false
     }
 
+    /// The longest package name `import_path` names among `names` — `name` or
+    /// `name/…` (longestName, workspace-packages.ts).
+    fn longest_package_name<'a>(import_path: &str, names: impl Iterator<Item = &'a String>) -> Option<&'a str> {
+        let mut best = None;
+        for name in names {
+            if (import_path == name.as_str() || import_path.starts_with(&format!("{}/", name)))
+                && best.is_none_or(|b: &str| name.len() > b.len())
+            {
+                best = Some(name.as_str());
+            }
+        }
+        best
+    }
+
+    /// matchPackage (workspace-packages.ts): the path dependency the nearest
+    /// manifest above `from_file` maps the import to, else a workspace member.
+    fn match_workspace_package(&self, import_path: &str, from_file: &str) -> Option<(String, String)> {
+        let ws = self.workspaces.as_ref()?;
+        // scopedPackage: manifests above the importing file declare their own
+        // `file:`/`link:`/`portal:` dependencies for the files under them.
+        let mut dir = from_file.replace('\\', "/");
+        while !dir.is_empty() {
+            dir = dir.rfind('/').map_or(String::new(), |s| dir[..s].to_string());
+            if let Some(names) = ws.scoped_by_name.get(&dir) {
+                if let Some(name) = Self::longest_package_name(import_path, names.keys()) {
+                    return Some((name.to_string(), names[name].clone()));
+                }
+            }
+        }
+        let name = Self::longest_package_name(import_path, ws.by_name.keys())?;
+        Some((name.to_string(), ws.by_name[name].clone()))
+    }
+
     /// resolveWorkspaceImport (workspace-packages.ts): sourceEntries first,
-    /// then longest matching package name; a bare member import resolves to
-    /// its declared entry when the manifest names one.
-    pub(super) fn resolve_workspace_import(&self, import_path: &str) -> Option<String> {
+    /// then the matching package; a bare member import resolves to its
+    /// declared entry when the manifest names one.
+    pub(super) fn resolve_workspace_import(&self, import_path: &str, from_file: &str) -> Option<String> {
         let ws = self.workspaces.as_ref()?;
         if let Some((_, src)) = ws.source_entries.iter().find(|(k, _)| k == import_path) {
             return Some(src.clone());
         }
-        let mut best: Option<(&str, &str)> = None;
-        for (name, dir) in &ws.by_name {
-            if (import_path == name.as_str() || import_path.starts_with(&format!("{}/", name)))
-                && best.is_none_or(|(b, _)| name.len() > b.len())
-            {
-                best = Some((name, dir));
-            }
-        }
-        let (name, dir) = best?;
+        let (name, dir) = self.match_workspace_package(import_path, from_file)?;
         let subpath = &import_path[name.len()..]; // '' or '/widgets'
         if subpath.is_empty() {
             if let Some(entry_by_name) = &ws.entry_by_name {
-                if let Some(entry) = entry_by_name.get(name) {
+                if let Some(entry) = entry_by_name.get(&name) {
                     return Some(entry.clone());
                 }
             }
@@ -111,6 +136,99 @@ impl KernelResolver {
         Some(multi_slash().replace_all(&joined, "/").to_string())
     }
 
+    /// workspaceImportTargets (workspace-packages.ts): what the package's
+    /// manifest declares for the import, and its directory form.
+    fn workspace_import_targets(&self, import_path: &str, from_file: &str) -> Option<WorkspaceTargets> {
+        let ws = self.workspaces.as_ref()?;
+        let (name, dir) = self.match_workspace_package(import_path, from_file)?;
+        let subpath = &import_path[name.len()..]; // '' or '/widgets'
+        let joined = format!("{}{}", dir, subpath);
+        let directory = re!(r"/{2,}").replace_all(&joined, "/").to_string();
+        let ohpm = if subpath.is_empty() {
+            ws.entry_by_name.as_ref().and_then(|m| m.get(&name)).cloned()
+        } else {
+            None
+        };
+        let declared = match ohpm {
+            Some(entry) => vec![entry],
+            None => self.declared_workspace_entries(dir.as_str(), subpath),
+        };
+        Some(WorkspaceTargets { declared, directory, package_dir: dir })
+    }
+
+    /// declaredEntries: the targets a package's manifest declares for
+    /// `subpath` (`''` or `/widgets`), best first: its `exports` entry, then
+    /// the root's `main`-style fields.
+    fn declared_workspace_entries(&self, package_dir: &str, subpath: &str) -> Vec<String> {
+        let Some(entries) = self.workspaces.as_ref().and_then(|ws| ws.entries_by_dir.get(package_dir)) else {
+            return vec![];
+        };
+        let exported = exported_targets(&entries.exports, &format!(".{subpath}"));
+        if !subpath.is_empty() {
+            return exported;
+        }
+        let mut out = exported;
+        for m in &entries.main {
+            if !out.contains(m) {
+                out.push(m.clone());
+            }
+        }
+        out
+    }
+
+    /// indexedTarget (import-resolver.ts): `target` as a file the index
+    /// holds — as written, with the language's extensions or index files, or
+    /// as the source of an emitted `.js`. Only the index counts: build output
+    /// a local build left on disk is not linked.
+    fn indexed_target(&self, target: &str, language: &str) -> Option<String> {
+        let as_is = indexed_spelling(target, language);
+        if self.known_file(&as_is) {
+            return Some(as_is);
+        }
+        for ext in extension_resolution(language) {
+            let candidate = indexed_spelling(&format!("{target}{ext}"), language);
+            if self.known_file(&candidate) {
+                return Some(candidate);
+            }
+        }
+        // findSourceForEmittedSpecifier restricted to the index.
+        let sources = emitted_to_source(&as_is, language)?;
+        let stem_len = as_is.rfind('.')?;
+        let stem = &as_is[..stem_len];
+        for ext in sources {
+            let candidate = format!("{}{}", stem, ext);
+            if self.known_file(&candidate) {
+                return Some(candidate);
+            }
+        }
+        None
+    }
+
+    /// builtSourceOf: `target`, build output the index lacks, as the indexed
+    /// source it is built from (`dist/index.js` → `src/index.ts`).
+    fn built_source_of(&self, target: &str, package_dir: &str, language: &str) -> Option<String> {
+        for source in built_sources_of(target, package_dir) {
+            if let Some(hit) = self.indexed_target(&source, language) {
+                return Some(hit);
+            }
+        }
+        None
+    }
+
+    /// declaredWorkspaceEntry: the first declared target the index holds, or
+    /// that is build output the index lacks read as its source.
+    fn declared_workspace_entry(&self, targets: &WorkspaceTargets, language: &str) -> Option<String> {
+        for target in &targets.declared {
+            if let Some(hit) = self
+                .indexed_target(target, language)
+                .or_else(|| self.built_source_of(target, &targets.package_dir, language))
+            {
+                return Some(hit);
+            }
+        }
+        None
+    }
+
     /// applyAliases (path-aliases.ts): candidate paths relative to
     /// projectRoot in tsconfig priority order.
     pub(super) fn apply_aliases(&self, import_path: &str, alias_map: &KernelAliasMapIn) -> Vec<String> {
@@ -233,9 +351,22 @@ impl KernelResolver {
             }
         }
         if self.workspaces.is_some() {
-            if let Some(base) = self.resolve_workspace_import(import_path) {
-                if let Some(hit) = self.probe_extensions(&base, language) {
-                    return Ok(Some(hit));
+            // The entry the package's manifest declares for the import (#2502),
+            // else the member's directory where extension/index permutations
+            // find its barrel, else the source its build output mirrors.
+            if let Some(targets) = self.workspace_import_targets(import_path, from_file) {
+                if let Some(declared) = self.declared_workspace_entry(&targets, language) {
+                    return Ok(Some(declared));
+                }
+                let direct = self.probe_extensions(&targets.directory, language);
+                if direct.as_ref().is_some_and(|d| self.known_file(d)) {
+                    return Ok(direct);
+                }
+                if let Some(built) = self.built_source_of(&targets.directory, &targets.package_dir, language) {
+                    return Ok(Some(built));
+                }
+                if direct.is_some() {
+                    return Ok(direct);
                 }
             }
         }
@@ -1792,6 +1923,92 @@ fn indexed_spelling(file_path: &str, language: &str) -> String {
     }
 }
 
+/// WorkspaceImportTargets (workspace-packages.ts): where an import of a
+/// project package lands before any file is probed.
+struct WorkspaceTargets {
+    /// The entries the package declares for the import, best first.
+    declared: Vec<String>,
+    /// The package's directory plus the import's subpath, extension-less.
+    directory: String,
+    /// The package's directory.
+    package_dir: String,
+}
+
+/// exportedTargets (workspace-packages.ts): `exports`' targets for `key` —
+/// the exact key's, else the `*` pattern's with the longest prefix, its `*`
+/// filled in.
+fn exported_targets(exports: &[(String, Vec<String>)], key: &str) -> Vec<String> {
+    for (k, targets) in exports {
+        if k == key {
+            return targets.clone();
+        }
+    }
+    let mut best: Option<(usize, String, &Vec<String>)> = None;
+    for (pattern, targets) in exports {
+        let Some(star) = pattern.find('*') else { continue };
+        if pattern[star + 1..].contains('*') {
+            continue;
+        }
+        let (prefix, suffix) = (&pattern[..star], &pattern[star + 1..]);
+        if key.len() < prefix.len() + suffix.len() || !key.starts_with(prefix) || !key.ends_with(suffix) {
+            continue;
+        }
+        if best.as_ref().is_some_and(|(b, _, _)| prefix.len() <= *b) {
+            continue;
+        }
+        best = Some((
+            prefix.len(),
+            key[prefix.len()..key.len() - suffix.len()].to_string(),
+            targets,
+        ));
+    }
+    match best {
+        Some((_, matched, targets)) => targets.iter().map(|t| t.replace('*', &matched)).collect(),
+        None => vec![],
+    }
+}
+
+/// builtSourcesOf (import-resolver.ts): `target` inside `package_dir`'s build
+/// output (`dist/`, `lib/`, `esm/`…) as the `src/` sources it is built from,
+/// best first.
+fn built_sources_of(target: &str, package_dir: &str) -> Vec<String> {
+    let prefix = if package_dir.is_empty() {
+        String::new()
+    } else {
+        format!("{package_dir}/")
+    };
+    if !target.starts_with(&prefix) {
+        return vec![];
+    }
+    let in_package = &target[prefix.len()..];
+    fn build_root() -> Rc<Regex> {
+        re!(r"^(?:dist|build|lib|out|output|es|esm|cjs|umd)/")
+    }
+    fn build_format() -> Rc<Regex> {
+        re!(r"^(?:esm|cjs|es|mjs|module|modules|commonjs|types|typings|umd|node|browser|src)/")
+    }
+    fn emitted_extension() -> Rc<Regex> {
+        re!(r"(?:\.d)?\.(?:[cm]?[jt]s|[jt]sx)$")
+    }
+    let Some(root) = build_root().find(in_package) else {
+        return vec![];
+    };
+    let mirrored = &in_package[root.end()..];
+    let format = build_format().find(mirrored);
+    let mut stems = vec![mirrored.to_string()];
+    if let Some(f) = format {
+        stems.push(mirrored[f.end()..].to_string());
+    }
+    let mut seen = HashSet::new();
+    stems
+        .iter()
+        .map(|rest| emitted_extension().replace(rest, "").to_string())
+        .filter(|stem| !stem.is_empty() && !stem.starts_with("src/"))
+        .filter(|stem| seen.insert(stem.clone()))
+        .map(|stem| format!("{prefix}src/{stem}"))
+        .collect()
+}
+
 #[cfg(test)]
 mod plain_import_tests {
     use super::plain_import_names;
diff --git a/codegraph-kernel/src/resolve/mod.rs b/codegraph-kernel/src/resolve/mod.rs
index df308205a..a6152cd19 100644
--- a/codegraph-kernel/src/resolve/mod.rs
+++ b/codegraph-kernel/src/resolve/mod.rs
@@ -100,6 +100,31 @@ pub struct KernelScopedAliasIn {
     pub map: KernelAliasMapIn,
 }
 
+/// A string-keyed entry whose value is a list — `exports` subpath → targets.
+#[cfg_attr(feature = "addon", napi(object))]
+pub struct KernelKvList {
+    pub key: String,
+    pub values: Vec<String>,
+}
+
+/// A package directory's declared entries (workspace-packages.ts PackageEntries).
+#[cfg_attr(feature = "addon", napi(object))]
+pub struct KernelPackageEntriesIn {
+    /// Package directory relative to projectRoot.
+    pub dir: String,
+    /// `exports` key (`.`, `./widgets`, `./schema/*`) → its targets, best first.
+    pub exports: Vec<KernelKvList>,
+    /// source/module/main/types/typings targets, best first.
+    pub main: Vec<String>,
+}
+
+/// A manifest directory's path-dependency names → package directories.
+#[cfg_attr(feature = "addon", napi(object))]
+pub struct KernelScopedPackageIn {
+    pub dir: String,
+    pub names: Vec<KernelKv>,
+}
+
 #[cfg_attr(feature = "addon", napi(object))]
 pub struct KernelWorkspaceIn {
     /// Import-source path prefix → workspace package name (longest prefix wins).
@@ -110,6 +135,10 @@ pub struct KernelWorkspaceIn {
     pub entry_by_name: Option<Vec<KernelKv>>,
     /// Link-source package names skipped during directory checks.
     pub local_link_names: Option<Vec<String>>,
+    /// Package directory → its manifest's declared entries (exports, main fields).
+    pub entries_by_dir: Option<Vec<KernelPackageEntriesIn>>,
+    /// Manifest directory → `file:`/`link:`/`portal:` dependency name → package dir.
+    pub scoped_by_name: Option<Vec<KernelScopedPackageIn>>,
 }
 
 #[cfg_attr(feature = "addon", napi(object))]
@@ -934,6 +963,39 @@ impl KernelResolver {
                 .local_link_names
                 .map(|v| v.into_iter().collect())
                 .unwrap_or_default(),
+            entries_by_dir: w
+                .entries_by_dir
+                .map(|v| {
+                    v.into_iter()
+                        .map(|e| {
+                            (
+                                e.dir,
+                                WorkspaceEntriesK {
+                                    exports: e
+                                        .exports
+                                        .into_iter()
+                                        .map(|kv| (kv.key, kv.values))
+                                        .collect(),
+                                    main: e.main,
+                                },
+                            )
+                        })
+                        .collect()
+                })
+                .unwrap_or_default(),
+            scoped_by_name: w
+                .scoped_by_name
+                .map(|v| {
+                    v.into_iter()
+                        .map(|s| {
+                            (
+                                s.dir,
+                                s.names.into_iter().map(|kv| (kv.key, kv.value)).collect(),
+                            )
+                        })
+                        .collect()
+                })
+                .unwrap_or_default(),
         });
         // context.getCppIncludeDirs?.() ?? [] — the TS side resolves
         // compile_commands.json + convention heuristics and passes the list;
diff --git a/codegraph-kernel/src/resolve/node_table.rs b/codegraph-kernel/src/resolve/node_table.rs
index 79be11601..0f060d9c6 100644
--- a/codegraph-kernel/src/resolve/node_table.rs
+++ b/codegraph-kernel/src/resolve/node_table.rs
@@ -544,11 +544,23 @@ pub(super) struct FileExportIndexK {
 
 /// WorkspacePackages (workspace-packages.ts).
 #[derive(Clone, Debug, Default)]
+/// workspace-packages.ts PackageEntries.
+pub(super) struct WorkspaceEntriesK {
+    /// `exports` key → targets, best first (ordered like the map was read).
+    pub(super) exports: Vec<(String, Vec<String>)>,
+    /// source/module/main/types/typings targets, best first.
+    pub(super) main: Vec<String>,
+}
+
 pub(super) struct WorkspaceK {
     pub(super) source_entries: Vec<(String, String)>,
     pub(super) by_name: HashMap<String, String>,
     pub(super) entry_by_name: Option<HashMap<String, String>>,
     pub(super) local_link_names: HashSet<String>,
+    /// Package directory → its manifest's declared entries.
+    pub(super) entries_by_dir: HashMap<String, WorkspaceEntriesK>,
+    /// Manifest directory → path-dependency name → package directory.
+    pub(super) scoped_by_name: HashMap<String, HashMap<String, String>>,
 }
 
 // ---------------------------------------------------------------------------
diff --git a/codegraph-kernel/src/resolve/prefilter.rs b/codegraph-kernel/src/resolve/prefilter.rs
index 8ca8f89f8..e32bc9df2 100644
--- a/codegraph-kernel/src/resolve/prefilter.rs
+++ b/codegraph-kernel/src/resolve/prefilter.rs
@@ -298,7 +298,7 @@ impl KernelResolver {
                 if self.known_file(&file) { return local; }
             }
         }
-        if self.workspaces.is_some() && self.resolve_workspace_import(&source).is_some() {
+        if self.workspaces.is_some() && self.resolve_workspace_import(&source, &r.file_path).is_some() {
             return local;
         }
         if !self.is_declared_outside_package(&source, &r.file_path)
@@ -359,7 +359,7 @@ impl KernelResolver {
     /// playground fixtures.
     pub(super) fn repository_package(&mut self, package: &str, from_file: &str) -> RepositoryPackage {
         if let Some(ws) = &self.workspaces {
-            if ws.local_link_names.contains(package) || self.resolve_workspace_import(package).is_some() {
+            if ws.local_link_names.contains(package) || self.resolve_workspace_import(package, from_file).is_some() {
                 return RepositoryPackage::Mapped;
             }
         }
diff --git a/src/codegraph.ts b/src/codegraph.ts
index 21bce07e1..cc998a847 100644
--- a/src/codegraph.ts
+++ b/src/codegraph.ts
@@ -68,6 +68,7 @@ import { extractSegmentSearchWords, segmentLookupVariants, splitIdentifierSegmen
 import { seedLiteralsInQuery, seedRouteNamesInQuery } from './extraction/literal-capture';
 import { createYielder } from './resolution/cooperative-yield';
 import { createImportReader, reopenNameMatchedImports, reopenReferencesThroughAddedFiles, reopenReferencesThroughBarrels, reopenReferencesThroughChangedDefaults, reopenReferencesThroughDeclaredPackages } from './resolution/module-importers';
+import { ESM_IMPORT_LANGUAGES } from './resolution/import-resolver';
 import { minRefsForPool } from './resolution/resolver-pool';
 
 /** The extraction, resolution and watcher modules, loaded on first use. */
@@ -148,6 +149,7 @@ export interface IndexOptions {
  */
 /** project_metadata key for the Python package-root digest (see sync). */
 const PYTHON_ROOTS_METADATA_KEY = 'python_root_fingerprint';
+const WORKSPACE_METADATA_KEY = 'js_workspace_fingerprint';
 
 export class CodeGraph {
   private db: DatabaseConnection;
@@ -852,6 +854,7 @@ export class CodeGraph {
         // real full index — a sync touches a subset, so it must NOT advance the
         // extraction stamp (the bulk would still be stale). See extraction-version.ts.
         if (result.success) this.stampPythonRootFingerprint();
+        if (result.success) this.stampWorkspaceFingerprint();
 
         if (result.success && result.filesIndexed > 0) {
           try {
@@ -974,6 +977,13 @@ export class CodeGraph {
     } catch { /* metadata is advisory */ }
   }
 
+  /** Record the workspace-map digest a later sync compares against. */
+  private stampWorkspaceFingerprint(fingerprint = this.resolver.getWorkspaceFingerprint()): void {
+    try {
+      this.queries.setMetadata(WORKSPACE_METADATA_KEY, fingerprint);
+    } catch { /* metadata is advisory */ }
+  }
+
   async sync(options: IndexOptions = {}): Promise<SyncResult> {
     if (options.requireComplete && process.env.CODEGRAPH_SYNC_RESYNTHESIS === '0') {
       throw new Error('Complete reconciliation requires synthesized-edge refresh to be enabled.');
@@ -1242,7 +1252,8 @@ export class CodeGraph {
               const tAdded = Date.now();
               const reopened = reopenReferencesThroughAddedFiles(
                 this.queries, importReader, added, edgesBeforeResolution,
-                (specifier, fromFile, language) => this.resolver.resolveModuleFile(specifier, fromFile, language)
+                (specifier, fromFile, language) => this.resolver.resolveModuleFile(specifier, fromFile, language),
+                (file) => this.resolver.workspacePackageDirOf(file)
               );
               if (process.env.CODEGRAPH_SYNTH_TIMINGS) console.error(`[phase-timing] sync-added-module-importers: ${Date.now() - tAdded}ms (${reopened} refs re-opened)`);
             }
@@ -1460,6 +1471,40 @@ export class CodeGraph {
           }
         }
 
+        // Workspace packages and path dependencies (#2456, #2502). A
+        // package.json edit — a member's name, its `main` or `exports`, a
+        // `file:` dependency — moves what an import of the package resolves to
+        // in files it never touched, and no indexed file changes with it. A
+        // full reconcile (`codegraph sync`, a git hook, the watcher's catch-up)
+        // reads the manifests again; when what they declare moved, every
+        // JavaScript-family reference is re-opened, as a moved Python root set
+        // re-opens Python's above, and the orphan sweep below resolves them by
+        // the new map exactly as a fresh index would. Package.json edits that
+        // leave the map alone (a version bump, a new registry dependency) cost
+        // one read. The watcher's scoped syncs follow source files only and
+        // skip the read: a monorepo's manifests take a walk of the tree to
+        // find. An index stamped by an older engine has no digest: record one.
+        if (fullReconcile) {
+          const tWorkspace = Date.now();
+          if (walValve) { walValve.stop(); await walValve.drain(); }
+          try {
+            const before = this.queries.getMetadata(WORKSPACE_METADATA_KEY);
+            const now = this.resolver.refreshWorkspacePackages();
+            if (before !== null && before !== now) {
+              let reopened = 0;
+              for (const language of ESM_IMPORT_LANGUAGES) reopened += this.orchestrator.resurrectResolutionEdgesForLanguage(language);
+              this.queries.setSynthesisPending(true);
+              if (process.env.CODEGRAPH_SYNTH_TIMINGS) {
+                console.error(`[phase-timing] sync-workspace-packages: ${Date.now() - tWorkspace}ms (${reopened} refs re-opened)`);
+              }
+            }
+            if (before !== now) this.stampWorkspaceFingerprint(now);
+          } finally {
+            this.resolver.closeKernel();
+            walValve?.start();
+          }
+        }
+
         // Orphan sweep (#1187). A resolution pass that dies mid-run — the #850
         // daemon liveness watchdog's SIGKILL (#1122), Ctrl-C, a crash — leaves
         // the refs it never reached in unresolved_refs, and the git-scoped fast
diff --git a/src/extraction/kernel/loader.ts b/src/extraction/kernel/loader.ts
index 607a324c2..531790715 100644
--- a/src/extraction/kernel/loader.ts
+++ b/src/extraction/kernel/loader.ts
@@ -178,11 +178,29 @@ export interface KernelAliasMapIn {
   patterns: KernelAliasPatternIn[];
 }
 
+export interface KernelKvList {
+  key: string;
+  values: string[];
+}
+
+export interface KernelPackageEntriesIn {
+  dir: string;
+  exports: KernelKvList[];
+  main: string[];
+}
+
+export interface KernelScopedPackageIn {
+  dir: string;
+  names: KernelKv[];
+}
+
 export interface KernelWorkspaceIn {
   sourceEntries: KernelKv[];
   byName: KernelKv[];
   entryByName?: KernelKv[];
   localLinkNames?: string[];
+  entriesByDir?: KernelPackageEntriesIn[];
+  scopedByName?: KernelScopedPackageIn[];
 }
 
 export interface KernelResolverConfig {
diff --git a/src/resolution/index.ts b/src/resolution/index.ts
index cb31f61d2..963fa7261 100644
--- a/src/resolution/index.ts
+++ b/src/resolution/index.ts
@@ -41,7 +41,7 @@ import { createYielder, type MaybeYield } from './cooperative-yield';
 import { MAX_SOURCE_FILE_SIZE_BYTES } from '../file-limits';
 import { loadProjectAliases, loadScopedAliases, scopedAliasesForFile, type AliasMap, type AliasScope } from './path-aliases';
 import { findGoModuleForImport, goModulePackageDir, loadGoModule, type GoModule } from './go-module';
-import { loadWorkspacePackages, type WorkspacePackages } from './workspace-packages';
+import { loadWorkspacePackages, workspaceFingerprint, workspacePackageDirOf, type WorkspacePackages } from './workspace-packages';
 import { logDebug } from '../errors';
 import { lexicalPathWithinRoot, safeJsonParse } from '../utils';
 import { builtinModules } from 'module';
@@ -1030,6 +1030,38 @@ export class ReferenceResolver {
     });
   }
 
+  /**
+   * The workspace packages and path dependencies as package.json files
+   * declare them now, read again from disk, and their fingerprint (see
+   * `workspaceFingerprint`). The resolver keeps the map for its lifetime, so
+   * a sync calls this to see a manifest edit; when the map moved, the
+   * resolver takes the new one and drops every memo resolved through the old
+   * one, and the caller re-opens what was linked by it.
+   */
+  refreshWorkspacePackages(): string {
+    const fresh = loadWorkspacePackages(this.projectRoot);
+    const fingerprint = workspaceFingerprint(fresh);
+    if (this.workspacePackages === undefined || workspaceFingerprint(this.workspacePackages) !== fingerprint) {
+      this.workspacePackages = fresh;
+      this.clearCaches();
+      // The kernel resolver takes the workspace map at construction: a moved
+      // map must reach a new instance, not just a cleared memo.
+      this.closeKernel();
+    }
+    return fingerprint;
+  }
+
+  /** The fingerprint of the workspace map this resolver resolves by (see `workspaceFingerprint`). */
+  getWorkspaceFingerprint(): string {
+    return workspaceFingerprint(this.context.getWorkspacePackages?.() ?? null);
+  }
+
+  /** The folder of the workspace package or path dependency `file` is in (see `workspacePackageDirOf`), or null. */
+  workspacePackageDirOf(file: string): string | null {
+    const ws = this.context.getWorkspacePackages?.();
+    return ws ? workspacePackageDirOf(ws, file) : null;
+  }
+
   getPythonReopenScope(changedFiles: string[]) {
     return this.withPythonKernel((kernel) => kernel.pythonPackageReopenScope(changedFiles));
   }
@@ -1366,6 +1398,16 @@ export class ReferenceResolver {
             byName: toKv(workspaces.byName),
             entryByName: workspaces.entryByName ? toKv(workspaces.entryByName) : undefined,
             localLinkNames: workspaces.localLinkNames ? [...workspaces.localLinkNames] : undefined,
+            entriesByDir: workspaces.entriesByDir
+              ? [...workspaces.entriesByDir.entries()].map(([dir, e]) => ({
+                  dir,
+                  exports: e.exports ? [...e.exports.entries()].map(([key, values]) => ({ key, values })) : [],
+                  main: e.main ?? [],
+                }))
+              : undefined,
+            scopedByName: workspaces.scopedByName
+              ? [...workspaces.scopedByName.entries()].map(([dir, names]) => ({ dir, names: toKv(names) }))
+              : undefined,
           }
         : undefined,
       goModules: this.getGoModules().map(m => ({ modulePath: m.modulePath, dir: path.relative(this.projectRoot, m.rootDir).split(path.sep).join('/') })),

From 97d93d7266a65b4056f3008d41f631e52bf5c4fd Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Wed, 28 Oct 2026 22:22:06 -0600
Subject: [PATCH 18/30] feat(kernel): a call on a this-field element resolves
 on the element's type
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Port 449eefa7's resolver half: `this.items[0].save()` arrives as
`this.items[].save` from the extractors (already ported) and now binds the
element type the field's declaration writes instead of bare-name matching
any project method.

- method_call_shape: elementOf arm `^this\.(#?[\w$]+)\[\]\.([\w$]+)$` →
  match_ts_this_field_call(field, method, r, element=true) — exclusive,
  like the plain `this.field.m` arm.
- TsFieldDecl gains element; ts_field_element_type reads it off the
  written type (`Item[]`, `Array<Item>`, `ReadonlyArray<Item>`,
  `Record<string, Item>`) and rejects unions, arrays of arrays and
  non-plain elements; ts_field_element adds tsFieldRead's multi-line
  continuation guard (`| Other[]` on the lines below).
- ts_field_held filters element reads through ts_class_type_parameter —
  `class Store<Item> { items: Item[] }` holds no project `Item`.
- ts_class_type_parameter ported upstream: `class|interface|type` keyword
  anchor, 24-line multi-line head, returns true when the list's `>` is
  not found (drop the type rather than take a parameter for a class).

ts-this-field-element 11/11; expression-receiver-calls +
ts-array-annotated-receivers green; receiver sweep shows only tracked
debt (08478eea #2811, 013b91c1 #2825); golden dumps unchanged.
---
 codegraph-kernel/src/resolve/fields.rs      | 137 +++++++++++++++++++-
 codegraph-kernel/src/resolve/method_call.rs |  20 ++-
 codegraph-kernel/src/resolve/ts_known.rs    |  20 ++-
 3 files changed, 161 insertions(+), 16 deletions(-)

diff --git a/codegraph-kernel/src/resolve/fields.rs b/codegraph-kernel/src/resolve/fields.rs
index 027c56a8b..15763e31a 100644
--- a/codegraph-kernel/src/resolve/fields.rs
+++ b/codegraph-kernel/src/resolve/fields.rs
@@ -589,6 +589,7 @@ impl KernelResolver {
                 }
                 let rest = &line[at + field.len() + caps.get(0).map_or(0, |m| m.end())..];
                 return Ok(Some(TsFieldDecl {
+                    element: ts_field_element(&caps[1], rest, &source, line_no),
                     ty: caps[1].to_string(),
                     value_type: false,
                     typed_collection: guard1_tail_re().is_match(rest),
@@ -615,7 +616,9 @@ impl KernelResolver {
                         continue;
                     }
                     let rest = &line[m.end..];
+                    let element = if *value_type { None } else { ts_field_element(&line[gs..ge], rest, &source, line_no) };
                     return Ok(Some(TsFieldDecl {
+                        element,
                         ty: line[gs..ge].to_string(),
                         value_type: *value_type,
                         typed_collection: guard1_tail_re().is_match(rest),
@@ -638,6 +641,7 @@ impl KernelResolver {
                 if declares && self.ts_init_is_read(owner, &source, start + i, &init)? {
                     let rest = &line[init.end..];
                     return Ok(Some(TsFieldDecl {
+                        element: None,
                         ty: init.ty,
                         value_type: false,
                         typed_collection: guard1_tail_re().is_match(rest),
@@ -1267,15 +1271,39 @@ impl KernelResolver {
         self.resolve_rust_module_file(&segs[..segs.len() - 1], &owner.file_path)
     }
 
+    /// `this.<field>[k].<method>()` calls the element's type: what the field's
+    /// declaration writes for it, or nothing. A type parameter of the
+    /// declaring class names no type (`class Store<Item> { items: Item[] }`),
+    /// whatever project class shares its name.
+    fn ts_field_held(&mut self, decl: TsFieldDecl, cls: &KNode, element: bool) -> Res<Option<TsFieldDecl>> {
+        if !element {
+            return Ok(Some(decl));
+        }
+        let Some(element_ty) = decl.element.clone() else { return Ok(None) };
+        if decl.value_type || self.ts_class_type_parameter(cls, &element_ty) {
+            return Ok(None);
+        }
+        Ok(Some(TsFieldDecl {
+            element: None,
+            ty: element_ty,
+            value_type: false,
+            typed_collection: false,
+            array: false,
+            nullable: false,
+        }))
+    }
+
     /// matchTsThisFieldCall — the `this.field.method` entry point of
     /// matchMethodCall's requireReceiverEvidence=false arm. The owner is the
     /// enclosing class written on the calling method's qualified name, so it
     /// is not a guess — same exclusive discipline as the go/rust field arms.
+    /// `element` selects the field's element type (`this.<field>[].<method>`).
     pub(super) fn match_ts_this_field_call(
         &mut self,
         field: &str,
         method: &str,
         r: &ResolveRefIn,
+        element: bool,
     ) -> Res<Option<KCand>> {
         if field.is_empty() || field.contains('.') {
             return Ok(None);
@@ -1297,7 +1325,7 @@ impl KernelResolver {
         if owner.is_empty() {
             return Ok(None);
         }
-        self.match_ts_field_call_free(owner, field, method, r)
+        self.match_ts_field_call_free(owner, field, method, r, element)
     }
 
     /// matchTsFieldCall without boundOwner — the unbound variant used by the
@@ -1312,6 +1340,7 @@ impl KernelResolver {
         field: &str,
         method: &str,
         r: &ResolveRefIn,
+        element: bool,
     ) -> Res<Option<KCand>> {
         let owners = prefer_call_site_file(
             self.nodes_by_name(owner)?
@@ -1330,14 +1359,17 @@ impl KernelResolver {
         // nothing about this one's field.
         let mut found: Vec<(TsFieldDecl, Arc<KNode>)> = Vec::new();
         for cls in owners.iter().filter(|c| c.file_path == r.file_path) {
-            if let Some(hit) = self.ts_field_through_bases(cls, field, r, 0)? {
-                found.push(hit);
+            if let Some((decl, cls)) = self.ts_field_through_bases(cls, field, r, 0)? {
+                if let Some(decl) = self.ts_field_held(decl, &cls, element)? {
+                    found.push((decl, cls));
+                }
                 break;
             }
         }
         if found.is_empty() {
             for cls in owners.iter().filter(|c| c.file_path != r.file_path) {
-                let Some(decl) = self.ts_field_decl(cls, field)? else { continue };
+                let Some(read) = self.ts_field_decl(cls, field)? else { continue };
+                let Some(decl) = self.ts_field_held(read, cls, element)? else { continue };
                 if self.ts_type_visible_in(&decl.ty, r)? {
                     // The type is the class the call's file names.
                     let mut at = (**cls).clone();
@@ -1729,6 +1761,103 @@ pub(super) struct TsFieldDecl {
     pub(super) array: bool,
     /// The only union members after the type are `undefined`/`null`.
     pub(super) nullable: bool,
+    /// What one of the field's elements holds: `Item` of `Item[]`, `Array<Item>` or `Record<string, Item>`.
+    pub(super) element: Option<String>,
+}
+
+/// Whether what follows a field's type joins it with another type: `| Other[]`,
+/// `& Extra`. `| null` and `| undefined` do not.
+fn ts_joins_another_type(tail: &str) -> bool {
+    let mut rest = tail.trim_start();
+    while let Some(t) = rest.strip_prefix('|') {
+        let t = t.trim_start();
+        if let Some(t) = t.strip_prefix("null").or_else(|| t.strip_prefix("undefined")) {
+            let mut b = t.as_bytes().iter();
+            if matches!(b.next(), None | Some(b' ' | b'\t' | b'|' | b'&' | b';' | b'=' | b')' | b',' | b'<' | b'{' | b'[' | b'/' | b'\n' | b'\r')) {
+                rest = t.trim_start();
+                continue;
+            }
+        }
+        break;
+    }
+    rest.starts_with('|') || rest.starts_with('&')
+}
+
+/// Container types whose element type is one of their type arguments, and which.
+fn ts_element_container(ty: &str) -> Option<(usize, usize)> {
+    match ty {
+        "Array" | "ReadonlyArray" => Some((1, 0)),
+        "Record" => Some((2, 1)),
+        _ => None,
+    }
+}
+
+/// The type an element of a field holds, from the field's written type (`ty`)
+/// and what follows it on the line (`rest`): `Item` of `Item[]`, `Array<Item>`
+/// and `Record<string, Item>`. None for any other type, an array of arrays, an
+/// element that is not a plain type name (a union, a generic), or a field
+/// typed as a union with another type (`Item[] | Other[]`); `| null` and
+/// `| undefined` leave the element as it is.
+fn ts_field_element_type(ty: &str, rest: &str) -> Option<String> {
+    let plain = |t: &str| -> Option<String> {
+        let ok = !t.is_empty()
+            && t.bytes().next().is_some_and(|b| b.is_ascii_alphabetic() || b == b'_' || b == b'$')
+            && t.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_' || b == b'$' || b == b'.');
+        ok.then(|| t.to_string())
+    };
+    let trimmed = rest.trim_start();
+    if let Some(tail) = trimmed.strip_prefix("[]") {
+        return (!tail.trim_start().starts_with('[') && !ts_joins_another_type(tail)).then(|| ty.to_string());
+    }
+    let (args_n, at) = ts_element_container(ty)?;
+    if !trimmed.starts_with('<') {
+        return None;
+    }
+    let mut depth = 0i32;
+    let mut from = rest.len() - trimmed.len() + 1;
+    let mut args: Vec<String> = Vec::new();
+    let bytes = rest.as_bytes();
+    let mut i = from;
+    while i < bytes.len() {
+        match bytes[i] {
+            b'<' | b'(' | b'[' | b'{' => depth += 1,
+            b'>' | b')' | b']' | b'}' if depth > 0 => depth -= 1,
+            b',' if depth == 0 => {
+                args.push(rest[from..i].trim().to_string());
+                from = i + 1;
+            }
+            b'>' if depth == 0 => {
+                args.push(rest[from..i].trim().to_string());
+                let tail = &rest[i + 1..];
+                if tail.trim_start().starts_with('[') || ts_joins_another_type(tail) {
+                    return None;
+                }
+                return (args.len() == args_n).then(|| args.get(at)).flatten().and_then(|a| plain(a));
+            }
+            _ => {}
+        }
+        i += 1;
+    }
+    None
+}
+
+/// The field's element type, with the multi-line guard of tsFieldRead: a type
+/// that goes on below with `| Other[]` holds no one element type.
+fn ts_field_element(ty: &str, rest: &str, source: &SourceFile, line_no: i64) -> Option<String> {
+    let element = ts_field_element_type(ty, rest)?;
+    let mut below = String::new();
+    let mut r = line_no as usize;
+    while let Some(raw) = source.get(r) {
+        let line = strip_line_comments(raw);
+        let t = line.trim_start();
+        if !t.starts_with('|') && !t.starts_with('&') {
+            break;
+        }
+        below.push(' ');
+        below.push_str(t);
+        r += 1;
+    }
+    (!ts_joins_another_type(&below)).then_some(element)
 }
 
 /// Whether the class's constructor passes `field` as an argument of `super(...)`,
diff --git a/codegraph-kernel/src/resolve/method_call.rs b/codegraph-kernel/src/resolve/method_call.rs
index 437c610bd..b24bbcf36 100644
--- a/codegraph-kernel/src/resolve/method_call.rs
+++ b/codegraph-kernel/src/resolve/method_call.rs
@@ -642,6 +642,14 @@ impl KernelResolver {
                 });
             }
         }
+        // An element of a field — `this.listeners[type].push()`, emitted as
+        // `this.listeners[].push`: the element type the field's declaration
+        // writes, or nothing (matchMethodCall's elementOf arm).
+        if is_js_family(&r.language) {
+            if let Some(m) = re!(r"^this\.(#?[A-Za-z0-9_$]+)\[\]\.([A-Za-z0-9_$]+)$").captures(&r.reference_name) {
+                return Ok(McShape::Done(self.match_ts_this_field_call(&m[1], &m[2], r, true)?));
+            }
+        }
         let dot_re = re!(r"^((?:this\.#)?[A-Za-z0-9_.]+)\.([A-Za-z0-9_]+:?(?:[A-Za-z0-9_]+:)*)$");
         // A JS/TS method name may carry `$`, which `\w` doesn't: an RxJS-style
         // `this.organizationService.organizations$()`, vscode's RPC
@@ -1149,16 +1157,16 @@ if inferred.is_none() && r.language == "dart" {
         }
 
         // TS/JS `this.field.method` — EXCLUSIVE; the field's declared type
-        // off the enclosing class, validated by rmot, or nothing.
+        // off the enclosing class, validated by rmot, or nothing. An element
+        // of a field — `this.listeners[type].push()`, emitted as
+        // `this.listeners[].push` — resolves on the element's type.
         if matches!(r.language.as_str(), "typescript" | "javascript" | "tsx" | "jsx")
             && dotted
             && object_or_class.starts_with("this.")
         {
-            return self.match_ts_this_field_call(
-                &object_or_class["this.".len()..],
-                &method_name,
-                r,
-            );
+            let field = &object_or_class["this.".len()..];
+            let (field, element) = field.strip_suffix("[]").map_or((field, false), |f| (f, true));
+            return self.match_ts_this_field_call(field, &method_name, r, element);
         }
 
         // Java/Kotlin field receiver inference — non-exclusive (a miss still
diff --git a/codegraph-kernel/src/resolve/ts_known.rs b/codegraph-kernel/src/resolve/ts_known.rs
index ec673841f..1ab56c740 100644
--- a/codegraph-kernel/src/resolve/ts_known.rs
+++ b/codegraph-kernel/src/resolve/ts_known.rs
@@ -22,6 +22,9 @@ fn is_member_owner_kind(kind: &str) -> bool {
     matches!(kind, "class" | "interface")
 }
 
+/// Lines of a class header the type-parameter reader looks through: decorators, then `class C<…>` over several lines.
+const TS_CLASS_HEAD_LINES: usize = 24;
+
 impl KernelResolver {
     /// tsTypeDeclaredIn: the class or interface named `name` that `file` declares.
     pub(super) fn ts_type_declared_in(&mut self, file: &str, name: &str) -> Res<Option<Arc<KNode>>> {
@@ -397,16 +400,21 @@ impl KernelResolver {
         Ok(None)
     }
 
-    /// Is `name` one of the type parameters the head of the TS class or
-    /// interface `cls` declares (`class Emitter<T>`)?
-    fn ts_class_type_parameter(&mut self, cls: &KNode, name: &str) -> bool {
+    /// Is `name` one of the type parameters the head of the TS class,
+    /// interface or type alias `cls` declares (`class Emitter<T>`,
+    /// `type State<T> = …`)? The list is read from the `class` / `interface` /
+    /// `type` keyword to its own `>`, over several lines and through
+    /// constraints and defaults that hold braces (`<T extends { id: string }>`).
+    /// A list whose `>` is not found reads as declaring `name`: a caller drops
+    /// the type rather than take a parameter for a project class.
+    pub(super) fn ts_class_type_parameter(&mut self, cls: &KNode, name: &str) -> bool {
         let Some(source) = self.read_file(&cls.file_path) else { return false };
         let from = (cls.start_line - 1).max(0) as usize;
-        let head = source.get(from..(from + 3).min(source.len())).unwrap_or_default().join(" ");
+        let head = source.get(from..(from + TS_CLASS_HEAD_LINES).min(source.len())).unwrap_or_default().join("\n");
         // No `{`-cut: `class Shaped<Item extends { id: string }>` carries a
         // brace inside its parameter list; the `>` scan below is depth-aware.
         let head = head.as_str();
-        let Ok(open) = Self::cached_regex(&format!(r"(?-u:\b){}\s*<", regex::escape(&cls.name))) else { return false };
+        let Ok(open) = Self::cached_regex(&format!(r"(?-u:\b)(?:class|interface|type)\s+{}\s*<", regex::escape(&cls.name))) else { return false };
         let Some(open) = open.find(head) else { return false };
         // The parameters between the `<` after the name and its own `>`, split
         // at their top level: `T`, `K extends keyof T = never`.
@@ -437,7 +445,7 @@ impl KernelResolver {
                 _ => {}
             }
         }
-        false
+        true
     }
 }
 

From 7f0757e736486d9e34d37f6280dd51b474d07c07 Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Wed, 28 Oct 2026 23:01:39 -0600
Subject: [PATCH 19/30] feat(kernel): calls on a typed local or parameter reach
 the builtin-named method (#2821)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A python call `reg.get()` on a builtin-named method was dropped by the
builtin filter before any strategy could read the receiver. Port
matchPythonTypedLocalCall (#2583) into python_attribute_verdict: a plain
local or parameter receiver settles only through scope evidence —
`python_local_class` agrees a binding def's parameter annotation (quoted,
Optional[T], Union[..., None], T | None, read off the raw def header) or
its assignments (ctor/factory/None; any foreign binding shape, rebinding
or contested evidence refuses). Members come from `python_strict_members`
— the class's own or a declared base's, resolved through the file's
imports, so a base from outside the project holds none of its methods
and the extends edges never substitute a same-name class.

Sync side: FAILED_PY_ATTR_REF widened to the one-dot `x.y` shape. The
fork's delta-narrowed retry keys (perf/sync-delta-retry) never list an
unchanged name like `get`, so a signature-only edit to the factory a
failed typed-local call reads its type from gave no retry key; the
attr-retry lane kernel-probes candidates and retries only resolvable
ones, which also lands the edge's typeFrom stamp for future edits.
---
 codegraph-kernel/src/resolve/python_types.rs | 570 ++++++++++++++++++-
 codegraph-kernel/src/resolve/tables.rs       |  28 +
 src/db/queries.ts                            |  10 +-
 3 files changed, 592 insertions(+), 16 deletions(-)

diff --git a/codegraph-kernel/src/resolve/python_types.rs b/codegraph-kernel/src/resolve/python_types.rs
index 04555adf3..0fe1b860b 100644
--- a/codegraph-kernel/src/resolve/python_types.rs
+++ b/codegraph-kernel/src/resolve/python_types.rs
@@ -2,6 +2,7 @@
 //! Syntax trees distinguish executable assignments/returns from strings,
 //! nested definitions and incomplete expressions. All evidence names its
 //! source files so incremental sync can reopen dependent edges.
+use super::super::bound::{python_def_params, python_param_names, PyFile};
 use super::*;
 use tree_sitter::Node as PyNode;
 
@@ -14,7 +15,7 @@ pub struct PythonAttributeResult {
     pub type_from: Vec<String>,
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 enum Answer {
     Class(Arc<KNode>),
     Declared(Arc<KNode>),
@@ -614,6 +615,7 @@ impl KernelResolver {
             return Ok(result);
         };
         let mut read = HashSet::new();
+        let mut strict_local = false;
         let answer = if let Some(callee) = receiver.strip_suffix("()") {
             if !simple_name(callee) {
                 return Ok(result);
@@ -624,13 +626,10 @@ impl KernelResolver {
                 return Ok(result);
             }
             self.python_callable_result(callee, r, &mut read, 0, false)?
-        } else {
-            let Some((head, attr)) = receiver
-                .split_once('.')
-                .filter(|(_, a)| simple_name(a) && !a.contains('.'))
-            else {
-                return Ok(result);
-            };
+        } else if let Some((head, attr)) = receiver
+            .split_once('.')
+            .filter(|(_, a)| simple_name(a) && !a.contains('.'))
+        {
             if self.python_outside_module_receiver(head, r)? {
                 result.claimed = true;
                 return Ok(result);
@@ -662,16 +661,41 @@ impl KernelResolver {
                 return Ok(result);
             };
             self.python_attribute_type(&class, attr, r, &mut read, &mut HashSet::new())?
+        } else {
+            // matchPythonTypedLocalCall (#2583): `reg.get()`-shaped calls —
+            // a plain local or parameter receiver on a builtin-named method —
+            // settle only through the strict scope evidence read; a name it
+            // cannot type, or whose evidence contests, stays refused rather
+            // than name-guessed. A `self`/`cls` receiver or a builtin type
+            // name keeps the ordinary paths.
+            if !re!(r"^[A-Za-z_]\w*$").is_match(receiver)
+                || !PYTHON_BUILT_IN_METHODS.contains(method)
+                || PYTHON_BUILT_IN_TYPES.contains(receiver)
+                || receiver == "self"
+                || receiver == "cls"
+            {
+                return Ok(result);
+            }
+            strict_local = true;
+            result.claimed = true;
+            self.python_local_class(receiver, r, &mut read)?
         };
-        let declared = matches!(answer, Answer::Declared(_));
+        let declared = matches!(answer, Answer::Declared(_)) && !strict_local;
         match answer {
             Answer::Runtime => result.claimed = true,
             Answer::Class(class) | Answer::Declared(class) => {
                 result.claimed = true;
-                if let Some(mro) = self.python_mro(&class, 0)? {
-                    read.extend(mro.iter().map(|c| c.file_path.clone()));
-                }
-                let mut members = self.python_members(&class, method, r, &mut HashSet::new())?;
+                let mut members = if strict_local {
+                    // pythonMethodOnClass: own member, else a declared base's —
+                    // read through the file's imports so a base from outside
+                    // the project holds none of its methods.
+                    self.python_strict_members(&class, method, r, &mut HashSet::new())?
+                } else {
+                    if let Some(mro) = self.python_mro(&class, 0)? {
+                        read.extend(mro.iter().map(|c| c.file_path.clone()));
+                    }
+                    self.python_members(&class, method, r, &mut HashSet::new())?
+                };
                 if members.is_empty() && declared {
                     members = self.python_descendant_members(&class, method, r)?;
                 }
@@ -690,6 +714,526 @@ impl KernelResolver {
         result.type_from.sort();
         Ok(result)
     }
+
+    /// pythonLocalClass (#2583): the project class the local or parameter
+    /// `name` holds at `r`, agreed by every binding of it in the binding
+    /// def's own body — a parameter annotation, `name: T`, `name = Ctor()`,
+    /// `name = factory()`, `name = None` (no evidence). Any other binding —
+    /// a `for`/`with`/`except`/comprehension target, a tuple or augmented
+    /// assignment, a walrus, an import, `del`, a nested `def` or `class` of
+    /// the name, a `nonlocal` write, a `global` — leaves it unknown, and a
+    /// contested one is no class at all.
+    fn python_local_class(&mut self, name: &str, r: &ResolveRefIn, read: &mut HashSet<String>) -> Res<Answer> {
+        let Some(src) = self.read_file(&r.file_path) else {
+            return Ok(Answer::Unknown);
+        };
+        let file = src.python_file();
+        let at = (r.line - 1).max(0) as usize;
+        // pythonBindingScope: the innermost def around the ref that binds the
+        // name — a parameter, or any binding in its own body. A `global`
+        // binding or no such def is no local.
+        let start = match file.stmt(at) {
+            Some((s, code)) if re!(r"^\s*(?:async\s+)?def\b").is_match(code) => Some(*s),
+            _ => file.scope.get(at).copied().flatten(),
+        };
+        let mut scope: Option<(usize, Option<Option<String>>, Vec<PyBinding>)> = None;
+        for d in file.functions_around(start) {
+            let (param, bindings) = python_scope_state(file, &src, d, name)?;
+            if param.is_some() {
+                scope = Some((d, param, bindings));
+                break;
+            }
+            if bindings.iter().any(|b| matches!(b, PyBinding::Global)) {
+                return Ok(Answer::Unknown);
+            }
+            if !bindings.is_empty() {
+                scope = Some((d, param, bindings));
+                break;
+            }
+        }
+        let Some((d, param, bindings)) = scope else {
+            return Ok(Answer::Unknown);
+        };
+        let mut evidence: Vec<Answer> = Vec::new();
+        if let Some(param) = param {
+            // A parameter without an annotation is no evidence.
+            let Some(ann) = param else {
+                return Ok(Answer::Unknown);
+            };
+            let ev = self.python_ann_answer(&ann, r, read)?;
+            if matches!(ev, Answer::Unknown) {
+                return Ok(Answer::Unknown);
+            }
+            evidence.push(ev);
+        }
+        for b in &bindings {
+            let PyBinding::Assign { ty, value, line } = b else {
+                return Ok(Answer::Unknown);
+            };
+            let value = value.trim();
+            let ev = if let Some(ty) = ty {
+                // `reg: Base = make()` trusts the annotation; `reg: A = B()` contradicts it.
+                if !value.is_empty() && value != "None" {
+                    if let Some(ctor) = python_constructor_call(value) {
+                        if ctor.rsplit('.').next() != ty.trim().trim_matches(['\'', '"']).rsplit('.').next() {
+                            return Ok(Answer::Unknown);
+                        }
+                    }
+                }
+                self.python_ann_answer(ty, r, read)?
+            } else if value == "None" {
+                continue;
+            } else if re!(r"^[A-Za-z_]\w*$").is_match(value) {
+                // `reg = cap`: what the def's parameter `cap` is annotated
+                // with, unless the def binds `cap` anywhere else.
+                let (copied_param, copied_bindings) = python_scope_state(file, &src, d, value)?;
+                let Some(Some(ann)) = copied_param else {
+                    return Ok(Answer::Unknown);
+                };
+                if !copied_bindings.is_empty() {
+                    return Ok(Answer::Unknown);
+                }
+                self.python_ann_answer(&ann, r, read)?
+            } else {
+                // A callee the def binds (`Store = load(); reg = Store()`) is no evidence.
+                for callee in python_value_callees(value) {
+                    let root = callee.split('.').next().unwrap_or(&callee);
+                    if self.python_binds_locally(root, &r.file_path, (*line + 1) as i64, false)? {
+                        return Ok(Answer::Unknown);
+                    }
+                }
+                self.python_value_text_answer(value, r, read, 0)?
+            };
+            if matches!(ev, Answer::Unknown | Answer::Absent) {
+                return Ok(Answer::Unknown);
+            }
+            evidence.push(ev);
+        }
+        // Nothing here can be a project class: a builtin, or no evidence.
+        if !evidence.iter().any(|e| !matches!(e, Answer::Runtime)) {
+            return Ok(if evidence.is_empty() { Answer::Unknown } else { Answer::Runtime });
+        }
+        // A def or class of the name nested in the scope binds it there; a
+        // def nested in it can rebind the scope's own through `nonlocal`;
+        // `with … as (a, name)` binds it in a way bindings don't read.
+        let end = python_scope_end(file, d);
+        if self.nodes_in_file(&r.file_path)?.iter().any(|n| {
+            matches!(n.kind.as_str(), "function" | "method" | "class")
+                && n.name == name
+                && n.start_line > d as i64 + 1
+                && n.end_line <= end as i64 + 1
+        }) {
+            return Ok(Answer::Unknown);
+        }
+        for i in d..=end.min(file.code.len().saturating_sub(1)) {
+            let Some((_, code)) = file.code.get(i) else { break };
+            if !code.contains(name) {
+                continue;
+            }
+            if re!(r"^\s*nonlocal\b").is_match(code) && bare_word(code, name) {
+                return Ok(Answer::Unknown);
+            }
+            if let Some(cap) = re!(r"\bas\s*\(([^)]*)\)").captures(code) {
+                if bare_word(&cap[1], name) {
+                    return Ok(Answer::Unknown);
+                }
+            }
+        }
+        Ok(agree(evidence))
+    }
+
+    /// pythonFindMethod's member walk for the strict local path: `member` on
+    /// `cls` itself, else on a base the class's file declares — resolved
+    /// through that file's imports (`python_bases`), never through the
+    /// `extends` edges, so a base spelled from a module outside the project
+    /// holds none of its methods.
+    fn python_strict_members(
+        &mut self,
+        cls: &Arc<KNode>,
+        member: &str,
+        r: &ResolveRefIn,
+        seen: &mut HashSet<String>,
+    ) -> Res<Vec<Arc<KNode>>> {
+        if seen.len() >= 16 || !seen.insert(cls.id.clone()) {
+            return Ok(Vec::new());
+        }
+        if self.python_class_assigns(cls, member)? {
+            return Ok(vec![cls.clone()]);
+        }
+        let own: Vec<Arc<KNode>> = self
+            .nodes_by_qualified_name(&format!("{}::{}", cls.qualified_name, member))?
+            .iter()
+            .filter(|n| n.file_path == cls.file_path)
+            .cloned()
+            .collect();
+        if !own.is_empty() {
+            return Ok(own);
+        }
+        let mut out: Vec<Arc<KNode>> = Vec::new();
+        for base in self.python_bases(cls, r)? {
+            for n in self.python_strict_members(&base, member, r, seen)? {
+                if !out.iter().any(|o| o.id == n.id) {
+                    out.push(n);
+                }
+            }
+        }
+        Ok(out)
+    }
+
+    /// pythonAnnotationEvidence → pythonEvidenceClass: `Optional[T]`,
+    /// `Union[T, None]`, `T | None` and `"T"` unwrap to `T`; a runtime
+    /// container type is 'runtime', anything unreadable is unknown.
+    fn python_ann_answer(&mut self, raw: &str, site: &ResolveRefIn, read: &mut HashSet<String>) -> Res<Answer> {
+        let mut t = raw.trim().trim_matches(['\'', '"']).trim().to_string();
+        for _ in 0..4 {
+            if t.is_empty() {
+                break;
+            }
+            let cap = re!(r"^(?:typing\.)?Optional\s*\[\s*(.+)\s*\]$").captures(&t)
+                .or_else(|| re!(r"^(?:typing\.)?Union\s*\[\s*([^,\]]+?)\s*,\s*None\s*\]$").captures(&t))
+                .or_else(|| re!(r"^(.+?)\s*\|\s*None$").captures(&t))
+                .or_else(|| re!(r"^None\s*\|\s*(.+)$").captures(&t));
+            let Some(cap) = cap else {
+                break;
+            };
+            t = cap[1].trim().trim_matches(['\'', '"']).trim().to_string();
+        }
+        let head = t.split('[').next().unwrap_or("").trim().trim_start_matches("typing.");
+        if PYTHON_RUNTIME_TYPES.contains(head) {
+            return Ok(Answer::Runtime);
+        }
+        if t.contains('[') || !re!(r"^[A-Za-z_][\w.]*$").is_match(&t) || head == "Any" {
+            return Ok(Answer::Unknown);
+        }
+        self.python_named_answer(&t, site, read)
+    }
+
+    /// pythonValueEvidence → pythonEvidenceClass for a whole assigned value:
+    /// a conditional's arms must agree; literals and runtime containers are
+    /// 'runtime'; `Ctor()` is that class; `factory(...)` resolves by what the
+    /// factory produces; anything else is unknown.
+    fn python_value_text_answer(
+        &mut self,
+        raw: &str,
+        site: &ResolveRefIn,
+        read: &mut HashSet<String>,
+        depth: usize,
+    ) -> Res<Answer> {
+        if depth >= 8 {
+            return Ok(Answer::Unknown);
+        }
+        if let Some((a, b)) = python_conditional_arms(raw) {
+            let x = self.python_value_text_answer(&a, site, read, depth + 1)?;
+            let y = self.python_value_text_answer(&b, site, read, depth + 1)?;
+            return Ok(agree(vec![x, y]));
+        }
+        let mut awaited = false;
+        let mut v = raw.trim();
+        if let Some(rest) = v.strip_prefix("await") {
+            if rest.starts_with(char::is_whitespace) {
+                v = rest.trim();
+                awaited = true;
+            }
+        }
+        let Some(shape) = python_expr_shape(v) else {
+            return Ok(Answer::Unknown);
+        };
+        if re!(r"^(?:S(?: S)*|-?\d[\w.]*|True|False|\[\]|\{\}|\(\))$").is_match(&shape) {
+            return Ok(if awaited { Answer::Unknown } else { Answer::Runtime });
+        }
+        if let Some(cap) = re!(r"^([A-Za-z_][\w.]*) ?\(\)$").captures(&shape) {
+            let callee = cap[1].to_string();
+            if PYTHON_RUNTIME_TYPES.contains(callee.as_str()) {
+                return Ok(if awaited { Answer::Unknown } else { Answer::Runtime });
+            }
+            if callee
+                .rsplit('.')
+                .next()
+                .is_some_and(|leaf| leaf.starts_with(|c: char| c.is_ascii_uppercase()))
+            {
+                return if awaited {
+                    Ok(Answer::Unknown)
+                } else {
+                    self.python_named_answer(&callee, site, read)
+                };
+            }
+            return self.python_callable_result(&callee, site, read, depth + 1, awaited);
+        }
+        Ok(Answer::Unknown)
+    }
+}
+
+/// pythonScopeBindings: `name`'s parameter-annotation state in the def at
+/// statement line `d` — None when it is no parameter, Some(None) for a bare
+/// or starred one, Some(Some) for `name: T` — plus every binding of the name
+/// in the def's own body (a one-line body on the header line counts).
+fn python_scope_state(
+    file: &PyFile,
+    lines: &[String],
+    d: usize,
+    name: &str,
+) -> Res<(Option<Option<String>>, Vec<PyBinding>)> {
+    let header = file.stmt(d).map(|(_, h)| h.clone()).unwrap_or_default();
+    // Params are read off the raw header — the statement's strings are
+    // blanked, so `reg: "T"` reads `reg: "          "` there; offsets match.
+    let raw = file
+        .stmts
+        .iter()
+        .position(|(i, _)| *i == d)
+        .map(|k| python_raw_stmt(file, lines, k))
+        .unwrap_or_else(|| header.clone());
+    let params = python_def_params(&header)
+        .map(|p| raw.get(p.clone()).map_or_else(|| header[p].to_string(), str::to_string))
+        .unwrap_or_default();
+    let param = python_param_names(&params)
+        .contains(&name)
+        .then(|| python_param_ann(&params, name))
+        .flatten();
+    let mut bindings = Vec::new();
+    if let Some(body) = header_colon(&header)
+        .map(|at| &header[at + 1..])
+        .filter(|b| !b.trim().is_empty())
+    {
+        bindings.extend(python_stmt_bindings(body, body, name, d)?);
+    }
+    for (k, (i, code)) in file.stmts.iter().enumerate() {
+        if file.scope[*i] != Some(d) || !mentions(code, name) {
+            continue;
+        }
+        let raw = python_raw_stmt(file, lines, k);
+        bindings.extend(python_stmt_bindings(code, &raw, name, *i)?);
+    }
+    Ok((param, bindings))
+}
+
+/// The last line inside the `def`/`class` at line `d`, nested bodies
+/// included — the range a `nonlocal` or `as (…)` scan must cover.
+fn python_scope_end(file: &PyFile, d: usize) -> usize {
+    let mut end = d;
+    for (i, s) in file.scope.iter().enumerate().skip(d + 1) {
+        let mut at = *s;
+        while let Some(h) = at {
+            if h == d {
+                end = i;
+                break;
+            }
+            at = file.scope[h];
+        }
+    }
+    end
+}
+
+/// pythonBlankStrings: `line` with the contents of its string literals
+/// blanked (quotes kept), so a string never reads as code. A quote left open
+/// blanks the rest of the line.
+fn python_blank_strings(line: &str) -> String {
+    let bytes = line.as_bytes();
+    let mut out = bytes.to_vec();
+    let mut i = 0usize;
+    while i < bytes.len() {
+        let c = bytes[i];
+        if c != b'"' && c != b'\'' {
+            i += 1;
+            continue;
+        }
+        let triple = bytes.get(i + 1) == Some(&c) && bytes.get(i + 2) == Some(&c);
+        let qlen = if triple { 3 } else { 1 };
+        let mut j = i + qlen;
+        while j < bytes.len() && !line.get(j..).is_some_and(|s| s.starts_with(&line[i..i + qlen])) {
+            j += if bytes[j] == b'\\' { 2 } else { 1 };
+        }
+        for o in out.iter_mut().take(j.min(bytes.len())).skip(i + qlen) {
+            *o = b' ';
+        }
+        i = (j + qlen).min(bytes.len());
+    }
+    String::from_utf8_lossy(&out).into_owned()
+}
+
+/// `name: T` or `name: T = d` in a def's parameter list: Some(Some(T)),
+/// Some(None) for a bare or starred parameter, None when not a parameter.
+/// Commas and the default's `=` are read on a string-blanked copy.
+fn python_param_ann(params: &str, name: &str) -> Option<Option<String>> {
+    let blank = python_blank_strings(params);
+    let mut depth = 0i32;
+    let mut from = 0usize;
+    let mut parts: Vec<std::ops::Range<usize>> = Vec::new();
+    for (i, c) in blank.char_indices() {
+        match c {
+            '(' | '[' | '{' => depth += 1,
+            ')' | ']' | '}' => depth -= 1,
+            ',' if depth == 0 => {
+                parts.push(from..i);
+                from = i + 1;
+            }
+            _ => {}
+        }
+    }
+    parts.push(from..blank.len());
+    for range in parts {
+        let part = &params[range.clone()];
+        let Some(cap) = re!(r"^\s*(\*{0,2})([A-Za-z_]\w*)\s*(:?)").captures(part) else {
+            continue;
+        };
+        if &cap[2] != name {
+            continue;
+        }
+        if !cap[1].is_empty() || cap[3].is_empty() {
+            return Some(None);
+        }
+        let at = cap[0].len();
+        // The annotation runs up to the default's `=`, outside brackets.
+        let mut d = 0i32;
+        let mut to = part.len();
+        for (i, c) in blank[range.clone()][at..].char_indices() {
+            match c {
+                '(' | '[' | '{' => d += 1,
+                ')' | ']' | '}' => d -= 1,
+                '=' if d == 0 => {
+                    to = at + i;
+                    break;
+                }
+                _ => {}
+            }
+        }
+        let ann = part[at..to].trim();
+        return Some((!ann.is_empty()).then(|| ann.to_string()));
+    }
+    None
+}
+
+/// pythonValueCallees: the names `value` calls as a whole expression or
+/// conditional arm — `Client(...)`, `make()` — whose local rebinding would
+/// make the evidence wrong.
+fn python_value_callees(value: &str) -> Vec<String> {
+    if let Some((a, b)) = python_conditional_arms(value.trim()) {
+        return [a, b].into_iter().flat_map(|arm| python_value_callees(&arm)).collect();
+    }
+    let mut v = value.trim();
+    if let Some(rest) = v.strip_prefix("await") {
+        if rest.starts_with(char::is_whitespace) {
+            v = rest.trim();
+        }
+    }
+    python_expr_shape(v)
+        .and_then(|shape| re!(r"^([A-Za-z_][\w.]*) ?\(\)$").captures(&shape).map(|c| c[1].to_string()))
+        .into_iter()
+        .collect()
+}
+
+/// pythonConditionalArms: the two arms of a top-level `A if c else B`;
+/// keywords inside brackets or strings do not count.
+fn python_conditional_arms(raw: &str) -> Option<(String, String)> {
+    let mut depth = 0i32;
+    let mut if_at: Option<usize> = None;
+    let bytes = raw.as_bytes();
+    let mut i = 0usize;
+    while i < bytes.len() {
+        let c = bytes[i];
+        let ch = raw[i..].chars().next().unwrap();
+        if c == b'"' || c == b'\'' {
+            let triple = bytes.get(i + 1) == Some(&c) && bytes.get(i + 2) == Some(&c);
+            let close_len = if triple { 3 } else { 1 };
+            let close = &raw[i..i + close_len];
+            let mut j = i + close_len;
+            while j < bytes.len() && !raw.get(j..).is_some_and(|s| s.starts_with(close)) {
+                j += if bytes[j] == b'\\' { 2 } else { 1 };
+            }
+            i = j + close_len;
+            continue;
+        }
+        if matches!(c, b'(' | b'[' | b'{') {
+            depth += 1;
+        } else if matches!(c, b')' | b']' | b'}') {
+            depth -= 1;
+        } else if depth == 0 && raw[..i].chars().next_back().is_some_and(|p| p.is_whitespace()) {
+            let rest = &raw[i..];
+            if if_at.is_none()
+                && rest.starts_with("if")
+                && rest.len() > 2
+                && rest.as_bytes()[2].is_ascii_whitespace()
+            {
+                if_at = Some(i);
+            } else if if_at.is_some()
+                && rest.starts_with("else")
+                && rest.len() > 4
+                && rest.as_bytes()[4].is_ascii_whitespace()
+            {
+                let at = if_at.unwrap();
+                return Some((raw[..at].trim().to_string(), raw[i + 4..].trim().to_string()));
+            }
+        }
+        i += ch.len_utf8();
+    }
+    None
+}
+
+/// pythonExprShape: the top-level shape of a python expression — string
+/// literals collapse to `S` and everything inside brackets is dropped, so
+/// `Client(a, f(b))` reads `Client()` and `Client() if t else Fake()` keeps
+/// its `if`. None when the expression is left open or unrecoverable.
+fn python_expr_shape(raw: &str) -> Option<String> {
+    python_expr_scan(raw).0
+}
+
+/// pythonExprScan: `shape` plus why there is none — 'continues' for an open
+/// bracket or triple-quoted string or a trailing `\`, 'broken' for a
+/// single-line string left open or a bracket closed that was never opened.
+fn python_expr_scan(raw: &str) -> (Option<String>, &'static str) {
+    let mut out = String::new();
+    let mut depth = 0i32;
+    let bytes = raw.as_bytes();
+    let mut i = 0usize;
+    while i < bytes.len() {
+        let c = bytes[i];
+        let ch = raw[i..].chars().next().unwrap();
+        if c == b'"' || c == b'\'' {
+            let triple = bytes.get(i + 1) == Some(&c) && bytes.get(i + 2) == Some(&c);
+            let close_len = if triple { 3 } else { 1 };
+            let close = &raw[i..i + close_len];
+            let mut j = i + close_len;
+            while j < bytes.len() && !raw.get(j..).is_some_and(|s| s.starts_with(close)) {
+                j += if bytes[j] == b'\\' { 2 } else { 1 };
+            }
+            if j >= bytes.len() {
+                return (None, if triple { "continues" } else { "broken" });
+            }
+            if depth == 0 {
+                let strip = out
+                    .chars()
+                    .rev()
+                    .take(2)
+                    .take_while(|k| "rbfuRBFU".contains(*k))
+                    .count();
+                out.truncate(out.len() - strip);
+                out.push('S');
+            }
+            i = j + close_len;
+            continue;
+        }
+        if matches!(c, b'(' | b'[' | b'{') {
+            if depth == 0 {
+                out.push(ch);
+            }
+            depth += 1;
+        } else if matches!(c, b')' | b']' | b'}') {
+            depth -= 1;
+            if depth < 0 {
+                return (None, "broken");
+            }
+            if depth == 0 {
+                out.push(ch);
+            }
+        } else if depth == 0 {
+            out.push(ch);
+        }
+        i += ch.len_utf8();
+    }
+    let shape = out.split_whitespace().collect::<Vec<_>>().join(" ");
+    if depth > 0 || shape.ends_with('\\') {
+        return (None, "continues");
+    }
+    (Some(shape), "none")
 }
 #[cfg_attr(feature = "addon", napi)]
 impl KernelResolver {
diff --git a/codegraph-kernel/src/resolve/tables.rs b/codegraph-kernel/src/resolve/tables.rs
index 32368bc74..5d583d183 100644
--- a/codegraph-kernel/src/resolve/tables.rs
+++ b/codegraph-kernel/src/resolve/tables.rs
@@ -1010,6 +1010,34 @@ pub(super) static PYTHON_BUILT_IN_METHODS: LazyLock<HashSet<&'static str>> = Laz
     .collect()
 });
 
+/// PYTHON_BUILT_IN_TYPES (index.ts isPythonBuiltinNamedMethodCall): receiver
+/// spellings that ARE the builtin type — `dict.get` is the dict's own method,
+/// never a project class's.
+pub(super) static PYTHON_BUILT_IN_TYPES: LazyLock<HashSet<&'static str>> = LazyLock::new(|| {
+    [
+        "list", "dict", "set", "tuple", "str", "int", "float", "bool",
+        "bytes", "bytearray", "frozenset", "object", "super",
+    ]
+    .into_iter()
+    .collect()
+});
+
+/// PYTHON_RUNTIME_TYPES (name-matcher.ts pythonAnnotationEvidence /
+/// pythonValueEvidence): annotation or `Ctor()` names that produce a runtime
+/// container, not a project class.
+pub(super) static PYTHON_RUNTIME_TYPES: LazyLock<HashSet<&'static str>> = LazyLock::new(|| {
+    [
+        "list", "dict", "set", "frozenset", "tuple", "str", "bytes", "bytearray",
+        "int", "float", "complex", "bool", "object", "type", "range", "slice",
+        "List", "Dict", "Set", "FrozenSet", "Tuple", "Sequence", "Mapping",
+        "MutableMapping", "MutableSequence", "Iterable", "Iterator", "Callable",
+        "deque", "defaultdict", "OrderedDict", "Counter",
+        "collections.deque", "collections.defaultdict", "collections.OrderedDict", "collections.Counter",
+    ]
+    .into_iter()
+    .collect()
+});
+
 // GO_STDLIB_PACKAGES (index.ts isBuiltInOrExternal `pkg.member` arm) — live
 // for non-bare names (`pkg.Member` where pkg is a stdlib import).
 pub(super) static GO_STDLIB_PACKAGES: LazyLock<HashSet<&'static str>> = LazyLock::new(|| {
diff --git a/src/db/queries.ts b/src/db/queries.ts
index bb192ea7d..fa6a08cce 100644
--- a/src/db/queries.ts
+++ b/src/db/queries.ts
@@ -265,10 +265,14 @@ function rowToNode(row: NodeRow): Node {
 /**
  * Convert database row to Edge object
  */
-/** A failed python ref through one attribute (`self.c.send`) or a call receiver (`make().send`). */
+/** A failed python ref through one attribute (`self.c.send`), a call receiver
+ * (`make().send`), or a receiver-typed local's call (`reg.get`) — the last is
+ * the builtin-named-method shape the typed-local evidence pass may later
+ * satisfy once the file it reads its type from changes (#2583). One or two
+ * dots, not three: `a.b.c.d` chains never come back through a local's type. */
 const FAILED_PY_ATTR_REF = `status = 'failed' AND language = 'python'
-  AND reference_name NOT GLOB '*.*.*.*'
-  AND (reference_name GLOB '*.*.*' OR reference_name GLOB '*().*')`;
+  AND reference_name GLOB '*.*'
+  AND reference_name NOT GLOB '*.*.*.*'`;
 
 function rowToEdge(row: EdgeRow): Edge {
   return {

From 9a8c42b044b1f3ee52c7b1cb3f57868f640ad305 Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Wed, 28 Oct 2026 23:34:02 -0600
Subject: [PATCH 20/30] feat(kernel): a call on an unqualified call result
 resolves on its return type (#2822)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`repository().pending()` — and `val repo = repository()` locals — type the
receiver by the inner call's declared return, so `pending` is the method the
returned project type declares, never a same-named method elsewhere. A type
from outside the project leaves the name strategies untouched, and an
extension the bound-member walk can't see keeps the old name match.

The extractor's return_type keeps only a user_type's first identifier
(`Request`), so `kotlin_scoped_hit` retypes the callee through its signature
(`(): Request.Builder`) and writes a lone nested name through its declaring
outer (`Builder` → `Shop.Builder`).

Two pre-existing filters were misaligned with the kotlinCall/kotlinBare
split this relies on: member-scope reachability vetted receiver-written
names (`text().reverse`) as if receiver-less, and a Chain-shape call with a
non-project receiver type (`StringBuilder`) vetoed every name match —
upstream only constrains standard-library names there. Both now match
upstream's isReceiverLessKotlinCall / kotlinStdChain boundary.

Also: python_local_class returns Option<Answer> — a name no enclosing def
binds (module-level, global) is upstream's `undefined`, not a refused local,
which restores module-global `store = Store()` receivers the strict arm
claimed and dropped.
---
 codegraph-kernel/src/resolve/call_shape.rs    |  12 +-
 .../src/resolve/kotlin_receiver.rs            | 169 ++++++++++++++++++
 codegraph-kernel/src/resolve/lang_scope.rs    |   6 +
 codegraph-kernel/src/resolve/pipeline.rs      |   6 +
 codegraph-kernel/src/resolve/python_types.rs  |  47 ++---
 codegraph-kernel/src/resolve/receivers.rs     |   3 +
 6 files changed, 222 insertions(+), 21 deletions(-)

diff --git a/codegraph-kernel/src/resolve/call_shape.rs b/codegraph-kernel/src/resolve/call_shape.rs
index cda904aea..bfab5c500 100644
--- a/codegraph-kernel/src/resolve/call_shape.rs
+++ b/codegraph-kernel/src/resolve/call_shape.rs
@@ -419,7 +419,17 @@ impl KernelResolver {
                 if facts.infix_site == Some(true) && !is_std_method("kotlin",&r.reference_name) {return Ok(true);}
                 if facts.receiver_type.is_none() { facts.receiver_type = Some(self.kotlin_call_receiver_type(r)?); }
                 if let Some(receiver) = facts.receiver_type.as_ref().and_then(Option::as_ref) {
-                    return self.kotlin_receiver_accepts(n, receiver, r);
+                    if self.resolve_bound_type(&receiver.ty, &receiver.site, 0)?.is_some() {
+                        return self.kotlin_receiver_accepts(n, receiver, r);
+                    }
+                    // The receiver's type is no type the project declares
+                    // (`text(): StringBuilder` — the JDK's): only a
+                    // standard-library name constrains it, as upstream's
+                    // kotlinStdChain does; any other name match stands
+                    // unvetoed (#2822).
+                    return Ok(!is_std_method("kotlin", &r.reference_name)
+                        || site.receiver == "this"
+                        || (!site.receiver.is_empty() && shares_receiver_word(&site.receiver, n)));
                 }
                 Ok(!matches!(n.kind.as_str(), "method" | "function") || site.receiver == "this"
                     || (is_std_method("kotlin",&r.reference_name) && !site.receiver.is_empty() && shares_receiver_word(&site.receiver, n))
diff --git a/codegraph-kernel/src/resolve/kotlin_receiver.rs b/codegraph-kernel/src/resolve/kotlin_receiver.rs
index bae796fc1..f18143d4d 100644
--- a/codegraph-kernel/src/resolve/kotlin_receiver.rs
+++ b/codegraph-kernel/src/resolve/kotlin_receiver.rs
@@ -314,6 +314,14 @@ impl KernelResolver {
             let ty=simple_type(text(ty,source)).to_string();
             return Ok(self.resolve_bound_type(&ty,&site,0)?.map(|_|KotlinReceiverHit{ty,site,heuristic:false}));
         }
+        if matches!(node.kind(),"postfix_unary_expression"|"postfix_expression") {
+            return match node.named_child(0) {Some(inner)=>self.kotlin_expression_type(inner,source,r,implicit,depth+1),None=>Ok(None)};
+        }
+        if node.kind()=="this_expression" {
+            let enclosing=self.nodes_in_file(&site.file_path)?.iter().filter(|n|super::call_shape::type_kind(&n.kind) && n.start_line<=site.line && n.end_line>=site.line).min_by_key(|n|n.end_line-n.start_line).cloned();
+            let Some(owner)=enclosing else {return Ok(None)};
+            return Ok(Some(KotlinReceiverHit{ty:owner.name.clone(),site:site.clone().at(&owner),heuristic:false}));
+        }
         if node.kind() == "simple_identifier" {
             if let Some(hit)=self.kotlin_narrowed_identifier(node,source,&site,depth)? {return Ok(Some(hit));}
             let name = text(node, source);
@@ -394,6 +402,18 @@ impl KernelResolver {
                     None => {
                         let enclosing=self.nodes_in_file(&site.file_path)?.iter().filter(|n|super::call_shape::type_kind(&n.kind) && n.start_line<=site.line && n.end_line>=site.line).min_by_key(|n|n.end_line-n.start_line).cloned();
                         if let Some(owner)=enclosing {member=self.match_bound_type_member(&owner.name,name,&site)?.map(|c|c.node);}
+                        // `fun Shop.reopen() { newBuilder() }` — inside an extension body a bare
+                        // call reaches the receiver type's members: the caller's qualified owner
+                        // (kotlinCallResultType's same-owner pool, #2822).
+                        if member.is_none() {
+                            if let Some(caller)=self.node_by_opt_id(Some(site.from_node_id.as_str()))? {
+                                if let Some((owner,_))=caller.qualified_name.rsplit_once("::") {
+                                    for spelling in [owner.replace("::","."), owner.rsplit([':','.']).next().unwrap_or(owner).to_string()] {
+                                        if let Some(m)=self.match_bound_type_member(&spelling,name,&site)? {member=Some(m.node);break;}
+                                    }
+                                }
+                            }
+                        }
                         let candidates: Vec<_> = self.nodes_by_name(name)?.iter().filter(|n| n.language == "kotlin" && n.kind == "function").cloned().collect();
                         let mut visible = Vec::new();
                         for n in candidates { if self.kotlin_top_level_visible(&n, &site)? { visible.push(n); } }
@@ -508,4 +528,153 @@ impl KernelResolver {
         // A project scope function can return a different type.
         Ok(!self.kotlin_user_member(&receiver.ty, "apply", &site)? && !self.kotlin_user_scope_callee(func, "apply", file.text(), &site)?)
     }
+
+    /// matchKotlinCallResultCall (name-matcher.ts #2822): `repository().pending(1)`
+    /// is emitted as bare `pending` at the property's column; the receiver is
+    /// the inner call's declared return, so the method is the one that type
+    /// declares — never a same-named method elsewhere. `Some(None)` is
+    /// upstream's terminal `null`; `None` is `undefined`, leaving the name
+    /// strategies their old behavior.
+    pub(super) fn match_kotlin_call_result_call(&mut self, r: &ResolveRefIn) -> Res<Option<Option<KCand>>> {
+        if r.language != "kotlin" || r.reference_kind != "calls" || !re!(r"^[A-Za-z_]\w*$").is_match(&r.reference_name) { return Ok(None); }
+        let Some(hit) = self.kotlin_call_result_receiver(r)? else { return Ok(None) };
+        let hit = self.kotlin_scoped_hit(hit)?;
+        let owner = self.resolve_bound_type(&hit.ty, &hit.site, 0)?;
+        // isKotlinProjectType — a type from outside the project is no help.
+        if owner.is_none() { return Ok(None); }
+        let found = self.kotlin_receiver_member(&hit, &r.reference_name, r)?;
+        match found {
+            Some(member) => Ok(Some(Some(KCand { node: member, confidence: 0.85, resolved_by: "instance-method" }))),
+            None => {
+                // An extension the index doesn't keep under the type may be it
+                // (a top-level function, or one kept under a bare/nested
+                // receiver name): keep the old name-match behavior.
+                let extension = self.nodes_by_name(&r.reference_name)?.iter().any(|n| {
+                    n.language == "kotlin" && (n.kind == "function"
+                        || (n.kind == "method" && !n.qualified_name.rsplit_once("::").is_some_and(|(path, _)| path.contains("::"))))
+                });
+                if extension { Ok(None) } else { Ok(Some(None)) }
+            }
+        }
+    }
+
+    /// `repository().pending` — the bare ref sits on the property identifier,
+    /// and its navigation's receiver being a `call_expression` is the shape.
+    /// The inner call is unqualified (`repository(`, `this.repository(`, as
+    /// upstream's KOTLIN_UNQUALIFIED_CALL requires) and the outer suffix names
+    /// the ref: `repository().other().pending()` keeps the inner call a call.
+    fn kotlin_call_result_receiver(&mut self, r: &ResolveRefIn) -> Res<Option<KotlinReceiverHit>> {
+        let Some(file) = self.read_file(&r.file_path) else { return Ok(None) };
+        let Some(tree) = self.parsed_tree(&file, r) else { return Ok(None) };
+        let source = file.text();
+        let node = descendant_for_position(tree.root_node(), source, ((r.line - 1).max(0) as usize, r.column.max(0) as usize));
+        if node.kind() != "simple_identifier" { return Ok(None); }
+        let Some(suffix) = node.parent().filter(|p| p.kind() == "navigation_suffix") else { return Ok(None) };
+        let Some(nav) = suffix.parent().filter(|p| p.kind() == "navigation_expression") else { return Ok(None) };
+        let Some(mut recv) = nav.named_child(0) else { return Ok(None) };
+        while matches!(recv.kind(), "postfix_unary_expression" | "postfix_expression" | "parenthesized_expression") {
+            let Some(inner) = recv.named_child(0) else { return Ok(None) };
+            recv = inner;
+        }
+        if recv.kind() != "call_expression" || nav.parent().is_none_or(|p| p.kind() != "call_expression") { return Ok(None); }
+        if !Self::kotlin_unqualified_callee(recv, source) { return Ok(None); }
+        self.kotlin_expression_type(recv, source, r, None, 0)
+    }
+
+    /// KOTLIN_UNQUALIFIED_CALL — `(?:this\s*\.\s*)?[a-z_]\w*\s*(<…>)?(`: the
+    /// callee of `call` is a lowercase bare name or `this.`-qualified.
+    fn kotlin_unqualified_callee(call: Node, source: &str) -> bool {
+        let Some(func) = call.named_child(0) else { return false };
+        match func.kind() {
+            "simple_identifier" => text(func, source).chars().next().is_some_and(|c| c.is_ascii_lowercase() || c == '_'),
+            "navigation_expression" => func.named_child(0).is_some_and(|h| h.kind() == "this_expression")
+                && property(func).is_some_and(|p| text(p, source).chars().next().is_some_and(|c| c.is_ascii_lowercase() || c == '_')),
+            _ => false,
+        }
+    }
+
+    /// kotlinLocalCallResultType — `val repo = repository()` types the local
+    /// by the call's declared return; `var repo = this.repository()!!` too.
+    /// The initializer must be an unqualified call alone (#2805).
+    pub(super) fn kotlin_local_call_result_type(&mut self, receiver: &str, site: &ResolveRefIn) -> Res<Option<String>> {
+        let bindings = self.bindings(&site.file_path)?;
+        let Some(binding) = innermost_binding(&bindings, receiver, Some(site.line)).filter(|b| b.kind != "import") else { return Ok(None) };
+        let decl = self.node_by_opt_id(binding.node_id.as_deref())?;
+        let path = decl.as_ref().map_or(site.file_path.as_str(), |n| n.file_path.as_str());
+        let Some(file) = self.read_file(path) else { return Ok(None) };
+        let Some(tree) = self.parsed_tree(&file, site) else { return Ok(None) };
+        let prop = match &decl {
+            Some(d) => Self::kotlin_decl_tree_node(&tree, file.text(), d, "property_declaration"),
+            None => Self::kotlin_local_property(tree.root_node(), file.text(), binding),
+        };
+        let Some(prop) = prop else { return Ok(None) };
+        let Some(mut init) = named_children(prop).into_iter().last() else { return Ok(None) };
+        while matches!(init.kind(), "postfix_unary_expression" | "postfix_expression" | "parenthesized_expression") {
+            let Some(inner) = init.named_child(0) else { return Ok(None) };
+            init = inner;
+        }
+        if init.kind() != "call_expression" || !Self::kotlin_unqualified_callee(init, file.text()) { return Ok(None); }
+        let Some(hit) = self.kotlin_expression_type(init, file.text(), site, None, 0)? else { return Ok(None) };
+        let hit = self.kotlin_scoped_hit(hit)?;
+        if self.resolve_bound_type(&hit.ty, &hit.site, 0)?.is_none() { return Ok(None); }
+        Ok(Some(hit.ty))
+    }
+
+    /// The `hit` retyped by the callee's signature when it points at one:
+    /// `return_type` keeps a user_type's first identifier (`Request`), while
+    /// kotlinDeclaredReturnType reads the signature's whole path
+    /// (`Request.Builder`) and kotlinScopedReturnType writes a lone nested
+    /// name through its declaring outer (`Builder` → `Shop.Builder`).
+    fn kotlin_scoped_hit(&mut self, hit: KotlinReceiverHit) -> Res<KotlinReceiverHit> {
+        let members: Vec<_> = self.nodes_in_file(&hit.site.file_path)?.iter()
+            .filter(|n| matches!(n.kind.as_str(), "function" | "method") && n.start_line == hit.site.line).cloned().collect();
+        let [member] = members.as_slice() else { return Ok(hit) };
+        let Some(ty) = self.kotlin_scoped_return_type(member)? else { return Ok(hit) };
+        Ok(KotlinReceiverHit { ty, site: hit.site, heuristic: hit.heuristic })
+    }
+
+    /// kotlinScopedReturnType — the signature's declared return path, a lone
+    /// name taken as the nested type of the innermost declaring scope that
+    /// has it: `fun newBuilder(): Builder` in `Shop` returns `Shop.Builder`.
+    fn kotlin_scoped_return_type(&mut self, member: &KNode) -> Res<Option<String>> {
+        let Some(written) = member.signature.as_deref().and_then(Self::kotlin_declared_return_type) else { return Ok(None) };
+        if written.contains('.') { return Ok(Some(written)); }
+        let scopes: Vec<&str> = member.qualified_name.split("::").collect();
+        let scopes = &scopes[..scopes.len().saturating_sub(1)];
+        for i in (1..=scopes.len()).rev() {
+            let scope = scopes[..i].join("::");
+            let is_type = |q: String| -> Res<bool> { Ok(self.nodes_by_qualified_name(&q)?.iter().any(|n| super::call_shape::type_kind(&n.kind) || n.kind == "module")) };
+            if is_type(scope.clone())? && is_type(format!("{scope}::{written}"))? {
+                return Ok(Some(format!("{}.{}", scopes[i - 1], written)));
+            }
+        }
+        Ok(Some(written))
+    }
+
+    /// kotlinDeclaredReturnType — the signature's `(): path` after the closing
+    /// paren, from its outermost type on, without `?`, `<>` or a package:
+    /// `(source: Buffer): Hpack.Reader` → `Hpack.Reader`.
+    fn kotlin_declared_return_type(sig: &str) -> Option<String> {
+        let sig = sig.trim();
+        if !sig.starts_with('(') { return None; }
+        let bytes = sig.as_bytes();
+        let (mut depth, mut close, mut i) = (0usize, None, 0usize);
+        while i < bytes.len() {
+            let c = bytes[i];
+            if c == b'"' || c == b'\'' {
+                i += 1;
+                while i < bytes.len() && bytes[i] != c { i += if bytes[i] == b'\\' { 2 } else { 1 }; }
+            } else if c == b'(' { depth += 1; }
+            else if c == b')' { depth -= 1; if depth == 0 { close = Some(i); break; } }
+            i += 1;
+        }
+        let written = sig.get(close? + 1..)?.trim_start().strip_prefix(':')?.trim();
+        let written = written.trim_end_matches('?');
+        let written = if written.ends_with('>') { written.find('<').map_or(written, |at| written[..at].trim_end()) } else { written };
+        let path: Vec<&str> = written.split('.').map(str::trim).collect();
+        if !path.iter().all(|p| re!(r"^[A-Za-z_]\w*$").is_match(p)) { return None; }
+        let types: Vec<&str> = path.iter().skip_while(|p| !p.starts_with(|c: char| c.is_ascii_uppercase())).copied().collect();
+        if types.is_empty() || !types.iter().all(|p| p.starts_with(|c: char| c.is_ascii_uppercase())) { return None; }
+        Some(types.join("."))
+    }
 }
diff --git a/codegraph-kernel/src/resolve/lang_scope.rs b/codegraph-kernel/src/resolve/lang_scope.rs
index ff43137ac..25a8d5303 100644
--- a/codegraph-kernel/src/resolve/lang_scope.rs
+++ b/codegraph-kernel/src/resolve/lang_scope.rs
@@ -214,6 +214,12 @@ impl KernelResolver {
         if n.language != "kotlin" {
             return Ok(false);
         }
+        // isReceiverLessKotlinCall — a name written through a receiver
+        // (`text().reverse`) answers to that receiver, not to member scope;
+        // scope only judges what a receiver-less name can reach (#2822).
+        if !self.is_receiver_less_call(r)? {
+            return Ok(true);
+        }
         if !self.is_kotlin_member(n)? {
             return Ok(true);
         }
diff --git a/codegraph-kernel/src/resolve/pipeline.rs b/codegraph-kernel/src/resolve/pipeline.rs
index aff53129f..f6095cfdb 100644
--- a/codegraph-kernel/src/resolve/pipeline.rs
+++ b/codegraph-kernel/src/resolve/pipeline.rs
@@ -1046,6 +1046,12 @@ if super::lang_scope::is_dart_member_read(r) {
                 None => Ok(ResolveOutcome::unresolved()),
             };
         }
+        // A Kotlin call on an unqualified call's result — `repository().pending()`
+        // — resolves against the inner call's declared return type, never a
+        // same-named method elsewhere (#2822). `Some(None)` is terminal.
+        if let Some(result) = self.match_kotlin_call_result_call(r)? {
+            return match result { Some(candidate) => self.finish_pre_framework(r, candidate), None => Ok(self.refused()) };
+        }
         if is_js_family(&r.language) && r.reference_kind == "calls" {
             // matchJsSuperCall: `super.m()` binds to the nearest `extends`
             // ancestor's method before any name strategy can guess (#2497).
diff --git a/codegraph-kernel/src/resolve/python_types.rs b/codegraph-kernel/src/resolve/python_types.rs
index 0fe1b860b..e03a7fc65 100644
--- a/codegraph-kernel/src/resolve/python_types.rs
+++ b/codegraph-kernel/src/resolve/python_types.rs
@@ -677,8 +677,13 @@ impl KernelResolver {
                 return Ok(result);
             }
             strict_local = true;
+            // `None` is upstream's `undefined`: no enclosing def binds the
+            // name, so it is no local — the ordinary paths keep it.
+            let Some(answer) = self.python_local_class(receiver, r, &mut read)? else {
+                return Ok(result);
+            };
             result.claimed = true;
-            self.python_local_class(receiver, r, &mut read)?
+            answer
         };
         let declared = matches!(answer, Answer::Declared(_)) && !strict_local;
         match answer {
@@ -721,11 +726,13 @@ impl KernelResolver {
     /// `name = factory()`, `name = None` (no evidence). Any other binding —
     /// a `for`/`with`/`except`/comprehension target, a tuple or augmented
     /// assignment, a walrus, an import, `del`, a nested `def` or `class` of
-    /// the name, a `nonlocal` write, a `global` — leaves it unknown, and a
-    /// contested one is no class at all.
-    fn python_local_class(&mut self, name: &str, r: &ResolveRefIn, read: &mut HashSet<String>) -> Res<Answer> {
+    /// the name, a `nonlocal` write — leaves it unknown, and a contested
+    /// one is no class at all. `None` is no local at all — a `global`
+    /// binding, a module-level name, or no enclosing def — upstream's
+    /// `undefined`, where the ordinary paths keep the call.
+    fn python_local_class(&mut self, name: &str, r: &ResolveRefIn, read: &mut HashSet<String>) -> Res<Option<Answer>> {
         let Some(src) = self.read_file(&r.file_path) else {
-            return Ok(Answer::Unknown);
+            return Ok(None);
         };
         let file = src.python_file();
         let at = (r.line - 1).max(0) as usize;
@@ -744,7 +751,7 @@ impl KernelResolver {
                 break;
             }
             if bindings.iter().any(|b| matches!(b, PyBinding::Global)) {
-                return Ok(Answer::Unknown);
+                return Ok(None);
             }
             if !bindings.is_empty() {
                 scope = Some((d, param, bindings));
@@ -752,23 +759,23 @@ impl KernelResolver {
             }
         }
         let Some((d, param, bindings)) = scope else {
-            return Ok(Answer::Unknown);
+            return Ok(None);
         };
         let mut evidence: Vec<Answer> = Vec::new();
         if let Some(param) = param {
             // A parameter without an annotation is no evidence.
             let Some(ann) = param else {
-                return Ok(Answer::Unknown);
+                return Ok(Some(Answer::Unknown));
             };
             let ev = self.python_ann_answer(&ann, r, read)?;
             if matches!(ev, Answer::Unknown) {
-                return Ok(Answer::Unknown);
+                return Ok(Some(Answer::Unknown));
             }
             evidence.push(ev);
         }
         for b in &bindings {
             let PyBinding::Assign { ty, value, line } = b else {
-                return Ok(Answer::Unknown);
+                return Ok(Some(Answer::Unknown));
             };
             let value = value.trim();
             let ev = if let Some(ty) = ty {
@@ -776,7 +783,7 @@ impl KernelResolver {
                 if !value.is_empty() && value != "None" {
                     if let Some(ctor) = python_constructor_call(value) {
                         if ctor.rsplit('.').next() != ty.trim().trim_matches(['\'', '"']).rsplit('.').next() {
-                            return Ok(Answer::Unknown);
+                            return Ok(Some(Answer::Unknown));
                         }
                     }
                 }
@@ -788,10 +795,10 @@ impl KernelResolver {
                 // with, unless the def binds `cap` anywhere else.
                 let (copied_param, copied_bindings) = python_scope_state(file, &src, d, value)?;
                 let Some(Some(ann)) = copied_param else {
-                    return Ok(Answer::Unknown);
+                    return Ok(Some(Answer::Unknown));
                 };
                 if !copied_bindings.is_empty() {
-                    return Ok(Answer::Unknown);
+                    return Ok(Some(Answer::Unknown));
                 }
                 self.python_ann_answer(&ann, r, read)?
             } else {
@@ -799,19 +806,19 @@ impl KernelResolver {
                 for callee in python_value_callees(value) {
                     let root = callee.split('.').next().unwrap_or(&callee);
                     if self.python_binds_locally(root, &r.file_path, (*line + 1) as i64, false)? {
-                        return Ok(Answer::Unknown);
+                        return Ok(Some(Answer::Unknown));
                     }
                 }
                 self.python_value_text_answer(value, r, read, 0)?
             };
             if matches!(ev, Answer::Unknown | Answer::Absent) {
-                return Ok(Answer::Unknown);
+                return Ok(Some(Answer::Unknown));
             }
             evidence.push(ev);
         }
         // Nothing here can be a project class: a builtin, or no evidence.
         if !evidence.iter().any(|e| !matches!(e, Answer::Runtime)) {
-            return Ok(if evidence.is_empty() { Answer::Unknown } else { Answer::Runtime });
+            return Ok(if evidence.is_empty() { Some(Answer::Unknown) } else { Some(Answer::Runtime) });
         }
         // A def or class of the name nested in the scope binds it there; a
         // def nested in it can rebind the scope's own through `nonlocal`;
@@ -823,7 +830,7 @@ impl KernelResolver {
                 && n.start_line > d as i64 + 1
                 && n.end_line <= end as i64 + 1
         }) {
-            return Ok(Answer::Unknown);
+            return Ok(Some(Answer::Unknown));
         }
         for i in d..=end.min(file.code.len().saturating_sub(1)) {
             let Some((_, code)) = file.code.get(i) else { break };
@@ -831,15 +838,15 @@ impl KernelResolver {
                 continue;
             }
             if re!(r"^\s*nonlocal\b").is_match(code) && bare_word(code, name) {
-                return Ok(Answer::Unknown);
+                return Ok(Some(Answer::Unknown));
             }
             if let Some(cap) = re!(r"\bas\s*\(([^)]*)\)").captures(code) {
                 if bare_word(&cap[1], name) {
-                    return Ok(Answer::Unknown);
+                    return Ok(Some(Answer::Unknown));
                 }
             }
         }
-        Ok(agree(evidence))
+        Ok(Some(agree(evidence)))
     }
 
     /// pythonFindMethod's member walk for the strict local path: `member` on
diff --git a/codegraph-kernel/src/resolve/receivers.rs b/codegraph-kernel/src/resolve/receivers.rs
index f6efcd70f..9ce3043f8 100644
--- a/codegraph-kernel/src/resolve/receivers.rs
+++ b/codegraph-kernel/src/resolve/receivers.rs
@@ -267,6 +267,9 @@ impl KernelResolver {
         if php_property {
             return self.infer_php_assigned_property_type(&scan_receiver, &lines, call_idx);
         }
+        if site.language == "kotlin" {
+            return self.kotlin_local_call_result_type(&scan_receiver, site);
+        }
         Ok(None)
     }
 

From ace5b8610edd0c16417ad8b69f9c86d496bf5687 Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Thu, 29 Oct 2026 07:11:22 -0600
Subject: [PATCH 21/30] feat(kernel): non-test refs resolve as if Jest manual
 mocks were absent (#2790)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Port upstream e69546e4's mockless context: a ref from non-test code resolves
on a graph without the project's __mocks__/ files, while test code keeps the
whole graph. resolve_ref sets a per-ref mockless flag; nodes_by_name,
nodes_by_lower_name and nodes_by_qualified_name then drop __mocks__/ nodes
(gated on the cached mock-name sets so unaffected names aren't re-collected).
The TS callback-synthesis guards were already in place.

Also fix ts_scoped_reference's type-ref tail: upstream importedTypeMember
falls through (undefined) on a found-miss unless the specifier is outside
the repository — a resolved package directory whose exports can't be read
is not a refusal. The old gate refused references/extends refs bound to a
no-entry workspace package, which upstream answers by name-match.
---
 codegraph-kernel/src/resolve/mod.rs      |  8 +++
 codegraph-kernel/src/resolve/pipeline.rs | 12 ++++
 codegraph-kernel/src/resolve/query.rs    | 80 ++++++++++++++++++++----
 codegraph-kernel/src/resolve/tables.rs   |  6 ++
 codegraph-kernel/src/resolve/ts_known.rs | 21 +++++--
 5 files changed, 110 insertions(+), 17 deletions(-)

diff --git a/codegraph-kernel/src/resolve/mod.rs b/codegraph-kernel/src/resolve/mod.rs
index a6152cd19..4343d31dc 100644
--- a/codegraph-kernel/src/resolve/mod.rs
+++ b/codegraph-kernel/src/resolve/mod.rs
@@ -694,6 +694,12 @@ pub struct KernelResolver {
     /// The run token the table is shared under (see NodeTable); None keeps
     /// the table private.
     generation: Option<String>,
+    /// manualMockNames (#2455): the names every Jest/Vitest manual mock
+    /// (`__mocks__/`) declares; `None` when the project has none.
+    mock_names: OnceCell<Option<Rc<query::MockNames>>>,
+    /// Set for one `resolve_ref` from non-test code: node lookups then
+    /// answer as if no `__mocks__/` file were indexed (mocklessContextFor).
+    mockless: std::cell::Cell<bool>,
     /// A file's bindings rows. Lookups cluster by file, so 128 files keep
     /// nearly every hit: unbounded, n8n's workers held 86-140 MB each.
     bindings_cache: Lru<Rc<Vec<KBinding>>>,
@@ -1005,6 +1011,8 @@ impl KernelResolver {
             conn: Some(conn),
             live: !snapshot,
             table: std::cell::OnceCell::new(),
+            mock_names: std::cell::OnceCell::new(),
+            mockless: std::cell::Cell::new(false),
             lookups: config.query_lookups.unwrap_or(false).then(Default::default),
             db_path: config.db_path,
             generation: config.generation,
diff --git a/codegraph-kernel/src/resolve/pipeline.rs b/codegraph-kernel/src/resolve/pipeline.rs
index f6095cfdb..6f435c3fb 100644
--- a/codegraph-kernel/src/resolve/pipeline.rs
+++ b/codegraph-kernel/src/resolve/pipeline.rs
@@ -886,6 +886,18 @@ if super::lang_scope::is_dart_member_read(r) {
 
     /// The per-ref pipeline: the Rust `::`-path arm, then one route.
     pub(super) fn resolve_ref(&mut self, r: &ResolveRefIn) -> Res<ResolveOutcome> {
+        // mocklessContextFor (#2455): a ref from non-test code resolves on a
+        // graph without the project's Jest/Vitest manual mocks — every name
+        // lookup answers as if no `__mocks__/` file were indexed. Test code,
+        // a mock included, keeps the whole graph.
+        let mockless = !is_test_path(&r.file_path) && self.manual_mock_names()?.is_some();
+        let prev = self.mockless.replace(mockless);
+        let outcome = self.resolve_ref_scoped(r);
+        self.mockless.set(prev);
+        outcome
+    }
+
+    fn resolve_ref_scoped(&mut self, r: &ResolveRefIn) -> Res<ResolveOutcome> {
         let attribute = if r.language == "python" && r.reference_kind == "calls" {
             Some(self.resolve_python_attribute(r.clone())?)
         } else { None };
diff --git a/codegraph-kernel/src/resolve/query.rs b/codegraph-kernel/src/resolve/query.rs
index 463f7a142..141a560a0 100644
--- a/codegraph-kernel/src/resolve/query.rs
+++ b/codegraph-kernel/src/resolve/query.rs
@@ -21,6 +21,21 @@ pub(super) fn read_source(path: impl AsRef<std::path::Path>) -> Option<String> {
     Some(String::from_utf8(bytes).unwrap_or_else(|e| String::from_utf8_lossy(e.as_bytes()).into_owned()))
 }
 
+/// manualMockNames' payload: every name (and its lowercase) a `__mocks__/`
+/// file declares.
+pub(super) struct MockNames {
+    pub names: HashSet<String>,
+    pub lower: HashSet<String>,
+}
+
+/// The mockless view's node filter: `__mocks__/` nodes out, order kept.
+fn drop_mock_nodes(list: NodeList) -> NodeList {
+    if !list.iter().any(|n| is_manual_mock_path(&n.file_path)) {
+        return list;
+    }
+    Arc::new(list.iter().filter(|n| !is_manual_mock_path(&n.file_path)).cloned().collect())
+}
+
 impl KernelResolver {
     /// The live connection — errors once close() has run. Statements borrow
     /// it, so the Option indirection stays inside this accessor.
@@ -52,30 +67,71 @@ impl KernelResolver {
 
     /// queries.getNodesByName — ORDER BY file_path, start_line.
     pub(super) fn nodes_by_name(&self, name: &str) -> Res<NodeList> {
-        if let Some(r) = self.with_lookups(|l, c| l.nodes(c, LookupKey::Name(name))) {
-            return r;
+        let list = if let Some(r) = self.with_lookups(|l, c| l.nodes(c, LookupKey::Name(name))) {
+            r?
+        } else {
+            let t = self.table()?;
+            t.by_name.get(name).cloned().unwrap_or_else(|| t.empty.clone())
+        };
+        // Only a name some mock declares can lose a node (mocklessContextFor).
+        if !self.mockless.get() || !self.manual_mock_names()?.is_some_and(|m| m.names.contains(name)) {
+            return Ok(list);
         }
-        let t = self.table()?;
-        Ok(t.by_name.get(name).cloned().unwrap_or_else(|| t.empty.clone()))
+        Ok(drop_mock_nodes(list))
     }
 
     /// queries.getNodesByLowerName — `WHERE lower(name) = lower(?)`, no
     /// ORDER BY (rowid order, same as the TS reader).
     pub(super) fn nodes_by_lower_name(&self, name: &str) -> Res<NodeList> {
-        if let Some(r) = self.with_lookups(|l, c| l.nodes(c, LookupKey::Lower(name))) {
-            return r;
+        let list = if let Some(r) = self.with_lookups(|l, c| l.nodes(c, LookupKey::Lower(name))) {
+            r?
+        } else {
+            let t = self.table()?;
+            t.by_lower().get(&name.to_ascii_lowercase()).cloned().unwrap_or_else(|| t.empty.clone())
+        };
+        if !self.mockless.get()
+            || !self.manual_mock_names()?.is_some_and(|m| m.lower.contains(&name.to_lowercase()))
+        {
+            return Ok(list);
         }
-        let t = self.table()?;
-        Ok(t.by_lower().get(&name.to_ascii_lowercase()).cloned().unwrap_or_else(|| t.empty.clone()))
+        Ok(drop_mock_nodes(list))
     }
 
     /// queries.getNodesByQualifiedName — no ORDER BY (TS uses rowid order).
     pub(super) fn nodes_by_qualified_name(&self, qname: &str) -> Res<NodeList> {
-        if let Some(r) = self.with_lookups(|l, c| l.nodes(c, LookupKey::QualifiedName(qname))) {
-            return r;
+        let list = if let Some(r) = self.with_lookups(|l, c| l.nodes(c, LookupKey::QualifiedName(qname))) {
+            r?
+        } else {
+            let t = self.table()?;
+            t.by_qname.get(qname).cloned().unwrap_or_else(|| t.empty.clone())
+        };
+        if !self.mockless.get() || self.manual_mock_names()?.is_none() {
+            return Ok(list);
         }
-        let t = self.table()?;
-        Ok(t.by_qname.get(qname).cloned().unwrap_or_else(|| t.empty.clone()))
+        Ok(drop_mock_nodes(list))
+    }
+
+    /// manualMockNames (resolution/index.ts #2455): the names every Jest or
+    /// Vitest manual mock (`__mocks__/`) declares, `None` when the project
+    /// has none. Read once — the node table it feeds is a run constant.
+    pub(super) fn manual_mock_names(&self) -> Res<Option<Rc<MockNames>>> {
+        if let Some(v) = self.mock_names.get() {
+            return Ok(v.clone());
+        }
+        let files: Vec<String> = match &self.lookups {
+            Some(_) => self.sorted_files().unwrap_or_default().as_ref().clone(),
+            None => self.table()?.files.iter().cloned().collect(),
+        };
+        let mut names = HashSet::new();
+        let mut lower = HashSet::new();
+        for file in files.iter().filter(|f| is_manual_mock_path(f)) {
+            for n in self.nodes_in_file(file)?.iter() {
+                lower.insert(n.name.to_lowercase());
+                names.insert(n.name.clone());
+            }
+        }
+        let v = if names.is_empty() { None } else { Some(Rc::new(MockNames { names, lower })) };
+        Ok(self.mock_names.get_or_init(|| v).clone())
     }
 
     /// queries.getNodesInFile — ORDER BY start_line.
diff --git a/codegraph-kernel/src/resolve/tables.rs b/codegraph-kernel/src/resolve/tables.rs
index 5d583d183..a2c57238f 100644
--- a/codegraph-kernel/src/resolve/tables.rs
+++ b/codegraph-kernel/src/resolve/tables.rs
@@ -1233,6 +1233,12 @@ pub(super) fn is_test_path(path: &str) -> bool {
         || re!(r"(?:^|/)(?:unittests|[\w.]+[-_]unittests?)/").is_match(&lower)
 }
 
+/// isManualMockPath (query-utils.ts #2455): a Jest or Vitest manual mock —
+/// a file under a `__mocks__/` directory.
+pub(super) fn is_manual_mock_path(path: &str) -> bool {
+    re!(r"(?:^|/)__mocks__/").is_match(&path.replace('\\', "/").to_lowercase())
+}
+
 #[cfg(test)]
 mod tests {
     use super::{collect_rust_use_bindings, is_test_path};
diff --git a/codegraph-kernel/src/resolve/ts_known.rs b/codegraph-kernel/src/resolve/ts_known.rs
index 1ab56c740..68488c0b8 100644
--- a/codegraph-kernel/src/resolve/ts_known.rs
+++ b/codegraph-kernel/src/resolve/ts_known.rs
@@ -1256,12 +1256,23 @@ impl KernelResolver {
                 }
                 let hit = self.resolve_via_import(&r.clone().naming(&written, "references"))?;
                 if hit.as_ref().is_some_and(|hit| hit.node.language == "arkts") { return Ok(Some(hit)); }
-                if let (Some(hit), Some(file)) = (&hit, self.resolve_import_path(&binding.source, &r.file_path, &r.language)?) {
-                    if !self.ts_import_target_visible(&hit.node, &file, r)? { return Ok(Some(None)); }
+                let file = self.resolve_import_path(&binding.source, &r.file_path, &r.language)?;
+                if let (Some(hit), Some(file)) = (&hit, &file) {
+                    if !self.ts_import_target_visible(&hit.node, file, r)? { return Ok(Some(None)); }
+                }
+                if hit.is_none() {
+                    // importedTypeMember (import-resolver.ts): a specifier the
+                    // import resolver can't follow — not to a file, not to a
+                    // `declare module` block — that a manifest declares outside
+                    // the repository is terminal (`null`); every other miss
+                    // keeps the ordinary strategies (`undefined`), including a
+                    // resolved package directory whose exports can't be read.
+                    let outside = file.is_none()
+                        && self.ts_ambient_lookup(&binding.source, "*", false, r)?.is_none()
+                        && self.is_out_of_repo_import(&binding.source, &r.file_path, &r.language)?;
+                    if outside { return Ok(Some(None)); }
+                    return Ok(None);
                 }
-                if hit.is_none() && self.resolve_import_path(&binding.source, &r.file_path, &r.language)?.is_some()
-                    && (binding.is_namespace || member.is_some() || binding.exported_name == binding.local_name) { return Ok(Some(None)); }
-                if hit.is_none() && !self.is_declared_outside_package(&binding.source, &r.file_path) { return Ok(None); }
                 return Ok(Some(hit));
             }
             if imported { return Ok(None); }

From 153fe95a4a2a0a960ae6d09149c188859cf3e559 Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Thu, 29 Oct 2026 07:13:25 -0600
Subject: [PATCH 22/30] fix(sync): record files a JSX tag import reads through
 as synthesis inputs (#2563)

collectSynthesisInputs only kept files whose own content matched
mayFeedSynthesis, so a barrel or index that merely forwarded another
module's component was never recorded as an input. When a later sync
edited only that index, the JSX pass never reran and the tag kept its
stale endpoint.

Port upstream's importedTagModules: for each JSX-bearing file, map its
capitalized tags to project imports and collect every file
exportedComponent reads through, memoized per collection run.
---
 src/resolution/callback-synthesizer.ts | 44 ++++++++++++++++++++++++--
 1 file changed, 41 insertions(+), 3 deletions(-)

diff --git a/src/resolution/callback-synthesizer.ts b/src/resolution/callback-synthesizer.ts
index fb6c060ce..f8c2b5b38 100644
--- a/src/resolution/callback-synthesizer.ts
+++ b/src/resolution/callback-synthesizer.ts
@@ -2195,6 +2195,9 @@ const JSX_CHILD_KINDS = new Set<NodeKind>(['component', 'function', 'class']);
  */
 const JSX_CHILD_LANGUAGES = [...JS_FAMILY, 'vue', 'svelte'];
 
+/** A file whose tags the JSX pass reads: a script, or a single-file component's. */
+const JSX_INPUT_FILE = /\.(?:[cm]?[jt]sx?|vue|svelte|astro)$/;
+
 /**
  * Whether a JSX tag can render `node` (`jsxChild`): a script's component,
  * function or class named with a tag's capital, or any component, which a
@@ -2275,6 +2278,34 @@ function projectImport(ctx: ResolutionContext, name: string, file: string): { mo
   return { module, exported: binding.isDefault || binding.exportedName === 'default' ? 'default' : binding.exportedName };
 }
 
+/**
+ * The files a JSX file's project-imported tags are read through: each tag's
+ * module, the index or barrel that hands its component on, and the module
+ * that declares it (`exportedComponent`'s reads). A sync that edits one of
+ * them — `index.ts` forwarding another module, a default export rewired —
+ * redraws the tag. `memo` holds each module and export's reads for one run.
+ */
+function importedTagModules(ctx: ResolutionContext, file: string, content: string, memo: Map<string, Set<string>>): Set<string> {
+  const out = new Set<string>();
+  JSX_TAG_RE.lastIndex = 0;
+  const names = new Set<string>();
+  for (let m = JSX_TAG_RE.exec(content); m; m = JSX_TAG_RE.exec(content)) names.add(m[1]!);
+  for (const name of names) {
+    const imported = projectImport(ctx, name, file);
+    if (!imported) continue;
+    const key = `${imported.module}\0${imported.exported}`;
+    let reads = memo.get(key);
+    if (!reads) {
+      reads = new Set<string>();
+      exportedComponent(imported.module, imported.exported, ctx, new Set(), reads);
+      memo.set(key, reads);
+    }
+    for (const read of reads) out.add(read);
+  }
+  out.delete(file);
+  return out;
+}
+
 /**
  * The component a JSX tag names, among every node that shares the name.
  *
@@ -7188,12 +7219,19 @@ export function mayFeedSynthesis(filePath: string, content: string): boolean {
  * edges dropped out (a channel crossing the fan-out cap) or the file is gone.
  */
 export function collectSynthesisInputs(ctx: ResolutionContext): string[] {
-  const inputs: string[] = [];
+  const inputs = new Set<string>();
+  const tagModules = new Map<string, Set<string>>();
   for (const file of ctx.getAllFiles()) {
     const content = ctx.readFile(file);
-    if (content && mayFeedSynthesis(file, content)) inputs.push(file);
+    if (!content) continue;
+    if (mayFeedSynthesis(file, content)) inputs.add(file);
+    // Every file a tag imported from the project is read through feeds the
+    // JSX pass too — a rewired index redraws the tag (#2563).
+    if (JSX_INPUT_FILE.test(file) && (content.includes('</') || content.includes('/>'))) {
+      for (const read of importedTagModules(ctx, file, content, tagModules)) inputs.add(read);
+    }
   }
-  return inputs;
+  return [...inputs];
 }
 
 /**

From f879ce43ea4973cd1cefde8df16d7b28f5d1b72a Mon Sep 17 00:00:00 2001
From: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Date: Thu, 29 Oct 2026 07:32:40 -0600
Subject: [PATCH 23/30] feat(kernel): resolve Rust calls by the receiver's
 written type (#2831)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Port upstream 8fdc8a1e: a field chain or struct literal receiver's declared
type decides the call — `vis.map.get` is HashMap's, `Xyz{}.to_val` is Xyz's —
and a path call naming a type std or a dependency owns reaches only the
project's impls of that type or the named trait, never a project namesake.

- rust_expr_type types tuple-struct/enum-variant constructor calls
- undeclared-type guard limited to plain named `field_expression` heads,
  exempting generics, Self, outside types, use-aliases and wrapper-own
  methods; derived-trait provided methods resolve through `#[derive]`
- rust_path_call_reachable gates name-match on the path's outside type

Rust sweep 28 files/206 tests green; kernel golden dumps clean; the 16
remaining full-suite failures are all tracked port debt.
---
 .../src/resolve/overloads_upstream.rs         |  14 +-
 codegraph-kernel/src/resolve/rust_impls.rs    | 299 +++++++++++++++++-
 codegraph-kernel/src/resolve/rust_types.rs    | 171 +++++++++-
 3 files changed, 472 insertions(+), 12 deletions(-)

diff --git a/codegraph-kernel/src/resolve/overloads_upstream.rs b/codegraph-kernel/src/resolve/overloads_upstream.rs
index 7f5284746..62ee3dcbb 100644
--- a/codegraph-kernel/src/resolve/overloads_upstream.rs
+++ b/codegraph-kernel/src/resolve/overloads_upstream.rs
@@ -740,8 +740,18 @@ impl KernelResolver {
     }
 
     pub(super) fn name_post_guard(&mut self, hit: &KCand, r: &ResolveRefIn) -> Res<bool> {
-        if (r.language == "rust" && r.reference_kind == "calls" && !self.rust_foreign_impl_callable(&hit.node, r)?)
-            || self.is_import_binding_call_target(&hit.node, r)? {
+        if r.language == "rust" && r.reference_kind == "calls" {
+            // `J::from(i)` under `use serde_json::Value as J` reaches only the
+            // project's impls for the outside type — never a project type's
+            // same-named function (#2614).
+            if r.reference_name.contains("::") && !self.rust_path_call_reachable(&hit.node, r)? {
+                return Ok(false);
+            }
+            if !self.rust_foreign_impl_callable(&hit.node, r)? {
+                return Ok(false);
+            }
+        }
+        if self.is_import_binding_call_target(&hit.node, r)? {
             return Ok(false);
         }
         if self.java_outside_import(r)? || !self.language_type_visible(&hit.node, r)?
diff --git a/codegraph-kernel/src/resolve/rust_impls.rs b/codegraph-kernel/src/resolve/rust_impls.rs
index 911dfb272..5c1700915 100644
--- a/codegraph-kernel/src/resolve/rust_impls.rs
+++ b/codegraph-kernel/src/resolve/rust_impls.rs
@@ -1,6 +1,8 @@
 //! Rust associated calls and foreign-type trait implementations (#2697, #2700).
 use super::*;
 use super::iteration::descendant_for_position;
+use super::rust_modules::rust_paths::rust_at;
+use self::rust_types::Written;
 
 const STD_TYPES: &[&str] = &[
     "String", "str", "Vec", "VecDeque", "HashMap", "HashSet", "BTreeMap", "BTreeSet",
@@ -17,6 +19,8 @@ pub(super) struct SelfContext {
     pub(super) trait_name: Option<String>,
     trait_args: Vec<String>,
     is_trait: bool,
+    /// The impl header's `type` field as written (`serde_json::Value`, `&'a mut T`).
+    self_text: String,
 }
 
 fn type_name(node: tree_sitter::Node, text: &str) -> Option<String> {
@@ -39,7 +43,7 @@ impl KernelResolver {
         loop {
             if at.kind() == "trait_item" {
                 return Some(SelfContext { owner: type_name(at.child_by_field_name("name")?, text)?,
-                    root: None, trait_name: None, trait_args: Vec::new(), is_trait: true });
+                    root: None, trait_name: None, trait_args: Vec::new(), is_trait: true, self_text: String::new() });
             }
             if at.kind() == "impl_item" {
                 let ty = at.child_by_field_name("type")?;
@@ -54,7 +58,8 @@ impl KernelResolver {
                         re!(r"[A-Za-z_]\w*").find_iter(&args).map(|m| m.as_str().to_string())
                             .filter(|s| s != "mut" && s != "dyn").collect()
                     }).unwrap_or_default();
-                return Some(SelfContext { owner: type_name(ty, text)?, root, trait_name, trait_args, is_trait: false });
+                return Some(SelfContext { owner: type_name(ty, text)?, root, trait_name, trait_args,
+                    is_trait: false, self_text: written.to_string() });
             }
             at = at.parent()?;
         }
@@ -118,6 +123,296 @@ impl KernelResolver {
         Ok(true)
     }
 
+    /// The `use` path a local name binds at `at` (`use serde_json::Value as J`
+    /// binds `J` to `serde_json::Value`), innermost binding first.
+    fn rust_use_path_at(&mut self, name: &str, file: &str, at: usize) -> Option<Vec<String>> {
+        self.rust_visible_uses(file, at)
+            .into_iter()
+            .find(|(local, _, _)| local == name)
+            .map(|(_, p, _)| p)
+    }
+
+    /// The crate dir a file belongs to: the longest crate dir prefixing it, or
+    /// the root crate's "".
+    fn rust_crate_dir_of(file: &str, graph: &super::rust_crates::RustCrateGraph) -> Option<String> {
+        let mut best = graph.crates.contains_key("").then(String::new);
+        for dir in graph.crates.keys() {
+            if !dir.is_empty()
+                && file.starts_with(&format!("{dir}/"))
+                && best.as_ref().is_none_or(|b| dir.len() > b.len())
+            {
+                best = Some(dir.clone());
+            }
+        }
+        best
+    }
+
+    /// Whether a Rust path's first segment names std, or a crate the manifests
+    /// depend on that the project doesn't hold. A path dependency the project
+    /// holds, a workspace member or not, is the project's.
+    fn is_rust_outside_crate(&mut self, root: &str, r: &ResolveRefIn) -> Res<bool> {
+        if matches!(root, "std" | "core" | "alloc" | "proc_macro") {
+            return Ok(true);
+        }
+        if matches!(root, "crate" | "self" | "super") {
+            return Ok(false);
+        }
+        let graph = self.rust_crate_graph()?;
+        if graph.crates.values().any(|c| c.name == root) {
+            return Ok(false);
+        }
+        let _ = self.rust_use_facts(&r.file_path);
+        let Some(deps) = &self.upstream_rust_deps else {
+            return Ok(false);
+        };
+        if !deps.contains(root) {
+            return Ok(false);
+        }
+        if let Some(own) = Self::rust_crate_dir_of(&r.file_path, &graph) {
+            if graph.crates.get(&own).is_some_and(|c| c.keys.contains_key(root)) {
+                return Ok(false);
+            }
+        }
+        Ok(true)
+    }
+
+    /// The name of the type a Rust path `path::type` names from std or a
+    /// dependency, where the file's `use`s or the path itself say it is from
+    /// there — `J` under `use serde_json::Value as J` is `Value` — or None:
+    /// one of the project's, or one nothing written says is from outside it.
+    fn rust_outside_path_type(
+        &mut self,
+        ty: &str,
+        path: &[&str],
+        r: &ResolveRefIn,
+    ) -> Res<Option<String>> {
+        let at = self
+            .rust_tree_for(&r.file_path)
+            .map(|(s, t)| rust_at(&t, s.text(), r.line, r.column).start_byte())
+            .unwrap_or(0);
+        let (root, real);
+        if path.is_empty() {
+            let Some(bound) = self.rust_use_path_at(ty, &r.file_path, at) else {
+                return Ok(None);
+            };
+            if bound.len() < 2 {
+                return Ok(None);
+            }
+            root = bound[0].clone();
+            real = bound.last().unwrap().clone();
+        } else {
+            root = self
+                .rust_use_path_at(path[0], &r.file_path, at)
+                .and_then(|p| p.first().cloned())
+                .unwrap_or_else(|| path[0].to_string());
+            real = ty.to_string();
+        }
+        Ok(self.is_rust_outside_crate(&root, r)?.then_some(real))
+    }
+
+    /// `(segments, name)` of a written Rust path (`serde_json::Value` →
+    /// `(["serde_json"], "Value")`), trailing generic arguments dropped.
+    fn rust_path_head(text: &str) -> Option<(Vec<String>, String)> {
+        let t = text.trim().trim_start_matches("::").trim();
+        let t = if let Some(open) = t.find('<') {
+            let mut depth = 0usize;
+            let mut end = None;
+            for (i, c) in t[open..].char_indices() {
+                match c {
+                    '<' => depth += 1,
+                    '>' => {
+                        depth = depth.checked_sub(1)?;
+                        if depth == 0 {
+                            end = Some(open + i);
+                            break;
+                        }
+                    }
+                    _ => {}
+                }
+            }
+            if end != Some(t.len() - 1) {
+                return None;
+            }
+            t[..open].trim().trim_end_matches("::").trim()
+        } else {
+            t
+        };
+        let parts: Vec<String> = t.split("::").map(|s| s.trim().to_string()).collect();
+        if !parts.iter().all(|p| re!(r"^[A-Za-z_]\w*$").is_match(p)) {
+            return None;
+        }
+        let name = parts.last().cloned()?;
+        Some((parts[..parts.len() - 1].to_vec(), name))
+    }
+
+    /// Whether the type a `Written` names is std's or a dependency's, as the
+    /// written path or the file's `use`s say — the `outside` arm of
+    /// `rustReadType` (#2614): a `std::fs::File` parameter's, a
+    /// `serde_json::Value` the `use` binds, or a `File` leaf the file pulls
+    /// from outside and nothing inside.
+    fn rust_written_outside(
+        &mut self,
+        w: &Written,
+        leaf: &str,
+        head: &str,
+    ) -> Res<bool> {
+        let mut segs: Vec<String> = head.split("::").map(|s| s.trim().to_string()).collect();
+        let single = segs.len() == 1;
+        let mut has_root = !single;
+        if !single {
+            if let Some(bound) = self.rust_use_path_at(&segs[0], &w.file, w.at) {
+                if !bound.is_empty() {
+                    segs.splice(0..1, bound);
+                }
+            }
+        } else if let Some(bound) = self.rust_use_path_at(leaf, &w.file, w.at) {
+            if bound.len() > 1 {
+                segs = bound[..bound.len() - 1].to_vec();
+                has_root = true;
+            }
+        }
+        if has_root {
+            if let Some(root) = segs.first().map(String::as_str) {
+                if matches!(root, "std" | "core" | "alloc") {
+                    return Ok(true);
+                }
+                if !matches!(root, "crate" | "self" | "super")
+                    && !self
+                        .rust_crate_graph()?
+                        .crates
+                        .values()
+                        .any(|c| c.name == root)
+                {
+                    let _ = self.rust_use_facts(&w.file);
+                    if self
+                        .upstream_rust_deps
+                        .as_ref()
+                        .is_some_and(|d| d.contains(root))
+                    {
+                        return Ok(true);
+                    }
+                }
+            }
+        }
+        if single {
+            let facts = self.rust_use_facts(&w.file).unwrap_or_default();
+            if facts.external.contains(leaf) && !facts.bound.contains(leaf) {
+                return Ok(true);
+            }
+            if STD_TYPES.contains(&leaf) {
+                return Ok(true);
+            }
+        }
+        Ok(false)
+    }
+
+    /// Whether a Rust call through a type's path can mean `target` (#2614). A
+    /// type the path names from std or a dependency — through the file's `use`
+    /// (`J::from(i)` under `use serde_json::Value as J`, `Value::default()`
+    /// under `use serde_json::Value`) or as written
+    /// (`serde_json::Value::default()`) — is that crate's own: the project
+    /// holds a function of it only as its own impl of a trait for it (`impl
+    /// Blank for serde_json::Value`, `impl From<Fail> for PathBuf`), and a call
+    /// through a trait's path (`W::flush(s)` under `use std::io::Write as W`)
+    /// reaches the project's impls of that trait. A same-named function of a
+    /// project type is another type's: the reporter's `J::from(i)` went to a
+    /// local `impl From<io::Error> for Fail`, a guess by the name alone, and
+    /// `Value::default()` to a project `Value` of its own.
+    pub(super) fn rust_path_call_reachable(&mut self, target: &KNode, r: &ResolveRefIn) -> Res<bool> {
+        if target.language != "rust" {
+            return Ok(true);
+        }
+        let segments: Vec<&str> = r.reference_name.split("::").collect();
+        if segments.len() < 2
+            || !segments.iter().all(|s| re!(r"^[A-Za-z_]\w*$").is_match(s))
+        {
+            return Ok(true);
+        }
+        let ty = segments[segments.len() - 2];
+        if !ty.starts_with(|c: char| c.is_ascii_uppercase()) || ty == "Self" {
+            return Ok(true);
+        }
+        let Some(outside) =
+            self.rust_outside_path_type(ty, &segments[..segments.len() - 2], r)?
+        else {
+            return Ok(true);
+        };
+        if target.kind != "method" {
+            return Ok(false);
+        }
+        let mut site = r.clone().at(target);
+        site.column = target.start_column;
+        let Some(cx) = self.rust_self_context(&site) else {
+            return Ok(false);
+        };
+        if cx.is_trait {
+            return Ok(false);
+        }
+        if cx.trait_name.as_deref() == Some(outside.as_str()) {
+            return Ok(true);
+        }
+        if cx.owner != outside {
+            return Ok(false);
+        }
+        // The type the impl is for, as its own file names it: the outside one,
+        // not a project namesake.
+        let text = re!(r"^(?:&\s*(?:'\w+\s+)?(?:mut\s+)?)+")
+            .replace(&cx.self_text, "")
+            .to_string();
+        let Some((written, name)) = Self::rust_path_head(&text) else {
+            return Ok(false);
+        };
+        let at = self
+            .rust_impl_start(&target.file_path, target.start_line, target.start_column)
+            .unwrap_or(0);
+        let mut segs = written.clone();
+        let mut real = name.clone();
+        if segs.is_empty() {
+            if let Some(bound) = self.rust_use_path_at(&name, &target.file_path, at) {
+                if bound.len() > 1 {
+                    real = bound.last().cloned().unwrap_or(real);
+                    segs = bound[..bound.len() - 1].to_vec();
+                }
+            }
+        } else if let Some(head) = self.rust_use_path_at(&segs[0], &target.file_path, at) {
+            if !head.is_empty() {
+                segs.splice(0..1, head);
+            }
+        }
+        if let Some(root) = segs.first().map(String::as_str) {
+            if matches!(root, "std" | "core" | "alloc") {
+                return Ok(true);
+            }
+            if !matches!(root, "crate" | "self" | "super")
+                && !self
+                    .rust_crate_graph()?
+                    .crates
+                    .values()
+                    .any(|c| c.name == root)
+            {
+                let _ = self.rust_use_facts(&target.file_path);
+                if self
+                    .upstream_rust_deps
+                    .as_ref()
+                    .is_some_and(|deps| deps.contains(root))
+                {
+                    return Ok(true);
+                }
+            }
+        }
+        if !self.rust_project_named(&real)? {
+            return Ok(true);
+        }
+        Ok(!self
+            .rust_type_decls(&Written {
+                text: text.clone(),
+                file: target.file_path.clone(),
+                at,
+            })?
+            .iter()
+            .any(|n| matches!(n.kind.as_str(), "struct" | "enum" | "union")))
+    }
+
     fn rust_outside_self(&mut self, cx: &SelfContext, r: &ResolveRefIn) -> Res<bool> {
         let facts = self.rust_use_facts(&r.file_path).unwrap_or_default();
         if let Some(root) = &cx.root {
diff --git a/codegraph-kernel/src/resolve/rust_types.rs b/codegraph-kernel/src/resolve/rust_types.rs
index fcbd8a5bd..75537086d 100644
--- a/codegraph-kernel/src/resolve/rust_types.rs
+++ b/codegraph-kernel/src/resolve/rust_types.rs
@@ -3,10 +3,10 @@ use super::super::rust_modules::rust_paths::*;
 use super::super::*;
 
 #[derive(Clone, Debug)]
-struct Written {
-    text: String,
-    file: String,
-    at: usize,
+pub(super) struct Written {
+    pub(super) text: String,
+    pub(super) file: String,
+    pub(super) at: usize,
 }
 impl Written {
     fn with(&self, text: impl Into<String>) -> Self {
@@ -218,7 +218,7 @@ impl KernelResolver {
             cursor = cursor.parent()?;
         }
     }
-    fn rust_type_decls(&mut self, w: &Written) -> Res<Vec<Arc<KNode>>> {
+    pub(super) fn rust_type_decls(&mut self, w: &Written) -> Res<Vec<Arc<KNode>>> {
         let (head, _, _) = type_head(&w.text);
         let leaf = head.rsplit("::").next().unwrap_or(&head);
         let mut path: Vec<String> = head.split("::").map(str::to_string).collect();
@@ -855,6 +855,25 @@ impl KernelResolver {
                     }
                 }
                 if path.len() == 1 {
+                    let last = path[0].as_str();
+                    // A tuple struct (`Wrapper(x)`) or a `Some`/`Ok`/`Err`
+                    // variant makes a value of its own type; a SCREAMING name
+                    // is a const's call on nothing the index types.
+                    if last.starts_with(|c: char| c.is_ascii_uppercase()) {
+                        if last.len() > 1
+                            && last.chars().all(|c| {
+                                c.is_ascii_uppercase() || c.is_ascii_digit() || c == '_'
+                            })
+                        {
+                            return Ok(None);
+                        }
+                        let ty = match last {
+                            "Some" => "Option<_>",
+                            "Ok" | "Err" => "Result<_, _>",
+                            _ => last,
+                        };
+                        return Ok(Some(written(ty.to_string())));
+                    }
                     let mut scope = n;
                     loop {
                         let local = rust_children(scope).into_iter().find(|item|
@@ -1213,7 +1232,7 @@ impl KernelResolver {
             },
         }))
     }
-    fn rust_project_named(&mut self, name: &str) -> Res<bool> {
+    pub(super) fn rust_project_named(&mut self, name: &str) -> Res<bool> {
         Ok(self.nodes_by_name(name)?.iter().any(|n| {
             n.language == "rust"
                 && matches!(
@@ -1674,7 +1693,7 @@ impl KernelResolver {
             None
         })
     }
-    fn rust_impl_start(&mut self, file: &str, line: i64, col: i64) -> Option<usize> {
+    pub(super) fn rust_impl_start(&mut self, file: &str, line: i64, col: i64) -> Option<usize> {
         let (s, t) = self.rust_tree_for(file)?;
         rust_ancestor(
             rust_at(&t, s.text(), line, col),
@@ -1869,7 +1888,42 @@ impl KernelResolver {
                 return Ok(None);
             }
         }
-        let node = self.rust_method_on(&written, &method, r, 0)?;
+        // A field chain or struct literal receiver — `vis.map.get("a")`,
+        // `Xyz { x: 1.0 }.to_val()` — whose type the receiver is written with
+        // says what the call reaches (matchRustWrittenReceiverCall). A type no
+        // declaration the index holds names — one a macro declares, like
+        // tokio's `type AtomicUnsignedShort = …` inside `cfg_has_atomic_u64!`
+        // — says nothing of it, unless a wrapper around it has the method
+        // itself (`Arc::clone`): the name strategies decide.
+        let leaf = head.rsplit("::").next().unwrap_or(&head);
+        if function.kind() == "field_expression" {
+            // `read.kind === 'named'`: a plain type path — not `Self`, a
+            // `&[T]`, a generic parameter's bound (`R: AsyncRead`), or a type
+            // std or a dependency owns (rust_written_outside).
+            let named = leaf != "Self"
+                && re!(r"^[A-Za-z_]\w*(?:::\s*[A-Za-z_]\w*)*$").is_match(&head)
+                && self
+                    .rust_generic_traits(leaf, &written.file, written.at)
+                    .is_none()
+                && !self.rust_written_outside(&written, leaf, &head)?;
+            if named
+                && !own_wrapper_method(&type_head(&written.text).0, &method)
+                && !self.rust_project_named(leaf)?
+                && self.rust_type_decls(&written)?.is_empty()
+                && self.rust_methods_named(leaf, &method)?.is_empty()
+            {
+                return Ok(None);
+            }
+        }
+        let node = match self.rust_method_on(&written, &method, r, 0)? {
+            Some(node) => Some(node),
+            // A provided method of a project trait the type derives counts
+            // (axum-extra's #[derive(TypedPath)]).
+            None if function.kind() == "field_expression" => {
+                self.rust_derived_trait_method(&written, &method, r)?
+            }
+            None => None,
+        };
         if node.is_some() {
             self.mark_rust_typed(r);
         }
@@ -1879,4 +1933,105 @@ impl KernelResolver {
             resolved_by: if function.kind() == "field_expression" { "instance-method" } else { "qualified-name" },
         })))
     }
+
+    /// The names a Rust type's `#[derive(…)]` attributes write, each by its
+    /// path's last segment.
+    fn rust_derived_names(&mut self, decl: &KNode) -> Res<Vec<String>> {
+        let Some((source, tree)) = self.rust_tree_for(&decl.file_path) else {
+            return Ok(Vec::new());
+        };
+        let text = source.text();
+        let Some(node) = self.rust_declaration_node(
+            decl,
+            &tree,
+            text,
+            &["struct_item", "enum_item", "union_item"],
+        ) else {
+            return Ok(Vec::new());
+        };
+        let mut names = Vec::new();
+        let mut attr = node.prev_named_sibling();
+        while let Some(a) = attr {
+            if a.kind() != "attribute_item" {
+                break;
+            }
+            for m in re!(r"\bderive\s*\(([^()]*)\)").captures_iter(rust_text(a, text)) {
+                for part in m[1].split(',') {
+                    if let Some(name) = part
+                        .trim()
+                        .rsplit("::")
+                        .next()
+                        .map(str::trim)
+                        .filter(|s| re!(r"^[A-Za-z_]\w*$").is_match(s))
+                    {
+                        names.push(name.to_string());
+                    }
+                }
+            }
+            attr = a.prev_named_sibling();
+        }
+        Ok(names)
+    }
+
+    /// Whether a Rust method's declaration writes a body — a provided trait
+    /// method is a `function_item`; a required one a `function_signature_item`.
+    fn rust_has_body(&mut self, m: &KNode) -> bool {
+        let Some((source, tree)) = self.rust_tree_for(&m.file_path) else {
+            return false;
+        };
+        self.rust_declaration_node(m, &tree, source.text(), &["function_item"])
+            .is_some()
+    }
+
+    /// The method a Rust project trait that a type derives provides, for a
+    /// call on a value of the type: `#[derive(TypedPath)] struct UsersShow {…}`
+    /// reaches axum-extra's `TypedPath::with_query_params` through the impl
+    /// the derive writes, which the index doesn't hold. None unless exactly
+    /// one derived trait in scope at the call declares the method with a body.
+    fn rust_derived_trait_method(
+        &mut self,
+        w: &Written,
+        method: &str,
+        r: &ResolveRefIn,
+    ) -> Res<Option<Arc<KNode>>> {
+        let decls = self.rust_type_decls(w)?;
+        let types: Vec<_> = decls
+            .into_iter()
+            .filter(|n| matches!(n.kind.as_str(), "struct" | "enum" | "union"))
+            .collect();
+        if types.len() != 1 {
+            return Ok(None);
+        }
+        let mut found: Vec<Arc<KNode>> = Vec::new();
+        for name in self.rust_derived_names(&types[0])? {
+            let traits: Vec<_> = self
+                .nodes_by_name(&name)?
+                .iter()
+                .filter(|n| n.kind == "trait" && n.language == "rust" && n.name == name)
+                .cloned()
+                .collect();
+            if traits.is_empty() {
+                continue;
+            }
+            for m in self.rust_trait_methods(w, &[name], method, 0)? {
+                let Some(trait_node) = self.rust_trait_of(&m)? else {
+                    continue;
+                };
+                if self.rust_has_body(&m)
+                    && self.rust_trait_in_scope(&trait_node.name, r, &m)?
+                {
+                    found.push(m);
+                }
+            }
+        }
+        found.sort_by(|a, b| a.id.cmp(&b.id));
+        found.dedup_by(|a, b| a.id == b.id);
+        let mut owners = HashSet::new();
+        for m in &found {
+            if let Some(t) = self.rust_trait_of(m)? {
+                owners.insert(t.id.clone());
+            }
+        }
+        Ok((owners.len() == 1).then(|| found.first().cloned()).flatten())
+    }
 }

From 194751e65a677687204595e460f4d66d79c09920 Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Thu, 29 Oct 2026 07:48:17 -0600
Subject: [PATCH 24/30] feat(kernel): scope named class expressions and export
 them over CommonJS (#2825)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A named class expression is a class bound inside its expression: index
its members and supertypes, but resolve references written outside the
expression on a graph where that class and its members are not — a
same-named declaration or binding keeps its links, and `new Widget()`
elsewhere links nothing. References written inside see the whole graph
unless the name is another expression's, bound inside that one alone.

`module.exports = class Router` / `exports.Store = class StoreImpl`
are the module's value: the class stays reachable to every importer,
and collect_cjs_export records the declared name as the export's
local binding.

Inheritance refs resolved through an import binding emit upstream's
import confidence 0.9; the scoped arm's 0.95 stays for type-position
references.
---
 codegraph-kernel/src/resolve/mod.rs        |  19 ++
 codegraph-kernel/src/resolve/node_table.rs |   4 +
 codegraph-kernel/src/resolve/pipeline.rs   |  22 +-
 codegraph-kernel/src/resolve/query.rs      | 242 +++++++++++++++++++--
 codegraph-kernel/src/tsjs/exports.rs       |  23 +-
 5 files changed, 283 insertions(+), 27 deletions(-)

diff --git a/codegraph-kernel/src/resolve/mod.rs b/codegraph-kernel/src/resolve/mod.rs
index 4343d31dc..b6d1d32d3 100644
--- a/codegraph-kernel/src/resolve/mod.rs
+++ b/codegraph-kernel/src/resolve/mod.rs
@@ -429,6 +429,11 @@ impl SourceFile {
         self.text.get_or_init(|| self.lines.join("\n"))
     }
 
+    /// The 0-based line, or None past the file's end.
+    pub(super) fn line(&self, i: usize) -> Option<&str> {
+        self.lines.get(i).map(String::as_str)
+    }
+
     fn dart_tokens(&self) -> &[dart_libraries::DartToken] {
         self.dart_tokens.get_or_init(|| dart_libraries::tokens(self.text()))
     }
@@ -700,6 +705,17 @@ pub struct KernelResolver {
     /// Set for one `resolve_ref` from non-test code: node lookups then
     /// answer as if no `__mocks__/` file were indexed (mocklessContextFor).
     mockless: std::cell::Cell<bool>,
+    /// classExpressions (#2499): the named class expressions' index; `None`
+    /// when the project has none.
+    class_expr_index: OnceCell<Option<Rc<query::ClassExprIndex>>>,
+    /// Set for one `resolve_ref` written outside every named class
+    /// expression: node lookups then answer as if the classes those
+    /// expressions declare and their members were not indexed
+    /// (classExpressionFreeContextFor).
+    class_expr_free: std::cell::Cell<bool>,
+    /// classExpressionOnlyNames' set: the names only class expressions'
+    /// classes and members carry.
+    class_expr_only: OnceCell<Rc<HashSet<String>>>,
     /// A file's bindings rows. Lookups cluster by file, so 128 files keep
     /// nearly every hit: unbounded, n8n's workers held 86-140 MB each.
     bindings_cache: Lru<Rc<Vec<KBinding>>>,
@@ -1013,6 +1029,9 @@ impl KernelResolver {
             table: std::cell::OnceCell::new(),
             mock_names: std::cell::OnceCell::new(),
             mockless: std::cell::Cell::new(false),
+            class_expr_index: std::cell::OnceCell::new(),
+            class_expr_free: std::cell::Cell::new(false),
+            class_expr_only: std::cell::OnceCell::new(),
             lookups: config.query_lookups.unwrap_or(false).then(Default::default),
             db_path: config.db_path,
             generation: config.generation,
diff --git a/codegraph-kernel/src/resolve/node_table.rs b/codegraph-kernel/src/resolve/node_table.rs
index 0f060d9c6..1f54f6eaa 100644
--- a/codegraph-kernel/src/resolve/node_table.rs
+++ b/codegraph-kernel/src/resolve/node_table.rs
@@ -351,6 +351,7 @@ pub(super) struct QueryLookups {
     by_lower: HashMap<String, NodeList>,
     by_qname: HashMap<String, NodeList>,
     by_file: HashMap<String, NodeList>,
+    by_kind: HashMap<String, NodeList>,
     by_id: HashMap<String, Option<Arc<KNode>>>,
     known_files: HashMap<String, bool>,
     /// `SELECT path FROM files`, sorted — the Lua/Rust file buckets.
@@ -362,6 +363,7 @@ pub(super) enum LookupKey<'a> {
     Lower(&'a str),
     QualifiedName(&'a str),
     File(&'a str),
+    Kind(&'a str),
 }
 
 impl QueryLookups {
@@ -387,6 +389,7 @@ impl QueryLookups {
             ),
             LookupKey::QualifiedName(k) => (self.by_qname.get(k), "WHERE qualified_name = ?1 ORDER BY rowid", k.to_string()),
             LookupKey::File(k) => (self.by_file.get(k), "WHERE file_path = ?1 ORDER BY start_line, rowid", k.to_string()),
+            LookupKey::Kind(k) => (self.by_kind.get(k), "WHERE kind = ?1 ORDER BY file_path, start_line, rowid", k.to_string()),
         };
         if let Some(hit) = memo_hit {
             return Ok(hit.clone());
@@ -400,6 +403,7 @@ impl QueryLookups {
             LookupKey::Lower(_) => &mut self.by_lower,
             LookupKey::QualifiedName(_) => &mut self.by_qname,
             LookupKey::File(_) => &mut self.by_file,
+            LookupKey::Kind(_) => &mut self.by_kind,
         };
         memo.insert(arg, list.clone());
         Ok(list)
diff --git a/codegraph-kernel/src/resolve/pipeline.rs b/codegraph-kernel/src/resolve/pipeline.rs
index 6f435c3fb..99a2681c8 100644
--- a/codegraph-kernel/src/resolve/pipeline.rs
+++ b/codegraph-kernel/src/resolve/pipeline.rs
@@ -891,9 +891,15 @@ if super::lang_scope::is_dart_member_read(r) {
         // lookup answers as if no `__mocks__/` file were indexed. Test code,
         // a mock included, keeps the whole graph.
         let mockless = !is_test_path(&r.file_path) && self.manual_mock_names()?.is_some();
+        // classExpressionFreeContextFor (#2499): a ref written outside every
+        // named class expression resolves on a graph without the classes they
+        // declare and their members.
+        let class_free = self.class_expr_free_for(r)?;
         let prev = self.mockless.replace(mockless);
+        let prev_free = self.class_expr_free.replace(class_free);
         let outcome = self.resolve_ref_scoped(r);
         self.mockless.set(prev);
+        self.class_expr_free.set(prev_free);
         outcome
     }
 
@@ -963,10 +969,18 @@ if super::lang_scope::is_dart_member_read(r) {
         }
         if let Some(result) = self.ts_scoped_reference(r)? {
             return match result {
-                Some(candidate) => match self.gate_target_kind(candidate, r)? {
-                    Some(candidate) => self.finish_pre_framework(r, candidate),
-                    None => Ok(self.refused()),
-                },
+                Some(mut candidate) => {
+                    // `extends`/`implements` resolve through the import
+                    // binding at upstream's `import` 0.9; the scoped arm's
+                    // 0.95 is for type-position `references` (#2825's dumps).
+                    if is_inheritance_ref(&r.reference_kind) && candidate.resolved_by == "import" {
+                        candidate.confidence = 0.9;
+                    }
+                    match self.gate_target_kind(candidate, r)? {
+                        Some(candidate) => self.finish_pre_framework(r, candidate),
+                        None => Ok(self.refused()),
+                    }
+                }
                 None => Ok(self.refused()),
             };
         }
diff --git a/codegraph-kernel/src/resolve/query.rs b/codegraph-kernel/src/resolve/query.rs
index 141a560a0..82a26456a 100644
--- a/codegraph-kernel/src/resolve/query.rs
+++ b/codegraph-kernel/src/resolve/query.rs
@@ -36,6 +36,37 @@ fn drop_mock_nodes(list: NodeList) -> NodeList {
     Arc::new(list.iter().filter(|n| !is_manual_mock_path(&n.file_path)).cloned().collect())
 }
 
+/// classExpressions' payload (#2499): the classes named class expressions
+/// declare — by name, by file, the files holding them, and the ids of them
+/// and their members, which a reference outside them resolves without.
+pub(super) struct ClassExprIndex {
+    pub by_name: HashMap<String, Vec<Arc<KNode>>>,
+    pub by_file: HashMap<String, Vec<Arc<KNode>>>,
+    pub files: HashSet<String>,
+    pub hidden_ids: HashSet<String>,
+}
+
+/// CLASS_EXPRESSION_REF_LANGUAGES: the languages a class expression's class
+/// and the references to its name can be written in — TS/JS, and the
+/// scripts of Vue, Svelte and Astro files.
+const CLASS_EXPR_LANGS: &[&str] = &[
+    "typescript", "tsx", "javascript", "jsx", "arkts", "vue", "svelte", "astro",
+];
+
+/// isJsClassExpression — a class a named class expression declares: its
+/// signature is its head (`class Widget extends Base`), which a class
+/// declaration doesn't carry.
+fn is_js_class_expression(n: &KNode) -> bool {
+    n.kind == "class" && n.signature.is_some() && CLASS_EXPR_LANGS.contains(&n.language.as_str())
+}
+
+/// writtenIn — `r` is written inside `node`'s source range.
+fn written_in(n: &KNode, r: &ResolveRefIn) -> bool {
+    n.file_path == r.file_path
+        && (r.line > n.start_line || (r.line == n.start_line && r.column >= n.start_column))
+        && (r.line < n.end_line || (r.line == n.end_line && r.column <= n.end_column))
+}
+
 impl KernelResolver {
     /// The live connection — errors once close() has run. Statements borrow
     /// it, so the Option indirection stays inside this accessor.
@@ -65,50 +96,72 @@ impl KernelResolver {
         })
     }
 
+    /// The class-expression-free view's node filter
+    /// (classExpressionFreeView's `keep`, #2499): the classes named class
+    /// expressions declare and their members, out; order kept.
+    fn drop_class_expr_nodes(&self, list: NodeList) -> Res<NodeList> {
+        let Some(idx) = self.class_expr_index()? else {
+            return Ok(list);
+        };
+        if !list.iter().any(|n| idx.hidden_ids.contains(&n.id)) {
+            return Ok(list);
+        }
+        Ok(Arc::new(list.iter().filter(|n| !idx.hidden_ids.contains(&n.id)).cloned().collect()))
+    }
+
     /// queries.getNodesByName — ORDER BY file_path, start_line.
     pub(super) fn nodes_by_name(&self, name: &str) -> Res<NodeList> {
-        let list = if let Some(r) = self.with_lookups(|l, c| l.nodes(c, LookupKey::Name(name))) {
+        let mut list = if let Some(r) = self.with_lookups(|l, c| l.nodes(c, LookupKey::Name(name))) {
             r?
         } else {
             let t = self.table()?;
             t.by_name.get(name).cloned().unwrap_or_else(|| t.empty.clone())
         };
         // Only a name some mock declares can lose a node (mocklessContextFor).
-        if !self.mockless.get() || !self.manual_mock_names()?.is_some_and(|m| m.names.contains(name)) {
-            return Ok(list);
+        if self.mockless.get() && self.manual_mock_names()?.is_some_and(|m| m.names.contains(name)) {
+            list = drop_mock_nodes(list);
+        }
+        if self.class_expr_free.get() {
+            list = self.drop_class_expr_nodes(list)?;
         }
-        Ok(drop_mock_nodes(list))
+        Ok(list)
     }
 
     /// queries.getNodesByLowerName — `WHERE lower(name) = lower(?)`, no
     /// ORDER BY (rowid order, same as the TS reader).
     pub(super) fn nodes_by_lower_name(&self, name: &str) -> Res<NodeList> {
-        let list = if let Some(r) = self.with_lookups(|l, c| l.nodes(c, LookupKey::Lower(name))) {
+        let mut list = if let Some(r) = self.with_lookups(|l, c| l.nodes(c, LookupKey::Lower(name))) {
             r?
         } else {
             let t = self.table()?;
             t.by_lower().get(&name.to_ascii_lowercase()).cloned().unwrap_or_else(|| t.empty.clone())
         };
-        if !self.mockless.get()
-            || !self.manual_mock_names()?.is_some_and(|m| m.lower.contains(&name.to_lowercase()))
+        if self.mockless.get()
+            && self.manual_mock_names()?.is_some_and(|m| m.lower.contains(&name.to_lowercase()))
         {
-            return Ok(list);
+            list = drop_mock_nodes(list);
         }
-        Ok(drop_mock_nodes(list))
+        if self.class_expr_free.get() {
+            list = self.drop_class_expr_nodes(list)?;
+        }
+        Ok(list)
     }
 
     /// queries.getNodesByQualifiedName — no ORDER BY (TS uses rowid order).
     pub(super) fn nodes_by_qualified_name(&self, qname: &str) -> Res<NodeList> {
-        let list = if let Some(r) = self.with_lookups(|l, c| l.nodes(c, LookupKey::QualifiedName(qname))) {
+        let mut list = if let Some(r) = self.with_lookups(|l, c| l.nodes(c, LookupKey::QualifiedName(qname))) {
             r?
         } else {
             let t = self.table()?;
             t.by_qname.get(qname).cloned().unwrap_or_else(|| t.empty.clone())
         };
-        if !self.mockless.get() || self.manual_mock_names()?.is_none() {
-            return Ok(list);
+        if self.mockless.get() && self.manual_mock_names()?.is_some() {
+            list = drop_mock_nodes(list);
         }
-        Ok(drop_mock_nodes(list))
+        if self.class_expr_free.get() {
+            list = self.drop_class_expr_nodes(list)?;
+        }
+        Ok(list)
     }
 
     /// manualMockNames (resolution/index.ts #2455): the names every Jest or
@@ -125,7 +178,7 @@ impl KernelResolver {
         let mut names = HashSet::new();
         let mut lower = HashSet::new();
         for file in files.iter().filter(|f| is_manual_mock_path(f)) {
-            for n in self.nodes_in_file(file)?.iter() {
+            for n in self.nodes_in_file_unfiltered(file)?.iter() {
                 lower.insert(n.name.to_lowercase());
                 names.insert(n.name.clone());
             }
@@ -134,8 +187,149 @@ impl KernelResolver {
         Ok(self.mock_names.get_or_init(|| v).clone())
     }
 
-    /// queries.getNodesInFile — ORDER BY start_line.
+    /// classExpressions (resolution/index.ts #2499): the classes named class
+    /// expressions declare — by name, by file, the files holding them, and
+    /// the ids of them and their members. A class a CommonJS module exports
+    /// is left out: the module binds it, so it reads as a declaration does.
+    /// Read once — the node table it feeds is a run constant.
+    pub(super) fn class_expr_index(&self) -> Res<Option<Rc<ClassExprIndex>>> {
+        if let Some(v) = self.class_expr_index.get() {
+            return Ok(v.clone());
+        }
+        let mut by_name: HashMap<String, Vec<Arc<KNode>>> = HashMap::new();
+        let mut by_file: HashMap<String, Vec<Arc<KNode>>> = HashMap::new();
+        let mut by_key: HashMap<(String, String), Arc<KNode>> = HashMap::new();
+        let mut files = HashSet::new();
+        let mut hidden_ids = HashSet::new();
+        for n in self.nodes_by_kind("class")?.iter() {
+            if !is_js_class_expression(n) || self.class_expr_common_js_exported(n) {
+                continue;
+            }
+            by_name.entry(n.name.clone()).or_default().push(n.clone());
+            by_file.entry(n.file_path.clone()).or_default().push(n.clone());
+            by_key.insert((n.file_path.clone(), n.qualified_name.clone()), n.clone());
+            files.insert(n.file_path.clone());
+            hidden_ids.insert(n.id.clone());
+        }
+        // A member is its class's when it is declared in its file under its
+        // qualified name (`Widget::run` of `Widget`).
+        for file in &files {
+            for n in self.nodes_in_file_unfiltered(file)?.iter() {
+                if !matches!(n.kind.as_str(), "method" | "property" | "field") {
+                    continue;
+                }
+                if let Some(cut) = n.qualified_name.rfind("::") {
+                    if by_key.contains_key(&(n.file_path.clone(), n.qualified_name[..cut].to_string())) {
+                        hidden_ids.insert(n.id.clone());
+                    }
+                }
+            }
+        }
+        let v = (!by_name.is_empty()).then(|| Rc::new(ClassExprIndex { by_name, by_file, files, hidden_ids }));
+        Ok(self.class_expr_index.get_or_init(|| v).clone())
+    }
+
+    /// isCommonJsExportedClass — `module.exports = class Router {…}` and
+    /// `exports.Store = class Store {…}` are their module's value, which a
+    /// require hands to every importer: the class is not scoped.
+    fn class_expr_common_js_exported(&self, n: &KNode) -> bool {
+        let Some(file) = self.read_file_uncached(&n.file_path) else {
+            return false;
+        };
+        let prev = (n.start_line >= 2)
+            .then(|| file.line((n.start_line - 2) as usize))
+            .flatten()
+            .unwrap_or("");
+        let Some(line) = file.line((n.start_line - 1) as usize) else {
+            return false;
+        };
+        let before = format!(
+            "{prev}\n{}",
+            &line[..usize::try_from(n.start_column).unwrap_or(0).min(line.len())]
+        );
+        re!(r"(?:^|[^\w$.])(?:module\.)?exports(?:\.[A-Za-z_$][\w$]*)?\s*=\s*$").is_match(&before)
+    }
+
+    /// classExpressionFreeContextFor (#2499): a reference written outside
+    /// every named class expression resolves without the classes they
+    /// declare and their members — `new Widget()` elsewhere links nothing,
+    /// and a same-named class, function or binding keeps its links. Inside
+    /// one the whole graph applies, unless the name is another class
+    /// expression's, bound inside that one alone.
+    pub(super) fn class_expr_free_for(&self, r: &ResolveRefIn) -> Res<bool> {
+        if !CLASS_EXPR_LANGS.contains(&r.language.as_str()) {
+            return Ok(false);
+        }
+        let Some(idx) = self.class_expr_index()? else {
+            return Ok(false);
+        };
+        let first = r.reference_name.split('.').next().unwrap_or("");
+        let named = idx.by_name.get(first);
+        let inside = idx
+            .by_file
+            .get(&r.file_path)
+            .is_some_and(|ns| ns.iter().any(|n| written_in(n, r)));
+        Ok(!inside || named.is_some_and(|ns| !ns.iter().any(|n| written_in(n, r))))
+    }
+
+    /// classExpressionOnlyNames (#2499): the names only class expressions'
+    /// classes and members carry — they name nothing in the free view, so
+    /// the prefilter drops the references that would search for them.
+    fn class_expr_only_names(&self) -> Res<Rc<HashSet<String>>> {
+        if let Some(v) = self.class_expr_only.get() {
+            return Ok(v.clone());
+        }
+        let mut only = HashSet::new();
+        if let Some(idx) = self.class_expr_index()? {
+            let mut names = HashSet::new();
+            for id in &idx.hidden_ids {
+                if let Some(n) = self.node_by_id(id)? {
+                    names.insert(n.name.clone());
+                }
+            }
+            for name in names {
+                if self
+                    .nodes_by_name(&name)?
+                    .iter()
+                    .all(|n| idx.hidden_ids.contains(&n.id))
+                {
+                    only.insert(name);
+                }
+            }
+        }
+        Ok(self.class_expr_only.get_or_init(|| Rc::new(only)).clone())
+    }
+
+    /// queries.getNodesByKind — ORDER BY file_path, start_line. The
+    /// class-expression index's raw read: no resolution path iterates nodes
+    /// by kind, so the free view has nothing to hide through it.
+    pub(super) fn nodes_by_kind(&self, kind: &str) -> Res<NodeList> {
+        if let Some(r) = self.with_lookups(|l, c| l.nodes(c, LookupKey::Kind(kind))) {
+            return r;
+        }
+        let t = self.table()?;
+        Ok(Arc::new(t.nodes.iter().filter(|n| n.kind == kind).cloned().collect()))
+    }
+
+    /// queries.getNodesInFile — ORDER BY start_line. In the
+    /// class-expression-free view the classes' files lose their hidden
+    /// nodes; the lookups an import reads a module's exports by
+    /// (`file_export_index`, `manual_mock_names`) stay whole.
     pub(super) fn nodes_in_file(&self, file_path: &str) -> Res<NodeList> {
+        let list = self.nodes_in_file_unfiltered(file_path)?;
+        if self.class_expr_free.get()
+            && self
+                .class_expr_index()?
+                .is_some_and(|idx| idx.files.contains(file_path))
+        {
+            return self.drop_class_expr_nodes(list);
+        }
+        Ok(list)
+    }
+
+    /// `nodes_in_file` before either resolution view filters it — what the
+    /// indexes and the export lookups read.
+    pub(super) fn nodes_in_file_unfiltered(&self, file_path: &str) -> Res<NodeList> {
         if let Some(r) = self.with_lookups(|l, c| l.nodes(c, LookupKey::File(file_path))) {
             return r;
         }
@@ -160,12 +354,18 @@ impl KernelResolver {
     }
 
     /// knownSymbols membership (`SELECT DISTINCT name FROM nodes`); false
-    /// once closed.
+    /// once closed. In the class-expression-free view a name only their
+    /// classes and members carry names nothing (classExpressionOnlyNames,
+    /// #2499).
     pub(super) fn known_name(&self, name: &str) -> bool {
-        if let Some(r) = self.with_lookups(|l, c| l.nodes(c, LookupKey::Name(name))) {
-            return r.is_ok_and(|list| !list.is_empty());
-        }
-        self.table().is_ok_and(|t| t.by_name.contains_key(name))
+        let known = if let Some(r) = self.with_lookups(|l, c| l.nodes(c, LookupKey::Name(name))) {
+            r.is_ok_and(|list| !list.is_empty())
+        } else {
+            self.table().is_ok_and(|t| t.by_name.contains_key(name))
+        };
+        known
+            && !(self.class_expr_free.get()
+                && self.class_expr_only_names().is_ok_and(|o| o.contains(name)))
     }
 
     /// knownFiles membership (`SELECT path FROM files`); false once closed.
@@ -359,7 +559,7 @@ impl KernelResolver {
         if let Some(v) = self.export_index.get(file_path) {
             return Ok(v.clone());
         }
-        let nodes = self.nodes_in_file(file_path)?;
+        let nodes = self.nodes_in_file_unfiltered(file_path)?;
         let mut by_name: HashMap<String, Arc<KNode>> = HashMap::new();
         let mut default_component: Option<Arc<KNode>> = None;
         for n in nodes.iter() {
diff --git a/codegraph-kernel/src/tsjs/exports.rs b/codegraph-kernel/src/tsjs/exports.rs
index 64130642e..f555368e7 100644
--- a/codegraph-kernel/src/tsjs/exports.rs
+++ b/codegraph-kernel/src/tsjs/exports.rs
@@ -79,11 +79,21 @@ impl<'t> Walker<'t> {
                 self.emit_reexport_binding("default", "default", &spec, expr);
             } else if right.kind() == "identifier" {
                 self.later_exports.entry(self.text(right).to_string()).or_insert(("default".to_string(), EXPORT_CJS));
+            } else if right.kind() == "class" {
+                // `module.exports = class Router {…}`: the class is the
+                // module's value — the local name it declares is the
+                // binding a `require` reaches (#2499).
+                if let Some(name) = right.child_by_field_name("name") {
+                    self.later_exports.entry(self.text(name).to_string()).or_insert(("default".to_string(), EXPORT_CJS));
+                }
             }
             return;
         }
         let fn_valued = matches!(right.kind(), "function_expression" | "arrow_function" | "generator_function");
-        if (right.kind() != "identifier" && !fn_valued) || !matches!(left.kind(), "member_expression" | "subscript_expression") {
+        // A named class expression is the member's value too: `exports.Store
+        // = class StoreImpl {…}` binds `Store` to `StoreImpl` (#2499).
+        let class_named = right.kind() == "class" && right.child_by_field_name("name").is_some();
+        if (right.kind() != "identifier" && !fn_valued && !class_named) || !matches!(left.kind(), "member_expression" | "subscript_expression") {
             return;
         }
         let Some(obj) = left.child_by_field_name("object") else { return };
@@ -100,7 +110,16 @@ impl<'t> Walker<'t> {
                 if fn_valued {
                     self.cjs_fn_exports.push((key, self.line_of(expr)));
                 } else {
-                    self.later_exports.entry(self.text(right).to_string()).or_insert((key, EXPORT_CJS));
+                    // A class binds by the name it declares (`exports.X =
+                    // class Y`), a bare identifier by its own text.
+                    let local = if class_named {
+                        right.child_by_field_name("name").map(|n| self.text(n).to_string())
+                    } else {
+                        Some(self.text(right).to_string())
+                    };
+                    if let Some(local) = local {
+                        self.later_exports.entry(local).or_insert((key, EXPORT_CJS));
+                    }
                 }
             }
         }

From 1652acef8566107460e25a71c1d79d88d748f896 Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Thu, 29 Oct 2026 07:51:00 -0600
Subject: [PATCH 25/30] fix(kernel): a call or new never lands on an interface
 or a type alias (#2801)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Nothing calls an interface or a type alias, or makes an instance of one.
A calls/instantiates result that found a TypeScript type by name or
through an import meant the value its file declares beside it — the
function under `interface Ok` in a result module, the class merged with
an interface — and a global the project only types, like `new Response()`
or `new Worker()`, links nothing.
---
 codegraph-kernel/src/resolve/pipeline.rs | 38 ++++++++++++++++++++++--
 1 file changed, 36 insertions(+), 2 deletions(-)

diff --git a/codegraph-kernel/src/resolve/pipeline.rs b/codegraph-kernel/src/resolve/pipeline.rs
index 99a2681c8..400f5ee0c 100644
--- a/codegraph-kernel/src/resolve/pipeline.rs
+++ b/codegraph-kernel/src/resolve/pipeline.rs
@@ -2,6 +2,12 @@
 
 use super::*;
 
+/// TYPE_COMPANION_VALUE_KINDS (index.ts #2801): the values a TypeScript
+/// type may share its name with in its file, which a call or `new` of the
+/// name means.
+static TYPE_COMPANION_VALUE_KINDS: &[&str] =
+    &["function", "class", "component", "constant", "variable"];
+
 impl KernelResolver {
     // -----------------------------------------------------------------------
     // Non-bare c/cpp `imports` refs — the #include-path slice (resolveOneInner
@@ -662,7 +668,7 @@ if super::lang_scope::is_dart_member_read(r) {
 
     /// gateTargetKind (index.ts): the imports/inheritance target-kind gates
     /// plus the out-of-repo import check.
-    pub(super) fn gate_target_kind(&mut self, cand: KCand, r: &ResolveRefIn) -> Res<Option<KCand>> {
+    pub(super) fn gate_target_kind(&mut self, mut cand: KCand, r: &ResolveRefIn) -> Res<Option<KCand>> {
         if r.language == "python" && r.reference_kind == "calls" && self.is_python_property(&cand.node) {
             return Ok(None);
         }
@@ -670,6 +676,21 @@ if super::lang_scope::is_dart_member_read(r) {
         if r.reference_kind == "calls" && cpp::is_define(&cand.node) {
             return Ok(None);
         }
+        // A TypeScript interface or type alias is no value: nothing calls
+        // one or makes an instance of it. A strategy that found one by name
+        // meant the value its file declares beside it (`interface Ok` and
+        // `function Ok` in a result module); with none there, the name is a
+        // value from elsewhere that the project only types (`new
+        // Response()`, `new Worker()`), and links nothing (#2801).
+        if matches!(r.reference_kind.as_str(), "calls" | "instantiates")
+            && is_esm_import_language(&r.language)
+            && matches!(cand.node.kind.as_str(), "interface" | "type_alias")
+        {
+            let Some(value) = self.same_named_value_of_type(&cand.node)? else {
+                return Ok(None);
+            };
+            cand.node = value;
+        }
         if r.reference_kind == "imports" {
             if r.language == "python" && self.is_python_from_import_module(r.clone())
                 && !matches!(cand.node.kind.as_str(), "file" | "module") { return Ok(None); }
@@ -690,7 +711,6 @@ if super::lang_scope::is_dart_member_read(r) {
         if self.is_import_binding_call_target(&cand.node, r)? {
             return Ok(None);
         }
-        let mut cand = cand;
         if r.language == "go" && cand.node.language == "go" {
             let is_type = matches!(cand.node.kind.as_str(), "struct" | "interface" | "type_alias");
             if r.reference_kind == "calls" && is_type && !r.reference_name.contains('.') && !self.is_bare_go_call(r)? {
@@ -753,6 +773,20 @@ if super::lang_scope::is_dart_member_read(r) {
         Ok(Some(cand))
     }
 
+    /// The value a file declares beside a type of the same name — `export
+    /// function Ok()` beside `export interface Ok`, a class merged with an
+    /// interface — which a call or `new` written with the name reaches
+    /// (sameNamedValueOfType, #2801). The first by position; None when the
+    /// file declares none.
+    fn same_named_value_of_type(&self, ty: &KNode) -> Res<Option<Arc<KNode>>> {
+        Ok(self
+            .nodes_in_file(&ty.file_path)?
+            .iter()
+            .filter(|n| n.name == ty.name && TYPE_COMPANION_VALUE_KINDS.contains(&n.kind.as_str()))
+            .min_by_key(|n| (n.start_line, n.start_column))
+            .cloned())
+    }
+
     /// The one supertype-kind node a TypeScript value shares its name and file with.
     fn same_named_type_of_value(&self, value: &KNode) -> Res<Option<Arc<KNode>>> {
         if !matches!(value.kind.as_str(), "constant" | "variable")

From 89217c466373fd80cfa5d71b746f597b2028bb4c Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Thu, 29 Oct 2026 08:42:10 -0600
Subject: [PATCH 26/30] fix(kernel): an explicit operator call reads its own
 argument list
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

tree-sitter-cpp parses `d.operator+=(c)` as a call on the receiver alone,
with the operator's name stranded in an ERROR sibling (`function:
(identifier) (ERROR ".operator+=") arguments: (c)`), so the callee never
spells `operator+=` and cpp_call_argument_types found no call. Every
overload then tied at 0 and the first — `operator+=(int)` — took a call
that `operator+=(const Counter&)` fits. Accept a call whose error spells
the operator name (the member-access dot is part of the error text), so
the argument types are read and the class overload wins.

`size_type` and `difference_type` count as numbers now, the container
convention upstream uses (6bd217a2): nlohmann/json's `p->operator[](0)`
reaches the index overload, not the `T*` one.
---
 codegraph-kernel/src/resolve/cpp_overloads.rs | 27 ++++++++++++++++++-
 1 file changed, 26 insertions(+), 1 deletion(-)

diff --git a/codegraph-kernel/src/resolve/cpp_overloads.rs b/codegraph-kernel/src/resolve/cpp_overloads.rs
index 07f7eae08..4f341e60e 100644
--- a/codegraph-kernel/src/resolve/cpp_overloads.rs
+++ b/codegraph-kernel/src/resolve/cpp_overloads.rs
@@ -44,6 +44,9 @@ const CHAR_TYPES: &[&str] = &["char", "wchar_t", "char8_t", "char16_t", "char32_
 const NUMBER_TYPES: &[&str] = &[
     "int", "unsigned", "signed", "short", "long", "float", "double", "size_t", "ssize_t", "ptrdiff_t",
     "int8_t", "int16_t", "int32_t", "int64_t", "uint8_t", "uint16_t", "uint32_t", "uint64_t", "intptr_t", "uintptr_t",
+    // A container's own integer aliases, by convention: nlohmann/json's `operator[](size_type idx)`
+    // takes a `0` over its `T* key` overload.
+    "size_type", "difference_type",
 ];
 const STRING_TYPES: &[&str] = &["string", "wstring", "string_view", "wstring_view", "basic_string", "basic_string_view"];
 
@@ -390,7 +393,10 @@ impl KernelResolver {
         let callee = shared_regex(&format!(r"(?:^|[.:>])\s*{}(?:\s*<[\s\S]*>)?\s*$", regex::escape(name)))?;
         let mut call = descendant_for_position(tree.root_node(), source.text(), ((r.line - 1).max(0) as usize, r.column.max(0) as usize));
         loop {
-            if call.kind() == "call_expression" && call.child_by_field_name("function").is_some_and(|f| callee.is_match(&source.text()[f.byte_range()])) { break; }
+            if call.kind() == "call_expression"
+                && (call.child_by_field_name("function").is_some_and(|f| callee.is_match(&source.text()[f.byte_range()]))
+                    || cpp_call_has_operator_error(call, source.text(), name))
+            { break; }
             let Some(parent) = call.parent() else { return Ok(None) };
             call = parent;
         }
@@ -520,6 +526,25 @@ fn opening_paren(text: &str, close: usize) -> Option<usize> {
     None
 }
 
+/// Whether `call` is an explicit operator call tree-sitter-cpp could not finish reading: it parses
+/// `b.operator+=(a)` and `s.operator()(4)` as a call on the receiver alone, with the operator's
+/// name stranded in an `ERROR` sibling (`function: (identifier) (ERROR (operator_name))
+/// arguments: …`), so the `function` field never spells the callee. The argument list is still the
+/// call's own; only the name has to come from the error.
+fn cpp_call_has_operator_error(call: tree_sitter::Node, text: &str, name: &str) -> bool {
+    let name: String = name.chars().filter(|c| !c.is_whitespace()).collect();
+    let mut cursor = call.walk();
+    let mut found = false;
+    for child in call.children(&mut cursor) {
+        if child.is_error() {
+            let spelled: String = text[child.byte_range()].chars().filter(|c| !c.is_whitespace()).collect();
+            // The error starts at the member access: `b.operator+=(a)` strands `".operator+="`.
+            if spelled.trim_start_matches(['.', '-', '>']) == name { found = true; break; }
+        }
+    }
+    found
+}
+
 /// The expanded definition a C++ method that a macro defines carries as its signature
 /// (cpp-macro-methods.ts), `inline const FileDescriptor* Descriptor::file() const` for protobuf's
 /// `PROTOBUF_DEFINE_ACCESSOR(Descriptor, file, const FileDescriptor*)`: its source is the

From a287fa62e016797033cc0d3b5e4e6f84ff9bfbd8 Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Thu, 29 Oct 2026 08:51:13 -0600
Subject: [PATCH 27/30] fix(kernel): a typed-local receiver keeps the
 invocation-time binding

The #2821 port (0b564c78) settled a builtin-named method call through
pythonLocalClass alone, which refuses when a name is bound more than
once. `store = A(); store = B(); store.get()` then resolved to nothing,
though the fork's receiver-scope rule has always read the binding in
effect at the call (B).

Read that binding: among plain assignments at or before the call, the
last one decides, and a bare annotation (`store: B`) does not rebind.
python_receiver_uncertain still holds back a same-line replacement and a
later replacement a closure's captured cell sees, and a later binding no
longer poisons an earlier one when the call reads before it. A def's
parameter keeps its annotation when nothing rebinds it.

Three shapes the strict read owns stay with it: a binding that is not a
plain assignment (a branch, loop, `with`, comprehension), a base from
outside the project, and a future binding read from a lambda body. A
receiver naming a class declared here (`File.write(f, "x")`) and a
lambda parameter of the receiver's name keep the ordinary paths.
---
 codegraph-kernel/src/resolve/python_types.rs | 102 ++++++++++++++++++-
 1 file changed, 100 insertions(+), 2 deletions(-)

diff --git a/codegraph-kernel/src/resolve/python_types.rs b/codegraph-kernel/src/resolve/python_types.rs
index e03a7fc65..8e6b68560 100644
--- a/codegraph-kernel/src/resolve/python_types.rs
+++ b/codegraph-kernel/src/resolve/python_types.rs
@@ -677,6 +677,25 @@ impl KernelResolver {
                 return Ok(result);
             }
             strict_local = true;
+            // A receiver that names a class declared here is a static-style
+            // call (`File.write(f, "x")`), which the ordinary paths resolve;
+            // the strict read is for a local or a parameter.
+            if self.python_ref_class(receiver, r)?.is_some() {
+                return Ok(result);
+            }
+            // A lambda's own parameter of the name shadows the outer binding;
+            // its default is that outer value, which the ordinary paths read.
+            if self.python_lambda_parameter_named(receiver, r)? {
+                return Ok(result);
+            }
+            // A lambda body reads its captured cell when invoked, and a name
+            // no binding reaches it yet (a future initialization) stays
+            // unresolved there, as the fork's receiver-scope rules hold.
+            let future = self.receiver_binding(receiver, r)?.is_some_and(|b| b.line > r.line);
+            if future && self.python_in_lambda_body(r)? {
+                result.claimed = true;
+                return Ok(result);
+            }
             // `None` is upstream's `undefined`: no enclosing def binds the
             // name, so it is no local — the ordinary paths keep it.
             let Some(answer) = self.python_local_class(receiver, r, &mut read)? else {
@@ -720,6 +739,60 @@ impl KernelResolver {
         Ok(result)
     }
 
+    /// Whether the reference sits in a lambda body whose parameters include
+    /// `name`: the lambda's own parameter, whose default is that outer value.
+    fn python_lambda_parameter_named(&mut self, name: &str, r: &ResolveRefIn) -> Res<bool> {
+        let Some(source) = self.read_file(&r.file_path) else { return Ok(false) };
+        let Some(tree) = self.parsed_tree(&source, r) else { return Ok(false) };
+        let text = source.text();
+        let leaf = super::iteration::descendant_for_position(
+            tree.root_node(),
+            text,
+            ((r.line - 1).max(0) as usize, r.column.max(0) as usize),
+        );
+        let at = leaf.start_byte();
+        let mut current = Some(leaf);
+        while let Some(node) = current {
+            if node.kind() == "lambda"
+                && node.child_by_field_name("body").is_some_and(|body| body.start_byte() <= at && at < body.end_byte())
+                && node.child_by_field_name("parameters").is_some_and(|params| {
+                    super::iteration::named_children(params).into_iter().any(|param| {
+                        let named = param.child_by_field_name("name").unwrap_or(param);
+                        named.kind() == "identifier" && &text[named.start_byte()..named.end_byte()] == name
+                    })
+                })
+            {
+                return Ok(true);
+            }
+            current = node.parent();
+        }
+        Ok(false)
+    }
+
+    /// Whether the reference `r` sits in a lambda's body (not its parameters or
+    /// a default), a deferred read with no graph function node of its own.
+    fn python_in_lambda_body(&mut self, r: &ResolveRefIn) -> Res<bool> {
+        let Some(source) = self.read_file(&r.file_path) else { return Ok(false) };
+        let Some(tree) = self.parsed_tree(&source, r) else { return Ok(false) };
+        let text = source.text();
+        let leaf = super::iteration::descendant_for_position(
+            tree.root_node(),
+            text,
+            ((r.line - 1).max(0) as usize, r.column.max(0) as usize),
+        );
+        let at = leaf.start_byte();
+        let mut current = Some(leaf);
+        while let Some(node) = current {
+            if node.kind() == "lambda"
+                && node.child_by_field_name("body").is_some_and(|body| body.start_byte() <= at && at < body.end_byte())
+            {
+                return Ok(true);
+            }
+            current = node.parent();
+        }
+        Ok(false)
+    }
+
     /// pythonLocalClass (#2583): the project class the local or parameter
     /// `name` holds at `r`, agreed by every binding of it in the binding
     /// def's own body — a parameter annotation, `name: T`, `name = Ctor()`,
@@ -762,6 +835,9 @@ impl KernelResolver {
             return Ok(None);
         };
         let mut evidence: Vec<Answer> = Vec::new();
+        // (evidence index, line, whether it rebinds the name): a bare
+        // annotation (`store: B`) does not.
+        let mut lines: Vec<(usize, usize, bool)> = Vec::new();
         if let Some(param) = param {
             // A parameter without an annotation is no evidence.
             let Some(ann) = param else {
@@ -771,6 +847,7 @@ impl KernelResolver {
             if matches!(ev, Answer::Unknown) {
                 return Ok(Some(Answer::Unknown));
             }
+            lines.push((evidence.len(), 0, true));
             evidence.push(ev);
         }
         for b in &bindings {
@@ -778,6 +855,7 @@ impl KernelResolver {
                 return Ok(Some(Answer::Unknown));
             };
             let value = value.trim();
+            let annotation_only = ty.is_some() && value.is_empty();
             let ev = if let Some(ty) = ty {
                 // `reg: Base = make()` trusts the annotation; `reg: A = B()` contradicts it.
                 if !value.is_empty() && value != "None" {
@@ -811,9 +889,10 @@ impl KernelResolver {
                 }
                 self.python_value_text_answer(value, r, read, 0)?
             };
-            if matches!(ev, Answer::Unknown | Answer::Absent) {
-                return Ok(Some(Answer::Unknown));
+            if matches!(ev, Answer::Absent) {
+                continue;
             }
+            lines.push((evidence.len(), *line, !annotation_only));
             evidence.push(ev);
         }
         // Nothing here can be a project class: a builtin, or no evidence.
@@ -846,6 +925,25 @@ impl KernelResolver {
                 }
             }
         }
+        // The fork's receiver-scope rule reads the binding in effect at the
+        // call, not every binding the def makes (`store = A(); store = B();
+        // store.get()` is B's). A same-line replacement, or a later one a
+        // closure's captured cell sees, leaves it unknown; so does a binding
+        // shape this read refuses (checked above).
+        if self.python_receiver_uncertain(r)? {
+            return Ok(Some(Answer::Unknown));
+        }
+        // `PyBinding` lines are zero-based; the ref's line is one-based.
+        let at = r.line.max(0) as usize;
+        if let Some((i, _, _)) = lines
+            .iter()
+            .filter(|(_, line, rebinds)| *rebinds && *line < at)
+            .max_by_key(|(_, line, _)| *line)
+        {
+            return Ok(Some(evidence[*i].clone()));
+        }
+        // Nothing binds the name at the call: a lone initialization, later or
+        // not, is retained only when it is the def's only evidence.
         Ok(Some(agree(evidence)))
     }
 

From 5912954d8124daf6e57294b136572e7d3d196fb5 Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Thu, 29 Oct 2026 08:51:14 -0600
Subject: [PATCH 28/30] fix(resolve): vet only name picks through a module's
 unexported bindings

2ca95adb applied isVisibleAcrossFiles to every strategy's pick. Upstream
guards just the name match (index.ts:1867), and the port's ESM leg
vetoed picks that were never name guesses: a typed store action
(`items$.getState().inc()`) and an imported component function value
were both dropped as unexported module bindings. Keep every language's
privacy rule for a structured pick, and skip the ESM export check for a
pick a receiver's type or a function value made.
---
 codegraph-kernel/src/resolve/names.rs    | 14 ++++++++++++++
 codegraph-kernel/src/resolve/pipeline.rs | 17 ++++++++++++-----
 2 files changed, 26 insertions(+), 5 deletions(-)

diff --git a/codegraph-kernel/src/resolve/names.rs b/codegraph-kernel/src/resolve/names.rs
index 00b0131c1..325e3dd5b 100644
--- a/codegraph-kernel/src/resolve/names.rs
+++ b/codegraph-kernel/src/resolve/names.rs
@@ -368,6 +368,17 @@ impl KernelResolver {
 
     /// isVisibleAcrossFiles (name-matcher.ts).
     pub(super) fn is_visible_across_files(&mut self, candidate: &KNode, r: &ResolveRefIn) -> Res<bool> {
+        self.is_visible_across_files_for(candidate, r, true)
+    }
+
+    /// `is_visible_across_files` for a pick a strategy made from the code's own
+    /// structure — a receiver's type, a function value — rather than from the
+    /// name. Upstream guards only the name strategies with this rule
+    /// (index.ts:1867), so a module's unexported binding is no bar to a typed
+    /// pick: `items$.getState().inc()` reaches the store action `inc`, and an
+    /// imported component reaches its default export. Every language's own
+    /// privacy still applies.
+    pub(super) fn is_visible_across_files_for(&mut self, candidate: &KNode, r: &ResolveRefIn, name_pick: bool) -> Res<bool> {
         if candidate.language == "go" {
             if self.go_external_qualified(r)? { return Ok(false); }
             if let Some(imp) = self.go_ref_qualifier(r)? {
@@ -459,6 +470,9 @@ impl KernelResolver {
         if (lang == "lua" || lang == "luau") && self.is_lua_local(candidate) {
             return Ok(self.lua_alias_target(r)?.flatten().is_some_and(|n| n.id == candidate.id));
         }
+        if !name_pick && is_esm_family(&candidate.language) {
+            return Ok(true);
+        }
         self.is_cross_file_reachable(candidate, r)
     }
 
diff --git a/codegraph-kernel/src/resolve/pipeline.rs b/codegraph-kernel/src/resolve/pipeline.rs
index 400f5ee0c..c6e2d27a8 100644
--- a/codegraph-kernel/src/resolve/pipeline.rs
+++ b/codegraph-kernel/src/resolve/pipeline.rs
@@ -1319,12 +1319,19 @@ if r.language == "dart" && r.reference_kind == "references"
         // what a name in another file means, whichever strategy chose it —
         // name-matcher.ts isVisibleAcrossFiles at index.ts:1867 (#1730), run
         // on the node after supertype/overload/alias retargets the way
-        // upstream vets the target matchReference reports. Only a name-match
-        // pick is vetted: upstream's import, file-path and framework results
-        // never reach that guard, and an import pick's alias forward can
-        // legitimately land on an unexported module member.
+        // upstream vets the target matchReference reports. Upstream's import,
+        // file-path and framework results never reach that guard, and an
+        // import pick's alias forward can legitimately land on an unexported
+        // module member. A pick a strategy made from the code's structure —
+        // a receiver's type or a function value — keeps every language's own
+        // privacy but not a module's unexported-binding rule, which upstream
+        // applies to the name strategies alone.
         if !matches!(winner.resolved_by, "import" | "framework" | "file-path")
-            && !self.is_visible_across_files(&winner.node, r)?
+            && !self.is_visible_across_files_for(
+                &winner.node,
+                r,
+                !matches!(winner.resolved_by, "instance-method" | "function-ref" | "field-call"),
+            )?
         {
             return Ok(ResolveOutcome::unresolved());
         }

From f4691fa9064f423699bf6180d15b9445e3a2402b Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Thu, 29 Oct 2026 08:53:17 -0600
Subject: [PATCH 29/30] test(eval): record the json, flask, vite and svelte
 precision runs

Every case held on each corpus (json 11 absent + 7 present, flask 2
present, vite 6 absent + 2 present, svelte 1 absent).
---
 .../precision-flask-d73fa1c-0ae0b138.json     |  60 ++++++
 .../precision-json-aa391dc-0ae0b138.json      | 200 ++++++++++++++++++
 .../precision-svelte-5895c63-0ae0b138.json    |  35 +++
 .../precision-vite-8492422-0ae0b138.json      |  95 +++++++++
 4 files changed, 390 insertions(+)
 create mode 100644 __tests__/evaluation/results/precision-flask-d73fa1c-0ae0b138.json
 create mode 100644 __tests__/evaluation/results/precision-json-aa391dc-0ae0b138.json
 create mode 100644 __tests__/evaluation/results/precision-svelte-5895c63-0ae0b138.json
 create mode 100644 __tests__/evaluation/results/precision-vite-8492422-0ae0b138.json

diff --git a/__tests__/evaluation/results/precision-flask-d73fa1c-0ae0b138.json b/__tests__/evaluation/results/precision-flask-d73fa1c-0ae0b138.json
new file mode 100644
index 000000000..4ad5ed553
--- /dev/null
+++ b/__tests__/evaluation/results/precision-flask-d73fa1c-0ae0b138.json
@@ -0,0 +1,60 @@
+{
+  "timestamp": "2026-10-29T14:52:50.836Z",
+  "corpus": "flask",
+  "repo": "https://github.com/pallets/flask.git",
+  "commit": "d73fa1c",
+  "codegraphSha": "0ae0b138",
+  "summary": {
+    "absentCases": 0,
+    "absentHeld": 0,
+    "presentCases": 2,
+    "presentHeld": 2,
+    "unjudgeable": 0
+  },
+  "resolvedBy": {
+    "(none)": 2474,
+    "import": 1180,
+    "instance-method": 730,
+    "exact-match": 633,
+    "function-ref": 191
+  },
+  "edges": 5208,
+  "results": [
+    {
+      "caseId": "flask-package-reexport-receiver",
+      "expect": "present",
+      "pass": true,
+      "found": [
+        {
+          "from": "file:examples/tutorial/flaskr/auth.py",
+          "to": "method:31833b8026746e7977b4c2736d71c63e",
+          "resolvedBy": "instance-method"
+        },
+        {
+          "from": "file:examples/tutorial/flaskr/auth.py",
+          "to": "method:31833b8026746e7977b4c2736d71c63e",
+          "resolvedBy": "instance-method"
+        },
+        {
+          "from": "file:examples/tutorial/flaskr/auth.py",
+          "to": "method:31833b8026746e7977b4c2736d71c63e",
+          "resolvedBy": "instance-method"
+        }
+      ],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "flask-control-relative-from-import",
+      "expect": "present",
+      "pass": true,
+      "found": [
+        {
+          "from": "file:src/flask/app.py",
+          "to": "function:00d6010e49ed947bc5858174234b23e4",
+          "resolvedBy": "import"
+        }
+      ],
+      "missingEndpoints": []
+    }
+  ]
+}
\ No newline at end of file
diff --git a/__tests__/evaluation/results/precision-json-aa391dc-0ae0b138.json b/__tests__/evaluation/results/precision-json-aa391dc-0ae0b138.json
new file mode 100644
index 000000000..ca540a12d
--- /dev/null
+++ b/__tests__/evaluation/results/precision-json-aa391dc-0ae0b138.json
@@ -0,0 +1,200 @@
+{
+  "timestamp": "2026-10-29T14:52:49.255Z",
+  "corpus": "json",
+  "repo": "https://github.com/nlohmann/json.git",
+  "commit": "aa391dc",
+  "codegraphSha": "0ae0b138",
+  "summary": {
+    "absentCases": 11,
+    "absentHeld": 11,
+    "presentCases": 7,
+    "presentHeld": 7,
+    "unjudgeable": 0
+  },
+  "resolvedBy": {
+    "(none)": 13070,
+    "instance-method": 6643,
+    "qualified-name": 3946,
+    "exact-match": 2641,
+    "file-path": 1742,
+    "import": 670,
+    "function-ref": 49,
+    "field-call": 1
+  },
+  "edges": 28762,
+  "results": [
+    {
+      "caseId": "json-value-not-internal-serializer",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-fuzzer-contains-word",
+      "expect": "present",
+      "pass": true,
+      "found": [
+        {
+          "from": "method:511ae2bab26a12794fe5b8e38095ef6f",
+          "to": "method:c7bd7bd104f933f1ecf2fcd44528462f",
+          "resolvedBy": "instance-method"
+        }
+      ],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-fuzzer-end-calls-begin",
+      "expect": "present",
+      "pass": true,
+      "found": [
+        {
+          "from": "method:a583c5de8fb77fcf2e47f72d5f052f20",
+          "to": "method:c7bd7bd104f933f1ecf2fcd44528462f",
+          "resolvedBy": "instance-method"
+        }
+      ],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-front-member",
+      "expect": "present",
+      "pass": true,
+      "found": [
+        {
+          "from": "method:8654732301dd561330bd7d76aaaac333",
+          "to": "method:3e3f4b2356976a63aaa31053c5cb2161",
+          "resolvedBy": "instance-method"
+        }
+      ],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-rend-member",
+      "expect": "present",
+      "pass": true,
+      "found": [
+        {
+          "from": "method:0dda1746e6adfea526da71f9367b169b",
+          "to": "method:3e3f4b2356976a63aaa31053c5cb2161",
+          "resolvedBy": "instance-method"
+        }
+      ],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-subscript-member",
+      "expect": "present",
+      "pass": true,
+      "found": [
+        {
+          "from": "method:77ad649124c3bf33008dde65773f52e6",
+          "to": "method:3e3f4b2356976a63aaa31053c5cb2161",
+          "resolvedBy": "instance-method"
+        }
+      ],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-emplace-member",
+      "expect": "present",
+      "pass": true,
+      "found": [
+        {
+          "from": "method:c3902fb60811ce9452300172d8c55ee0",
+          "to": "method:3e3f4b2356976a63aaa31053c5cb2161",
+          "resolvedBy": "instance-method"
+        }
+      ],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-no-cross-test-member",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-no-eigen-member",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-no-udt-member",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-no-fifo-member",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-no-array-member",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-no-ordered-map-this",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-no-adl-to-helper",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-no-using-std-to-proxy",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-no-doctest-to-dictionary",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-begin-no-abi-adl-to-member",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "json-items-calls-proxy-ctor",
+      "expect": "present",
+      "pass": true,
+      "found": [
+        {
+          "from": "method:43fd87584a379054069e29e9f2000a50",
+          "to": "method:2c30311abef74670c4da1607ca5259fb",
+          "resolvedBy": "import"
+        },
+        {
+          "from": "method:b768fbb5951dfeae8fcc4e6af4e53c84",
+          "to": "method:2c30311abef74670c4da1607ca5259fb",
+          "resolvedBy": "import"
+        }
+      ],
+      "missingEndpoints": []
+    }
+  ]
+}
\ No newline at end of file
diff --git a/__tests__/evaluation/results/precision-svelte-5895c63-0ae0b138.json b/__tests__/evaluation/results/precision-svelte-5895c63-0ae0b138.json
new file mode 100644
index 000000000..35dc6c9a6
--- /dev/null
+++ b/__tests__/evaluation/results/precision-svelte-5895c63-0ae0b138.json
@@ -0,0 +1,35 @@
+{
+  "timestamp": "2026-10-29T14:53:04.397Z",
+  "corpus": "svelte",
+  "repo": "https://github.com/sveltejs/svelte.git",
+  "commit": "5895c63",
+  "codegraphSha": "0ae0b138",
+  "summary": {
+    "absentCases": 1,
+    "absentHeld": 1,
+    "presentCases": 0,
+    "presentHeld": 0,
+    "unjudgeable": 0
+  },
+  "resolvedBy": {
+    "(none)": 30920,
+    "import": 22673,
+    "exact-match": 9040,
+    "qualified-name": 1874,
+    "instance-method": 390,
+    "framework": 220,
+    "function-ref": 196,
+    "file-path": 58,
+    "fuzzy": 13
+  },
+  "edges": 65384,
+  "results": [
+    {
+      "caseId": "svelte-bare-import-bundle",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    }
+  ]
+}
\ No newline at end of file
diff --git a/__tests__/evaluation/results/precision-vite-8492422-0ae0b138.json b/__tests__/evaluation/results/precision-vite-8492422-0ae0b138.json
new file mode 100644
index 000000000..49808c555
--- /dev/null
+++ b/__tests__/evaluation/results/precision-vite-8492422-0ae0b138.json
@@ -0,0 +1,95 @@
+{
+  "timestamp": "2026-10-29T14:52:56.623Z",
+  "corpus": "vite",
+  "repo": "https://github.com/vitejs/vite.git",
+  "commit": "8492422",
+  "codegraphSha": "0ae0b138",
+  "summary": {
+    "absentCases": 6,
+    "absentHeld": 6,
+    "presentCases": 2,
+    "presentHeld": 2,
+    "unjudgeable": 0
+  },
+  "resolvedBy": {
+    "(none)": 13392,
+    "import": 11144,
+    "exact-match": 3389,
+    "qualified-name": 1009,
+    "instance-method": 457,
+    "file-path": 197,
+    "function-ref": 163,
+    "framework": 1
+  },
+  "edges": 29752,
+  "results": [
+    {
+      "caseId": "vite-factory-receiver-control",
+      "expect": "present",
+      "pass": true,
+      "found": [
+        {
+          "from": "function:d321dd128d90578bc69867835ec73ef8",
+          "to": "method:db73e5f5d9c7af61d0f22c5b9971ced3",
+          "resolvedBy": "instance-method"
+        }
+      ],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "vite-external-receiver-not-project-method",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "vite-bare-import-self-edge",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "vite-bare-import-getEnv",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "vite-fuzzy-nested-resolveConfig-getEnv",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "vite-fuzzy-nested-build-scan",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "vite-sealed-module-defineConfig",
+      "expect": "absent",
+      "pass": true,
+      "found": [],
+      "missingEndpoints": []
+    },
+    {
+      "caseId": "vite-control-relative-import",
+      "expect": "present",
+      "pass": true,
+      "found": [
+        {
+          "from": "file:packages/vite/src/node/config.ts",
+          "to": "function:0c2f36c32c5742aee412978220fd5b23",
+          "resolvedBy": "import"
+        }
+      ],
+      "missingEndpoints": []
+    }
+  ]
+}
\ No newline at end of file

From 328930835d3b7fa4e37f182dd59caf707c460d86 Mon Sep 17 00:00:00 2001
From: bompus <bompus@users.noreply.github.com>
Date: Thu, 29 Oct 2026 09:25:17 -0600
Subject: [PATCH 30/30] fix(kernel): close the review findings on the three
 fixes

- C++ (P3): a comment inside the access (`b./* note */operator+=(a)`)
  left the comment in the error's text, so the operator name never
  matched. Compare the `operator_name` node the grammar still reads,
  and keep the trimmed-text form only when there is none.
- Python (P2): a local read before its only assignment in the same def
  (`result = store.get(); store = A()`) is an UnboundLocalError, not
  the later value; refuse it, keeping the future-initialization
  exception for a nested def that captures the outer name.
- Python (P2): two conditional bindings in different blocks leave no
  value in effect (`if flag: store = A() else: store = B()`, then
  `store.get()`); refuse. One conditional beside a `None` placeholder
  or a later plain assignment still reads, and a conflicting set whose
  binding in effect may not run stays unknown.
- ESM (P2): a function value is import-justified only when the file's
  own import resolves to the target's file, so a bare name fallback
  can no longer take an unexported namesake from another module. A
  default-exported wrapper still reaches its inner function through
  the default import, and `export default function Name` counts as an
  exported name.

Regression tests: commented operator access, a future local read, two
class-binding branches, and an imported name the module does not export.
---
 .../function-ref-project-imports.test.ts      | 15 +++
 __tests__/operator-method-names.test.ts       | 22 +++++
 .../python-typed-builtin-method-calls.test.ts | 31 +++++++
 codegraph-kernel/src/resolve/cpp_overloads.rs | 26 +++++-
 codegraph-kernel/src/resolve/esm_scope.rs     |  5 +
 codegraph-kernel/src/resolve/names.rs         | 16 ++++
 codegraph-kernel/src/resolve/pipeline.rs      | 14 ++-
 codegraph-kernel/src/resolve/python_types.rs  | 91 ++++++++++++++++++-
 8 files changed, 206 insertions(+), 14 deletions(-)

diff --git a/__tests__/function-ref-project-imports.test.ts b/__tests__/function-ref-project-imports.test.ts
index 866280dea..7b32d8839 100644
--- a/__tests__/function-ref-project-imports.test.ts
+++ b/__tests__/function-ref-project-imports.test.ts
@@ -222,4 +222,19 @@ export function list(present: (fn: unknown) => void): void {
       cg.close();
     }
   }, 60_000);
+
+  it('leaves a name the module does not export unresolved instead of taking an unexported namesake', async () => {
+    const cg = await indexProject({
+      'package.json': PACKAGE_JSON,
+      'tsconfig.json': TSCONFIG,
+      'src/empty.ts': 'export const anchor = 1;\n',
+      'src/other.ts': 'function secret() { return 1; }\nexport const keep = secret;\n',
+      'src/consumer.ts': "import { secret } from './empty';\nfunction register(cb: () => number) { return cb(); }\nregister(secret);\n",
+    });
+    try {
+      expect(fnRefsFrom(cg, 'src/consumer.ts')).toEqual([]);
+    } finally {
+      cg.close();
+    }
+  }, 60_000);
 });
diff --git a/__tests__/operator-method-names.test.ts b/__tests__/operator-method-names.test.ts
index b4ffae8fe..d73cbbd14 100644
--- a/__tests__/operator-method-names.test.ts
+++ b/__tests__/operator-method-names.test.ts
@@ -282,4 +282,26 @@ describe('a method whose name is not a plain word', () => {
     expect(callsFrom(cg, 'src/Vec.scala', lineOf(scala, 'def twice'))).toEqual([`Vec::++@Vec.scala:${lineOf(scala, 'def ++(n: Int, m: Int)')}`]);
     expect(callsFrom(cg, 'src/Weird.kt', lineOf(kotlin, 'fun use()'))).toEqual([`Weird::\`reads (a value\`@Weird.kt:${lineOf(kotlin, 'x: Int, y: Int')}`]);
   }, 120_000);
+
+  it('C++: a comment between the dot and the operator name still reads the arguments', async () => {
+    const hppText = lines(
+      'struct Total {',
+      '  int value = 0;',
+      '  Total& operator+=(int n) { value += n; return *this; }',
+      '  Total& operator+=(const Total& other) { value += other.value; return *this; }',
+      '};',
+    );
+    const cppText = lines(
+      '#include "total.hpp"',
+      'int addUp() {',
+      '  Total a;',
+      '  Total b;',
+      '  b./* note */operator+=(a);',
+      '  return b.value;',
+      '}',
+    );
+    const cg = await index(project({ 'src/total.hpp': hppText, 'src/total.cpp': cppText }));
+    expect(callsFrom(cg, 'src/total.cpp', lineOf(cppText, 'int addUp()')))
+      .toEqual([`Total::operator+=@total.hpp:${lineOf(hppText, 'Total& operator+=(const Total& other)')}`]);
+  }, 120_000);
 });
diff --git a/__tests__/python-typed-builtin-method-calls.test.ts b/__tests__/python-typed-builtin-method-calls.test.ts
index 8f826a33a..323b10ed0 100644
--- a/__tests__/python-typed-builtin-method-calls.test.ts
+++ b/__tests__/python-typed-builtin-method-calls.test.ts
@@ -281,6 +281,29 @@ def make():
 
 reg = {}
 reg.get("k")
+`,
+  'future_local.py': `class Store:
+    def get(self):
+        return 1
+
+def direct():
+    result = store.get()
+    store = Store()
+    return result
+`,
+  'branches_two.py': `class A:
+    def get(self):
+        return 'A'
+class B:
+    def get(self):
+        return 'B'
+
+def choose(flag):
+    if flag:
+        store = A()
+    else:
+        store = B()
+    return store.get()
 `,
   'outside_base.py': `from somepkg import BaseStore
 
@@ -420,6 +443,14 @@ describe('Python builtin-named methods through typed locals and parameters (#258
   it('links nothing for a method a base from outside the project could hold', () => {
     expect(callsFrom('outside_base.py', 'use_child')).toEqual([]);
   });
+
+  it('links nothing for a local read before its only assignment in the same def', () => {
+    expect(callsFrom('future_local.py', 'direct')).toEqual([]);
+  });
+
+  it('links nothing when branches bind the local to different classes', () => {
+    expect(callsFrom('branches_two.py', 'choose')).toEqual([]);
+  });
 });
 
 describe('sync after an edit to the file a typed local reads (#2583)', () => {
diff --git a/codegraph-kernel/src/resolve/cpp_overloads.rs b/codegraph-kernel/src/resolve/cpp_overloads.rs
index 4f341e60e..47c5e775d 100644
--- a/codegraph-kernel/src/resolve/cpp_overloads.rs
+++ b/codegraph-kernel/src/resolve/cpp_overloads.rs
@@ -532,19 +532,35 @@ fn opening_paren(text: &str, close: usize) -> Option<usize> {
 /// arguments: …`), so the `function` field never spells the callee. The argument list is still the
 /// call's own; only the name has to come from the error.
 fn cpp_call_has_operator_error(call: tree_sitter::Node, text: &str, name: &str) -> bool {
-    let name: String = name.chars().filter(|c| !c.is_whitespace()).collect();
+    let plain = |spelling: &str| -> String { spelling.chars().filter(|c| !c.is_whitespace()).collect() };
+    let name = plain(name);
     let mut cursor = call.walk();
     let mut found = false;
     for child in call.children(&mut cursor) {
-        if child.is_error() {
-            let spelled: String = text[child.byte_range()].chars().filter(|c| !c.is_whitespace()).collect();
-            // The error starts at the member access: `b.operator+=(a)` strands `".operator+="`.
-            if spelled.trim_start_matches(['.', '-', '>']) == name { found = true; break; }
+        if !child.is_error() { continue; }
+        // The grammar still reads the operator's own name when a comment sits
+        // inside the access (`b./* note */operator+=(a)`); the error's raw text
+        // then carries the comment, so compare the name node where there is one.
+        if let Some(operator) = cpp_operator_name_in(child, text) {
+            if plain(operator) == name { found = true; break; }
+            continue;
         }
+        // No name node: the error starts at the member access, so the text is
+        // `".operator+="` (or the same behind `->`).
+        let spelled = plain(&text[child.byte_range()]);
+        if spelled.trim_start_matches(['.', '-', '>']) == name { found = true; break; }
     }
     found
 }
 
+/// The `operator_name` a tree-sitter-cpp error holds, if it read one.
+fn cpp_operator_name_in<'t>(node: tree_sitter::Node, text: &'t str) -> Option<&'t str> {
+    if node.kind() == "operator_name" { return Some(&text[node.byte_range()]); }
+    let mut cursor = node.walk();
+    let children: Vec<_> = node.children(&mut cursor).collect();
+    children.into_iter().find_map(|child| cpp_operator_name_in(child, text))
+}
+
 /// The expanded definition a C++ method that a macro defines carries as its signature
 /// (cpp-macro-methods.ts), `inline const FileDescriptor* Descriptor::file() const` for protobuf's
 /// `PROTOBUF_DEFINE_ACCESSOR(Descriptor, file, const FileDescriptor*)`: its source is the
diff --git a/codegraph-kernel/src/resolve/esm_scope.rs b/codegraph-kernel/src/resolve/esm_scope.rs
index ee92edd0c..f73e1b06a 100644
--- a/codegraph-kernel/src/resolve/esm_scope.rs
+++ b/codegraph-kernel/src/resolve/esm_scope.rs
@@ -26,6 +26,11 @@ impl KernelResolver {
                 for m in re!(r"(?m)^[ \t]*export\s+(?:default|=)\s+([A-Za-z_$][\w$]*)\s*;?\s*$").captures_iter(&code) {
                     names.insert(m[1].to_string());
                 }
+                // `export default function Disclosure() {}` exports the
+                // declaration's own name to a default import.
+                for m in re!(r"(?m)^[ \t]*export\s+default\s+(?:async\s+)?(?:function|class)\s+([A-Za-z_$][\w$]*)").captures_iter(&code) {
+                    names.insert(m[1].to_string());
+                }
                 for m in re!(r"(?m)^[ \t]*export\s+default\s*\{([^}]*)\}|(?-u:\b)return\s*\{([^{}]*)\}").captures_iter(&code) {
                     for item in m.get(1).or_else(|| m.get(2)).unwrap().as_str().split(',') {
                         let value = item.rsplit(':').next().unwrap_or("").trim();
diff --git a/codegraph-kernel/src/resolve/names.rs b/codegraph-kernel/src/resolve/names.rs
index 325e3dd5b..493a67ed6 100644
--- a/codegraph-kernel/src/resolve/names.rs
+++ b/codegraph-kernel/src/resolve/names.rs
@@ -366,6 +366,22 @@ impl KernelResolver {
         Ok(!self.is_sealed_module(&candidate.file_path)? && !self.is_unexported_module_binding(candidate)?)
     }
 
+    /// Whether the reference's own import names the file `target` is in: a
+    /// default or named binding whose specifier resolves to that file. A
+    /// function value reached this way is import-justified, so a module's
+    /// unexported-binding rule does not bar it.
+    pub(super) fn ref_imports_target_file(&mut self, target: &KNode, r: &ResolveRefIn) -> Res<bool> {
+        let name = r.reference_name.trim();
+        if name.is_empty() { return Ok(false); }
+        let mappings = self.import_mappings(&r.file_path)?;
+        for mapping in mappings.iter() {
+            if mapping.local_name != name { continue; }
+            let Some(hit) = self.resolve_via_import(&r.clone().naming(&mapping.local_name, "references"))? else { continue; };
+            if hit.node.file_path == target.file_path { return Ok(true); }
+        }
+        Ok(false)
+    }
+
     /// isVisibleAcrossFiles (name-matcher.ts).
     pub(super) fn is_visible_across_files(&mut self, candidate: &KNode, r: &ResolveRefIn) -> Res<bool> {
         self.is_visible_across_files_for(candidate, r, true)
diff --git a/codegraph-kernel/src/resolve/pipeline.rs b/codegraph-kernel/src/resolve/pipeline.rs
index c6e2d27a8..74b45378d 100644
--- a/codegraph-kernel/src/resolve/pipeline.rs
+++ b/codegraph-kernel/src/resolve/pipeline.rs
@@ -1326,12 +1326,16 @@ if r.language == "dart" && r.reference_kind == "references"
         // a receiver's type or a function value — keeps every language's own
         // privacy but not a module's unexported-binding rule, which upstream
         // applies to the name strategies alone.
+        // A function value the file's own import names is justified by that
+        // import, not by its name: an unexported inner function behind a
+        // default-exported wrapper stays reachable through the default import.
+        let name_pick = match winner.resolved_by {
+            "instance-method" | "field-call" => false,
+            "function-ref" => !self.ref_imports_target_file(&winner.node, r)?,
+            _ => true,
+        };
         if !matches!(winner.resolved_by, "import" | "framework" | "file-path")
-            && !self.is_visible_across_files_for(
-                &winner.node,
-                r,
-                !matches!(winner.resolved_by, "instance-method" | "function-ref" | "field-call"),
-            )?
+            && !self.is_visible_across_files_for(&winner.node, r, name_pick)?
         {
             return Ok(ResolveOutcome::unresolved());
         }
diff --git a/codegraph-kernel/src/resolve/python_types.rs b/codegraph-kernel/src/resolve/python_types.rs
index 8e6b68560..3fd5719d8 100644
--- a/codegraph-kernel/src/resolve/python_types.rs
+++ b/codegraph-kernel/src/resolve/python_types.rs
@@ -688,6 +688,12 @@ impl KernelResolver {
             if self.python_lambda_parameter_named(receiver, r)? {
                 return Ok(result);
             }
+            // A binding a branch, loop or `try` may not run leaves no single
+            // value in effect; claim it and link nothing.
+            if self.python_conditional_bindings(receiver, r)? {
+                result.claimed = true;
+                return Ok(result);
+            }
             // A lambda body reads its captured cell when invoked, and a name
             // no binding reaches it yet (a future initialization) stays
             // unresolved there, as the fork's receiver-scope rules hold.
@@ -793,6 +799,49 @@ impl KernelResolver {
         Ok(false)
     }
 
+    /// Whether the def around `r` binds `name` inside a branch, loop, `try` or
+    /// `with` before the call: no single value is in effect there, so the
+    /// strict read refuses rather than taking the last written assignment.
+    fn python_conditional_bindings(&mut self, name: &str, r: &ResolveRefIn) -> Res<bool> {
+        let Some(src) = self.read_file(&r.file_path) else { return Ok(false) };
+        let file = src.python_file();
+        let at = (r.line - 1).max(0) as usize;
+        let start = match file.stmt(at) {
+            Some((s, code)) if re!(r"^\s*(?:async\s+)?def\b").is_match(code) => Some(*s),
+            _ => file.scope.get(at).copied().flatten(),
+        };
+        let Some(d) = start else { return Ok(false) };
+        let assign = Self::cached_regex(&format!(r"^\s*{}\s*(?::[^=]*)?=[^=]", regex::escape(name)))?;
+        // One conditional binding beside a `None` placeholder or a later plain
+        // assignment still has a value to read. Two conditional bindings in
+        // different blocks do not.
+        let end = python_scope_end(file, d);
+        let mut conditional = 0;
+        for i in (d + 1)..=end.min(file.code.len().saturating_sub(1)) {
+            let Some(line) = src.get(i) else { break };
+            if !assign.is_match(line.trim_start()) { continue; }
+            let indent = line.len() - line.trim_start().len();
+            let mut j = i;
+            let mut inside = false;
+            while j > d {
+                j -= 1;
+                let Some(above) = src.get(j) else { break };
+                let trimmed = above.trim_start();
+                if trimmed.is_empty() || trimmed.starts_with('#') { continue; }
+                if above.len() - trimmed.len() >= indent { continue; }
+                if re!(r"^(?:if|elif|else|for|while|try|except|finally|with)\b").is_match(trimmed) {
+                    inside = true;
+                    break;
+                }
+            }
+            if inside {
+                conditional += 1;
+                if conditional >= 2 { return Ok(true); }
+            }
+        }
+        Ok(false)
+    }
+
     /// pythonLocalClass (#2583): the project class the local or parameter
     /// `name` holds at `r`, agreed by every binding of it in the binding
     /// def's own body — a parameter annotation, `name: T`, `name = Ctor()`,
@@ -933,17 +982,51 @@ impl KernelResolver {
         if self.python_receiver_uncertain(r)? {
             return Ok(Some(Answer::Unknown));
         }
+        // A conditional, loop or `try` binding may not run, so no chronological
+        // order decides between it and another: `if flag: store = A() else:
+        // store = B()` leaves the call unknown, as #2821 refuses.
+        let control_bound = |line0: usize| -> bool {
+            let Some(binding) = src.get(line0) else { return false };
+            let binding_indent = binding.len() - binding.trim_start().len();
+            let mut i = line0;
+            while i > d {
+                i -= 1;
+                let Some(line) = src.get(i) else { break };
+                let trimmed = line.trim_start();
+                if trimmed.is_empty() || trimmed.starts_with('#') { continue; }
+                if line.len() - trimmed.len() >= binding_indent { continue; }
+                if re!(r"^(?:if|elif|else|for|while|try|except|finally|with)").is_match(trimmed) {
+                    return true;
+                }
+            }
+            false
+        };
         // `PyBinding` lines are zero-based; the ref's line is one-based.
         let at = r.line.max(0) as usize;
-        if let Some((i, _, _)) = lines
+        let eligible = |line: &usize, rebinds: &bool| *rebinds && *line < at;
+        if lines.iter().any(|(_, line, rebinds)| eligible(line, rebinds) && control_bound(*line)) {
+            return Ok(Some(Answer::Unknown));
+        }
+        if let Some((i, line, _)) = lines
             .iter()
-            .filter(|(_, line, rebinds)| *rebinds && *line < at)
+            .filter(|(_, line, rebinds)| eligible(line, rebinds))
             .max_by_key(|(_, line, _)| *line)
         {
+            // A conflicting set where the binding in effect may not run stays
+            // unknown: `store = A(); if flag: store = B(); store.get()`.
+            if control_bound(*line) && matches!(agree(evidence.clone()), Answer::Unknown) {
+                return Ok(Some(Answer::Unknown));
+            }
             return Ok(Some(evidence[*i].clone()));
         }
-        // Nothing binds the name at the call: a lone initialization, later or
-        // not, is retained only when it is the def's only evidence.
+        // Nothing binds the name before the call: `store.get(); store = A()`
+        // raises UnboundLocalError in the def's own body. A nested def that
+        // captures the outer name reads it when invoked, which the fork keeps.
+        if start == Some(d) {
+            return Ok(Some(Answer::Unknown));
+        }
+        // A lone initialization, later or not, is retained only when it is the
+        // def's only evidence.
         Ok(Some(agree(evidence)))
     }