fix(native): add first-write-wins dedup to Rust type-map entry helpers

* fix(native): add first-write-wins dedup to Rust type-map entry helpers

`push_type_map_entry` in helpers.rs always appended to the Vec without
checking for duplicate keys, diverging from the TS `setTypeMapEntry`
which only writes when the new confidence is strictly higher than any
existing entry for the same key.

Introduce `set_type_map_entry` (mirrors TS `setTypeMapEntry`) that
scans for an existing entry and skips/replaces based on confidence.
Rewrite `push_type_map_entry` to delegate to it so all existing call
sites get the fix automatically.

In the `field_definition` handler's `None` branch (class expressions),
replace the bare `push_type_map_entry` calls with `set_type_map_entry`
at the explicit confidence values that match the TS path. Also replace
the `Some(class_name)` branch's direct `symbols.type_map.push` calls
with `set_type_map_entry` so the fallback bare keys at 0.6 confidence
are likewise deduplicated.

Fixes #1501.

Impact: 3 functions changed, 5 affected

* docs(native): correct set_type_map_entry semantics label to highest-confidence-wins

Author: carlos-alm

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

@@ -958,24 +958,55 @@ pub fn extract_simple_parameters(
 
 // ── Type-map helpers ───────────────────────────────────────────────────────
 
-/// Record a parameter name → type binding in the type-map sink, using
-/// the default confidence of `0.9` shared by every Rust extractor.
-pub fn push_type_map_entry(
+/// Merge a type-map entry into the sink with highest-confidence-wins semantics,
+/// matching `setTypeMapEntry` in `src/extractors/helpers.ts`.
+///
+/// If the key already exists with equal-or-higher confidence the new entry is
+/// silently dropped; otherwise the old entry is replaced.  This prevents
+/// duplicate entries from accumulating when the same bare key is written
+/// multiple times (e.g. two class expressions in one file that both define a
+/// field with the same name).
+///
+/// Mirrors `setTypeMapEntry` in `src/extractors/helpers.ts`.
+pub fn set_type_map_entry(
     symbols: &mut FileSymbols,
     name: impl Into<String>,
     type_name: impl Into<String>,
+    confidence: f64,
 ) {
     let name = name.into();
     if name.is_empty() {
         return;
     }
+    // Scan for an existing entry with the same key.
+    if let Some(existing) = symbols.type_map.iter_mut().find(|e| e.name == name) {
+        if confidence > existing.confidence {
+            existing.type_name = type_name.into();
+            existing.confidence = confidence;
+        }
+        return;
+    }
     symbols.type_map.push(TypeMapEntry {
         name,
         type_name: type_name.into(),
-        confidence: 0.9,
+        confidence,
     });
 }
 
+/// Record a parameter name → type binding in the type-map sink, using
+/// the default confidence of `0.9` shared by every Rust extractor.
+///
+/// Delegates to [`set_type_map_entry`] so duplicate keys are deduplicated with
+/// highest-confidence-wins semantics (first-write-wins at the uniform 0.9
+/// confidence), matching `setTypeMapEntry` in `src/extractors/helpers.ts`.
+pub fn push_type_map_entry(
+    symbols: &mut FileSymbols,
+    name: impl Into<String>,
+    type_name: impl Into<String>,
+) {
+    set_type_map_entry(symbols, name, type_name, 0.9);
+}
+
 /// C-family `declaration` / `parameter_declaration` type-map matcher.
 ///
 /// The cpp / cuda / c extractors all emit verbatim copies of the same

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

@@ -224,28 +224,21 @@ fn match_js_type_map(node: &Node, source: &[u8], symbols: &mut FileSymbols, _dep
                             match enclosing_type_map_class(node, source) {
                                 Some(class_name) => {
                                     // Primary: class-scoped key prevents cross-class collision.
-                                    push_type_map_entry(
+                                    set_type_map_entry(
                                         symbols,
                                         format!("{}.{}", class_name, field_name),
                                         type_name.to_string(),
+                                        0.9,
                                     );
                                     // Fallback bare keys at lower confidence.
-                                    symbols.type_map.push(TypeMapEntry {
-                                        name: field_name.clone(),
-                                        type_name: type_name.to_string(),
-                                        confidence: 0.6,
-                                    });
-                                    symbols.type_map.push(TypeMapEntry {
-                                        name: format!("this.{}", field_name),
-                                        type_name: type_name.to_string(),
-                                        confidence: 0.6,
-                                    });
+                                    set_type_map_entry(symbols, field_name.clone(), type_name.to_string(), 0.6);
+                                    set_type_map_entry(symbols, format!("this.{}", field_name), type_name.to_string(), 0.6);
                                 }
                                 None => {
                                     // No enclosing class declaration (e.g. class expression)
                                     // — use bare keys only at full confidence.
-                                    push_type_map_entry(symbols, field_name.clone(), type_name.to_string());
-                                    push_type_map_entry(symbols, format!("this.{}", field_name), type_name.to_string());
+                                    set_type_map_entry(symbols, field_name.clone(), type_name.to_string(), 0.9);
+                                    set_type_map_entry(symbols, format!("this.{}", field_name), type_name.to_string(), 0.9);
                                 }
                             }
                         }