fix: credit destructured dynamic import() bindings as exports consumers

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

@@ -3036,14 +3036,35 @@ fn find_parent_class_no_fn_boundary(node: &Node, source: &[u8]) -> Option<String
     None
 }
 
+/// Wrapper node kinds that can sit between a dynamic `import()` call and its
+/// enclosing `variable_declarator` without changing which value gets bound —
+/// `await`, redundant parentheses, and TypeScript `as`/`satisfies` casts.
+/// Real-world call sites often combine several of these, e.g.
+/// `const { X } = (await import('./mod.js')) as { X: Fn }` nests
+/// await_expression → parenthesized_expression → as_expression before
+/// reaching the declarator (#1781). `satisfies_expression` (TS 4.9+
+/// `... satisfies { X: Fn }`) is structurally identical to `as_expression`
+/// here — Greptile follow-up, mirrors the TS extractor.
+const DYNAMIC_IMPORT_WRAPPER_KINDS: &[&str] = &[
+    "await_expression",
+    "parenthesized_expression",
+    "as_expression",
+    "satisfies_expression",
+];
+
 /// Extract named bindings from a dynamic `import()` call expression.
-/// Handles: `const { a, b } = await import(...)` and `const mod = await import(...)`
+/// Handles: `const { a, b } = await import(...)`, `const mod = await import(...)`,
+/// and casts/parens wrapping the awaited call, e.g.
+/// `const { a } = (await import(...)) as { a: Fn }`.
 fn extract_dynamic_import_names(call_node: &Node, source: &[u8]) -> Vec<String> {
-    // Walk up: call_expression → await_expression? → variable_declarator
+    // Walk up through any combination/nesting of await/parenthesized/as-cast
+    // wrappers to reach the variable_declarator.
     let mut current = call_node.parent();
-    if let Some(parent) = current {
-        if parent.kind() == "await_expression" {
+    while let Some(parent) = current {
+        if DYNAMIC_IMPORT_WRAPPER_KINDS.contains(&parent.kind()) {
             current = parent.parent();
+        } else {
+            break;
         }
     }
     let declarator = match current {
@@ -4205,6 +4226,58 @@ mod tests {
         assert!(!dyn_imports[0].names.contains(&"nested".to_string()));
     }
 
+    // Regression tests for #1781: `codegraph exports` failed to credit consumers
+    // reached via `const { X } = (await import('./mod.js')) as {...}` — the
+    // walk-up from the import() call to its enclosing variable_declarator only
+    // skipped a single optional await_expression, so the extra
+    // parenthesized_expression / as_expression layers introduced by wrapping
+    // parens and a TS type-assertion caused name extraction to bail out with
+    // an empty list, exactly as if the destructured names couldn't be
+    // determined at all.
+
+    #[test]
+    fn finds_dynamic_import_with_parenthesized_destructuring() {
+        let s = parse_ts("const { a, b } = (await import('./foo.js'));");
+        let dyn_imports: Vec<_> = s.imports.iter().filter(|i| i.dynamic_import == Some(true)).collect();
+        assert_eq!(dyn_imports.len(), 1);
+        assert!(dyn_imports[0].names.contains(&"a".to_string()));
+        assert!(dyn_imports[0].names.contains(&"b".to_string()));
+    }
+
+    #[test]
+    fn finds_dynamic_import_with_as_cast_destructuring() {
+        let s = parse_ts("const { a, b } = await import('./foo.js') as { a: Fn; b: Fn };");
+        let dyn_imports: Vec<_> = s.imports.iter().filter(|i| i.dynamic_import == Some(true)).collect();
+        assert_eq!(dyn_imports.len(), 1);
+        assert!(dyn_imports[0].names.contains(&"a".to_string()));
+        assert!(dyn_imports[0].names.contains(&"b".to_string()));
+    }
+
+    #[test]
+    fn finds_dynamic_import_with_satisfies_cast_destructuring() {
+        // TS 4.9+ `satisfies` is structurally identical to `as` here (Greptile
+        // follow-up to #1781) — same walk-up gap would otherwise reproduce.
+        let s = parse_ts("const { a, b } = await import('./foo.js') satisfies { a: Fn; b: Fn };");
+        let dyn_imports: Vec<_> = s.imports.iter().filter(|i| i.dynamic_import == Some(true)).collect();
+        assert_eq!(dyn_imports.len(), 1);
+        assert!(dyn_imports[0].names.contains(&"a".to_string()));
+        assert!(dyn_imports[0].names.contains(&"b".to_string()));
+    }
+
+    #[test]
+    fn finds_dynamic_import_with_parenthesized_as_cast_destructuring() {
+        // Exact repro shape from #1781 (native-orchestrator.ts):
+        // `const { X, Y } = (await import('../mod.js')) as { X: Fn; Y: Fn };`
+        let s = parse_ts(
+            "const { buildDataflowVerticesFromMap, buildDataflowEdges } = (await import('../../../../features/dataflow.js')) as { buildDataflowVerticesFromMap: Fn; buildDataflowEdges: Fn };",
+        );
+        let dyn_imports: Vec<_> = s.imports.iter().filter(|i| i.dynamic_import == Some(true)).collect();
+        assert_eq!(dyn_imports.len(), 1);
+        assert_eq!(dyn_imports[0].source, "../../../../features/dataflow.js");
+        assert!(dyn_imports[0].names.contains(&"buildDataflowVerticesFromMap".to_string()));
+        assert!(dyn_imports[0].names.contains(&"buildDataflowEdges".to_string()));
+    }
+
     #[test]
     fn extracts_callback_reference_in_router_use() {
         let s = parse_js("router.use(handleToken);");

src/extractors/javascript.ts

@@ -4051,22 +4051,44 @@ function extractImportNames(
   return names;
 }
 
+/**
+ * Wrapper node types that can sit between a dynamic `import()` call and its
+ * enclosing `variable_declarator` without changing which value gets bound —
+ * `await`, redundant parentheses, and TypeScript `as`/`satisfies` casts.
+ * Real-world dynamic-import call sites often combine several of these, e.g.
+ * `const { X } = (await import('./mod.js')) as { X: Fn }` nests
+ * await_expression → parenthesized_expression → as_expression before
+ * reaching the declarator (#1781). `satisfies_expression` (TS 4.9+
+ * `... satisfies { X: Fn }`) is structurally identical to `as_expression`
+ * here — same Greptile follow-up as the native mirror.
+ */
+const DYNAMIC_IMPORT_WRAPPER_TYPES = new Set([
+  'await_expression',
+  'parenthesized_expression',
+  'as_expression',
+  'satisfies_expression',
+]);
+
 /**
  * Extract destructured names from a dynamic import() call expression.
  *
  * Handles:
- *   const { a, b } = await import('./foo.js')   → ['a', 'b']
- *   const mod = await import('./foo.js')         → ['mod']
- *   import('./foo.js')                           → [] (no names extractable)
+ *   const { a, b } = await import('./foo.js')                    → ['a', 'b']
+ *   const mod = await import('./foo.js')                          → ['mod']
+ *   const { a } = (await import('./foo.js')) as { a: Fn }         → ['a']
+ *   import('./foo.js')                                            → [] (no names extractable)
  *
- * Walks up the AST from the call_expression to find the enclosing
+ * Walks up the AST from the call_expression — through any nesting of
+ * await/parenthesized/as-cast wrappers — to find the enclosing
  * variable_declarator and reads the name/object_pattern.
  */
 function extractDynamicImportNames(callNode: TreeSitterNode): string[] {
-  // Walk up: call_expression → await_expression → variable_declarator
+  // Walk up through await_expression / parenthesized_expression / as_expression
+  // wrappers, in any combination or order, to reach the variable_declarator.
   let current = callNode.parent;
-  // Skip await_expression wrapper if present
-  if (current && current.type === 'await_expression') current = current.parent;
+  while (current && DYNAMIC_IMPORT_WRAPPER_TYPES.has(current.type)) {
+    current = current.parent;
+  }
   // We should now be at a variable_declarator (or not, if standalone import())
   if (current?.type !== 'variable_declarator') return [];