fix(native): type map confidence-aware dedup for engine parity (#885)

* fix(native): type map confidence-aware dedup for engine parity

The native engine's type map used HashMap::collect() (last-wins) while
the JS engine used setTypeMapEntry (highest-confidence, first-wins on
tie). When the same variable name appeared in multiple function scopes
with different type annotations (e.g. `node: TreeSitterNode` and
`node: NodeRow` in cfg.ts), the engines disagreed on the resolved type,
producing different receiver/calls edges.

Additionally, the Rust JS extractor returned early after finding a type
annotation, skipping constructor inference — unlike the JS extractor
which lets constructors (confidence 1.0) override annotations (0.9).

Changes:
- Add `confidence` field to Rust TypeMapEntry and TypeMapInput structs
- Fix Rust edge builder to keep highest-confidence entry per name
- Remove early return in Rust JS extractor; emit both annotation and
  constructor entries with appropriate confidence levels
- Add confidence values to all 12 Rust language extractors
- Add JS-side type map dedup in buildCallEdgesNative for immediate
  parity without requiring a native addon rebuild

Verified: receiver edge counts now identical between engines (735=735),
cfg.ts correctly resolves to TreeSitterNode on both engines.

* feat(ci): gate release workflow on resolution precision/recall thresholds (#875)

Add resolution quality gates to the benchmark pipeline so regressions
are caught before publishing:

- benchmark.yml: run vitest resolution test after the benchmark script,
  failing the workflow if any language drops below its threshold
- update-benchmark-report.ts: warn on precision >5pp or recall >10pp
  drop per language between releases
- regression-guard.test.ts: hard-fail CI on precision/recall regressions
  across releases, with KNOWN_REGRESSIONS exemption support

* style: fix biome formatting in regression guard

* fix: remove invalid #[napi(default = 0.9)] attributes causing Rust compile failure

napi-rs v3 does not support the `default` attribute on `#[napi(object)]`
struct fields — only on function parameters. The macro expansion failed,
preventing TypeMapEntry and TypeMapInput from being generated, which
cascaded into "not found in scope" errors across all extractors and the
build pipeline. Removing the attribute is safe because all call sites
(JS buildCallEdgesNative and Rust build_pipeline) always provide the
confidence value explicitly.

* fix: clarify dedup comment per review — no-op for Map path, needed for Array path (#885)

Author: carlos-alm

.github/workflows/benchmark.yml

@@ -106,6 +106,10 @@ jobs:
           fi
           node $STRIP_FLAG --import ./scripts/ts-resolve-loader.js scripts/resolution-benchmark.ts $ARGS > resolution-result.json
 
+      - name: Gate on resolution thresholds
+        if: steps.existing.outputs.skip != 'true'
+        run: npx vitest run tests/benchmarks/resolution/resolution-benchmark.test.ts --reporter=verbose
+
       - name: Merge resolution into build result
         if: steps.existing.outputs.skip != 'true'
         run: |

Cargo.lock

@@ -877,6 +877,7 @@ fn build_and_insert_call_edges(
             .map(|t| TypeMapInput {
                 name: t.name.clone(),
                 type_name: t.type_name.clone(),
+                confidence: t.confidence,
             })
             .collect();
 

crates/codegraph-core/src/build_pipeline.rs

@@ -57,6 +57,8 @@ pub struct TypeMapInput {
     pub name: String,
     #[napi(js_name = "typeName")]
     pub type_name: String,
+    /// Confidence: 0.9 = type annotation, 1.0 = constructor, 0.7 = factory.
+    pub confidence: f64,
 }
 
 #[napi(object)]
@@ -153,10 +155,22 @@ fn process_file<'a>(
         .map(|im| (im.name.as_str(), im.file.as_str()))
         .collect();
 
-    let type_map: HashMap<&str, &str> = file_input
-        .type_map.iter()
-        .map(|tm| (tm.name.as_str(), tm.type_name.as_str()))
-        .collect();
+    // Build type map keeping the highest-confidence entry per name
+    // (first-wins on tie), matching the JS setTypeMapEntry behaviour.
+    let mut type_map: HashMap<&str, (&str, f64)> = HashMap::new();
+    for tm in &file_input.type_map {
+        let entry = type_map.entry(tm.name.as_str());
+        match entry {
+            std::collections::hash_map::Entry::Vacant(e) => {
+                e.insert((tm.type_name.as_str(), tm.confidence));
+            }
+            std::collections::hash_map::Entry::Occupied(mut e) => {
+                if tm.confidence > e.get().1 {
+                    e.insert((tm.type_name.as_str(), tm.confidence));
+                }
+            }
+        }
+    }
 
     let file_nodes: Vec<&NodeInfo> = all_nodes.iter().filter(|n| n.file == *rel_path).collect();
     let defs_with_ids: Vec<DefWithId> = file_input.definitions.iter().map(|d| {
@@ -210,7 +224,7 @@ fn resolve_call_targets<'a>(
     call: &CallInfo,
     rel_path: &str,
     imported_from: Option<&str>,
-    type_map: &HashMap<&str, &str>,
+    type_map: &HashMap<&str, (&str, f64)>,
 ) -> Vec<&'a NodeInfo> {
     // 1. Import-aware resolution
     if let Some(imp_file) = imported_from {
@@ -236,7 +250,7 @@ fn resolve_call_targets<'a>(
 
     // 4. Type-aware resolution via receiver → type map
     if let Some(ref receiver) = call.receiver {
-        if let Some(type_name) = type_map.get(receiver.as_str()) {
+        if let Some(&(type_name, _conf)) = type_map.get(receiver.as_str()) {
             let qualified = format!("{}.{}", type_name, call.name);
             let typed: Vec<&NodeInfo> = ctx.nodes_by_name
                 .get(qualified.as_str())
@@ -296,15 +310,15 @@ fn emit_call_edges(
 /// Emit a receiver edge from caller to the receiver's type node (if applicable).
 fn emit_receiver_edge(
     ctx: &EdgeContext, call: &CallInfo, caller_id: u32, rel_path: &str,
-    type_map: &HashMap<&str, &str>,
+    type_map: &HashMap<&str, (&str, f64)>,
     seen_edges: &mut HashSet<u64>, edges: &mut Vec<ComputedEdge>,
 ) {
     let Some(ref receiver) = call.receiver else { return };
     if ctx.builtin_set.contains(receiver.as_str())
         || receiver == "this" || receiver == "self" || receiver == "super"
     { return; }
 
-    let effective_receiver = type_map.get(receiver.as_str()).copied().unwrap_or(receiver.as_str());
+    let effective_receiver = type_map.get(receiver.as_str()).map(|&(t, _)| t).unwrap_or(receiver.as_str());
     let type_resolved = effective_receiver != receiver.as_str();
 
     let samefile = ctx.nodes_by_name_and_file

crates/codegraph-core/src/edge_builder.rs

@@ -39,6 +39,7 @@ fn match_c_type_map(node: &Node, source: &[u8], symbols: &mut FileSymbols, _dept
                                     symbols.type_map.push(TypeMapEntry {
                                         name: final_name,
                                         type_name: type_name.to_string(),
+                                        confidence: 0.9,
                                     });
                                 }
                             }
@@ -55,6 +56,7 @@ fn match_c_type_map(node: &Node, source: &[u8], symbols: &mut FileSymbols, _dept
                         symbols.type_map.push(TypeMapEntry {
                             name,
                             type_name: node_text(&type_node, source).to_string(),
+                            confidence: 0.9,
                         });
                     }
                 }

crates/codegraph-core/src/extractors/c.rs

@@ -38,6 +38,7 @@ fn match_cpp_type_map(node: &Node, source: &[u8], symbols: &mut FileSymbols, _de
                                     symbols.type_map.push(TypeMapEntry {
                                         name: final_name,
                                         type_name: type_name.to_string(),
+                                        confidence: 0.9,
                                     });
                                 }
                             }
@@ -54,6 +55,7 @@ fn match_cpp_type_map(node: &Node, source: &[u8], symbols: &mut FileSymbols, _de
                         symbols.type_map.push(TypeMapEntry {
                             name,
                             type_name: node_text(&type_node, source).to_string(),
+                            confidence: 0.9,
                         });
                     }
                 }

crates/codegraph-core/src/extractors/cpp.rs

@@ -428,6 +428,7 @@ fn match_csharp_type_map(node: &Node, source: &[u8], symbols: &mut FileSymbols,
                                             symbols.type_map.push(TypeMapEntry {
                                                 name: node_text(&name_node, source).to_string(),
                                                 type_name: type_name.to_string(),
+                                                confidence: 0.9,
                                             });
                                         }
                                     }
@@ -445,6 +446,7 @@ fn match_csharp_type_map(node: &Node, source: &[u8], symbols: &mut FileSymbols,
                         symbols.type_map.push(TypeMapEntry {
                             name: node_text(&name_node, source).to_string(),
                             type_name: type_name.to_string(),
+                            confidence: 0.9,
                         });
                     }
                 }

crates/codegraph-core/src/extractors/csharp.rs

@@ -330,6 +330,7 @@ fn collect_go_typed_identifiers(node: &Node, source: &[u8], type_map: &mut Vec<T
             type_map.push(TypeMapEntry {
                 name: node_text(&child, source).to_string(),
                 type_name: type_name.to_string(),
+                confidence: 0.9,
             });
         }
     }

crates/codegraph-core/src/extractors/go.rs

@@ -39,6 +39,7 @@ fn match_java_type_map(node: &Node, source: &[u8], symbols: &mut FileSymbols, _d
                                     symbols.type_map.push(TypeMapEntry {
                                         name: node_text(&name_node, source).to_string(),
                                         type_name: type_name.to_string(),
+                                        confidence: 0.9,
                                     });
                                 }
                             }
@@ -54,6 +55,7 @@ fn match_java_type_map(node: &Node, source: &[u8], symbols: &mut FileSymbols, _d
                         symbols.type_map.push(TypeMapEntry {
                             name: node_text(&name_node, source).to_string(),
                             type_name: type_name.to_string(),
+                            confidence: 0.9,
                         });
                     }
                 }

crates/codegraph-core/src/extractors/java.rs

@@ -58,23 +58,24 @@ fn match_js_type_map(node: &Node, source: &[u8], symbols: &mut FileSymbols, _dep
             if let Some(name_n) = node.child_by_field_name("name") {
                 if name_n.kind() == "identifier" {
                     let var_name = node_text(&name_n, source);
-                    // Type annotation takes priority
+                    // Type annotation: confidence 0.9
                     if let Some(type_anno) = find_child(node, "type_annotation") {
                         if let Some(type_name) = extract_simple_type_name(&type_anno, source) {
                             symbols.type_map.push(TypeMapEntry {
                                 name: var_name.to_string(),
                                 type_name: type_name.to_string(),
+                                confidence: 0.9,
                             });
-                            return; // Skip new_expression check — annotation wins
                         }
                     }
-                    // Fall back to new expression inference
+                    // Constructor: confidence 1.0 (overrides annotation in edge builder)
                     if let Some(value_n) = node.child_by_field_name("value") {
                         if value_n.kind() == "new_expression" {
                             if let Some(type_name) = extract_new_expr_type_name(&value_n, source) {
                                 symbols.type_map.push(TypeMapEntry {
                                     name: var_name.to_string(),
                                     type_name: type_name.to_string(),
+                                    confidence: 1.0,
                                 });
                             }
                         }
@@ -93,6 +94,7 @@ fn match_js_type_map(node: &Node, source: &[u8], symbols: &mut FileSymbols, _dep
                             symbols.type_map.push(TypeMapEntry {
                                 name: node_text(&name_node, source).to_string(),
                                 type_name: type_name.to_string(),
+                                confidence: 0.9,
                             });
                         }
                     }