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-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-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/function_ref.rs b/crates/codegraph-extract/src/function_ref.rs
index 205bbdf2..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: &[],
@@ -183,7 +193,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 +583,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 +803,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 +892,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 +1366,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 +1401,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 +1415,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 +2293,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/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/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-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-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-graph/src/graph/mod.rs b/crates/codegraph-graph/src/graph/mod.rs
index 4e856e73..8b134126 100644
--- a/crates/codegraph-graph/src/graph/mod.rs
+++ b/crates/codegraph-graph/src/graph/mod.rs
@@ -371,12 +371,20 @@ 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 = 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,16 +394,21 @@ 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,
-            &[EdgeKind::Calls, EdgeKind::References, EdgeKind::Imports],
+            &[
+                EdgeKind::Calls,
+                EdgeKind::References,
+                EdgeKind::Imports,
+                EdgeKind::Instantiates,
+            ],
         )?;
         if incoming.is_empty() {
             return Ok(());
@@ -404,26 +417,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,
+                    )?;
                 }
             }
         }
@@ -492,12 +506,20 @@ 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 = 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,16 +529,21 @@ 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,
-            &[EdgeKind::Calls, EdgeKind::References, EdgeKind::Imports],
+            &[
+                EdgeKind::Calls,
+                EdgeKind::References,
+                EdgeKind::Imports,
+                EdgeKind::Instantiates,
+            ],
         )?;
         if outgoing.is_empty() {
             return Ok(());
@@ -526,23 +553,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 +724,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 +747,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 +770,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 +808,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 +1429,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..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");
 }
 
@@ -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()
+    );
+}
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/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/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"]);
+}
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-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")
+    );
+}
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:
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
 
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)"
         }
       ]
     }