From daed6fa4d9dea12730434220b389f35efe48d108 Mon Sep 17 00:00:00 2001
From: CodeGraph Test <codegraph@example.invalid>
Date: Thu, 1 Oct 2026 08:13:43 +0800
Subject: [PATCH 1/6] fix(extract): keep same-line declarations that share a
 node id
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A same-kind, same-name declaration on one line — a getter/setter pair,
two {% render "x" %} tags — hashed to the node id of the first and
silently replaced it in the store. Within one file's extraction the first
declaration now keeps its id and every later one at a different column
appends :{column}, its zero-based UTF-16 column, as upstream v1.6.1 does
(#1349); revisiting a declaration yields the same id, so a declaration
that collides with nothing keeps exactly the id it had. Applied to the
tree-sitter walker (CFML included) and the Liquid extractor; the formula
in AGENTS.md and docs/equivalence.md records the suffix. Extraction
version 15.
---
 AGENTS.md                                     |   7 +-
 crates/codegraph-core/src/node_id.rs          |  79 ++++++++++
 .../codegraph-extract/src/embedded/liquid.rs  | 145 +++++++++++-------
 crates/codegraph-extract/src/walker.rs        |  13 +-
 .../codegraph-extract/tests/node_identity.rs  | 129 ++++++++++++++++
 .../tests/js_resolution_safety.rs             |  57 +++++++
 crates/codegraph-store/src/index_state.rs     |   2 +-
 crates/codegraph-store/tests/index_state.rs   |   2 +-
 docs/equivalence.md                           |   8 +
 9 files changed, 381 insertions(+), 61 deletions(-)
 create mode 100644 crates/codegraph-extract/tests/node_identity.rs

diff --git a/AGENTS.md b/AGENTS.md
index eedd0dc3..2ab410bd 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -45,8 +45,11 @@ or required by that guidance.
    in [`docs/equivalence.md`](docs/equivalence.md).
 3. **Stable node IDs.** Symbol IDs are
    `{kind}:{sha256("{filePath}:{kind}:{name}:{line}").hex[..32]}`; file nodes are
-   `file:{relative/path}`. Paths use `/`; lines are 1-based. Never change this
-   formula incidentally.
+   `file:{relative/path}`. Paths use `/`; lines are 1-based. Within one file's
+   extraction, a later declaration that collides with an earlier one at a
+   different column appends `:{column}` (zero-based UTF-16 code units, upstream
+   #1349), so it no longer overwrites the first. Never change this formula
+   incidentally.
 4. **No AI/vector runtime.** Do not add AI, LLM, embedding, vector-database, or
    inference dependencies. `scripts/guardrail.sh` enforces the dependency boundary.
 5. **Project containment.** Managed state stays under the selected project index
diff --git a/crates/codegraph-core/src/node_id.rs b/crates/codegraph-core/src/node_id.rs
index af806c9e..67e54d24 100644
--- a/crates/codegraph-core/src/node_id.rs
+++ b/crates/codegraph-core/src/node_id.rs
@@ -1,5 +1,7 @@
 //! Upstream-compatible node and content identifiers.
 
+use std::collections::HashMap;
+
 use sha2::{Digest, Sha256};
 
 use crate::types::NodeKind;
@@ -19,6 +21,50 @@ pub fn generate_node_id(file_path: &str, kind: NodeKind, name: &str, line: u32)
     format!("{}:{}", kind, &hex[..32])
 }
 
+/// Per-extraction node identities (upstream `NodeIdAllocator`, #1349).
+///
+/// A declaration keeps its [`generate_node_id`] identity unless an EARLIER
+/// declaration of the same extraction already holds that identity at a
+/// different source position — a same-kind, same-name declaration on the same
+/// line, such as a getter/setter pair. The later one then appends
+/// `:{column}`, its zero-based UTF-16 column, instead of overwriting the first
+/// in the store. Revisiting a declaration yields the identity it had.
+#[derive(Debug, Default)]
+pub struct NodeIdAllocator {
+    first_columns: HashMap<String, u32>,
+}
+
+impl NodeIdAllocator {
+    /// The identity of the declaration of `kind`/`name` at `line` (1-based)
+    /// and `utf16_column` (0-based UTF-16 code units).
+    pub fn generate(
+        &mut self,
+        file_path: &str,
+        kind: NodeKind,
+        name: &str,
+        line: u32,
+        utf16_column: u32,
+    ) -> String {
+        let id = generate_node_id(file_path, kind, name, line);
+        let first = *self.first_columns.entry(id.clone()).or_insert(utf16_column);
+        if first == utf16_column {
+            id
+        } else {
+            format!("{id}:{utf16_column}")
+        }
+    }
+}
+
+/// Zero-based UTF-16 column of byte offset `byte` in `source` — the column
+/// unit upstream's identities use, never tree-sitter's byte column.
+pub fn utf16_column(source: &str, byte: usize) -> u32 {
+    let byte = byte.min(source.len());
+    let line_start = source[..byte].rfind('\n').map_or(0, |newline| newline + 1);
+    source
+        .get(line_start..byte)
+        .map_or(0, |prefix| prefix.encode_utf16().count() as u32)
+}
+
 /// Generate the literal file-node ID used by the upstream tree-sitter extractor.
 pub fn file_node_id(file_path: &str) -> String {
     format!("file:{file_path}")
@@ -49,6 +95,39 @@ mod tests {
 
     use super::*;
 
+    #[test]
+    fn collisions_only_suffix_later_distinct_columns() {
+        // Upstream kernel `collision_only_identity_vectors`.
+        let mut ids = NodeIdAllocator::default();
+        let base = generate_node_id("src/a.ts", NodeKind::Function, "foo", 3);
+        for (column, expected) in [
+            (2, base.clone()),
+            (24, format!("{base}:24")),
+            (48, format!("{base}:48")),
+            (24, format!("{base}:24")),
+            (2, base.clone()),
+        ] {
+            assert_eq!(
+                ids.generate("src/a.ts", NodeKind::Function, "foo", 3, column),
+                expected
+            );
+        }
+        assert_eq!(
+            ids.generate("src/a.ts", NodeKind::Function, "bar", 3, 24),
+            generate_node_id("src/a.ts", NodeKind::Function, "bar", 3)
+        );
+    }
+
+    #[test]
+    fn utf16_columns_count_code_units_from_the_line_start() {
+        let source = "x\n/* é😀 */ set";
+        let byte = source.find("set").unwrap();
+        // `/* ` 3, `é` 1, `😀` 2, ` */ ` 4.
+        assert_eq!(utf16_column(source, byte), 10);
+        assert_eq!(utf16_column(source, 0), 0);
+        assert_eq!(utf16_column("ab", 99), 2);
+    }
+
     #[derive(Debug, Deserialize)]
     struct GoldenNode {
         id: String,
diff --git a/crates/codegraph-extract/src/embedded/liquid.rs b/crates/codegraph-extract/src/embedded/liquid.rs
index 55472674..05957051 100644
--- a/crates/codegraph-extract/src/embedded/liquid.rs
+++ b/crates/codegraph-extract/src/embedded/liquid.rs
@@ -1,4 +1,7 @@
-use codegraph_core::types::{EdgeKind, ExtractionResult, Language, NodeKind};
+use std::cell::RefCell;
+
+use codegraph_core::node_id::{NodeIdAllocator, utf16_column};
+use codegraph_core::types::{EdgeKind, ExtractionResult, Language, Node, NodeKind};
 use regex::Regex;
 
 use crate::embedded::shared::{
@@ -10,6 +13,7 @@ pub struct LiquidExtractor<'a> {
     file_path: &'a str,
     source: &'a str,
     line_starts: Vec<usize>,
+    node_ids: RefCell<NodeIdAllocator>,
 }
 
 impl<'a> LiquidExtractor<'a> {
@@ -18,9 +22,24 @@ impl<'a> LiquidExtractor<'a> {
             file_path,
             source,
             line_starts: line_starts(source),
+            node_ids: RefCell::new(NodeIdAllocator::default()),
         }
     }
 
+    /// Identify `node`, created at byte `offset`, through the per-file
+    /// allocator: a later same-kind, same-name node on the same line gains a
+    /// column suffix instead of overwriting the first (#1349).
+    fn identify(&self, mut node: Node, offset: usize) -> Node {
+        node.id = self.node_ids.borrow_mut().generate(
+            self.file_path,
+            node.kind,
+            &node.name,
+            node.start_line.max(1) as u32,
+            utf16_column(self.source, offset),
+        );
+        node
+    }
+
     pub fn extract(self) -> ExtractionResult {
         let start = std::time::Instant::now();
         let mut result = empty_result(0);
@@ -73,17 +92,20 @@ impl<'a> LiquidExtractor<'a> {
             let name = cap.get(2).unwrap().as_str();
             let line = line_number_for_offset(&self.line_starts, full.start());
             let col = full.start() as i64 - line_start_for(&self.line_starts, line) as i64;
-            self.push_import_node(result, file_id, name, full.as_str(), line, col);
-            let node = default_node(
-                self.file_path,
-                Language::Liquid,
-                NodeKind::Component,
-                name.to_string(),
-                format!("{}::{}:{}", self.file_path, tag_type, name),
-                line,
-                line,
-                col,
-                col + full.as_str().len() as i64,
+            self.push_import_node(result, file_id, name, full.as_str(), full.start());
+            let node = self.identify(
+                default_node(
+                    self.file_path,
+                    Language::Liquid,
+                    NodeKind::Component,
+                    name.to_string(),
+                    format!("{}::{}:{}", self.file_path, tag_type, name),
+                    line,
+                    line,
+                    col,
+                    col + full.as_str().len() as i64,
+                ),
+                full.start(),
             );
             let node_id = node.id.clone();
             result.nodes.push(node);
@@ -107,17 +129,20 @@ impl<'a> LiquidExtractor<'a> {
             let name = cap.get(1).unwrap().as_str();
             let line = line_number_for_offset(&self.line_starts, full.start());
             let col = full.start() as i64 - line_start_for(&self.line_starts, line) as i64;
-            self.push_import_node(result, file_id, name, full.as_str(), line, col);
-            let node = default_node(
-                self.file_path,
-                Language::Liquid,
-                NodeKind::Component,
-                name.to_string(),
-                format!("{}::section:{}", self.file_path, name),
-                line,
-                line,
-                col,
-                col + full.as_str().len() as i64,
+            self.push_import_node(result, file_id, name, full.as_str(), full.start());
+            let node = self.identify(
+                default_node(
+                    self.file_path,
+                    Language::Liquid,
+                    NodeKind::Component,
+                    name.to_string(),
+                    format!("{}::section:{}", self.file_path, name),
+                    line,
+                    line,
+                    col,
+                    col + full.as_str().len() as i64,
+                ),
+                full.start(),
             );
             let node_id = node.id.clone();
             result.nodes.push(node);
@@ -143,16 +168,19 @@ impl<'a> LiquidExtractor<'a> {
             let start_line = line_number_for_offset(&self.line_starts, full.start());
             let end_line = line_number_for_offset(&self.line_starts, full.end());
             let schema_name = schema_name(content);
-            let mut node = default_node(
-                self.file_path,
-                Language::Liquid,
-                NodeKind::Constant,
-                schema_name.clone(),
-                format!("{}::schema:{}", self.file_path, schema_name),
-                start_line,
-                end_line,
-                full.start() as i64 - line_start_for(&self.line_starts, start_line) as i64,
-                0,
+            let mut node = self.identify(
+                default_node(
+                    self.file_path,
+                    Language::Liquid,
+                    NodeKind::Constant,
+                    schema_name.clone(),
+                    format!("{}::schema:{}", self.file_path, schema_name),
+                    start_line,
+                    end_line,
+                    full.start() as i64 - line_start_for(&self.line_starts, start_line) as i64,
+                    0,
+                ),
+                full.start(),
             );
             node.docstring = None;
             let node_id = node.id.clone();
@@ -168,16 +196,19 @@ impl<'a> LiquidExtractor<'a> {
             let name = cap.get(1).unwrap().as_str();
             let line = line_number_for_offset(&self.line_starts, full.start());
             let col = full.start() as i64 - line_start_for(&self.line_starts, line) as i64;
-            let node = default_node(
-                self.file_path,
-                Language::Liquid,
-                NodeKind::Variable,
-                name.to_string(),
-                format!("{}::{}", self.file_path, name),
-                line,
-                line,
-                col,
-                col + full.as_str().len() as i64,
+            let node = self.identify(
+                default_node(
+                    self.file_path,
+                    Language::Liquid,
+                    NodeKind::Variable,
+                    name.to_string(),
+                    format!("{}::{}", self.file_path, name),
+                    line,
+                    line,
+                    col,
+                    col + full.as_str().len() as i64,
+                ),
+                full.start(),
             );
             let node_id = node.id.clone();
             result.nodes.push(node);
@@ -191,19 +222,23 @@ impl<'a> LiquidExtractor<'a> {
         file_id: &str,
         name: &str,
         signature: &str,
-        line: i64,
-        col: i64,
+        offset: usize,
     ) {
-        let mut node = default_node(
-            self.file_path,
-            Language::Liquid,
-            NodeKind::Import,
-            name.to_string(),
-            format!("{}::import:{}", self.file_path, name),
-            line,
-            line,
-            col,
-            col + signature.len() as i64,
+        let line = line_number_for_offset(&self.line_starts, offset);
+        let col = offset as i64 - line_start_for(&self.line_starts, line) as i64;
+        let mut node = self.identify(
+            default_node(
+                self.file_path,
+                Language::Liquid,
+                NodeKind::Import,
+                name.to_string(),
+                format!("{}::import:{}", self.file_path, name),
+                line,
+                line,
+                col,
+                col + signature.len() as i64,
+            ),
+            offset,
         );
         node.signature = Some(signature.to_string());
         let node_id = node.id.clone();
diff --git a/crates/codegraph-extract/src/walker.rs b/crates/codegraph-extract/src/walker.rs
index 623baa15..10f384e1 100644
--- a/crates/codegraph-extract/src/walker.rs
+++ b/crates/codegraph-extract/src/walker.rs
@@ -5,7 +5,7 @@
 //! `:580-650` becomes [`TreeSitterWalker::create_node`], `:748-983` maps to
 //! symbol extractors, and `:1872-2632` maps to import/call reference extraction.
 
-use codegraph_core::node_id::{file_node_id, generate_node_id};
+use codegraph_core::node_id::{NodeIdAllocator, file_node_id, utf16_column};
 use codegraph_core::types::{
     Edge, EdgeKind, ExtractionResult, Language, Node, NodeKind, ReferenceSubkind, UnresolvedRef,
 };
@@ -320,6 +320,8 @@ pub struct TreeSitterWalker<'a, 'tree> {
     unresolved_references: Vec<UnresolvedRef>,
     errors: Vec<String>,
     node_stack: Vec<String>,
+    /// Same-line, same-name declarations keep distinct identities (#1349).
+    node_ids: NodeIdAllocator,
     fn_ref_candidates: Vec<(crate::function_ref::FnRefCandidate, String)>,
     /// C++ enclosing `namespace ns { … }` names, prefixed onto contained
     /// symbols' `qualified_name`. Prefix-only (no namespace node) to avoid the
@@ -361,6 +363,7 @@ impl<'a, 'tree> TreeSitterWalker<'a, 'tree> {
             unresolved_references: Vec::new(),
             errors: Vec::new(),
             node_stack: Vec::new(),
+            node_ids: NodeIdAllocator::default(),
             fn_ref_candidates: Vec::new(),
             namespace_prefix: Vec::new(),
             erlang_last_fn_name: None,
@@ -2305,7 +2308,13 @@ impl<'a, 'tree> TreeSitterWalker<'a, 'tree> {
         }
 
         let start_line = node.start_position().row as u32 + 1;
-        let id = generate_node_id(self.file_path, kind, name, start_line);
+        let id = self.node_ids.generate(
+            self.file_path,
+            kind,
+            name,
+            start_line,
+            utf16_column(self.source, node.start_byte()),
+        );
         let mut new_node = Node {
             id: id.clone(),
             kind,
diff --git a/crates/codegraph-extract/tests/node_identity.rs b/crates/codegraph-extract/tests/node_identity.rs
new file mode 100644
index 00000000..b8ac6606
--- /dev/null
+++ b/crates/codegraph-extract/tests/node_identity.rs
@@ -0,0 +1,129 @@
+//! Same-line node identity (upstream v1.6.1 #1349).
+//!
+//! Same-kind, same-name declarations on one line used to share one node id, so
+//! the later silently replaced the earlier in the store. The first keeps its
+//! legacy id; a later distinct declaration appends `:{utf16Column}`.
+
+use codegraph_core::node_id::{generate_node_id, utf16_column};
+use codegraph_core::types::{EdgeKind, ExtractionResult, Language, Node, NodeKind};
+use codegraph_extract::extract_source;
+
+fn extract(file: &str, source: &str, language: Language) -> ExtractionResult {
+    let result = extract_source(file, source, Some(language));
+    assert!(result.errors.is_empty(), "{file}: {:?}", result.errors);
+    result
+}
+
+fn named<'a>(result: &'a ExtractionResult, name: &str, kind: NodeKind) -> Vec<&'a Node> {
+    let mut nodes = result
+        .nodes
+        .iter()
+        .filter(|node| node.name == name && node.kind == kind)
+        .collect::<Vec<_>>();
+    nodes.sort_by_key(|node| (node.start_line, node.start_column));
+    nodes
+}
+
+#[test]
+fn same_line_accessors_keep_distinct_identities_after_unicode() {
+    let source = "class Point { /* é😀 */ get x() { return read(); } set x(v) { write(v); } }";
+    let setter = utf16_column(source, source.find("set x").expect("setter"));
+    for (file, language) in [
+        ("point.ts", Language::TypeScript),
+        ("point.tsx", Language::Tsx),
+        ("point.js", Language::JavaScript),
+        ("point.jsx", Language::Jsx),
+    ] {
+        let result = extract(file, source, language);
+        let x = named(&result, "x", NodeKind::Method);
+        assert_eq!(x.len(), 2, "{file}: {:#?}", result.nodes);
+        assert_eq!(
+            x[0].id,
+            generate_node_id(file, NodeKind::Method, "x", 1),
+            "{file}"
+        );
+        assert_eq!(x[1].id, format!("{}:{setter}", x[0].id), "{file}");
+        let calls = result
+            .unresolved_references
+            .iter()
+            .filter(|reference| reference.reference_kind == EdgeKind::Calls)
+            .map(|reference| {
+                (
+                    reference.from_node_id.as_str(),
+                    reference.reference_name.as_str(),
+                )
+            })
+            .collect::<Vec<_>>();
+        assert_eq!(
+            calls,
+            vec![(x[0].id.as_str(), "read"), (x[1].id.as_str(), "write")],
+            "{file}"
+        );
+        // No state leaks between files or repeated extractions.
+        assert_eq!(
+            extract(file, source, language).nodes,
+            result.nodes,
+            "{file}"
+        );
+    }
+}
+
+#[test]
+fn distinct_lines_and_names_keep_their_legacy_ids() {
+    let source = "export class Point {\n  get y() { return 1; }\n  set y(v: number) {}\n}\n";
+    let result = extract("point.ts", source, Language::TypeScript);
+    for node in result
+        .nodes
+        .iter()
+        .filter(|node| node.kind != NodeKind::File)
+    {
+        assert_eq!(
+            node.id,
+            generate_node_id(
+                &node.file_path,
+                node.kind,
+                &node.name,
+                node.start_line as u32
+            ),
+            "{}",
+            node.name
+        );
+    }
+    assert_eq!(named(&result, "y", NodeKind::Method).len(), 2);
+}
+
+#[test]
+fn repeated_same_line_liquid_and_cfml_declarations_survive() {
+    let liquid = extract(
+        "template.liquid",
+        "é😀 {% render \"x\" %}{% render \"x\" %}{% assign v = 1 %}{% assign v = 2 %}",
+        Language::Liquid,
+    );
+    for (name, kind) in [
+        ("x", NodeKind::Component),
+        ("x", NodeKind::Import),
+        ("v", NodeKind::Variable),
+    ] {
+        let nodes = named(&liquid, name, kind);
+        assert_eq!(nodes.len(), 2, "{kind:?} {name}: {:#?}", liquid.nodes);
+        assert_ne!(nodes[0].id, nodes[1].id, "{kind:?} {name}");
+        for node in nodes {
+            assert!(
+                liquid
+                    .edges
+                    .iter()
+                    .any(|edge| edge.kind == EdgeKind::Contains && edge.target == node.id),
+                "{kind:?} {name} has no contains edge"
+            );
+        }
+    }
+
+    let cfml = extract(
+        "Service.cfc",
+        "<cfcomponent><!--- é😀 ---><cffunction name=\"x\"></cffunction><cffunction name=\"x\"></cffunction></cfcomponent>",
+        Language::Cfml,
+    );
+    let methods = named(&cfml, "x", NodeKind::Method);
+    assert_eq!(methods.len(), 2, "{:#?}", cfml.nodes);
+    assert_ne!(methods[0].id, methods[1].id);
+}
diff --git a/crates/codegraph-resolve/tests/js_resolution_safety.rs b/crates/codegraph-resolve/tests/js_resolution_safety.rs
index ebb94c96..ceaa5669 100644
--- a/crates/codegraph-resolve/tests/js_resolution_safety.rs
+++ b/crates/codegraph-resolve/tests/js_resolution_safety.rs
@@ -620,3 +620,60 @@ fn implements_whose_only_same_named_target_is_a_value_is_dropped() {
     );
     assert!(implements_targets(&project, "BarService").is_empty());
 }
+
+#[test]
+fn same_line_accessors_persist_with_their_own_call_edges() {
+    // Upstream #1349: the getter and setter share kind, name and line; before
+    // the column suffix the setter overwrote the getter in the store.
+    let project = resolve_project(
+        "same-line-accessors",
+        &[(
+            "point.ts",
+            "function read() { return 1; } function write(v: number) {}\n\
+             export class Point { /* é😀 */ get x() { return read(); } set x(v: number) { write(v); }\n\
+             \x20 get y() { return read(); }\n\
+             \x20 set y(v: number) { write(v); }\n\
+             }\n",
+        )],
+    );
+    let store = project.store.as_ref().expect("store");
+    let nodes = store.nodes_by_file_path("point.ts").expect("nodes");
+    let mut x = nodes
+        .iter()
+        .filter(|node| node.name == "x")
+        .collect::<Vec<_>>();
+    x.sort_by_key(|node| node.start_column);
+    assert_eq!(x.len(), 2, "{nodes:#?}");
+    let ids = nodes
+        .iter()
+        .map(|node| node.id.as_str())
+        .collect::<std::collections::BTreeSet<_>>();
+    assert_eq!(ids.len(), nodes.len());
+    assert_eq!(nodes.iter().filter(|node| node.name == "y").count(), 2);
+    let class = nodes
+        .iter()
+        .find(|node| node.name == "Point")
+        .expect("class");
+    for accessor in &x {
+        assert!(
+            store
+                .edges_by_target_kind(&accessor.id, Some(EdgeKind::Contains))
+                .expect("contains")
+                .iter()
+                .any(|edge| edge.source == class.id),
+            "{}",
+            accessor.id
+        );
+    }
+    let callee_names = |id: &str| {
+        store
+            .edges_by_source_kind(id, Some(EdgeKind::Calls))
+            .expect("calls")
+            .into_iter()
+            .filter_map(|edge| store.node_by_id(&edge.target).expect("target"))
+            .map(|node| node.name)
+            .collect::<Vec<_>>()
+    };
+    assert_eq!(callee_names(&x[0].id), vec!["read"]);
+    assert_eq!(callee_names(&x[1].id), vec!["write"]);
+}
diff --git a/crates/codegraph-store/src/index_state.rs b/crates/codegraph-store/src/index_state.rs
index 9a183410..08aa794a 100644
--- a/crates/codegraph-store/src/index_state.rs
+++ b/crates/codegraph-store/src/index_state.rs
@@ -115,7 +115,7 @@ pub const CURRENT_STORAGE_PROTOCOL: u64 = 2;
 
 /// The extraction-pipeline version this binary produces. This is the single
 /// source of truth: no other crate may define its own copy.
-pub const CURRENT_EXTRACTION_VERSION: u64 = 14;
+pub const CURRENT_EXTRACTION_VERSION: u64 = 15;
 
 /// The `project_metadata` key under which a built index records the extraction
 /// version it was produced with. Single source of truth for the key spelling.
diff --git a/crates/codegraph-store/tests/index_state.rs b/crates/codegraph-store/tests/index_state.rs
index 5b6cf64f..df760d91 100644
--- a/crates/codegraph-store/tests/index_state.rs
+++ b/crates/codegraph-store/tests/index_state.rs
@@ -119,7 +119,7 @@ fn assert_corrupt(
 fn index_state_constants_and_canonical_payload_are_exact() {
     /// The extraction version the immediately preceding release wrote. Read from
     /// `index_state.rs` at implementation time; see plan decision C1 step 0.
-    const PREVIOUS_EXTRACTION_VERSION: u64 = 13;
+    const PREVIOUS_EXTRACTION_VERSION: u64 = 14;
 
     assert_eq!(CURRENT_STORAGE_PROTOCOL, 2);
     assert_eq!(CURRENT_EXTRACTION_VERSION, PREVIOUS_EXTRACTION_VERSION + 1);
diff --git a/docs/equivalence.md b/docs/equivalence.md
index fbb4e3c2..4b796238 100644
--- a/docs/equivalence.md
+++ b/docs/equivalence.md
@@ -41,6 +41,14 @@ Inputs are part of the compatibility contract:
 - `line`: 1-based start line. The tree-sitter call site passes
   `node.startPosition.row + 1`.
 
+Same-kind, same-name declarations on one line (a getter/setter pair) hash to
+the same id. Since extraction version 15 the first one, in extraction order,
+keeps it, and every later declaration at a different column appends
+`:{column}`, its zero-based UTF-16 column — the column unit upstream uses, not
+tree-sitter's byte column (`NodeIdAllocator`, upstream #1349). Revisiting the
+same declaration yields the same id, so a declaration that collides with
+nothing keeps exactly the id above.
+
 ## File Node Special Case
 
 Tree-sitter file nodes do not call `generateNodeId()`. The tree-sitter file-node special case uses the literal ID:

From c1c4d8a5d90698690411a6fca66256d7aa0790a7 Mon Sep 17 00:00:00 2001
From: CodeGraph Test <codegraph@example.invalid>
Date: Thu, 1 Oct 2026 08:20:19 +0800
Subject: [PATCH 2/6] fix(graph): re-expand a node reached nearer than before
 in depth-limited walks
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

callers, callees and impact are depth-limited DFS walks. A node first
expanded through a longer path was never expanded again when a nearer
path reached it, so its own dependents within the limit were lost to edge
order — impact at depth 2 already, callers and callees from depth 3. The
walks now record the shallowest depth each node was expanded at and expand
it again from a nearer depth (upstream #1974). Each (node, edge kind) is
reported once per walk, keeping multi-kind rows while no longer repeating
a node once per parent, and impact records a node's edges on its first
expansion only.
---
 crates/codegraph-graph/src/graph/mod.rs   | 172 +++++++++++++++-------
 crates/codegraph-graph/tests/traversal.rs | 136 +++++++++++++++++
 2 files changed, 252 insertions(+), 56 deletions(-)

diff --git a/crates/codegraph-graph/src/graph/mod.rs b/crates/codegraph-graph/src/graph/mod.rs
index 4e856e73..58dd29e5 100644
--- a/crates/codegraph-graph/src/graph/mod.rs
+++ b/crates/codegraph-graph/src/graph/mod.rs
@@ -375,8 +375,16 @@ impl<'store> GraphTraverser<'store> {
     /// cycle-safe via `visited`.
     pub fn get_callers(&self, node_id: &str, max_depth: usize) -> rusqlite::Result<Vec<NodeEdge>> {
         let mut result = Vec::new();
-        let mut visited = HashSet::new();
-        self.callers_recursive(node_id, max_depth, 0, &mut result, &mut visited)?;
+        let mut visited = HashMap::new();
+        let mut reported = HashSet::new();
+        self.callers_recursive(
+            node_id,
+            max_depth,
+            0,
+            &mut result,
+            &mut visited,
+            &mut reported,
+        )?;
         Ok(result)
     }
 
@@ -386,12 +394,12 @@ impl<'store> GraphTraverser<'store> {
         max_depth: usize,
         current_depth: usize,
         result: &mut Vec<NodeEdge>,
-        visited: &mut HashSet<String>,
+        visited: &mut HashMap<String, usize>,
+        reported: &mut HashSet<(String, EdgeKind)>,
     ) -> rusqlite::Result<()> {
-        if current_depth >= max_depth || visited.contains(node_id) {
+        if current_depth >= max_depth || !enter_at_depth(visited, node_id, current_depth) {
             return Ok(());
         }
-        visited.insert(node_id.to_string());
 
         let incoming = self.incoming_edges_kinds(
             node_id,
@@ -404,26 +412,27 @@ impl<'store> GraphTraverser<'store> {
         let source_ids: Vec<String> = incoming.iter().map(|e| e.source.clone()).collect();
         let caller_nodes = self.store.nodes_by_ids(&source_ids)?;
 
-        // #1087 vs #1088: emit one NodeEdge per DISTINCT (caller, edge-kind) so a
-        // caller linked by several kinds (Calls AND References) surfaces BOTH
+        // #1087 vs #1088: report one NodeEdge per DISTINCT (caller, edge-kind) so
+        // a caller linked by several kinds (Calls AND References) surfaces BOTH
         // (#1087), while repeated SAME-kind sites of one caller still collapse to
-        // a single row (#1088). `visited` gates only the RECURSION (cycle safety),
-        // never the emission — so the node is still walked at most once.
-        let mut emitted: HashSet<(String, EdgeKind)> = HashSet::new();
+        // a single row (#1088) — across the whole walk, not per parent. `visited`
+        // gates only the RECURSION: a caller is expanded again only when a
+        // nearer path reaches it (#1974).
         for edge in incoming {
             if let Some(caller) = caller_nodes.get(&edge.source) {
-                if !emitted.insert((caller.id.clone(), edge.kind)) {
-                    continue;
-                }
-                let recurse = !visited.contains(&caller.id);
                 let caller_id = caller.id.clone();
                 let next_depth = current_depth + 1;
-                result.push(NodeEdge {
-                    node: caller.clone(),
-                    edge,
-                });
+                let recurse = nearer_than_before(visited, &caller_id, next_depth);
+                if reported.insert((caller_id.clone(), edge.kind)) {
+                    result.push(NodeEdge {
+                        node: caller.clone(),
+                        edge,
+                    });
+                }
                 if recurse {
-                    self.callers_recursive(&caller_id, max_depth, next_depth, result, visited)?;
+                    self.callers_recursive(
+                        &caller_id, max_depth, next_depth, result, visited, reported,
+                    )?;
                 }
             }
         }
@@ -496,8 +505,16 @@ impl<'store> GraphTraverser<'store> {
     /// cycle-safe via `visited`.
     pub fn get_callees(&self, node_id: &str, max_depth: usize) -> rusqlite::Result<Vec<NodeEdge>> {
         let mut result = Vec::new();
-        let mut visited = HashSet::new();
-        self.callees_recursive(node_id, max_depth, 0, &mut result, &mut visited)?;
+        let mut visited = HashMap::new();
+        let mut reported = HashSet::new();
+        self.callees_recursive(
+            node_id,
+            max_depth,
+            0,
+            &mut result,
+            &mut visited,
+            &mut reported,
+        )?;
         Ok(result)
     }
 
@@ -507,12 +524,12 @@ impl<'store> GraphTraverser<'store> {
         max_depth: usize,
         current_depth: usize,
         result: &mut Vec<NodeEdge>,
-        visited: &mut HashSet<String>,
+        visited: &mut HashMap<String, usize>,
+        reported: &mut HashSet<(String, EdgeKind)>,
     ) -> rusqlite::Result<()> {
-        if current_depth >= max_depth || visited.contains(node_id) {
+        if current_depth >= max_depth || !enter_at_depth(visited, node_id, current_depth) {
             return Ok(());
         }
-        visited.insert(node_id.to_string());
 
         let outgoing = self.outgoing_edges_kinds(
             node_id,
@@ -526,23 +543,24 @@ impl<'store> GraphTraverser<'store> {
         let callee_nodes = self.store.nodes_by_ids(&target_ids)?;
 
         // #1087 vs #1088: mirror of `callers_recursive` — one NodeEdge per
-        // DISTINCT (callee, edge-kind) keeps multi-kind pairs while collapsing
-        // repeated same-kind sites; `visited` gates only recursion.
-        let mut emitted: HashSet<(String, EdgeKind)> = HashSet::new();
+        // DISTINCT (callee, edge-kind) across the walk keeps multi-kind pairs
+        // while collapsing repeated same-kind sites; `visited` gates only
+        // recursion, by shallowest expansion depth (#1974).
         for edge in outgoing {
             if let Some(callee) = callee_nodes.get(&edge.target) {
-                if !emitted.insert((callee.id.clone(), edge.kind)) {
-                    continue;
-                }
-                let recurse = !visited.contains(&callee.id);
                 let callee_id = callee.id.clone();
                 let next_depth = current_depth + 1;
-                result.push(NodeEdge {
-                    node: callee.clone(),
-                    edge,
-                });
+                let recurse = nearer_than_before(visited, &callee_id, next_depth);
+                if reported.insert((callee_id.clone(), edge.kind)) {
+                    result.push(NodeEdge {
+                        node: callee.clone(),
+                        edge,
+                    });
+                }
                 if recurse {
-                    self.callees_recursive(&callee_id, max_depth, next_depth, result, visited)?;
+                    self.callees_recursive(
+                        &callee_id, max_depth, next_depth, result, visited, reported,
+                    )?;
                 }
             }
         }
@@ -696,10 +714,18 @@ impl<'store> GraphTraverser<'store> {
         };
 
         let mut graph = Subgraph::empty();
-        let mut visited = HashSet::new();
+        let mut visited = HashMap::new();
+        let mut expanded = HashSet::new();
         graph.set_node(focal);
 
-        self.impact_recursive(node_id, max_depth, 0, &mut graph, &mut visited)?;
+        self.impact_recursive(
+            node_id,
+            max_depth,
+            0,
+            &mut graph,
+            &mut visited,
+            &mut expanded,
+        )?;
 
         graph.roots = vec![node_id.to_string()];
         Ok(graph)
@@ -711,12 +737,15 @@ impl<'store> GraphTraverser<'store> {
         max_depth: usize,
         current_depth: usize,
         graph: &mut Subgraph,
-        visited: &mut HashSet<String>,
+        visited: &mut HashMap<String, usize>,
+        expanded: &mut HashSet<String>,
     ) -> rusqlite::Result<()> {
-        if current_depth >= max_depth || visited.contains(node_id) {
+        if current_depth >= max_depth || !enter_at_depth(visited, node_id, current_depth) {
             return Ok(());
         }
-        visited.insert(node_id.to_string());
+        // A node re-expanded from a nearer depth re-reads the same edges;
+        // record them on its first expansion only (#1974).
+        let first_expansion = expanded.insert(node_id.to_string());
 
         if let Some(focal) = self.store.node_by_id(node_id)?
             && CONTAINER_KINDS.contains(&focal.kind)
@@ -731,13 +760,22 @@ impl<'store> GraphTraverser<'store> {
                 )?;
                 for edge in contains {
                     if let Some(child) = children.get(&edge.target)
-                        && !visited.contains(&child.id)
+                        && nearer_than_before(visited, &child.id, current_depth)
                     {
-                        let child = child.clone();
                         let child_id = child.id.clone();
-                        graph.set_node(child);
-                        graph.edges.push(edge);
-                        self.impact_recursive(&child_id, max_depth, current_depth, graph, visited)?;
+                        if !graph.nodes.contains_key(&child_id) {
+                            graph.set_node(child.clone());
+                            graph.edges.push(edge);
+                        }
+                        // Children are part of the same symbol: same depth.
+                        self.impact_recursive(
+                            &child_id,
+                            max_depth,
+                            current_depth,
+                            graph,
+                            visited,
+                            expanded,
+                        )?;
                     }
                 }
             }
@@ -760,20 +798,23 @@ impl<'store> GraphTraverser<'store> {
 
         for edge in incoming {
             if let Some(source) = sources.get(&edge.source) {
-                // #1086: the direct-dependency edge is recorded unconditionally —
-                // even when `source` is already in the subgraph via another path,
-                // the edge between the two endpoints is a real dependency and must
-                // survive. Only the NODE addition + recursion is guarded so we
-                // neither duplicate the node nor re-walk an already-visited source.
-                let already_present = graph.nodes.contains_key(&source.id);
+                // #1086: the direct-dependency edge is recorded even when
+                // `source` is already in the subgraph via another path — it is a
+                // real dependency — but only on this node's first expansion, so
+                // a re-expansion never repeats it. A source is walked again only
+                // when this path reaches it nearer than before (#1974).
                 let source_id = source.id.clone();
                 let next_depth = current_depth + 1;
-                if !already_present {
+                if !graph.nodes.contains_key(&source_id) {
                     graph.set_node(source.clone());
                 }
-                graph.edges.push(edge);
-                if !already_present {
-                    self.impact_recursive(&source_id, max_depth, next_depth, graph, visited)?;
+                if first_expansion {
+                    graph.edges.push(edge);
+                }
+                if nearer_than_before(visited, &source_id, next_depth) {
+                    self.impact_recursive(
+                        &source_id, max_depth, next_depth, graph, visited, expanded,
+                    )?;
                 }
             }
         }
@@ -1378,6 +1419,25 @@ fn unvisited_neighbor_ids(edges: &[Edge], node_id: &str, visited: &HashSet<Strin
         .collect()
 }
 
+/// Whether `depth` is nearer than any depth `node_id` was expanded at.
+/// Depth-limited walks record the SHALLOWEST depth each node was expanded at,
+/// so a node first reached through a longer path is expanded again when a
+/// nearer path reaches it, and its own dependents within the limit are not lost
+/// to edge order (upstream #1974).
+fn nearer_than_before(visited: &HashMap<String, usize>, node_id: &str, depth: usize) -> bool {
+    visited.get(node_id).is_none_or(|&seen| depth < seen)
+}
+
+/// Record that `node_id` is expanded at `depth`; false when it already was at
+/// this depth or nearer.
+fn enter_at_depth(visited: &mut HashMap<String, usize>, node_id: &str, depth: usize) -> bool {
+    if !nearer_than_before(visited, node_id, depth) {
+        return false;
+    }
+    visited.insert(node_id.to_string(), depth);
+    true
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/codegraph-graph/tests/traversal.rs b/crates/codegraph-graph/tests/traversal.rs
index 00a27ecb..96ab28ae 100644
--- a/crates/codegraph-graph/tests/traversal.rs
+++ b/crates/codegraph-graph/tests/traversal.rs
@@ -1166,3 +1166,139 @@ fn callers_dedup_same_kind_multiple_sites_counted_once() {
         "same-kind repeated call site must dedup to one — #1088 (callers: {callers:?})"
     );
 }
+
+// ---- shallowest-depth expansion (#1974) -------------------------------------
+
+/// A store over function nodes `ids` and `calls` edges `(source, target)` in
+/// insertion order — the order the traversal reads them back.
+fn depth_store(test_name: &str, ids: &[&str], calls: &[(&str, &str)]) -> Store {
+    let mut store = Store::open(&temp_db_path(test_name)).expect("open store");
+    let nodes = ids
+        .iter()
+        .enumerate()
+        .map(|(line, id)| {
+            node(
+                &format!("function:{id}"),
+                NodeKind::Function,
+                id,
+                id,
+                "src/depth.ts",
+                Language::TypeScript,
+                line as i64 + 1,
+                line as i64 + 1,
+            )
+        })
+        .collect::<Vec<_>>();
+    store.upsert_nodes(&nodes).expect("insert nodes");
+    let edges = calls
+        .iter()
+        .enumerate()
+        .map(|(line, (source, target))| {
+            edge(
+                &format!("function:{source}"),
+                &format!("function:{target}"),
+                EdgeKind::Calls,
+                Some(line as i64 + 1),
+                Some(0),
+            )
+        })
+        .collect::<Vec<_>>();
+    store.insert_edges(&edges).expect("insert edges");
+    store
+}
+
+fn names(rows: &[codegraph_graph::graph::NodeEdge]) -> Vec<String> {
+    let mut names = rows
+        .iter()
+        .map(|row| row.node.name.clone())
+        .collect::<Vec<_>>();
+    names.sort();
+    names
+}
+
+#[test]
+fn impact_keeps_dependents_reached_first_through_a_longer_path() {
+    // The issue's graph: a→t, b→a, b→t, c→b. Edge order sends the walk to b
+    // through a first, before the direct b→t edge (upstream #1974).
+    let store = depth_store(
+        "impact-1974",
+        &["t", "a", "b", "c"],
+        &[("a", "t"), ("b", "a"), ("b", "t"), ("c", "b")],
+    );
+    let impact = GraphTraverser::new(&store)
+        .get_impact_radius("function:t", 2)
+        .expect("impact");
+    assert_eq!(
+        id_set(impact.nodes.keys().cloned()),
+        id_set(["a", "b", "c", "t"].map(|id| format!("function:{id}")))
+    );
+    assert!(
+        impact
+            .edges
+            .iter()
+            .any(|edge| edge.source == "function:c" && edge.target == "function:b")
+    );
+    let keys = impact
+        .edges
+        .iter()
+        .map(|edge| format!("{}>{}:{:?}", edge.source, edge.target, edge.line))
+        .collect::<Vec<_>>();
+    assert_eq!(
+        keys.iter().collect::<BTreeSet<_>>().len(),
+        keys.len(),
+        "re-expansion must not record an edge twice: {keys:?}"
+    );
+}
+
+#[test]
+fn callers_and_callees_report_every_node_within_the_depth_once() {
+    let store = depth_store(
+        "callers-1974",
+        &["t", "a", "b", "c"],
+        &[("a", "t"), ("b", "a"), ("b", "t"), ("c", "b")],
+    );
+    let traverser = GraphTraverser::new(&store);
+    assert_eq!(
+        names(&traverser.get_callers("function:t", 2).expect("callers")),
+        vec!["a", "b", "c"]
+    );
+    // Mirror image: t→a, a→b, t→b, b→c.
+    let store = depth_store(
+        "callees-1974",
+        &["t", "a", "b", "c"],
+        &[("t", "a"), ("a", "b"), ("t", "b"), ("b", "c")],
+    );
+    assert_eq!(
+        names(
+            &GraphTraverser::new(&store)
+                .get_callees("function:t", 2)
+                .expect("callees")
+        ),
+        vec!["a", "b", "c"]
+    );
+}
+
+#[test]
+fn a_nearer_path_re_expands_a_node_first_expanded_deeper() {
+    // t ← a ← b ← x ← d, and t ← x directly; the a-path reaches x at depth 3
+    // first. With max depth 3, x is one hop from t, so its caller d (two hops)
+    // must be found — the loss the shallowest-depth rule exists to prevent.
+    let store = depth_store(
+        "nearer-1974",
+        &["t", "a", "b", "x", "d"],
+        &[("a", "t"), ("b", "a"), ("x", "b"), ("x", "t"), ("d", "x")],
+    );
+    let traverser = GraphTraverser::new(&store);
+    assert_eq!(
+        names(&traverser.get_callers("function:t", 3).expect("callers")),
+        vec!["a", "b", "d", "x"]
+    );
+    let impact = traverser
+        .get_impact_radius("function:t", 3)
+        .expect("impact");
+    assert!(
+        impact.nodes.contains_key("function:d"),
+        "{:?}",
+        impact.nodes.keys()
+    );
+}

From 13ee6397a4a790f4f51660a322d0a1a74886a88d Mon Sep 17 00:00:00 2001
From: CodeGraph Test <codegraph@example.invalid>
Date: Thu, 1 Oct 2026 08:31:04 +0800
Subject: [PATCH 3/6] fix(resolve): scope Python and Go method values by their
 receiver
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

pool.submit(self.store.fetch) and Submit(c.store.Fetch) pass a method as a
value. The extractor now keeps the whole receiver path (self.store.fetch,
c.store.Fetch, Actual.fetch) instead of a last segment or a this. marker,
and resolution follows upstream v1.6.1 #1820: self/cls resolve on the
enclosing class and its bases, a field on its annotated, constructed or
parameter-assigned type, a local on its annotation or constructor, an
imported class through the import, a Go receiver on its declared type or a
struct field's in-module type, and a method expression on its type; a
base-typed field reaches only that base's descendants. Otherwise a method
name binds only when it is unique across the project — test doubles and
abstract bases count. Data attributes, @property members, ambiguity and
unknowable receivers stay unlinked, and the capitalization heuristic is no
longer used for method values.
---
 crates/codegraph-extract/src/function_ref.rs  | 103 ++-
 .../tests/batch_coverage_languages3.rs        |   7 +-
 crates/codegraph-resolve/src/lib.rs           |   1 +
 crates/codegraph-resolve/src/member_value.rs  | 650 ++++++++++++++++++
 crates/codegraph-resolve/src/name_matcher.rs  |  15 +-
 crates/codegraph-resolve/src/resolver.rs      |  10 +
 crates/codegraph-resolve/src/source_facts.rs  |  13 +
 .../codegraph-resolve/tests/method_values.rs  | 455 ++++++++++++
 8 files changed, 1220 insertions(+), 34 deletions(-)
 create mode 100644 crates/codegraph-resolve/src/member_value.rs
 create mode 100644 crates/codegraph-resolve/tests/method_values.rs

diff --git a/crates/codegraph-extract/src/function_ref.rs b/crates/codegraph-extract/src/function_ref.rs
index 205bbdf2..3f17a202 100644
--- a/crates/codegraph-extract/src/function_ref.rs
+++ b/crates/codegraph-extract/src/function_ref.rs
@@ -183,7 +183,7 @@ const GO_SPEC: FnRefSpec = FnRefSpec {
     ],
     layers: &[("literal_element", None), ("expression_list", None)],
     unwrap: &[],
-    special: &[],
+    special: &["selector_expression"],
     ungated_modes: &[],
     address_of_only: false,
 };
@@ -573,6 +573,33 @@ impl<'tree> NormalizedRef<'tree> {
             skip_gate: false,
         }
     }
+
+    /// A Python/Go member value: it retains its receiver for scoped
+    /// resolution, so the same-file/import name gate does not apply.
+    fn ungated(name: String, node: SyntaxNode<'tree>) -> Self {
+        Self {
+            name,
+            node,
+            skip_gate: true,
+        }
+    }
+}
+
+/// `^[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)+$` — a statically named member path.
+fn is_dotted_member_value(value: &str) -> bool {
+    let mut segments = value.split('.');
+    let Some(first) = segments.next() else {
+        return false;
+    };
+    let segment_ok = |segment: &str| {
+        let mut chars = segment.chars();
+        chars
+            .next()
+            .is_some_and(|ch| ch.is_ascii_alphabetic() || ch == '_')
+            && chars.all(|ch| ch.is_ascii_alphanumeric() || ch == '_')
+    };
+    let rest = segments.collect::<Vec<_>>();
+    segment_ok(first) && !rest.is_empty() && rest.into_iter().all(segment_ok)
 }
 
 /// Normalize one value expression to zero or more function names + source node.
@@ -766,6 +793,26 @@ fn normalize_special<'tree>(
         // Swift `#selector(fire)` / ObjC `@selector(storeImage:)`
         // (function-ref.ts:685-696).
         "selector_expression" => {
+            // Go `c.store.Fetch` (a `field` child) keeps its receiver path, so
+            // resolution can use the receiver's type before a unique name
+            // (#1820); Swift `#selector(...)` / ObjC `@selector(...)` have no
+            // `field`.
+            if let Some(field) = child_by_field(node, "field") {
+                let value = child_by_field(node, "operand")
+                    .map(|operand| {
+                        format!(
+                            "{}.{}",
+                            node_text(operand, source),
+                            node_text(field, source)
+                        )
+                    })
+                    .unwrap_or_default();
+                return if is_dotted_member_value(&value) {
+                    vec![NormalizedRef::ungated(value, field)]
+                } else {
+                    Vec::new()
+                };
+            }
             let Some(inner) = node.named_child(0) else {
                 return Vec::new();
             };
@@ -835,28 +882,21 @@ fn normalize_special<'tree>(
             Vec::new()
         }
 
-        // Python method values. A direct `self.handle_click` is class-scoped;
-        // `store.fetch` and `self.store.fetch` retain `store.fetch`, matching
-        // the representation used by direct calls so both paths choose the
-        // same target. Dynamic receivers remain unlinked (#1820).
+        // Python method values keep their whole receiver path —
+        // `self.handle_click`, `self.store.fetch`, `Actual.fetch` — so
+        // resolution can scope the member through the class, a field's type,
+        // a local's type or an import (#1820). A call or subscript receiver is
+        // not statically named and must not collapse to a bare method.
         "attribute" => {
-            let obj = child_by_field(node, "object");
-            let attr = child_by_field(node, "attribute");
-            if let (Some(obj), Some(attr)) = (obj, attr) {
-                if obj.kind() == "identifier" && node_text(obj, source) == "self" {
-                    return vec![NormalizedRef::new(
-                        format!("this.{}", node_text(attr, source)),
-                        attr,
-                    )];
-                }
-                if let Some(receiver) = method_value_receiver_segment(obj, source) {
-                    return vec![NormalizedRef::new(
-                        format!("{receiver}.{}", node_text(attr, source)),
-                        attr,
-                    )];
-                }
+            let Some(attr) = child_by_field(node, "attribute") else {
+                return Vec::new();
+            };
+            let value = node_text(node, source);
+            if is_dotted_member_value(&value) {
+                vec![NormalizedRef::ungated(value, attr)]
+            } else {
+                Vec::new()
             }
-            Vec::new()
         }
 
         // `this.Run0` (C#) (function-ref.ts:738-746).
@@ -1316,8 +1356,10 @@ class W:
         register("blur", handler)
 "#;
         let refs = fn_refs("src/w.py", src, Language::Python);
+        // Upstream v1.6.1 #1820: the receiver path is kept as written and the
+        // resolver scopes `self` to the enclosing class.
         assert!(
-            has_fn_ref(&refs, "this.on_click"),
+            has_fn_ref(&refs, "self.on_click"),
             "names={:?}",
             names(&refs)
         );
@@ -1349,9 +1391,11 @@ class Consumer:
         register(factory().fetch)
 "#;
         let refs = fn_refs("src/receiver_values.py", src, Language::Python);
+        // Upstream v1.6.1 #1820: every member value keeps its whole receiver
+        // path, so resolution can scope `self`, a field or a local.
         assert!(
-            has_fn_ref(&refs, "this.own_handler"),
-            "self method must retain class scope: names={:?}",
+            has_fn_ref(&refs, "self.own_handler"),
+            "self method must retain its receiver: names={:?}",
             names(&refs)
         );
         assert!(
@@ -1361,15 +1405,16 @@ class Consumer:
         );
         assert_eq!(
             refs.iter()
-                .filter(|reference| reference.reference_name == "store.fetch")
+                .filter(|reference| reference.reference_name == "self.store.fetch")
                 .count(),
-            3,
-            "argument, assignment, and list forms must retain their distinct source owners"
+            2,
+            "assignment and list forms must retain the field receiver and their owners"
         );
         assert!(
             !refs
                 .iter()
-                .any(|reference| reference.reference_name == "factory.fetch"),
+                .any(|reference| reference.reference_name.ends_with("fetch")
+                    && reference.reference_name.contains("factory")),
             "dynamic call-result receivers must remain unresolved"
         );
     }
@@ -2238,7 +2283,7 @@ object M {
         let lang = tree_sitter_python::LANGUAGE.into();
         let names = special_names(lang, "reg(self.handler)", "attribute");
         assert!(
-            names.contains(&"this.handler".to_string()),
+            names.contains(&"self.handler".to_string()),
             "self.attr; names={names:?}"
         );
     }
diff --git a/crates/codegraph-extract/tests/batch_coverage_languages3.rs b/crates/codegraph-extract/tests/batch_coverage_languages3.rs
index 8695415b..6c667336 100644
--- a/crates/codegraph-extract/tests/batch_coverage_languages3.rs
+++ b/crates/codegraph-extract/tests/batch_coverage_languages3.rs
@@ -128,10 +128,11 @@ class Widget:
     assert!(result.errors.is_empty(), "{:?}", result.errors);
     let refs = &result.unresolved_references;
     assert!(has_fn_ref(refs, "on_click"), "arg fn-ref; refs={refs:#?}");
-    // `self.handle` preserves the class-scoped owner marker so resolution can
-    // distinguish it from unrelated same-named methods.
+    // `self.handle` keeps its receiver as written (upstream v1.6.1 #1820);
+    // resolution scopes `self` to the enclosing class, so an unrelated
+    // same-named method cannot win.
     assert!(
-        has_fn_ref(refs, "this.handle"),
+        has_fn_ref(refs, "self.handle"),
         "self.attr fn-ref; refs={refs:#?}"
     );
     assert!(
diff --git a/crates/codegraph-resolve/src/lib.rs b/crates/codegraph-resolve/src/lib.rs
index e75c63bb..c35cc650 100644
--- a/crates/codegraph-resolve/src/lib.rs
+++ b/crates/codegraph-resolve/src/lib.rs
@@ -24,6 +24,7 @@ pub mod frameworks; // concrete react/vue/nestjs FrameworkResolvers
 pub mod import_resolver;
 mod js_store;
 pub mod lru_cache;
+mod member_value;
 pub mod name_matcher;
 mod object_literal;
 pub mod path_aliases;
diff --git a/crates/codegraph-resolve/src/member_value.rs b/crates/codegraph-resolve/src/member_value.rs
new file mode 100644
index 00000000..eb1498de
--- /dev/null
+++ b/crates/codegraph-resolve/src/member_value.rs
@@ -0,0 +1,650 @@
+//! Python and Go method values (upstream v1.6.1 #1820).
+//!
+//! `pool.submit(self.store.fetch)` and `Submit(c.store.Fetch)` pass a method
+//! as a value. The extractor keeps the whole receiver path, and this module
+//! resolves it through the receiver's own scope — the enclosing class for
+//! `self`/`cls`, a field's declared or constructed type, a local's type, an
+//! imported class, a Go struct field — before considering a globally unique
+//! method name. Ambiguity, a non-callable member (a data attribute, a
+//! `@property`) or an unknowable receiver leaves the value unresolved: a wrong
+//! callback edge is worse than none.
+
+use std::collections::{BTreeMap, HashSet};
+use std::sync::Arc;
+
+use codegraph_core::types::{EdgeKind, Language, Node, NodeKind};
+use regex::Regex;
+
+use crate::import_resolver::resolve_via_import;
+use crate::name_matcher::{
+    infer_local_receiver_type, prefer_call_site_file, resolve_method_on_type, same_language_family,
+};
+use crate::types::{RefView, ResolutionContext, ResolvedBy, ResolvedRef};
+
+/// Primitive and built-in Go field types: a field of one never names a
+/// project type.
+const GO_BUILTIN_FIELD_TYPES: [&str; 26] = [
+    "string",
+    "bool",
+    "byte",
+    "rune",
+    "error",
+    "any",
+    "int",
+    "int8",
+    "int16",
+    "int32",
+    "int64",
+    "uint",
+    "uint8",
+    "uint16",
+    "uint32",
+    "uint64",
+    "uintptr",
+    "float32",
+    "float64",
+    "complex64",
+    "complex128",
+    "chan",
+    "map",
+    "func",
+    "struct",
+    "interface",
+];
+
+/// Resolve a Python or Go member value `receiver.member` (#1820).
+pub(crate) fn match_member_function_ref(
+    reference: &RefView,
+    context: &dyn ResolutionContext,
+) -> Option<ResolvedRef> {
+    let (receiver, member) = reference.reference_name.rsplit_once('.')?;
+    let imports = context.get_import_mappings(&reference.file_path, reference.language);
+    let root = receiver.split('.').next().unwrap_or(receiver);
+    // An import is authoritative even when it points outside the project.
+    if imports.iter().any(|import| import.local_name == root) {
+        if reference.language == Language::Python
+            && let Some(class) = python_ref_class(receiver, reference, context)
+        {
+            return unique_callable(
+                python_members(&class, member, reference, context, &mut HashSet::new()),
+                reference,
+                context,
+                0.9,
+            );
+        }
+        let imported = resolve_via_import(reference, context)?;
+        let node = context.get_node_by_id_shared(&imported.target_node_id)?;
+        let same_name = context
+            .get_nodes_by_qualified_name_shared(&node.qualified_name)
+            .into_iter()
+            .filter(|candidate| candidate.file_path == node.file_path)
+            .collect();
+        return unique_callable(same_name, reference, context, 0.9);
+    }
+    if reference.language == Language::Go {
+        if receiver.contains('.') {
+            return match_go_field_chain_value(receiver, member, reference, context);
+        }
+        if let Some(type_name) = infer_local_receiver_type(receiver, reference, context) {
+            return go_method_value(&type_name, member, reference, context);
+        }
+        let types = context
+            .get_nodes_by_name_shared(receiver)
+            .into_iter()
+            .filter(|node| {
+                node.language == Language::Go
+                    && matches!(node.kind, NodeKind::Struct | NodeKind::Interface)
+            })
+            .count();
+        if types > 0 {
+            // A method expression `Store.Fetch` names its type directly.
+            return (types == 1)
+                .then(|| go_method_value(receiver, member, reference, context))
+                .flatten();
+        }
+    } else {
+        let owner = context
+            .get_nodes_in_file_shared(&reference.file_path)
+            .into_iter()
+            .filter(|node| {
+                node.kind == NodeKind::Class
+                    && node.start_line <= reference.line
+                    && node.end_line >= reference.line
+            })
+            .max_by_key(|node| node.start_line);
+        if receiver == "self" || receiver == "cls" {
+            let owner = owner?;
+            return unique_callable(
+                python_members(&owner, member, reference, context, &mut HashSet::new()),
+                reference,
+                context,
+                0.9,
+            );
+        }
+        let mut type_name = if let Some(field) = receiver
+            .strip_prefix("self.")
+            .or_else(|| receiver.strip_prefix("cls."))
+            .filter(|field| is_word(field))
+        {
+            python_field_type(field, owner.as_deref()?, reference, context)
+        } else {
+            python_local_type(receiver, reference, context)
+        };
+        // A type name used directly (`Store.fetch`) is scoped like an annotation.
+        if type_name.is_none()
+            && receiver
+                .chars()
+                .next()
+                .is_some_and(|ch| ch.is_ascii_uppercase())
+            && is_word(receiver)
+        {
+            type_name = Some(receiver.to_string());
+        }
+        if let Some(type_name) = type_name.filter(|name| name != "object" && name != "Any") {
+            let class = python_ref_class(&type_name, reference, context)?;
+            let members = python_members(&class, member, reference, context, &mut HashSet::new());
+            if !members.is_empty() {
+                return unique_callable(members, reference, context, 0.9);
+            }
+            // A base-typed field can hold a subclass-only method: keep only
+            // descendants of THAT base, so unrelated namesakes cannot win.
+            let descendants = context
+                .get_nodes_by_name_shared(member)
+                .into_iter()
+                .filter(|node| node.kind == NodeKind::Method && node.language == Language::Python)
+                .filter(|method| {
+                    context
+                        .get_nodes_in_file_shared(&method.file_path)
+                        .into_iter()
+                        .find(|candidate| {
+                            candidate.kind == NodeKind::Class
+                                && method.qualified_name
+                                    == format!("{}::{member}", candidate.qualified_name)
+                        })
+                        .is_some_and(|parent| {
+                            python_derives_from(
+                                &parent,
+                                &class,
+                                reference,
+                                context,
+                                &mut HashSet::new(),
+                            )
+                        })
+                })
+                .collect();
+            return unique_callable(descendants, reference, context, 0.8);
+        }
+    }
+    // An unknown receiver keeps the unique-or-drop discipline across ALL
+    // files; test doubles and abstract bases are candidates too.
+    unique_callable(
+        context.get_nodes_by_name_shared(member),
+        reference,
+        context,
+        0.8,
+    )
+}
+
+/// The single same-family candidate when it is a callable other than the
+/// referencing node itself and not a Python property.
+fn unique_callable(
+    nodes: Vec<Arc<Node>>,
+    reference: &RefView,
+    context: &dyn ResolutionContext,
+    confidence: f64,
+) -> Option<ResolvedRef> {
+    let pool = nodes
+        .into_iter()
+        .filter(|node| same_language_family(node.language, reference.language))
+        .collect::<Vec<_>>();
+    let [target] = pool.as_slice() else {
+        return None;
+    };
+    (matches!(target.kind, NodeKind::Function | NodeKind::Method)
+        && target.id != reference.from_node_id
+        && !is_python_property(target, context))
+    .then(|| ResolvedRef {
+        original: reference.clone(),
+        target_node_id: target.id.clone(),
+        confidence,
+        resolved_by: ResolvedBy::FunctionRef,
+    })
+}
+
+fn go_method_value(
+    type_name: &str,
+    member: &str,
+    reference: &RefView,
+    context: &dyn ResolutionContext,
+) -> Option<ResolvedRef> {
+    resolve_method_on_type(
+        type_name,
+        member,
+        reference,
+        context,
+        0.9,
+        ResolvedBy::FunctionRef,
+        None,
+        0,
+    )
+}
+
+/// `base.field.Method` — the field's declared type read off the base type's
+/// own struct declaration (upstream `matchGoFieldChainCall`, #1276/#1316). A
+/// package-qualified field type is followed only when the package is in the
+/// module; built-in types name no project type.
+fn match_go_field_chain_value(
+    receiver_chain: &str,
+    method: &str,
+    reference: &RefView,
+    context: &dyn ResolutionContext,
+) -> Option<ResolvedRef> {
+    let (base, field) = receiver_chain.split_once('.')?;
+    if base.is_empty() || field.is_empty() || field.contains('.') {
+        return None;
+    }
+    let base_type = infer_local_receiver_type(base, reference, context)?;
+    let field_type = Regex::new(&format!(
+        r"(?-u:\b){}\s+\*?\[?\]?([A-Za-z_][\w.]*)",
+        regex::escape(field)
+    ))
+    .ok()?;
+    let structs = prefer_call_site_file(
+        context.get_nodes_by_name_shared(&base_type),
+        &reference.file_path,
+    )
+    .into_iter()
+    .filter(|node| {
+        matches!(node.kind, NodeKind::Struct | NodeKind::Class) && node.language == Language::Go
+    })
+    .collect::<Vec<_>>();
+    for declaration in structs {
+        let Some(facts) = context.source_facts(&declaration.file_path) else {
+            continue;
+        };
+        let start = declaration.start_line.saturating_sub(1).max(0) as usize;
+        let end = (declaration.end_line.max(0) as usize).min(facts.line_count());
+        for index in start..end {
+            let line = strip_go_line_comments(facts.line(index));
+            let Some(raw_type) = field_type
+                .captures(&line)
+                .and_then(|captures| captures.get(1))
+                .map(|capture| capture.as_str().to_string())
+            else {
+                continue;
+            };
+            if let Some((package, _)) = raw_type.split_once('.') {
+                let in_module = context.get_go_modules().iter().any(|module| {
+                    context
+                        .get_import_mappings(&declaration.file_path, Language::Go)
+                        .iter()
+                        .any(|import| {
+                            import.local_name == package
+                                && (import.source == module.module_path
+                                    || import
+                                        .source
+                                        .starts_with(&format!("{}/", module.module_path)))
+                        })
+                });
+                if !in_module {
+                    continue;
+                }
+            }
+            let Some(type_name) = raw_type.rsplit('.').next() else {
+                continue;
+            };
+            if !type_name
+                .chars()
+                .next()
+                .is_some_and(|ch| ch.is_ascii_alphabetic() || ch == '_')
+                || GO_BUILTIN_FIELD_TYPES.contains(&type_name)
+            {
+                continue;
+            }
+            if let Some(resolved) = resolve_method_on_type(
+                type_name,
+                method,
+                reference,
+                context,
+                0.85,
+                ResolvedBy::FunctionRef,
+                None,
+                0,
+            ) {
+                return Some(resolved);
+            }
+        }
+    }
+    None
+}
+
+/// A Go declaration line without its `//` and single-line `/* */` comments.
+fn strip_go_line_comments(line: &str) -> String {
+    let line = line.split("//").next().unwrap_or(line);
+    let mut out = String::with_capacity(line.len());
+    let mut rest = line;
+    while let Some(open) = rest.find("/*") {
+        out.push_str(&rest[..open]);
+        match rest[open + 2..].find("*/") {
+            Some(close) => rest = &rest[open + 2 + close + 2..],
+            None => {
+                rest = "";
+                break;
+            }
+        }
+    }
+    out.push_str(rest);
+    out
+}
+
+/// The project class a Python name refers to: an import binding when the
+/// name's root is imported, else the one same-file class of that name.
+fn python_ref_class(
+    name: &str,
+    reference: &RefView,
+    context: &dyn ResolutionContext,
+) -> Option<Node> {
+    let root = name.split('.').next().unwrap_or(name);
+    if context
+        .get_import_mappings(&reference.file_path, Language::Python)
+        .iter()
+        .any(|import| import.local_name == root)
+    {
+        let mut lookup = reference.clone();
+        lookup.reference_name = name.to_string();
+        lookup.reference_kind = EdgeKind::References;
+        let hit = resolve_via_import(&lookup, context)?;
+        let node = context.get_node_by_id_shared(&hit.target_node_id)?;
+        let unique = context
+            .get_nodes_by_qualified_name_shared(&node.qualified_name)
+            .into_iter()
+            .filter(|candidate| {
+                candidate.kind == NodeKind::Class && candidate.file_path == node.file_path
+            })
+            .count()
+            == 1;
+        return (node.kind == NodeKind::Class && unique).then(|| node.as_ref().clone());
+    }
+    let classes = context
+        .get_nodes_by_name_shared(name)
+        .into_iter()
+        .filter(|node| node.kind == NodeKind::Class && node.file_path == reference.file_path)
+        .collect::<Vec<_>>();
+    match classes.as_slice() {
+        [class] => Some(class.as_ref().clone()),
+        _ => None,
+    }
+}
+
+/// The classes named in a Python class's base list, resolved from its file.
+fn python_bases(class: &Node, reference: &RefView, context: &dyn ResolutionContext) -> Vec<Node> {
+    let Some(facts) = context.source_facts(&class.file_path) else {
+        return Vec::new();
+    };
+    let Some(index) = usize::try_from(class.start_line)
+        .ok()
+        .and_then(|line| line.checked_sub(1))
+    else {
+        return Vec::new();
+    };
+    if index >= facts.line_count() {
+        return Vec::new();
+    }
+    let header = facts.line(index);
+    let Some(bases) = Regex::new(r"^\s*class\s+\w+\s*\(([^)]*)\)")
+        .ok()
+        .and_then(|pattern| pattern.captures(header))
+        .and_then(|captures| captures.get(1))
+        .map(|bases| bases.as_str().to_string())
+    else {
+        return Vec::new();
+    };
+    let mut at_class = reference.clone();
+    at_class.file_path = class.file_path.clone();
+    bases
+        .split(',')
+        .filter_map(|base| python_ref_class(base.trim(), &at_class, context))
+        .collect()
+}
+
+fn python_derives_from(
+    class: &Node,
+    base: &Node,
+    reference: &RefView,
+    context: &dyn ResolutionContext,
+    seen: &mut HashSet<String>,
+) -> bool {
+    if seen.len() >= 16 || !seen.insert(class.id.clone()) {
+        return false;
+    }
+    python_bases(class, reference, context)
+        .iter()
+        .any(|parent| {
+            parent.id == base.id || python_derives_from(parent, base, reference, context, seen)
+        })
+}
+
+/// What `class.member` names: an instance or class assignment shadows any
+/// method (the class itself is returned, which is not callable), else the
+/// class's own method, else what its bases provide.
+fn python_members(
+    class: &Node,
+    member: &str,
+    reference: &RefView,
+    context: &dyn ResolutionContext,
+    seen: &mut HashSet<String>,
+) -> Vec<Arc<Node>> {
+    if seen.len() >= 16 || !seen.insert(class.id.clone()) {
+        return Vec::new();
+    }
+    if let Some(facts) = context.source_facts(&class.file_path) {
+        let (code, lines) = facts.python_comment_free();
+        let start = class.start_line.saturating_sub(1).max(0) as usize;
+        let end = (class.end_line.max(0) as usize).min(lines.line_count());
+        let body = lines.join(code, start.min(end), end, "\n");
+        let shadow = Regex::new(&format!(
+            r"(?m)^\s*(?:(?:self|cls)\.)?{}\s*(?:=|:)",
+            regex::escape(member)
+        ));
+        if shadow.is_ok_and(|pattern| pattern.is_match(&body)) {
+            return vec![Arc::new(class.clone())];
+        }
+    }
+    let own = context
+        .get_nodes_by_qualified_name_shared(&format!("{}::{member}", class.qualified_name))
+        .into_iter()
+        .filter(|node| node.file_path == class.file_path)
+        .collect::<Vec<_>>();
+    if !own.is_empty() {
+        return own;
+    }
+    let mut inherited = BTreeMap::new();
+    for base in python_bases(class, reference, context) {
+        for node in python_members(&base, member, reference, context, seen) {
+            inherited.entry(node.id.clone()).or_insert(node);
+        }
+    }
+    inherited.into_values().collect()
+}
+
+fn is_python_property(node: &Node, context: &dyn ResolutionContext) -> bool {
+    if node.language != Language::Python || node.kind != NodeKind::Method {
+        return false;
+    }
+    let Some(facts) = context.source_facts(&node.file_path) else {
+        return false;
+    };
+    let decorator = Regex::new(r"^\s*@(?:property|(?:functools\.)?cached_property)\s*$")
+        .expect("property decorator pattern");
+    let mut index = node.start_line - 2;
+    while index >= 0 && (index as usize) < facts.line_count() {
+        let line = facts.line(index as usize);
+        if !line.trim_start().starts_with('@') {
+            break;
+        }
+        if decorator.is_match(line) {
+            return true;
+        }
+        index -= 1;
+    }
+    false
+}
+
+/// A local's type from its nearest declaration in the calling function —
+/// an annotation or a capitalized constructor call — or a parameter
+/// annotation; `<unknown>` for any other assignment.
+fn python_local_type(
+    receiver: &str,
+    reference: &RefView,
+    context: &dyn ResolutionContext,
+) -> Option<String> {
+    if !is_word(receiver) {
+        return None;
+    }
+    let caller = context.get_node_by_id_shared(&reference.from_node_id);
+    let facts = context.source_facts(&reference.file_path)?;
+    let (code, lines) = facts.python_comment_free();
+    let name = regex::escape(receiver);
+    let declaration = Regex::new(&format!(
+        r#"^\s*{name}\s*(?::\s*["']?([\w.]+)["']?)?\s*=\s*(.*)$"#
+    ))
+    .ok()?;
+    let annotation = Regex::new(&format!(r#"^\s*{name}\s*:\s*["']?([\w.]+)"#)).ok()?;
+    let constructor = Regex::new(r"^([A-Z][\w.]*)\s*\(").expect("constructor pattern");
+    let lowest = caller.as_ref().map_or(1, |caller| caller.start_line).max(1) - 1;
+    let mut index = reference.line - 1;
+    while index >= lowest {
+        if (index as usize) < lines.line_count() {
+            let line = lines.line(code, index as usize);
+            if let Some(assigned) = declaration.captures(line) {
+                if let Some(declared) = assigned.get(1) {
+                    return Some(declared.as_str().to_string());
+                }
+                let value = assigned.get(2).map_or("", |value| value.as_str());
+                return Some(
+                    constructor
+                        .captures(value)
+                        .and_then(|captures| captures.get(1))
+                        .map_or_else(
+                            || "<unknown>".to_string(),
+                            |class| class.as_str().to_string(),
+                        ),
+                );
+            }
+            if let Some(declared) = annotation
+                .captures(line)
+                .and_then(|captures| captures.get(1))
+            {
+                return Some(declared.as_str().to_string());
+            }
+        }
+        index -= 1;
+    }
+    let signature = caller?.signature.clone()?;
+    Regex::new(&format!(r#"(?-u:\b){name}\s*:\s*["']?([\w.]+)"#))
+        .ok()?
+        .captures(&signature)
+        .and_then(|captures| captures.get(1))
+        .map(|declared| declared.as_str().to_string())
+}
+
+/// A field's type from its class-level annotation, its own annotated or
+/// constructed assignment, or the annotated constructor parameter assigned to
+/// it. Conflicting assignments are known-but-ambiguous (`<ambiguous>`), never
+/// a name-only fallback.
+fn python_field_type(
+    field: &str,
+    owner: &Node,
+    reference: &RefView,
+    context: &dyn ResolutionContext,
+) -> Option<String> {
+    let facts = context.source_facts(&reference.file_path)?;
+    let (code, lines) = facts.python_comment_free();
+    let field = regex::escape(field);
+    let assignment = Regex::new(&format!(
+        r#"^\s*(?:self|cls)\.{field}\s*(?::\s*["']?([\w.]+)["']?)?\s*=\s*(.*)$"#
+    ))
+    .ok()?;
+    let annotation = Regex::new(&format!(
+        r#"^\s*(?:(?:self|cls)\.)?{field}\s*:\s*["']?([\w.]+)"#
+    ))
+    .ok()?;
+    let receiver_prefix = Regex::new(r"^\s*(?:self|cls)\.").expect("receiver prefix pattern");
+    let constructor = Regex::new(r"^([A-Z][\w.]*)\s*\(").expect("constructor pattern");
+    let member_prefix = format!("{}::", owner.qualified_name);
+    let methods = context
+        .get_nodes_in_file_shared(&reference.file_path)
+        .into_iter()
+        .filter(|node| {
+            node.kind == NodeKind::Method && node.qualified_name.starts_with(&member_prefix)
+        })
+        .collect::<Vec<_>>();
+    let mut types = std::collections::BTreeSet::new();
+    let start = owner.start_line.max(0) as usize;
+    let end = (owner.end_line.max(0) as usize).min(lines.line_count());
+    for index in start..end {
+        let line_number = index as i64 + 1;
+        let method = methods
+            .iter()
+            .find(|method| method.start_line <= line_number && method.end_line >= line_number);
+        if let Some(method) = method {
+            if method.name != "__init__" && method.id != reference.from_node_id {
+                continue;
+            }
+            if method.id == reference.from_node_id && line_number > reference.line {
+                continue;
+            }
+        }
+        let line = lines.line(code, index);
+        if (method.is_none() || receiver_prefix.is_match(line))
+            && let Some(declared) = annotation
+                .captures(line)
+                .and_then(|captures| captures.get(1))
+        {
+            types.insert(declared.as_str().to_string());
+        }
+        let Some(assigned) = assignment.captures(line) else {
+            continue;
+        };
+        if let Some(declared) = assigned.get(1) {
+            types.insert(declared.as_str().to_string());
+            continue;
+        }
+        let value = assigned.get(2).map_or("", |value| value.as_str());
+        if let Some(class) = constructor
+            .captures(value)
+            .and_then(|captures| captures.get(1))
+        {
+            types.insert(class.as_str().to_string());
+            continue;
+        }
+        let parameter = value.trim();
+        if let Some(method) = method
+            && is_word(parameter)
+        {
+            if let Some(declared) = method.signature.as_deref().and_then(|signature| {
+                Regex::new(&format!(
+                    r#"(?-u:\b){}\s*:\s*["']?([\w.]+)"#,
+                    regex::escape(parameter)
+                ))
+                .ok()?
+                .captures(signature)
+                .and_then(|captures| captures.get(1))
+                .map(|declared| declared.as_str().to_string())
+            }) {
+                types.insert(declared);
+            }
+        } else {
+            types.insert("<unknown>".to_string());
+        }
+    }
+    match types.len() {
+        0 => None,
+        1 => types.into_iter().next(),
+        _ => Some("<ambiguous>".to_string()),
+    }
+}
+
+fn is_word(text: &str) -> bool {
+    !text.is_empty() && text.chars().all(|ch| ch.is_alphanumeric() || ch == '_')
+}
diff --git a/crates/codegraph-resolve/src/name_matcher.rs b/crates/codegraph-resolve/src/name_matcher.rs
index 71895502..306ecd05 100644
--- a/crates/codegraph-resolve/src/name_matcher.rs
+++ b/crates/codegraph-resolve/src/name_matcher.rs
@@ -1113,7 +1113,10 @@ pub fn match_by_qualified_name(
 /// `a/svc`. No-op when there are <2 candidates or none share the call site's
 /// file. The partition is STABLE (preserves within-group order), so edge output
 /// stays deterministic.
-fn prefer_call_site_file<T: Borrow<Node>>(nodes: Vec<T>, call_site_file: &str) -> Vec<T> {
+pub(crate) fn prefer_call_site_file<T: Borrow<Node>>(
+    nodes: Vec<T>,
+    call_site_file: &str,
+) -> Vec<T> {
     if nodes.len() < 2 {
         return nodes;
     }
@@ -1818,7 +1821,7 @@ pub(crate) fn enclosing_scope_start_line(
 /// languages without patterns or when no declaration is found. Bounded to the
 /// enclosing scope. The caller validates the method via `resolve_method_on_type`,
 /// so a mis-inference produces no edge.
-fn infer_local_receiver_type(
+pub(crate) fn infer_local_receiver_type(
     receiver_name: &str,
     reference: &RefView,
     context: &dyn ResolutionContext,
@@ -3846,6 +3849,14 @@ pub fn match_function_ref(
         return None;
     }
 
+    // Python and Go member values retain their receiver path and resolve
+    // through the receiver's scope before a unique name (upstream #1820).
+    if matches!(reference.language, Language::Python | Language::Go)
+        && reference.reference_name.contains('.')
+    {
+        return crate::member_value::match_member_function_ref(reference, context);
+    }
+
     // Receiver-qualified first-class method value (#1820): reuse the exact
     // same conservative target selection as `obj.method(...)`, but preserve
     // the original `references` kind and label the result as function-ref.
diff --git a/crates/codegraph-resolve/src/resolver.rs b/crates/codegraph-resolve/src/resolver.rs
index e32987b5..051759ce 100644
--- a/crates/codegraph-resolve/src/resolver.rs
+++ b/crates/codegraph-resolve/src/resolver.rs
@@ -1805,6 +1805,16 @@ impl ReferenceResolver {
                 let (resolved, deferred) = self.resolve_this_member_fn_ref_pure(reference, context);
                 return (self.gate_language(resolved, reference, context), deferred);
             }
+            // Python/Go member values are scoped by their receiver; import
+            // lookups happen inside that scoping (#1820).
+            if matches!(reference.language, Language::Python | Language::Go)
+                && reference.reference_name.contains('.')
+            {
+                return (
+                    self.gate_language(match_function_ref(reference, context), reference, context),
+                    None,
+                );
+            }
             if let Some(via_import) =
                 self.gate_language(resolve_via_import(reference, context), reference, context)
             {
diff --git a/crates/codegraph-resolve/src/source_facts.rs b/crates/codegraph-resolve/src/source_facts.rs
index d41ae642..529b29f1 100644
--- a/crates/codegraph-resolve/src/source_facts.rs
+++ b/crates/codegraph-resolve/src/source_facts.rs
@@ -122,6 +122,7 @@ pub struct SourceFacts {
     source: Arc<str>,
     lines: OnceLock<LineIndex>,
     ts_comment_free: OnceLock<(String, LineIndex)>,
+    python_comment_free: OnceLock<(String, LineIndex)>,
     ts_blanked: OnceLock<String>,
     js_sealed_module: OnceLock<bool>,
     js_binding_sites: OnceLock<LocalBindingSites>,
@@ -143,6 +144,7 @@ impl SourceFacts {
             source,
             lines: OnceLock::new(),
             ts_comment_free: OnceLock::new(),
+            python_comment_free: OnceLock::new(),
             ts_blanked: OnceLock::new(),
             js_sealed_module: OnceLock::new(),
             js_binding_sites: OnceLock::new(),
@@ -200,6 +202,17 @@ impl SourceFacts {
         (code, lines)
     }
 
+    /// The whole file through [`strip_comments_for_regex`] with the Python
+    /// rules, plus its line index.
+    pub fn python_comment_free(&self) -> (&str, &LineIndex) {
+        let (code, lines) = self.python_comment_free.get_or_init(|| {
+            let code = strip_comments_for_regex(&self.source, CommentLang::Python);
+            let lines = LineIndex::new(&code);
+            (code, lines)
+        });
+        (code, lines)
+    }
+
     /// [`Self::ts_comment_free`] with every string and template literal's
     /// contents blanked too (`blankStringContents(stripCommentsForRegex(…))`),
     /// so line-anchored patterns see only code.
diff --git a/crates/codegraph-resolve/tests/method_values.rs b/crates/codegraph-resolve/tests/method_values.rs
new file mode 100644
index 00000000..e4c7fc66
--- /dev/null
+++ b/crates/codegraph-resolve/tests/method_values.rs
@@ -0,0 +1,455 @@
+//! Python and Go method values passed as callbacks (upstream v1.6.1 #1820).
+//!
+//! Ported from upstream `function-ref.test.ts`: a member value keeps its
+//! receiver path and resolves through the receiver's scope before a unique
+//! name; ambiguity, non-callable members and unknowable receivers stay
+//! unlinked.
+
+use std::path::PathBuf;
+use std::sync::atomic::{AtomicU64, Ordering};
+
+use codegraph_core::types::{Edge, EdgeKind, FileRecord, NodeKind};
+use codegraph_extract::{detect_language, extract_file};
+use codegraph_resolve::ReferenceResolver;
+use codegraph_store::Store;
+
+static NONCE: AtomicU64 = AtomicU64::new(0);
+
+struct Project {
+    root: PathBuf,
+    store: Option<Store>,
+}
+
+impl Drop for Project {
+    fn drop(&mut self) {
+        drop(self.store.take());
+        let _ = std::fs::remove_dir_all(&self.root);
+    }
+}
+
+impl Project {
+    fn store(&self) -> &Store {
+        self.store.as_ref().expect("store")
+    }
+
+    /// Function-ref `references` edges into callables named `name`.
+    fn fn_ref_edges_into(&self, name: &str) -> Vec<Edge> {
+        self.store()
+            .nodes_by_name(name)
+            .expect("nodes by name")
+            .into_iter()
+            .filter(|node| matches!(node.kind, NodeKind::Function | NodeKind::Method))
+            .flat_map(|node| {
+                self.store()
+                    .edges_by_target_kind(&node.id, Some(EdgeKind::References))
+                    .expect("references")
+            })
+            .filter(|edge| {
+                edge.metadata
+                    .as_ref()
+                    .and_then(|metadata| metadata.get("fnRef"))
+                    .and_then(serde_json::Value::as_bool)
+                    == Some(true)
+            })
+            .collect()
+    }
+
+    /// Sorted names of the edges' sources.
+    fn source_names(&self, edges: &[Edge]) -> Vec<String> {
+        let mut names = edges
+            .iter()
+            .map(|edge| {
+                self.store()
+                    .node_by_id(&edge.source)
+                    .expect("source query")
+                    .expect("source node")
+                    .name
+            })
+            .collect::<Vec<_>>();
+        names.sort();
+        names
+    }
+
+    fn target(&self, edge: &Edge) -> codegraph_core::types::Node {
+        self.store()
+            .node_by_id(&edge.target)
+            .expect("target query")
+            .expect("target node")
+    }
+
+    /// Sorted names of every `calls`/`references` caller of the one method
+    /// named `name`.
+    fn callers_of_method(&self, name: &str) -> Vec<String> {
+        let method = self
+            .store()
+            .nodes_by_name(name)
+            .expect("nodes by name")
+            .into_iter()
+            .find(|node| node.kind == NodeKind::Method)
+            .unwrap_or_else(|| panic!("missing method {name}"));
+        let mut names = [EdgeKind::Calls, EdgeKind::References]
+            .into_iter()
+            .flat_map(|kind| {
+                self.store()
+                    .edges_by_target_kind(&method.id, Some(kind))
+                    .expect("incoming")
+            })
+            .map(|edge| {
+                self.store()
+                    .node_by_id(&edge.source)
+                    .expect("source query")
+                    .expect("source node")
+                    .name
+            })
+            .collect::<Vec<_>>();
+        names.sort();
+        names.dedup();
+        names
+    }
+}
+
+fn resolve_project(files: &[(&str, &str)]) -> Project {
+    let root = std::env::temp_dir().join(format!(
+        "codegraph-method-values-{}-{}",
+        std::process::id(),
+        NONCE.fetch_add(1, Ordering::Relaxed)
+    ));
+    std::fs::create_dir_all(&root).expect("create fixture root");
+    for (relative, source) in files {
+        let path = root.join(relative);
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent).expect("create fixture parent");
+        }
+        std::fs::write(path, source).expect("write fixture");
+    }
+    let mut store = Store::open(&root.join("graph.db")).expect("open store");
+    for (relative, _) in files {
+        let result = extract_file(&root, relative).expect("extract fixture");
+        assert!(result.errors.is_empty(), "{relative}: {:?}", result.errors);
+        store
+            .upsert_file(&FileRecord {
+                path: (*relative).to_string(),
+                content_hash: "fixture".to_string(),
+                language: detect_language(relative),
+                size: 0,
+                modified_at: 0,
+                indexed_at: 0,
+                node_count: result.nodes.len() as i64,
+                errors: Vec::new(),
+                generated: false,
+            })
+            .expect("upsert file");
+        store.upsert_nodes(&result.nodes).expect("upsert nodes");
+        store.insert_edges(&result.edges).expect("insert edges");
+        store
+            .insert_unresolved_refs(&result.unresolved_references)
+            .expect("insert unresolved refs");
+    }
+    let root_str = root.to_string_lossy().to_string();
+    let mut resolver = ReferenceResolver::new(root_str.clone());
+    resolver.initialize(&codegraph_resolve::StoreResolutionContext::new(
+        &store, &root_str,
+    ));
+    resolver
+        .resolve_and_persist(&mut store)
+        .expect("resolve fixture");
+    Project {
+        root,
+        store: Some(store),
+    }
+}
+
+#[test]
+fn python_member_value_through_an_annotated_base_field_is_a_caller() {
+    let project = resolve_project(&[
+        (
+            "store.py",
+            "class Base:\n    pass\n\nclass Store(Base):\n    def fetch(self, ids):\n        return ids\n",
+        ),
+        (
+            "consumer.py",
+            "from concurrent.futures import ThreadPoolExecutor\n\
+             from store import Base\n\
+             \n\
+             class Consumer:\n\
+             \x20   def __init__(self, store: Base):\n\
+             \x20       self.store = store\n\
+             \n\
+             \x20   def direct(self, ids):\n\
+             \x20       return self.store.fetch(ids)\n\
+             \n\
+             \x20   def via_callback(self, ids, pool: ThreadPoolExecutor):\n\
+             \x20       return pool.submit(self.store.fetch, ids)\n",
+        ),
+    ]);
+    let edges = project.fn_ref_edges_into("fetch");
+    assert_eq!(project.source_names(&edges), vec!["via_callback"]);
+    assert!(
+        project
+            .callers_of_method("fetch")
+            .contains(&"via_callback".to_string())
+    );
+}
+
+#[test]
+fn python_unknown_receivers_stay_ambiguous_with_test_doubles_bases_or_namesakes() {
+    let consumer = "class Consumer:\n\
+                    \x20   def __init__(self, store):\n\
+                    \x20       self.store = store\n\
+                    \x20   def via_callback(self, pool, ids):\n\
+                    \x20       return pool.submit(self.store.fetch, ids)\n";
+    for files in [
+        vec![
+            (
+                "store.py",
+                "class Store:\n    def fetch(self, ids):\n        return ids\n",
+            ),
+            (
+                "tests/test_store.py",
+                "class FakeStore:\n    def fetch(self, ids):\n        return ids\n",
+            ),
+            ("consumer.py", consumer),
+        ],
+        vec![
+            (
+                "base.py",
+                "class Base:\n    def fetch(self, ids):\n        raise NotImplementedError(\"subclass\")\n",
+            ),
+            (
+                "store.py",
+                "from base import Base\nclass Store(Base):\n    def fetch(self, ids):\n        return ids\n",
+            ),
+            ("consumer.py", consumer),
+        ],
+        vec![
+            (
+                "a.py",
+                "class A:\n    def fetch(self, ids):\n        return ids\n",
+            ),
+            (
+                "b.py",
+                "class B:\n    def fetch(self, ids):\n        return ids\n",
+            ),
+            ("consumer.py", consumer),
+        ],
+    ] {
+        let project = resolve_project(&files);
+        assert_eq!(project.fn_ref_edges_into("fetch"), Vec::new(), "{files:?}");
+    }
+}
+
+#[test]
+fn go_method_values_are_callers_and_go_statements_stay_calls() {
+    let project = resolve_project(&[
+        (
+            "store.go",
+            "package demo\n\ntype Store struct{}\n\nfunc (s *Store) Fetch(ids []string) []string { return ids }\n",
+        ),
+        (
+            "consumer.go",
+            "package demo\n\n\
+             func Submit(fn func([]string) []string, ids []string) []string { return fn(ids) }\n\n\
+             type Consumer struct{ store *Store }\n\n\
+             func (c *Consumer) Direct(ids []string) []string { return c.store.Fetch(ids) }\n\n\
+             func (c *Consumer) ViaGo(ids []string) { go c.store.Fetch(ids) }\n\n\
+             func (c *Consumer) ViaSubmit(ids []string) []string { return Submit(c.store.Fetch, ids) }\n",
+        ),
+    ]);
+    let callers = project.callers_of_method("Fetch");
+    for caller in ["Direct", "ViaGo", "ViaSubmit"] {
+        assert!(
+            callers.contains(&caller.to_string()),
+            "{caller}: {callers:?}"
+        );
+    }
+    assert_eq!(
+        project.source_names(&project.fn_ref_edges_into("Fetch")),
+        vec!["ViaSubmit"]
+    );
+}
+
+#[test]
+fn python_receiver_identity_beats_same_file_and_imported_decoys() {
+    let project = resolve_project(&[
+        (
+            "store.py",
+            "class Store:\n    def fetch(self, ids):\n        return ids\n",
+        ),
+        (
+            "main.py",
+            "from store import Store as Actual\n\
+             class Store:\n\
+             \x20   def fetch(self, ids):\n\
+             \x20       return ids\n\
+             class Consumer:\n\
+             \x20   def __init__(self, store: Actual):\n\
+             \x20       self.store = store\n\
+             \x20   def callback(self, pool, ids):\n\
+             \x20       return pool.submit(self.store.fetch, ids)\n\
+             \x20   def assigned(self):\n\
+             \x20       cb = self.store.fetch\n\
+             \x20   def collected(self):\n\
+             \x20       return [self.store.fetch]\n\
+             def typed(obj: Actual, pool):\n\
+             \x20   pool.submit(obj.fetch)\n\
+             def static(pool):\n\
+             \x20   pool.submit(Actual.fetch)\n",
+        ),
+    ]);
+    let edges = project.fn_ref_edges_into("fetch");
+    assert_eq!(
+        project.source_names(&edges),
+        vec!["assigned", "callback", "collected", "static", "typed"]
+    );
+    assert!(
+        edges
+            .iter()
+            .all(|edge| project.target(edge).file_path == "store.py")
+    );
+}
+
+#[test]
+fn python_same_file_ambiguity_and_noncallable_members_stay_unlinked() {
+    let project = resolve_project(&[(
+        "main.py",
+        "class A:\n\
+         \x20   def fetch(self):\n\
+         \x20       return 1\n\
+         class B:\n\
+         \x20   def fetch(self):\n\
+         \x20       return 2\n\
+         class Data:\n\
+         \x20   fetch = 42\n\
+         class Property:\n\
+         \x20   @property\n\
+         \x20   def fetch(self):\n\
+         \x20       return 42\n\
+         def unknown(obj, pool):\n\
+         \x20   pool.submit(obj.fetch)\n\
+         def data(obj: Data, pool):\n\
+         \x20   pool.submit(obj.fetch)\n\
+         def prop(obj: Property, pool):\n\
+         \x20   pool.submit(obj.fetch)\n\
+         def bare(fetch, pool):\n\
+         \x20   pool.submit(fetch)\n\
+         class Own:\n\
+         \x20   def fetch(self):\n\
+         \x20       return 3\n\
+         \x20   def bound(self, pool):\n\
+         \x20       pool.submit(self.fetch)\n\
+         \x20   @classmethod\n\
+         \x20   def class_bound(cls, pool):\n\
+         \x20       pool.submit(cls.fetch)\n",
+    )]);
+    let edges = project.fn_ref_edges_into("fetch");
+    assert_eq!(project.source_names(&edges), vec!["bound", "class_bound"]);
+    assert!(
+        edges
+            .iter()
+            .all(|edge| project.target(edge).qualified_name == "Own::fetch")
+    );
+}
+
+#[test]
+fn python_typed_constructed_and_inherited_receivers_exclude_noncallable_values() {
+    let project = resolve_project(&[(
+        "main.py",
+        "class Store:\n\
+         \x20   def fetch(self):\n\
+         \x20       return 1\n\
+         class Child(Store):\n\
+         \x20   def inherited(self, pool):\n\
+         \x20       pool.submit(self.fetch)\n\
+         class Data:\n\
+         \x20   def __init__(self):\n\
+         \x20       self.fetch = 42\n\
+         class Override(Store):\n\
+         \x20   def __init__(self):\n\
+         \x20       self.fetch = 42\n\
+         class Consumer:\n\
+         \x20   def __init__(self):\n\
+         \x20       self.store = Store()\n\
+         \x20   def keyword(self, pool):\n\
+         \x20       pool.submit(callback=self.store.fetch)\n\
+         def constructor(pool):\n\
+         \x20   obj = Store()\n\
+         \x20   pool.submit(obj.fetch)\n\
+         def partial_ref(obj: Store):\n\
+         \x20   return partial(obj.fetch, 1)\n\
+         def mapped(obj: Store, xs):\n\
+         \x20   return map(obj.fetch, xs)\n\
+         def data(obj: Data, pool):\n\
+         \x20   pool.submit(obj.fetch)\n\
+         def override(obj: Override, pool):\n\
+         \x20   pool.submit(obj.fetch)\n\
+         def primitive(obj: int, pool):\n\
+         \x20   pool.submit(obj.fetch)\n\
+         def literal(pool):\n\
+         \x20   obj = 42\n\
+         \x20   pool.submit(obj.fetch)\n\
+         def reassigned(obj: Store, pool):\n\
+         \x20   obj = 42\n\
+         \x20   pool.submit(obj.fetch)\n\
+         def direct(obj: Store):\n\
+         \x20   obj.fetch()\n",
+    )]);
+    assert_eq!(
+        project.source_names(&project.fn_ref_edges_into("fetch")),
+        vec![
+            "constructor",
+            "inherited",
+            "keyword",
+            "mapped",
+            "partial_ref"
+        ]
+    );
+    let fetch = project
+        .store()
+        .nodes_by_name("fetch")
+        .expect("nodes")
+        .into_iter()
+        .find(|node| node.kind == NodeKind::Method)
+        .expect("fetch");
+    let calls = project
+        .store()
+        .edges_by_target_kind(&fetch.id, Some(EdgeKind::Calls))
+        .expect("calls");
+    assert!(project.source_names(&calls).contains(&"direct".to_string()));
+}
+
+#[test]
+fn go_receiver_types_disambiguate_method_values_and_reject_external_fields() {
+    let project = resolve_project(&[(
+        "main.go",
+        "package demo\n\
+         import \"database/sql\"\n\
+         type Store struct{}\n\
+         func (s *Store) Fetch() {}\n\
+         type Decoy struct{}\n\
+         func (d *Decoy) Fetch() {}\n\
+         type Consumer struct { store *Store; external *sql.DB }\n\
+         func (c *Consumer) Callback() { Submit(c.store.Fetch) }\n\
+         func Typed(s *Store) { Submit(s.Fetch) }\n\
+         func Assigned(s *Store) { cb := s.Fetch }\n\
+         func Collected(s *Store) { table := []func(){s.Fetch} }\n\
+         func MethodExpression() { Submit(Store.Fetch) }\n\
+         func (c *Consumer) External() { Submit(c.external.Fetch) }\n\
+         func Unknown(obj interface{}) { Submit(obj.Fetch) }\n",
+    )]);
+    let edges = project.fn_ref_edges_into("Fetch");
+    assert_eq!(
+        project.source_names(&edges),
+        vec![
+            "Assigned",
+            "Callback",
+            "Collected",
+            "MethodExpression",
+            "Typed"
+        ]
+    );
+    assert!(
+        edges
+            .iter()
+            .all(|edge| project.target(edge).qualified_name == "Store::Fetch")
+    );
+}

From fafeeedd107a16322a36d39945c156916585515b Mon Sep 17 00:00:00 2001
From: CodeGraph Test <codegraph@example.invalid>
Date: Thu, 1 Oct 2026 08:37:34 +0800
Subject: [PATCH 4/6] feat(resolve): resolve default-exported namespace objects
 and JSX handler values
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

const UploadApi = { uploadARCapture, makeFolder: createFolder };
export default UploadApi made every UploadApi.member() call from another
file land on a guessed first exported function, because the constant is
not exported at its declaration. A default import now finds the binding the
export default statement names — a namespace object included — after a
component file and before the first-exported-function guess, and the
member resolves through the literal's own bindings.

TS/JS function values also cover JSX attribute expressions
(onPress={handleSubmit}) and object shorthand members (a hook's
return { handleApprove }), so the handler a component or hook hands out has
an edge (upstream F13, 873f133).
---
 crates/codegraph-extract/src/function_ref.rs  | 12 +++-
 .../tests/js_callable_semantics.rs            | 54 +++++++++++++++++
 .../codegraph-resolve/src/import_resolver.rs  | 34 ++++++++++-
 .../tests/js_receiver_evidence.rs             | 58 +++++++++++++++++++
 4 files changed, 156 insertions(+), 2 deletions(-)

diff --git a/crates/codegraph-extract/src/function_ref.rs b/crates/codegraph-extract/src/function_ref.rs
index 3f17a202..ce3cc1a2 100644
--- a/crates/codegraph-extract/src/function_ref.rs
+++ b/crates/codegraph-extract/src/function_ref.rs
@@ -137,13 +137,23 @@ const OBJC_SPEC: FnRefSpec = c_family_spec(&["selector_expression"], false);
 
 /// Ports `TS_JS_SPEC` (function-ref.ts:177-187).
 const TS_JS_SPEC: FnRefSpec = FnRefSpec {
-    id_types: &["identifier"],
+    // `shorthand_property_identifier`: `{ handleSubmit }` — the object a hook
+    // returns its handlers in, and a namespace object's members.
+    id_types: &["identifier", "shorthand_property_identifier"],
     dispatch: &[
         ("arguments", CaptureMode::Args, None),
         ("assignment_expression", CaptureMode::Rhs, Some("right")),
         ("variable_declarator", CaptureMode::VarInit, Some("value")),
         ("pair", CaptureMode::Value, Some("value")),
         ("array", CaptureMode::List, None),
+        // A JSX attribute value or child — `onPress={handleSubmit}`,
+        // `renderItem={renderRow}`: React's handler-binding idiom. A spread or
+        // a call normalizes to nothing.
+        ("jsx_expression", CaptureMode::List, None),
+        // An object literal's shorthand members — `return { handleApprove }`
+        // from a hook, `const Api = { upload }`. Only a shorthand identifier
+        // normalizes; a `pair` is its own container above.
+        ("object", CaptureMode::List, None),
     ],
     layers: &[],
     unwrap: &[],
diff --git a/crates/codegraph-extract/tests/js_callable_semantics.rs b/crates/codegraph-extract/tests/js_callable_semantics.rs
index e3015c00..21f82c0b 100644
--- a/crates/codegraph-extract/tests/js_callable_semantics.rs
+++ b/crates/codegraph-extract/tests/js_callable_semantics.rs
@@ -287,3 +287,57 @@ export const mixed = {
     let make = node(&result, NodeKind::Function, "make");
     assert!(!calls_from(&result, &make.id).contains(&"helper"));
 }
+
+#[test]
+fn jsx_attributes_and_returned_shorthands_are_function_values() {
+    // Upstream F13 (`873f133`): `onPress={handleApprove}` and a hook's
+    // `return { handleApprove, handleRetake, extra: helper }` hand handlers
+    // out as values; a shorthand naming a non-callable (`count`) does not.
+    let screen = extract(
+        "src/app/review.tsx",
+        r#"
+import { useCallback } from 'react'
+export default function ReviewScreen() {
+  const handleApprove = useCallback(() => {
+    finalize()
+  }, [])
+  return <Button onPress={handleApprove} />
+}
+"#,
+        Language::Tsx,
+    );
+    let component = node(&screen, NodeKind::Function, "ReviewScreen");
+    assert!(
+        screen.unresolved_references.iter().any(|reference| {
+            reference.from_node_id == component.id
+                && reference.is_function_ref
+                && reference.reference_name == "handleApprove"
+        }),
+        "{:#?}",
+        screen.unresolved_references
+    );
+
+    let hooks = extract(
+        "src/hooks.ts",
+        r#"
+import { useCallback } from 'react'
+export function useReviewHandlers() {
+  const handleApprove = useCallback(() => { finalize() }, [])
+  const handleRetake = useCallback(() => { retake() }, [])
+  const count = 1
+  return { handleApprove, handleRetake, count, extra: helper }
+}
+function helper() {}
+"#,
+        Language::TypeScript,
+    );
+    let hook = node(&hooks, NodeKind::Function, "useReviewHandlers");
+    let mut values = hooks
+        .unresolved_references
+        .iter()
+        .filter(|reference| reference.from_node_id == hook.id && reference.is_function_ref)
+        .map(|reference| reference.reference_name.as_str())
+        .collect::<Vec<_>>();
+    values.sort_unstable();
+    assert_eq!(values, vec!["handleApprove", "handleRetake", "helper"]);
+}
diff --git a/crates/codegraph-resolve/src/import_resolver.rs b/crates/codegraph-resolve/src/import_resolver.rs
index 7d3ba576..e5ee6fee 100644
--- a/crates/codegraph-resolve/src/import_resolver.rs
+++ b/crates/codegraph-resolve/src/import_resolver.rs
@@ -1969,8 +1969,10 @@ fn find_exported_symbol(
     let nodes_in_file = context.get_nodes_in_file_shared(file_path);
     let re_exports = context.get_re_exports(file_path, language);
 
+    // A default request is answered below, where a component file and the
+    // `export default NAME` binding take precedence (upstream F13).
     let requested_name = if want.is_default {
-        Some("default")
+        None
     } else if want.is_namespace {
         want.member_name.as_deref()
     } else {
@@ -1997,9 +1999,39 @@ fn find_exported_symbol(
 
     // Direct hit (import-resolver.ts:1829-1853).
     if want.is_default {
+        // A component file IS its default export; otherwise the binding an
+        // `export default NAME` statement names — a function, class, component,
+        // or a namespace object such as `const Api = { upload }` that is not
+        // exported at its declaration — beats the first-exported-function
+        // guess (upstream F13 / `defaultExportBindingNode`).
+        let bound_name = re_exports.iter().find_map(|rex| match rex {
+            ReExport::LocalAlias {
+                exported_name,
+                original_name,
+            } if exported_name == "default" => Some(original_name.as_str()),
+            _ => None,
+        });
+        let bound = || {
+            let name = bound_name?;
+            nodes_in_file
+                .iter()
+                .filter(|n| {
+                    n.name == name
+                        && matches!(
+                            n.kind,
+                            NodeKind::Function
+                                | NodeKind::Class
+                                | NodeKind::Component
+                                | NodeKind::Constant
+                                | NodeKind::Variable
+                        )
+                })
+                .min_by_key(|n| (n.start_line, n.start_column))
+        };
         if let Some(direct) = nodes_in_file
             .iter()
             .find(|n| n.is_exported && n.kind == NodeKind::Component)
+            .or_else(bound)
             .or_else(|| {
                 nodes_in_file.iter().find(|n| {
                     n.is_exported && matches!(n.kind, NodeKind::Function | NodeKind::Class)
diff --git a/crates/codegraph-resolve/tests/js_receiver_evidence.rs b/crates/codegraph-resolve/tests/js_receiver_evidence.rs
index cb84c8da..5bf1d9ac 100644
--- a/crates/codegraph-resolve/tests/js_receiver_evidence.rs
+++ b/crates/codegraph-resolve/tests/js_receiver_evidence.rs
@@ -1359,3 +1359,61 @@ export function crossCaller() { return facade.run(); }
         "{nested:?}"
     );
 }
+
+// ---- default-export namespace objects (F13) --------------------------------
+
+#[test]
+fn a_default_exported_namespace_object_resolves_its_members() {
+    let project = resolve_project(&files(&[
+        ("package.json", "{\"name\":\"app\"}"),
+        (
+            "src/api/frames.ts",
+            "export async function uploadARCapture(uri: string) {\n  return uri\n}\n",
+        ),
+        (
+            "src/api/folders.ts",
+            "export function createFolder(name: string) {\n  return name\n}\n",
+        ),
+        (
+            "src/api/index.ts",
+            "import { uploadARCapture } from './frames'\n\
+             import { createFolder } from './folders'\n\
+             function localHelper() {\n  return 1\n}\n\
+             const UploadApi = {\n  uploadARCapture,\n  makeFolder: createFolder,\n  localHelper,\n}\n\
+             export default UploadApi\n",
+        ),
+        (
+            "src/hooks.ts",
+            "import UploadApi from './api'\n\
+             export function handleZipComplete(uri: string) {\n\
+             \x20 UploadApi.makeFolder(uri)\n\
+             \x20 UploadApi.localHelper()\n\
+             \x20 return UploadApi.uploadARCapture(uri)\n\
+             }\n",
+        ),
+    ]));
+    assert_eq!(
+        project.callees("handleZipComplete", None),
+        vec!["createFolder", "localHelper", "uploadARCapture"]
+    );
+}
+
+#[test]
+fn a_default_import_of_a_later_exported_const_finds_that_const() {
+    let project = resolve_project(&files(&[
+        ("package.json", "{\"name\":\"app\"}"),
+        (
+            "src/store.ts",
+            "const useStore = {\n  read() {\n    return 1\n  },\n}\n\
+             export function unrelated() {\n  return 2\n}\n\
+             export default useStore\n",
+        ),
+        (
+            "src/use.ts",
+            "import store from './store'\nexport function consume() {\n  return store.read()\n}\n",
+        ),
+    ]));
+    // Without the `export default NAME` binding the default import guessed the
+    // first exported function (`unrelated`).
+    assert_eq!(project.callees("consume", None), vec!["useStore::read"]);
+}

From 78c4e02a069efd2823838bd78ab4999d8373580b Mon Sep 17 00:00:00 2001
From: CodeGraph Test <codegraph@example.invalid>
Date: Thu, 1 Oct 2026 08:47:55 +0800
Subject: [PATCH 5/6] feat(cli): report how each caller or callee relates to
 the symbol
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

callers and callees now follow instantiates edges, as upstream has since
#774/#804: a function that constructs a class is that class's caller, and
the class is its callee. Each node in the callers/callees JSON — per
definition and in the union list — carries relationships, the distinct
edge kinds that link it to the queried symbol, and text output marks a
non-call link as [instantiates] or [references] (upstream #1839).

Three structural MCP fixtures move with the instantiation edge and nothing
else: runDemo's callees gain Counter, Counter's trail and blast radius gain
runDemo, and explore's symbol count and file-header order follow.
---
 crates/codegraph-cli/src/main.rs              | 91 +++++++++++++++----
 .../tests/definition_grouping.rs              | 41 +++++++++
 crates/codegraph-graph/src/graph/mod.rs       | 22 +++--
 crates/codegraph-graph/tests/traversal.rs     |  6 +-
 reference/golden/mcp/codegraph_callees.json   |  2 +-
 reference/golden/mcp/codegraph_explore.json   |  2 +-
 reference/golden/mcp/codegraph_node.json      |  2 +-
 7 files changed, 134 insertions(+), 32 deletions(-)

diff --git a/crates/codegraph-cli/src/main.rs b/crates/codegraph-cli/src/main.rs
index 9e77d466..1ea248a0 100644
--- a/crates/codegraph-cli/src/main.rs
+++ b/crates/codegraph-cli/src/main.rs
@@ -4289,11 +4289,6 @@ fn cmd_callers(
         Related::Callers,
         file.as_deref(),
     )?;
-    let summaries = report
-        .union
-        .iter()
-        .map(NodeSummary::from)
-        .collect::<Vec<_>>();
     let godot = godot_honesty_for_symbol(&store, &project, &symbol)?;
     if json_output {
         let targets = report
@@ -4311,14 +4306,14 @@ fn cmd_callers(
             "filteredOut": report.filtered_out,
             "note": report.note,
             "definitions": related_definitions_json(&report, Related::Callers),
-            "callers": summaries,
+            "callers": related_union_json(&report, Related::Callers),
             "total": report.total,
             "limit": report.limit,
             "truncated": report.total > report.limit,
             "godotDynamic": godot.as_json(),
         }))?;
     } else {
-        print_related_report("Callers", "callers", &symbol, &report);
+        print_related_report("Callers", "callers", &symbol, &report, Related::Callers);
         godot.print_cli(report.union.is_empty());
     }
     if strict && report.union.is_empty() {
@@ -4345,11 +4340,6 @@ fn cmd_callees(
         Related::Callees,
         file.as_deref(),
     )?;
-    let summaries = report
-        .union
-        .iter()
-        .map(NodeSummary::from)
-        .collect::<Vec<_>>();
     if json_output {
         let targets = report
             .definitions
@@ -4366,13 +4356,13 @@ fn cmd_callees(
             "filteredOut": report.filtered_out,
             "note": report.note,
             "definitions": related_definitions_json(&report, Related::Callees),
-            "callees": summaries,
+            "callees": related_union_json(&report, Related::Callees),
             "total": report.total,
             "limit": report.limit,
             "truncated": report.total > report.limit,
         }))?;
     } else {
-        print_related_report("Callees", "callees", &symbol, &report);
+        print_related_report("Callees", "callees", &symbol, &report, Related::Callees);
     }
     if strict && report.union.is_empty() {
         bail!("codegraph callees: no callees found for \"{symbol}\"");
@@ -6239,10 +6229,12 @@ fn related_definitions_json(report: &RelatedReport, related: Related) -> Vec<ser
                         .map(|node| {
                             let mut value = serde_json::to_value(NodeSummary::from(node))
                                 .expect("node summary serializes");
-                            value
-                                .as_object_mut()
-                                .expect("node summary is object")
-                                .insert("id".to_string(), json!(node.id));
+                            let object = value.as_object_mut().expect("node summary is object");
+                            object.insert("id".to_string(), json!(node.id));
+                            object.insert(
+                                "relationships".to_string(),
+                                json!(relationships(node, &definition.edges, related)),
+                            );
                             value
                         })
                         .collect(),
@@ -6269,6 +6261,49 @@ enum Related {
     Callees,
 }
 
+/// The distinct edge kinds that link `node` to the queried symbol, in edge
+/// order — `["calls", "instantiates"]` for a caller that both calls and
+/// constructs it (upstream #1839).
+fn relationships(node: &Node, edges: &[Edge], related: Related) -> Vec<&'static str> {
+    let mut kinds = Vec::new();
+    for edge in edges {
+        let end = match related {
+            Related::Callers => &edge.source,
+            Related::Callees => &edge.target,
+        };
+        if end == &node.id && !kinds.contains(&edge.kind.as_str()) {
+            kinds.push(edge.kind.as_str());
+        }
+    }
+    kinds
+}
+
+/// The legacy union list with each node's relationships across every
+/// definition.
+fn related_union_json(report: &RelatedReport, related: Related) -> Vec<serde_json::Value> {
+    let edges = report
+        .definitions
+        .iter()
+        .flat_map(|definition| definition.edges.iter().cloned())
+        .collect::<Vec<_>>();
+    report
+        .union
+        .iter()
+        .map(|node| {
+            let mut value =
+                serde_json::to_value(NodeSummary::from(node)).expect("node summary serializes");
+            value
+                .as_object_mut()
+                .expect("node summary is object")
+                .insert(
+                    "relationships".to_string(),
+                    json!(relationships(node, &edges, related)),
+                );
+            value
+        })
+        .collect()
+}
+
 /// Collected Godot honesty signals for the matched symbols of one query: the
 /// runtime-reachability reasons (so "no static callers" is never reported as
 /// dead) and the symbols' own `godot:dynamic:` computed call-sites. Empty for
@@ -7018,7 +7053,13 @@ fn print_related(label: &str, symbol: &str, nodes: &[NodeSummary]) {
     }
 }
 
-fn print_related_report(title: &str, label: &str, symbol: &str, report: &RelatedReport) {
+fn print_related_report(
+    title: &str,
+    label: &str,
+    symbol: &str,
+    report: &RelatedReport,
+    related: Related,
+) {
     if let Some(note) = &report.note {
         println!("Note: {note}");
     }
@@ -7057,7 +7098,17 @@ fn print_related_report(title: &str, label: &str, symbol: &str, report: &Related
             continue;
         }
         for node in definition.nodes.iter().take(report.limit) {
-            println!("{:<12}{}", node.kind, node.name);
+            // Kinds other than a plain call — `[instantiates]`, `[references]`.
+            let kinds = relationships(node, &definition.edges, related)
+                .into_iter()
+                .filter(|kind| *kind != "calls")
+                .collect::<Vec<_>>();
+            let relation = if kinds.is_empty() {
+                String::new()
+            } else {
+                format!(" [{}]", kinds.join(", "))
+            };
+            println!("{:<12}{}{relation}", node.kind, node.name);
             println!("  {}:{}\n", node.file_path, node.start_line);
         }
         if definition.nodes.len() > report.limit {
diff --git a/crates/codegraph-cli/tests/definition_grouping.rs b/crates/codegraph-cli/tests/definition_grouping.rs
index 1de58e07..01e42bc8 100644
--- a/crates/codegraph-cli/tests/definition_grouping.rs
+++ b/crates/codegraph-cli/tests/definition_grouping.rs
@@ -189,3 +189,44 @@ fn limits_and_impact_metadata_tell_the_truth() {
         assert!(definition["affected"][0]["id"].is_string());
     }
 }
+
+#[test]
+fn callers_report_each_callers_relationship_kinds() {
+    // Upstream #1839 (CLI): a caller that constructs the symbol is marked, in
+    // JSON and in text, so it is not read as a plain call.
+    let dir = TestDir::new();
+    fs::write(
+        dir.0.join("widget.ts"),
+        "export class Widget {}\n\
+         export function make() { return new Widget(); }\n\
+         export function use() { return make(); }\n",
+    )
+    .unwrap();
+    let path = dir.0.to_str().unwrap();
+    let (stdout, stderr, ok) = run(&dir.0, &["init", path]);
+    assert!(ok, "init failed: stdout={stdout} stderr={stderr}");
+
+    let widget = json(&dir.0, &["callers", "Widget", "--path", path, "--json"]);
+    assert_eq!(widget["callers"][0]["name"], "make");
+    assert_eq!(
+        widget["callers"][0]["relationships"],
+        serde_json::json!(["instantiates"])
+    );
+    assert_eq!(
+        widget["definitions"][0]["callers"][0]["relationships"],
+        serde_json::json!(["instantiates"])
+    );
+    let make = json(&dir.0, &["callers", "make", "--path", path, "--json"]);
+    assert_eq!(
+        make["callers"][0]["relationships"],
+        serde_json::json!(["calls"])
+    );
+
+    let (text, stderr, ok) = run(&dir.0, &["callers", "Widget", "--path", path]);
+    assert!(ok, "callers failed: {stderr}");
+    assert!(text.contains("make [instantiates]"), "{text}");
+    let (text, stderr, ok) = run(&dir.0, &["callers", "make", "--path", path]);
+    assert!(ok, "callers failed: {stderr}");
+    assert!(text.contains("use\n"), "{text}");
+    assert!(!text.contains("[calls]"), "{text}");
+}
diff --git a/crates/codegraph-graph/src/graph/mod.rs b/crates/codegraph-graph/src/graph/mod.rs
index 58dd29e5..8b134126 100644
--- a/crates/codegraph-graph/src/graph/mod.rs
+++ b/crates/codegraph-graph/src/graph/mod.rs
@@ -371,8 +371,8 @@ impl<'store> GraphTraverser<'store> {
     }
 
     /// Ports `getCallers` from `upstream graph/traversal.ts:230-266`.
-    /// Incoming `calls`/`references`/`imports` edges, recursive to `max_depth`,
-    /// cycle-safe via `visited`.
+    /// Incoming `calls`/`references`/`imports`/`instantiates` edges, recursive
+    /// to `max_depth`, cycle-safe via `visited`.
     pub fn get_callers(&self, node_id: &str, max_depth: usize) -> rusqlite::Result<Vec<NodeEdge>> {
         let mut result = Vec::new();
         let mut visited = HashMap::new();
@@ -403,7 +403,12 @@ impl<'store> GraphTraverser<'store> {
 
         let incoming = self.incoming_edges_kinds(
             node_id,
-            &[EdgeKind::Calls, EdgeKind::References, EdgeKind::Imports],
+            &[
+                EdgeKind::Calls,
+                EdgeKind::References,
+                EdgeKind::Imports,
+                EdgeKind::Instantiates,
+            ],
         )?;
         if incoming.is_empty() {
             return Ok(());
@@ -501,8 +506,8 @@ impl<'store> GraphTraverser<'store> {
     }
 
     /// Ports `getCallees` from `upstream graph/traversal.ts:275-310`.
-    /// Outgoing `calls`/`references`/`imports` edges, recursive to `max_depth`,
-    /// cycle-safe via `visited`.
+    /// Outgoing `calls`/`references`/`imports`/`instantiates` edges, recursive
+    /// to `max_depth`, cycle-safe via `visited`.
     pub fn get_callees(&self, node_id: &str, max_depth: usize) -> rusqlite::Result<Vec<NodeEdge>> {
         let mut result = Vec::new();
         let mut visited = HashMap::new();
@@ -533,7 +538,12 @@ impl<'store> GraphTraverser<'store> {
 
         let outgoing = self.outgoing_edges_kinds(
             node_id,
-            &[EdgeKind::Calls, EdgeKind::References, EdgeKind::Imports],
+            &[
+                EdgeKind::Calls,
+                EdgeKind::References,
+                EdgeKind::Imports,
+                EdgeKind::Instantiates,
+            ],
         )?;
         if outgoing.is_empty() {
             return Ok(());
diff --git a/crates/codegraph-graph/tests/traversal.rs b/crates/codegraph-graph/tests/traversal.rs
index 96ab28ae..157d253e 100644
--- a/crates/codegraph-graph/tests/traversal.rs
+++ b/crates/codegraph-graph/tests/traversal.rs
@@ -270,9 +270,9 @@ fn callees_returns_outgoing_call_reference_import_targets() {
     let callees = traverser.get_callees(RUN_DEMO, 1).expect("callees");
     let got = id_set(callees.iter().map(|c| c.node.id.clone()));
 
-    // runDemo calls increment (x2, deduped) and add; instantiates Counter is
-    // excluded (not in the calls/references/imports callee kinds).
-    let want = id_set([INCREMENT, ADD].map(str::to_string));
+    // runDemo calls increment (x2, deduped) and add, and instantiates Counter:
+    // class instantiation is a caller/callee edge (upstream #774/#804).
+    let want = id_set([INCREMENT, ADD, COUNTER].map(str::to_string));
     assert_eq!(got, want, "callees(runDemo) mismatch");
 }
 
diff --git a/reference/golden/mcp/codegraph_callees.json b/reference/golden/mcp/codegraph_callees.json
index 688d2e1b..41ea9f0b 100644
--- a/reference/golden/mcp/codegraph_callees.json
+++ b/reference/golden/mcp/codegraph_callees.json
@@ -18,7 +18,7 @@
       "content": [
         {
           "type": "text",
-          "text": "## Callees of runDemo (2 found)\n\n- increment (method) - src/math.ts:8\n- add (function) - src/math.ts:1"
+          "text": "## Callees of runDemo (3 found)\n\n- increment (method) - src/math.ts:8\n- add (function) - src/math.ts:1\n- Counter (class) - src/math.ts:5"
         }
       ]
     }
diff --git a/reference/golden/mcp/codegraph_explore.json b/reference/golden/mcp/codegraph_explore.json
index 4b00da06..43bf55da 100644
--- a/reference/golden/mcp/codegraph_explore.json
+++ b/reference/golden/mcp/codegraph_explore.json
@@ -18,7 +18,7 @@
       "content": [
         {
           "type": "text",
-          "text": "## Exploration: Counter add runDemo\n\nFound 6 symbols across 2 files.\n\n### Blast radius — what depends on these (update/verify before editing)\n\n- `runDemo` (src/app.ts:3) — 1 caller in `src/app.ts`; no tests found within 3 caller hops\n- `add` (src/math.ts:1) — 3 callers in `src/app.ts`, `src/math.ts`; no tests found within 3 caller hops\n- `Counter` (src/math.ts:5) — 1 caller in `src/app.ts`; no tests found within 3 caller hops\n- `increment` (src/math.ts:8) — 1 caller in `src/app.ts`; no tests found within 3 caller hops\n\n### Source Code\n\n> The code below is the **verbatim, current on-disk source** of these files — re-read from disk on this call and line-numbered, byte-for-byte identical to what the Read tool returns. It is NOT a summary, outline, or stale cache. Treat each block as a Read you have already performed: do not Read a file shown here.\n\n#### src/math.ts — add(function), Counter(class), value(property), increment(method)\n\n```typescript\n1\texport function add(left: number, right: number): number {\n2\t  return left + right;\n3\t}\n4\t\n5\texport class Counter {\n6\t  private value = 0;\n7\t\n8\t  increment(step: number = 1): number {\n9\t    this.value = add(this.value, step);\n10\t    return this.value;\n11\t  }\n12\t}\n```\n\n#### src/app.ts — runDemo(function), app.ts(file)\n\n```typescript\n1\timport { Counter, add } from './math';\n2\t\n3\texport function runDemo(): number {\n4\t  const counter = new Counter();\n5\t  counter.increment(add(1, 2));\n6\t  return counter.increment();\n7\t}\n8\t\n9\trunDemo();\n```\n"
+          "text": "## Exploration: Counter add runDemo\n\nFound 7 symbols across 2 files.\n\n### Blast radius — what depends on these (update/verify before editing)\n\n- `runDemo` (src/app.ts:3) — 1 caller in `src/app.ts`; no tests found within 3 caller hops\n- `add` (src/math.ts:1) — 3 callers in `src/app.ts`, `src/math.ts`; no tests found within 3 caller hops\n- `Counter` (src/math.ts:5) — 2 callers in `src/app.ts`; no tests found within 3 caller hops\n- `increment` (src/math.ts:8) — 1 caller in `src/app.ts`; no tests found within 3 caller hops\n\n### Source Code\n\n> The code below is the **verbatim, current on-disk source** of these files — re-read from disk on this call and line-numbered, byte-for-byte identical to what the Read tool returns. It is NOT a summary, outline, or stale cache. Treat each block as a Read you have already performed: do not Read a file shown here.\n\n#### src/math.ts — add(function), Counter(class), value(property), increment(method)\n\n```typescript\n1\texport function add(left: number, right: number): number {\n2\t  return left + right;\n3\t}\n4\t\n5\texport class Counter {\n6\t  private value = 0;\n7\t\n8\t  increment(step: number = 1): number {\n9\t    this.value = add(this.value, step);\n10\t    return this.value;\n11\t  }\n12\t}\n```\n\n#### src/app.ts — app.ts(file), runDemo(function)\n\n```typescript\n1\timport { Counter, add } from './math';\n2\t\n3\texport function runDemo(): number {\n4\t  const counter = new Counter();\n5\t  counter.increment(add(1, 2));\n6\t  return counter.increment();\n7\t}\n8\t\n9\trunDemo();\n```\n"
         }
       ]
     }
diff --git a/reference/golden/mcp/codegraph_node.json b/reference/golden/mcp/codegraph_node.json
index 357c85da..1f55b559 100644
--- a/reference/golden/mcp/codegraph_node.json
+++ b/reference/golden/mcp/codegraph_node.json
@@ -19,7 +19,7 @@
       "content": [
         {
           "type": "text",
-          "text": "## Counter (class)\n\n**Location:** src/math.ts:5\n\n**Members (2):**\n\n- value (property):6 — `value`\n- increment (method):8 — `(step: number = 1): number`\n\n> Structural outline only. Read `src/math.ts` or call codegraph_node on a specific member for its body.\n### Trail — codegraph_node any of these to follow it (no Read needed)\n**Called by ←** app.ts (src/app.ts:1)"
+          "text": "## Counter (class)\n\n**Location:** src/math.ts:5\n\n**Members (2):**\n\n- value (property):6 — `value`\n- increment (method):8 — `(step: number = 1): number`\n\n> Structural outline only. Read `src/math.ts` or call codegraph_node on a specific member for its body.\n### Trail — codegraph_node any of these to follow it (no Read needed)\n**Called by ←** app.ts (src/app.ts:1), runDemo (src/app.ts:3)"
         }
       ]
     }

From 7b42f4b868617f3a6f48eb454b5d3d7bce803b19 Mon Sep 17 00:00:00 2001
From: CodeGraph Test <codegraph@example.invalid>
Date: Thu, 1 Oct 2026 08:52:33 +0800
Subject: [PATCH 6/6] docs(upstream): record where the v1.6.1 rows landed

---
 docs/upstream-sync/V1_6_1_AUDIT_2026-09-30.md | 107 ++++++++++--------
 1 file changed, 57 insertions(+), 50 deletions(-)

diff --git a/docs/upstream-sync/V1_6_1_AUDIT_2026-09-30.md b/docs/upstream-sync/V1_6_1_AUDIT_2026-09-30.md
index 65240abd..fa994fb8 100644
--- a/docs/upstream-sync/V1_6_1_AUDIT_2026-09-30.md
+++ b/docs/upstream-sync/V1_6_1_AUDIT_2026-09-30.md
@@ -20,38 +20,45 @@ documented divergence).
 
 ## Resolution and extraction
 
-| Issue / PR                                                            | Upstream             | Behavior                                                                                                                                                                            | Disposition                                                     | State                                                                                                                                                             |
-| --------------------------------------------------------------------- | -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| #1862 (a)                                                             | `4297b8e`            | an identifier-rooted TS/JS chain of three or more segments keeps its qualified call site; only a framework resolver may bind it                                                     | CORRECT                                                         | landed in this PR                                                                                                                                                 |
-| #1862 (b)                                                             | `4297b8e`            | typed method lookup matches within a language family (`.tsx` reaches `.ts`, `.js` reaches `.jsx`)                                                                                   | PORT                                                            | landed in #275                                                                                                                                                    |
-| #1862 (c), #647                                                       | `4297b8e`, `68eaf0d` | Zustand `get()`, `useStore.getState()`, destructured and selector bindings resolve inside one identified store; requires the store-initializer action extraction the port never had | PORT                                                            | landed in this PR                                                                                                                                                 |
-| #1987                                                                 | `b65e05b`            | `this.#field.m()` resolves on the private field's type; JS built-in method names need receiver evidence                                                                             | PORT                                                            | landed in this PR                                                                                                                                                 |
-| #1986                                                                 | `9649ce1`            | code references crossing code families need bridge evidence; TS/JS receiver wrappers peel and untyped expression receivers emit nothing                                             | PORT                                                            | landed in this PR                                                                                                                                                 |
-| #1857                                                                 | `53fe53d`            | a receiver-less Go call never binds a method                                                                                                                                        | CORRECT                                                         | landed in #275                                                                                                                                                    |
-| #1882                                                                 | `8f80819`            | Rust `self.m()` with same-named owners in several modules pins the caller's file                                                                                                    | CORRECT                                                         | landed in #275                                                                                                                                                    |
-| #1885 / #1840                                                         | `d0996a2`            | awaited receiver inference: block scope, reassignment, call tail, imported or reachable factory, `Promise<T>`                                                                       | CORRECT                                                         | landed in #275                                                                                                                                                    |
-| #1824                                                                 | `e27d6da`            | a Scala object is never a supertype target but owns methods and supertypes                                                                                                          | CORRECT                                                         | landed in #275                                                                                                                                                    |
-| #2040                                                                 | `9be3f1a`            | an unknown member of a named Python import stays unresolved                                                                                                                         | PORT                                                            | landed in this PR                                                                                                                                                 |
-| #2055                                                                 | `4960720`            | an inheritance ref that lands on a TS value moves to the same-file same-named type                                                                                                  | PORT                                                            | landed in this PR                                                                                                                                                 |
-| #1932                                                                 | `17d09bf`            | object-literal members that alias a function follow the binding lexically (last own property, spread/computed invalidation, shadowing)                                              | CORRECT                                                         | landed in this PR                                                                                                                                                 |
-| #1747                                                                 | `9fb2c25`            | a curried-wrapper function that is an object member is named by its key                                                                                                             | CORRECT                                                         | landed in this PR                                                                                                                                                 |
-| #1905                                                                 | `bd993b1`            | Python module/class/function body docstrings (PEP 257), joined after a preceding comment                                                                                            | PORT                                                            | landed in this PR                                                                                                                                                 |
-| #1373                                                                 | `9b5c8e4`            | single-argument C/C++ function macros recover the defined function name with local `#define` evidence                                                                               | PORT                                                            | landed in this PR                                                                                                                                                 |
-| #1820                                                                 | `5eaa6fe`            | Python attribute and Go selector method values keep their receiver and resolve through type/import scope                                                                            | CORRECT                                                         | receiver-qualified JS/TS/Python values landed in #275 and the Python named-import module fallback in this PR; Go selector values and Python scoped lookup planned |
-| #1838 / #1839 / #2069 / #2070                                         | `fa25883`, `15a5d1d` | translation-unit-ordered macro visibility; `extern`, array and `initializer_list` constructor rules; macro-name calls bind only functions                                           | CORRECT                                                         | constructor/macro basics landed in #275; the remainder planned                                                                                                    |
-| #1974                                                                 | `52df4d2`            | depth-limited traversal re-expands a node reached again at a shallower depth                                                                                                        | PORT                                                            | planned                                                                                                                                                           |
-| #1349                                                                 | `86708bf`            | a later same-line, same-name declaration gets a column-suffixed node id                                                                                                             | PORT, touches the node-id invariant                             | approved by the owner on 2026-10-01; planned                                                                                                                      |
-| #2072                                                                 | `fef3776`            | performance: memoised gates and caches, graph output unchanged                                                                                                                      | partial PORT                                                    | `this.<field>` declaration memo landed in this PR; per-file source facts in #275; the `file_exists` miss cache is planned                                         |
-| #1719                                                                 | (09-15 row)          | sealed-module markers read after blanking                                                                                                                                           | CORRECT                                                         | landed in #275                                                                                                                                                    |
-| #1642                                                                 | `4ebd0d6`            | `src/*/{java,kotlin,scala}/**/build/` is source, not build output                                                                                                                   | PORT                                                            | planned                                                                                                                                                           |
-| #1553                                                                 | `276df3a`            | resolver file reads stat first and skip non-regular or oversized files                                                                                                              | PORT                                                            | planned                                                                                                                                                           |
-| #1910                                                                 | `04ec5f5`            | bounded extraction reads and MPEG-TS sniffing for `.ts`                                                                                                                             | PORT                                                            | planned                                                                                                                                                           |
-| #1209 / #1222                                                         | `9e4b8e7`            | MyBatis closing tags tolerate whitespace                                                                                                                                            | PORT (refid half ALREADY-HAVE)                                  | planned                                                                                                                                                           |
-| #1906                                                                 | `c505d0d`            | Liquid `{% liquid %}` blocks                                                                                                                                                        | PORT                                                            | planned                                                                                                                                                           |
-| #1360                                                                 | `6184610`            | sync reports recovered orphan references                                                                                                                                            | PORT                                                            | planned                                                                                                                                                           |
-| #1829 / #1878                                                         | `4871114`            | git-stamped fast path for pending status                                                                                                                                            | KEEP-RUST (full inventory); fast path DEFER pending measurement | —                                                                                                                                                                 |
-| #1833 / #1849, #1830, #1784, #1823, #1519, #1350, #1348, #1359, #1361 | various              | already implemented by the port                                                                                                                                                     | ALREADY-HAVE                                                    | —                                                                                                                                                                 |
-| #1827, #1773, #1864, #1973 / #1543, #1355 / #1988 / #2038             | various              | Spring DI heuristics, Node `indexAll` spin, dominant-file SQL, dead-code, callback synthesis storage                                                                                | N/A                                                             | —                                                                                                                                                                 |
+| Issue / PR                                                            | Upstream             | Behavior                                                                                                                                                                            | Disposition                                                     | State                                                                                                                                                          |
+| --------------------------------------------------------------------- | -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| #1862 (a)                                                             | `4297b8e`            | an identifier-rooted TS/JS chain of three or more segments keeps its qualified call site; only a framework resolver may bind it                                                     | CORRECT                                                         | landed in #277                                                                                                                                                 |
+| #1862 (b)                                                             | `4297b8e`            | typed method lookup matches within a language family (`.tsx` reaches `.ts`, `.js` reaches `.jsx`)                                                                                   | PORT                                                            | landed in #275                                                                                                                                                 |
+| #1862 (c), #647                                                       | `4297b8e`, `68eaf0d` | Zustand `get()`, `useStore.getState()`, destructured and selector bindings resolve inside one identified store; requires the store-initializer action extraction the port never had | PORT                                                            | landed in #277                                                                                                                                                 |
+| #1987                                                                 | `b65e05b`            | `this.#field.m()` resolves on the private field's type; JS built-in method names need receiver evidence                                                                             | PORT                                                            | landed in #277                                                                                                                                                 |
+| #1986                                                                 | `9649ce1`            | code references crossing code families need bridge evidence; TS/JS receiver wrappers peel and untyped expression receivers emit nothing                                             | PORT                                                            | landed in #277                                                                                                                                                 |
+| #1857                                                                 | `53fe53d`            | a receiver-less Go call never binds a method                                                                                                                                        | CORRECT                                                         | landed in #275                                                                                                                                                 |
+| #1882                                                                 | `8f80819`            | Rust `self.m()` with same-named owners in several modules pins the caller's file                                                                                                    | CORRECT                                                         | landed in #275                                                                                                                                                 |
+| #1885 / #1840                                                         | `d0996a2`            | awaited receiver inference: block scope, reassignment, call tail, imported or reachable factory, `Promise<T>`                                                                       | CORRECT                                                         | landed in #275                                                                                                                                                 |
+| #1824                                                                 | `e27d6da`            | a Scala object is never a supertype target but owns methods and supertypes                                                                                                          | CORRECT                                                         | landed in #275                                                                                                                                                 |
+| #2040                                                                 | `9be3f1a`            | an unknown member of a named Python import stays unresolved                                                                                                                         | PORT                                                            | landed in #277                                                                                                                                                 |
+| #2055                                                                 | `4960720`            | an inheritance ref that lands on a TS value moves to the same-file same-named type                                                                                                  | PORT                                                            | landed in #277                                                                                                                                                 |
+| #1932                                                                 | `17d09bf`            | object-literal members that alias a function follow the binding lexically (last own property, spread/computed invalidation, shadowing)                                              | CORRECT                                                         | landed in #277                                                                                                                                                 |
+| #1747                                                                 | `9fb2c25`            | a curried-wrapper function that is an object member is named by its key                                                                                                             | CORRECT                                                         | landed in #277                                                                                                                                                 |
+| #1905                                                                 | `bd993b1`            | Python module/class/function body docstrings (PEP 257), joined after a preceding comment                                                                                            | PORT                                                            | landed in #277                                                                                                                                                 |
+| #1373                                                                 | `9b5c8e4`            | single-argument C/C++ function macros recover the defined function name with local `#define` evidence                                                                               | PORT                                                            | landed in #277                                                                                                                                                 |
+| #1820                                                                 | `5eaa6fe`            | Python attribute and Go selector method values keep their receiver and resolve through type/import scope                                                                            | CORRECT                                                         | receiver-qualified JS/TS/Python values landed in #275, the Python named-import module fallback in #277, Go selector values and Python receiver scoping in #278 |
+| #1838 / #1839 / #2069 / #2070                                         | `fa25883`, `15a5d1d` | translation-unit-ordered macro visibility; `extern`, array and `initializer_list` constructor rules; macro-name calls bind only functions                                           | CORRECT                                                         | constructor/macro basics landed in #275; translation-unit macro visibility, the newer constructor rules, #2069 and #2070 planned                               |
+| #1974                                                                 | `52df4d2`            | depth-limited traversal re-expands a node reached again at a shallower depth                                                                                                        | PORT                                                            | landed in #278                                                                                                                                                 |
+| #1349                                                                 | `86708bf`            | a later same-line, same-name declaration gets a column-suffixed node id                                                                                                             | PORT, touches the node-id invariant                             | landed in #278 (approved by the owner on 2026-10-01)                                                                                                           |
+| #2072                                                                 | `fef3776`            | performance: memoised gates and caches, graph output unchanged                                                                                                                      | partial PORT                                                    | `this.<field>` declaration memo landed in #277; per-file source facts in #275; the `file_exists` miss cache is planned                                         |
+| #1719                                                                 | (09-15 row)          | sealed-module markers read after blanking                                                                                                                                           | CORRECT                                                         | landed in #275                                                                                                                                                 |
+| #1642                                                                 | `4ebd0d6`            | `src/*/{java,kotlin,scala}/**/build/` is source, not build output                                                                                                                   | PORT                                                            | planned                                                                                                                                                        |
+| #1553                                                                 | `276df3a`            | resolver file reads stat first and skip non-regular or oversized files                                                                                                              | PORT                                                            | planned                                                                                                                                                        |
+| #1910                                                                 | `04ec5f5`            | bounded extraction reads and MPEG-TS sniffing for `.ts`                                                                                                                             | PORT                                                            | planned                                                                                                                                                        |
+| #1209 / #1222                                                         | `9e4b8e7`            | MyBatis closing tags tolerate whitespace                                                                                                                                            | PORT (refid half ALREADY-HAVE)                                  | planned                                                                                                                                                        |
+| #1906                                                                 | `c505d0d`            | Liquid `{% liquid %}` blocks                                                                                                                                                        | PORT                                                            | planned                                                                                                                                                        |
+| #1360                                                                 | `6184610`            | sync reports recovered orphan references                                                                                                                                            | PORT                                                            | planned                                                                                                                                                        |
+| #1829 / #1878                                                         | `4871114`            | git-stamped fast path for pending status                                                                                                                                            | KEEP-RUST (full inventory); fast path DEFER pending measurement | —                                                                                                                                                              |
+| #1833 / #1849, #1830, #1784, #1823, #1519, #1350, #1348, #1359, #1361 | various              | already implemented by the port                                                                                                                                                     | ALREADY-HAVE                                                    | —                                                                                                                                                              |
+| #1827, #1773, #1864, #1973 / #1543, #1355 / #1988 / #2038             | various              | Spring DI heuristics, Node `indexAll` spin, dominant-file SQL, dead-code, callback synthesis storage                                                                                | N/A                                                             | —                                                                                                                                                              |
+
+Findings outside the upstream range, recorded so the next audit starts from
+them: callers/callees never followed `instantiates` edges (upstream #774/#804,
+2026-06-11; fixed in #278), and Go field-chain calls such as
+`c.store.Fetch()` still resolve through the last receiver segment, where
+upstream reads the field's declared type (#1276/#1316); since #278 Go method
+values use that field-type rule.
 
 Two corrections found while porting, outside the upstream range but required
 for the rows above: the Rust TSX and JSX specs did not delegate the
@@ -72,23 +79,23 @@ KEEP-RUST divergences taken in this PR:
 
 ## MCP, CLI, installer, lifecycle and explore
 
-| Issue / PR                                                                           | Upstream                                                         | Behavior                                                                                                                                                        | Disposition                                                                                       | State          |
-| ------------------------------------------------------------------------------------ | ---------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- | -------------- |
-| #1832                                                                                | `cba44c9`                                                        | only a prompt that is entirely a task-notification envelope is skipped                                                                                          | CORRECT                                                                                           | landed in #275 |
-| #1967                                                                                | `94ae04d`                                                        | dynamic-import boundaries: template or concatenated specifiers are runtime imports                                                                              | PORT                                                                                              | planned        |
-| #1964                                                                                | `a9c8808`                                                        | a failed sync keeps the pending paths and owed full scan and retries                                                                                            | PORT                                                                                              | planned        |
-| #1959                                                                                | `2268a09`                                                        | restart a degraded watcher, RECOVERING/DISABLED banners, refuse drifted answers while degraded                                                                  | PORT                                                                                              | planned        |
-| #1654                                                                                | `4fd3e6d`                                                        | `como`/`wie` leave the unconditional structural keyword list                                                                                                    | PORT                                                                                              | planned        |
-| #1870                                                                                | `98718cf`                                                        | installer `detect()` is read-only; backups only when a config is rewritten                                                                                      | PORT                                                                                              | planned        |
-| #1839 (CLI)                                                                          | `fa25883`                                                        | callers/callees JSON carries each node's `relationships`                                                                                                        | PORT                                                                                              | planned        |
-| #1895                                                                                | `ee97a57`                                                        | MCP root discovery ignores a `codegraph.db` without a schema                                                                                                    | PORT (CLI ALREADY-HAVE)                                                                           | planned        |
-| #995                                                                                 | `c13bd08`                                                        | WSL `/mnt/<drive>` defaults to `.codegraph-wsl` and maps SQLITE_IOERR to guidance                                                                               | PORT                                                                                              | planned        |
-| #2053 / #1773                                                                        | `0a9f3de`, `c405ac5`                                             | bounded retry when Windows sharing violations block `daemon.pid` replacement                                                                                    | PORT                                                                                              | planned        |
-| #1294                                                                                | `d3671fa`                                                        | `install.sh` under MINGW/MSYS/CYGWIN points at the PowerShell installer                                                                                         | PORT                                                                                              | planned        |
-| #1904, PR #2062, PR #2063, PR #2068, PR #2071, PR #2077                              | `9ad6ee9`, `adad840`, `47840a6`, `724b5de`, `290e03f`, `003305f` | explore: empty-result lexical diagnostics, cluster budget order, line anchors as exact targets, single-file budget, same-basename pins, honest completion notes | PORT                                                                                              | planned        |
-| #1834, #1831, #1830, #1968, #1372, #1361, #1835, #1963 / #1356, #1325, #1902         | various                                                          | already implemented by the port                                                                                                                                 | ALREADY-HAVE                                                                                      | —              |
-| #770                                                                                 | `c897daf`                                                        | watch symlinked directories                                                                                                                                     | DEFER until the scan's symlink policy is settled (the scan does not follow symlinked directories) | —              |
-| telemetry, npm/fnm, Node timers, `FILE_NOTIFY_CHANGE_LAST_ACCESS`, test-only commits | various                                                          | no Rust analogue                                                                                                                                                | N/A                                                                                               | —              |
+| Issue / PR                                                                           | Upstream                                                         | Behavior                                                                                                                                                        | Disposition                                                                                       | State                                                                                                         |
+| ------------------------------------------------------------------------------------ | ---------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
+| #1832                                                                                | `cba44c9`                                                        | only a prompt that is entirely a task-notification envelope is skipped                                                                                          | CORRECT                                                                                           | landed in #275                                                                                                |
+| #1967                                                                                | `94ae04d`                                                        | dynamic-import boundaries: template or concatenated specifiers are runtime imports                                                                              | PORT                                                                                              | planned                                                                                                       |
+| #1964                                                                                | `a9c8808`                                                        | a failed sync keeps the pending paths and owed full scan and retries                                                                                            | PORT                                                                                              | planned                                                                                                       |
+| #1959                                                                                | `2268a09`                                                        | restart a degraded watcher, RECOVERING/DISABLED banners, refuse drifted answers while degraded                                                                  | PORT                                                                                              | planned                                                                                                       |
+| #1654                                                                                | `4fd3e6d`                                                        | `como`/`wie` leave the unconditional structural keyword list                                                                                                    | PORT                                                                                              | planned                                                                                                       |
+| #1870                                                                                | `98718cf`                                                        | installer `detect()` is read-only; backups only when a config is rewritten                                                                                      | PORT                                                                                              | planned                                                                                                       |
+| #1839 (CLI)                                                                          | `fa25883`                                                        | callers/callees JSON carries each node's `relationships`                                                                                                        | PORT                                                                                              | landed in #278, with callers/callees following `instantiates` edges (upstream #774/#804, never ported before) |
+| #1895                                                                                | `ee97a57`                                                        | MCP root discovery ignores a `codegraph.db` without a schema                                                                                                    | PORT (CLI ALREADY-HAVE)                                                                           | planned                                                                                                       |
+| #995                                                                                 | `c13bd08`                                                        | WSL `/mnt/<drive>` defaults to `.codegraph-wsl` and maps SQLITE_IOERR to guidance                                                                               | PORT                                                                                              | planned                                                                                                       |
+| #2053 / #1773                                                                        | `0a9f3de`, `c405ac5`                                             | bounded retry when Windows sharing violations block `daemon.pid` replacement                                                                                    | PORT                                                                                              | planned                                                                                                       |
+| #1294                                                                                | `d3671fa`                                                        | `install.sh` under MINGW/MSYS/CYGWIN points at the PowerShell installer                                                                                         | PORT                                                                                              | planned                                                                                                       |
+| #1904, PR #2062, PR #2063, PR #2068, PR #2071, PR #2077                              | `9ad6ee9`, `adad840`, `47840a6`, `724b5de`, `290e03f`, `003305f` | explore: empty-result lexical diagnostics, cluster budget order, line anchors as exact targets, single-file budget, same-basename pins, honest completion notes | PORT                                                                                              | planned                                                                                                       |
+| #1834, #1831, #1830, #1968, #1372, #1361, #1835, #1963 / #1356, #1325, #1902         | various                                                          | already implemented by the port                                                                                                                                 | ALREADY-HAVE                                                                                      | —                                                                                                             |
+| #770                                                                                 | `c897daf`                                                        | watch symlinked directories                                                                                                                                     | DEFER until the scan's symlink policy is settled (the scan does not follow symlinked directories) | —                                                                                                             |
+| telemetry, npm/fnm, Node timers, `FILE_NOTIFY_CHANGE_LAST_ACCESS`, test-only commits | various                                                          | no Rust analogue                                                                                                                                                | N/A                                                                                               | —                                                                                                             |
 
 A Rust-only defect found by this pass: the watcher treats only `locked`/`busy`
 errors as lock contention, but an index-lease timeout reports `timed out
@@ -111,7 +118,7 @@ were re-triaged:
 | F9 server route naming                                                                      | Express mount prefixes, FastAPI, ASP.NET groups                                             | resolvers the port does not have         | DEFER to the next round (owner decision, 2026-10-01) |
 | F10 / F11 explore Flow and branch guards                                                    | named-symbol flow section and `when` conditions                                             | explore output                           | DEFER to the next round (owner decision, 2026-10-01) |
 | F12 React Native bridge                                                                     | `NativeModules` → native methods                                                            | new resolver                             | DEFER to the next round (owner decision, 2026-10-01) |
-| F13 JS handler value references                                                             | JSX attribute and shorthand fnRefs, later-exported store actions, default namespace objects | extraction                               | PORT this round                                      |
+| F13 JS handler value references                                                             | JSX attribute and shorthand fnRefs, later-exported store actions, default namespace objects | extraction                               | PORT this round — landed in #278                     |
 
 ## Owner decisions