feat(parity): port the JS points-to solver to the native engine and unify per-engine resolution

Native (Rust):
- Extract all eight pts binding kinds in the JS extractor (param,
  this-call, array-element, spread-arg, for-of, array-callback,
  object-rest-param, object-prop) and surface them on FileSymbols
- Run the same fixed-point points-to solver as the WASM path inside
  build_call_edges: thisCall-to-fnRef conversion, four-case key gate with
  receiver-key fallback, hop-penalised alias edges with pts upgrade
- Normalize inline-new receivers (new A().t() -> receiver "A") in
  extract_receiver_name, mirroring extractReceiverName in the TS extractor
- Apply the >=0.5 confidence filter on exact cross-file lookups (#1439)

WASM/TS:
- Plumb params and all eight binding arrays through NativeFileEntry so the
  hybrid path feeds the native solver
- Serialize thisCallBindings across the WASM worker boundary
- Backport the native engine's class-field type-annotation extraction
  (private repo: Repository seeds typeMap "repo"/"this.repo")
- Remove the four JS pts post-passes that duplicated the native solver on
  the hybrid path (param-flow, fnRef, thisCall, object-rest)
- Report the native build summary and build_meta counts after the JS
  edge-writing post-passes so they include CHA/this-dispatch edges (#1452)

WASM, full-native orchestrator, and hybrid builds now produce identical
edge multisets on the javascript fixture (155 rows each, including
confidence and dynamic flags); javascript 42/42 and pts-javascript 13/13
expected edges on both engines; 392 Rust tests, 3043 JS tests, and the
176-test resolution benchmark are green.

Closes #1453
Closes #1452
Closes #1439

Author: carlos-alm

crates/codegraph-core/src/domain/graph/builder/pipeline.rs

@@ -1348,6 +1348,10 @@ fn build_and_insert_call_edges(
             })
             .collect();
 
+        fn non_empty<T: Clone>(v: &[T]) -> Option<Vec<T>> {
+            if v.is_empty() { None } else { Some(v.to_vec()) }
+        }
+
         file_entries.push(FileEdgeInput {
             file: rel_path.clone(),
             file_node_id,
@@ -1359,6 +1363,15 @@ fn build_and_insert_call_edges(
                     kind: d.kind.clone(),
                     line: d.line,
                     end_line: d.end_line,
+                    // Phase 8.3c: ordered parameter names for parameter-flow pts —
+                    // mirrors buildDefinitionParamsMap reading def.children.
+                    params: d.children.as_ref().map(|children| {
+                        children
+                            .iter()
+                            .filter(|c| c.kind == "parameter")
+                            .map(|c| c.name.clone())
+                            .collect()
+                    }),
                 })
                 .collect(),
             calls: symbols
@@ -1382,11 +1395,15 @@ fn build_and_insert_call_edges(
                 })
                 .collect(),
             type_map,
-            fn_ref_bindings: if symbols.fn_ref_bindings.is_empty() {
-                None
-            } else {
-                Some(symbols.fn_ref_bindings.clone())
-            },
+            fn_ref_bindings: non_empty(&symbols.fn_ref_bindings),
+            param_bindings: non_empty(&symbols.param_bindings),
+            this_call_bindings: non_empty(&symbols.this_call_bindings),
+            array_elem_bindings: non_empty(&symbols.array_elem_bindings),
+            spread_arg_bindings: non_empty(&symbols.spread_arg_bindings),
+            for_of_bindings: non_empty(&symbols.for_of_bindings),
+            array_callback_bindings: non_empty(&symbols.array_callback_bindings),
+            object_rest_param_bindings: non_empty(&symbols.object_rest_param_bindings),
+            object_prop_bindings: non_empty(&symbols.object_prop_bindings),
         });
     }
 

crates/codegraph-core/src/domain/graph/builder/stages/build_edges.rs

@@ -566,6 +566,14 @@ mod tests {
             dataflow: None,
             line_count: None,
             fn_ref_bindings: vec![],
+            param_bindings: vec![],
+            this_call_bindings: vec![],
+            array_elem_bindings: vec![],
+            spread_arg_bindings: vec![],
+            for_of_bindings: vec![],
+            array_callback_bindings: vec![],
+            object_rest_param_bindings: vec![],
+            object_prop_bindings: vec![],
         }
     }
 

crates/codegraph-core/src/domain/graph/builder/stages/import_edges.rs

@@ -921,21 +921,8 @@ mod tests {
     #[test]
     fn line_count_map_from_symbols() {
         let mut file_symbols = HashMap::new();
-        let mut sym = FileSymbols {
-            file: "src/a.ts".to_string(),
-            definitions: vec![],
-            imports: vec![],
-            calls: vec![],
-            classes: vec![],
-            exports: vec![],
-            type_map: vec![],
-            return_type_map: vec![],
-            call_assignments: vec![],
-            ast_nodes: vec![],
-            dataflow: None,
-            line_count: Some(42),
-            fn_ref_bindings: vec![],
-        };
+        let mut sym = FileSymbols::new("src/a.ts".to_string());
+        sym.line_count = Some(42);
         file_symbols.insert("src/a.ts".to_string(), sym.clone());
 
         sym.file = "src/b.ts".to_string();

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

@@ -318,6 +318,102 @@ pub struct FnRefBinding {
     pub rhs_receiver: Option<String>,
 }
 
+/// Argument-to-parameter binding at a call site (Phase 8.3c).
+/// Records `f(x)` where `x` is an identifier that may carry a function reference.
+/// Mirrors the `ParamBinding` interface in `src/types.ts`.
+#[napi(object)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ParamBinding {
+    pub callee: String,
+    #[napi(js_name = "argIndex")]
+    pub arg_index: u32,
+    #[napi(js_name = "argName")]
+    pub arg_name: String,
+}
+
+/// This-context binding from `fn.call(ctx, ...)` / `fn.apply(ctx, ...)`.
+/// Mirrors the `ThisCallBinding` interface in `src/types.ts`.
+#[napi(object)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ThisCallBinding {
+    pub callee: String,
+    #[napi(js_name = "thisArg")]
+    pub this_arg: String,
+}
+
+/// Array-element binding from `const arr = [fn1, fn2]` (Phase 8.3e).
+/// Mirrors the `ArrayElemBinding` interface in `src/types.ts`.
+#[napi(object)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ArrayElemBinding {
+    #[napi(js_name = "arrayName")]
+    pub array_name: String,
+    pub index: u32,
+    #[napi(js_name = "elemName")]
+    pub elem_name: String,
+}
+
+/// Spread-argument binding from `f(...arr)` (Phase 8.3e).
+/// Mirrors the `SpreadArgBinding` interface in `src/types.ts`.
+#[napi(object)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SpreadArgBinding {
+    pub callee: String,
+    #[napi(js_name = "arrayName")]
+    pub array_name: String,
+    #[napi(js_name = "startIndex")]
+    pub start_index: u32,
+}
+
+/// For-of iteration binding from `for (const x of arr)` (Phase 8.3e).
+/// Mirrors the `ForOfBinding` interface in `src/types.ts`.
+#[napi(object)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ForOfBinding {
+    #[napi(js_name = "varName")]
+    pub var_name: String,
+    #[napi(js_name = "sourceName")]
+    pub source_name: String,
+    #[napi(js_name = "enclosingFunc")]
+    pub enclosing_func: String,
+}
+
+/// Array-callback binding from `Array.from(arr, cb)` (Phase 8.3e).
+/// Mirrors the `ArrayCallbackBinding` interface in `src/types.ts`.
+#[napi(object)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ArrayCallbackBinding {
+    #[napi(js_name = "sourceName")]
+    pub source_name: String,
+    #[napi(js_name = "calleeName")]
+    pub callee_name: String,
+}
+
+/// Object-rest parameter binding from `function f({ a, ...rest })` (Phase 8.3f).
+/// Mirrors the `ObjectRestParamBinding` interface in `src/types.ts`.
+#[napi(object)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ObjectRestParamBinding {
+    pub callee: String,
+    #[napi(js_name = "restName")]
+    pub rest_name: String,
+    #[napi(js_name = "argIndex")]
+    pub arg_index: u32,
+}
+
+/// Object-property binding from `const obj = { e4 }` / `{ e4: fn }` (Phase 8.3f).
+/// Mirrors the `ObjectPropBinding` interface in `src/types.ts`.
+#[napi(object)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ObjectPropBinding {
+    #[napi(js_name = "objectName")]
+    pub object_name: String,
+    #[napi(js_name = "propName")]
+    pub prop_name: String,
+    #[napi(js_name = "valueName")]
+    pub value_name: String,
+}
+
 #[napi(object)]
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct FileSymbols {
@@ -341,6 +437,30 @@ pub struct FileSymbols {
     /// Phase 8.3: function-reference bindings for points-to analysis.
     #[napi(js_name = "fnRefBindings")]
     pub fn_ref_bindings: Vec<FnRefBinding>,
+    /// Phase 8.3c: argument-to-parameter bindings for parameter-flow pts.
+    #[napi(js_name = "paramBindings")]
+    pub param_bindings: Vec<ParamBinding>,
+    /// This-context bindings from `fn.call(ctx)` / `fn.apply(ctx)`.
+    #[napi(js_name = "thisCallBindings")]
+    pub this_call_bindings: Vec<ThisCallBinding>,
+    /// Phase 8.3e: array-element bindings from `const arr = [fn1, fn2]`.
+    #[napi(js_name = "arrayElemBindings")]
+    pub array_elem_bindings: Vec<ArrayElemBinding>,
+    /// Phase 8.3e: spread-argument bindings from `f(...arr)`.
+    #[napi(js_name = "spreadArgBindings")]
+    pub spread_arg_bindings: Vec<SpreadArgBinding>,
+    /// Phase 8.3e: for-of iteration variable bindings.
+    #[napi(js_name = "forOfBindings")]
+    pub for_of_bindings: Vec<ForOfBinding>,
+    /// Phase 8.3e: array callback bindings from `Array.from(arr, cb)`.
+    #[napi(js_name = "arrayCallbackBindings")]
+    pub array_callback_bindings: Vec<ArrayCallbackBinding>,
+    /// Phase 8.3f: object-rest parameter bindings from `function f({ ...rest })`.
+    #[napi(js_name = "objectRestParamBindings")]
+    pub object_rest_param_bindings: Vec<ObjectRestParamBinding>,
+    /// Phase 8.3f: object-property bindings from `const obj = { fn }`.
+    #[napi(js_name = "objectPropBindings")]
+    pub object_prop_bindings: Vec<ObjectPropBinding>,
 }
 
 impl FileSymbols {
@@ -359,6 +479,14 @@ impl FileSymbols {
             return_type_map: Vec::new(),
             call_assignments: Vec::new(),
             fn_ref_bindings: Vec::new(),
+            param_bindings: Vec::new(),
+            this_call_bindings: Vec::new(),
+            array_elem_bindings: Vec::new(),
+            spread_arg_bindings: Vec::new(),
+            for_of_bindings: Vec::new(),
+            array_callback_bindings: Vec::new(),
+            object_rest_param_bindings: Vec::new(),
+            object_prop_bindings: Vec::new(),
         }
     }
 }