fix: handle satisfies-cast dynamic imports, add WASM timeout (#1921)

docs check acknowledged — per Greptile review, no new functionality.

Author: carlos-alm

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

@@ -3038,13 +3038,19 @@ fn find_parent_class_no_fn_boundary(node: &Node, source: &[u8]) -> Option<String
 
 /// 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` casts. Real-world call
-/// sites often combine several of these, e.g.
+/// `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).
-const DYNAMIC_IMPORT_WRAPPER_KINDS: &[&str] =
-    &["await_expression", "parenthesized_expression", "as_expression"];
+/// 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(...)`, `const mod = await import(...)`,
@@ -4247,6 +4253,17 @@ mod tests {
         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):

src/extractors/javascript.ts

@@ -4054,16 +4054,19 @@ function extractImportNames(
 /**
  * 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` casts. Real-world
- * dynamic-import call sites often combine several of these, e.g.
+ * `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).
+ * 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',
 ]);
 
 /**

tests/integration/issue-1781-dynamic-import-destructure-consumer.test.ts

@@ -126,7 +126,7 @@ describe('dynamic import() + destructure consumer crediting (#1781) — WASM', (
     tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-1781-wasm-'));
     writeFixture(tmpDir);
     await buildGraph(tmpDir, { engine: 'wasm', incremental: false, skipRegistry: true });
-  });
+  }, 60_000);
 
   afterAll(() => {
     fs.rmSync(tmpDir, { recursive: true, force: true });

tests/parsers/javascript.test.ts

@@ -211,6 +211,16 @@ describe('JavaScript parser', () => {
       expect(symbols.imports[0].names).toEqual(['a', 'b']);
     });
 
+    it('extracts destructured names through a TypeScript `satisfies {...}` assertion', () => {
+      // TS 4.9+ `satisfies` is structurally identical to `as` here (Greptile
+      // follow-up to #1781) — same walk-up gap would otherwise reproduce.
+      const symbols = parseTS(
+        `const { a, b } = await import('./foo.js') satisfies { a: Fn; b: Fn };`,
+      );
+      expect(symbols.imports).toHaveLength(1);
+      expect(symbols.imports[0].names).toEqual(['a', 'b']);
+    });
+
     it('extracts destructured names through parens + `as`-cast combined (exact repro shape)', () => {
       // Matches native-orchestrator.ts's actual production pattern:
       //   const { X, Y } = (await import('./mod.js')) as { X: Fn; Y: Fn };