From 996909ded582ed04065af4710d18b90d16e2024e Mon Sep 17 00:00:00 2001
From: Pierre Le Fevre <hello@pierrelf.com>
Date: Thu, 28 May 2026 21:25:47 +0200
Subject: [PATCH] Resolve dynamic import() through the module registry (isu
 issue 304)

Implements sub-step 4 of the document-level ES module work: dynamic
`import(specifier)` now evaluates to a Promise for the target module's
namespace object, resolved off the same loader that handles static
imports.

Engine (crates/js):
- Parser routes `import(...)` (but not `import.meta`) to a new
  `__we_dynamic_import` runtime helper.
- New `dynamic_import` module: the helper resolves the specifier against
  the document base URL, returns a pending promise, and queues it; the
  event loop (`pump`/`run_event_loop`) drains the queue, settling each
  promise from the shared `__we_modules` registry (resolve with the
  namespace when present, otherwise reject with a "failed to fetch
  dynamically imported module" reason). Pending promises are GC-rooted.
- `module::dynamic_import_specifiers` best-effort-collects string-literal
  `import("<literal>")` specifiers from a program.

Loader (crates/browser):
- The module graph builder eagerly fetches and executes
  statically-discoverable dynamic-import targets as ordinary
  dependencies so the runtime import resolves from the populated
  registry.

Tests:
- Unit tests for promise resolution, the returned promise shape,
  rejection of unloaded modules, and literal specifier discovery.
- e2e page + scenario (`dynamic_import.we`) loading a `data:` module via
  `import()` and asserting the resolved namespace's constant and a
  callable export render into the DOM.

Known follow-ups (still tracked under #304/#280): import-map bare
specifiers, module-relative (vs document-base) specifier resolution,
classic-script dynamic-import preloading, and lazy (non-eager) fetching
of runtime-computed specifiers.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 crates/browser/src/module_loader.rs     |  28 ++-
 crates/e2e/pages/44_dynamic_import.html |  28 +++
 crates/e2e/scenarios/dynamic_import.we  |  18 ++
 crates/js/src/builtins.rs               |   4 +
 crates/js/src/dynamic_import.rs         | 206 ++++++++++++++++++
 crates/js/src/fetch.rs                  |   9 +
 crates/js/src/lib.rs                    |   1 +
 crates/js/src/module.rs                 | 269 +++++++++++++++++++++++-
 crates/js/src/parser.rs                 |  23 +-
 crates/js/src/vm.rs                     |   6 +
 10 files changed, 580 insertions(+), 12 deletions(-)
 create mode 100644 crates/e2e/pages/44_dynamic_import.html
 create mode 100644 crates/e2e/scenarios/dynamic_import.we
 create mode 100644 crates/js/src/dynamic_import.rs

diff --git a/crates/browser/src/module_loader.rs b/crates/browser/src/module_loader.rs
index 26dbc84..0797736 100644
--- a/crates/browser/src/module_loader.rs
+++ b/crates/browser/src/module_loader.rs
@@ -13,7 +13,13 @@
 //! Specifier resolution currently handles relative (`./`, `../`, `/`) and
 //! absolute-URL specifiers. Bare specifiers (which require an import map) are
 //! left unresolved; their imported bindings evaluate to `undefined`. Import
-//! maps and dynamic `import()` are tracked as follow-up sub-steps.
+//! maps are tracked as a follow-up sub-step.
+//!
+//! Statically-discoverable dynamic-import targets — `import("<literal>")` calls
+//! whose specifier is a string literal — are fetched and executed eagerly as
+//! ordinary graph dependencies so the runtime `import()` resolves the module
+//! namespace from the populated registry (see [`we_js::dynamic_import`]).
+//! Runtime-computed specifiers are not preloaded and reject at call time.
 
 use crate::loader::{Resource, ResourceLoader, ResourceRequestType};
 use std::collections::HashMap;
@@ -136,6 +142,26 @@ fn build_graph(
             }
         }
 
+        // Eagerly fetch and execute statically-discoverable dynamic-import
+        // targets so a later `import("<literal>")` resolves from the populated
+        // module registry. These are sequenced as ordinary dependencies (they
+        // run before the importing module) but, unlike static imports, are not
+        // added to `resolve`: dynamic import reads the registry at call time
+        // rather than binding names at link time.
+        for specifier in module::dynamic_import_specifiers(&program) {
+            if let Some(dep_url) = resolve_specifier(&specifier, &base) {
+                let dep_key = dep_url.serialize();
+                if !deps.contains(&dep_key) {
+                    deps.push(dep_key.clone());
+                }
+                if !graph.contains_key(&dep_key) {
+                    if let Some(dep_source) = fetch_module_source(loader, &dep_url, origin) {
+                        pending.push((dep_key, dep_url, dep_source));
+                    }
+                }
+            }
+        }
+
         graph.insert(
             key,
             ModuleRecord {
diff --git a/crates/e2e/pages/44_dynamic_import.html b/crates/e2e/pages/44_dynamic_import.html
new file mode 100644
index 0000000..29a6a75
--- /dev/null
+++ b/crates/e2e/pages/44_dynamic_import.html
@@ -0,0 +1,28 @@
+<!doctype html>
+<html>
+<head>
+  <title>Dynamic import() (isu issue 304)</title>
+</head>
+<body>
+  <div id="out">pending</div>
+  <div id="sum">sum-pending</div>
+
+  <!-- A `<script type="module">` dynamically imports a sibling `data:` module
+       via `import(...)`, which returns a Promise for the module namespace. The
+       loader preloads the string-literal specifier so the runtime import
+       resolves from the populated module registry (see we_js::dynamic_import),
+       then the `.then` reaction writes the imported values into the DOM. -->
+  <script type="module">
+    import("data:text/javascript,export const label = 'dynamic-loaded'; export function add(a, b) { return a + b; }")
+      .then(function (mod) {
+        document.getElementById("out").textContent = mod.label;
+        document.getElementById("sum").textContent = "sum:" + mod.add(2, 3);
+        console.log("dynamic-import: " + mod.label + " add=" + mod.add(2, 3));
+      })
+      .catch(function (e) {
+        document.getElementById("out").textContent = "error:" + e;
+        console.log("dynamic-import-error: " + e);
+      });
+  </script>
+</body>
+</html>
diff --git a/crates/e2e/scenarios/dynamic_import.we b/crates/e2e/scenarios/dynamic_import.we
new file mode 100644
index 0000000..b2902fb
--- /dev/null
+++ b/crates/e2e/scenarios/dynamic_import.we
@@ -0,0 +1,18 @@
+# Regression scenario for isu issue 304: dynamic `import()`.
+# A `<script type="module">` calls `import("data:...")`, which returns a Promise
+# for the imported module's namespace. The loader must preload the
+# string-literal specifier, and the event loop must settle the promise from the
+# module registry so the `.then` reaction can write the imported values
+# (a constant and a callable function) into the DOM.
+
+viewport 800 600
+goto_as https://we.test/44_dynamic_import.html crates/e2e/pages/44_dynamic_import.html
+dump_dom 44_dynamic_import.dom.txt
+dump_console 44_dynamic_import.console.txt
+
+# Promise resolved with the namespace; the exported constant was read.
+assert_dom_contains "dynamic-loaded"
+# The exported function is callable through the dynamically imported namespace.
+assert_dom_contains "sum:5"
+
+assert_console_contains "dynamic-import: dynamic-loaded add=5"
diff --git a/crates/js/src/builtins.rs b/crates/js/src/builtins.rs
index f3ce3c8..4e7027b 100644
--- a/crates/js/src/builtins.rs
+++ b/crates/js/src/builtins.rs
@@ -369,6 +369,10 @@ pub fn init_builtins(vm: &mut Vm) {
     // consume ReadableStream-backed bodies.
     crate::fetch::init_fetch_api(vm);
 
+    // Register the dynamic `import()` helper after Promise and Fetch: it
+    // resolves the document base URL via the same machinery fetch() uses.
+    crate::dynamic_import::init_dynamic_import_api(vm);
+
     // Register EventSource after the base event primitives and streams.
     crate::eventsource::init_eventsource_api(vm);
 
diff --git a/crates/js/src/dynamic_import.rs b/crates/js/src/dynamic_import.rs
new file mode 100644
index 0000000..97c98f0
--- /dev/null
+++ b/crates/js/src/dynamic_import.rs
@@ -0,0 +1,206 @@
+//! Dynamic `import()` support.
+//!
+//! A dynamic `import(specifier)` expression evaluates to a `Promise` for the
+//! target module's namespace object. The parser routes `import(...)` to the
+//! `__we_dynamic_import` runtime helper installed by [`init_dynamic_import_api`];
+//! the helper resolves the specifier against the document base URL, creates a
+//! pending promise, and records it in a thread-local queue. The event loop then
+//! drains the queue ([`drain_dynamic_imports`]), settling each promise from the
+//! shared module registry (`__we_modules`) that the static module loader
+//! populates — so a dynamic import is "resolved off the same loader" as a static
+//! one.
+//!
+//! Resolution is registry-backed: the module must already be present in
+//! `__we_modules` (loaded by the document-level module loader, which eagerly
+//! fetches statically-discoverable `import("<literal>")` targets — see
+//! [`crate::module::dynamic_import_specifiers`]). A specifier that resolves to a
+//! module that was never loaded rejects the promise, matching the spec's
+//! "failed to fetch dynamically imported module" surface. Relative specifiers
+//! resolve against the document base URL rather than the importing module's own
+//! URL; module-relative resolution and lazy (non-eager) fetching of
+//! runtime-computed specifiers are tracked as follow-ups to the document-level
+//! ES module work (isu issue 304).
+
+use std::cell::RefCell;
+
+use crate::builtins::{
+    create_promise_object_pub, reject_promise_internal, resolve_promise_internal,
+};
+use crate::gc::GcRef;
+use crate::vm::{HeapObject, NativeContext, RuntimeError, Value, Vm};
+
+/// Registry global installed by the module-linkage preamble. Module namespaces
+/// live here keyed by resolved absolute URL.
+const MODULE_REGISTRY: &str = "__we_modules";
+
+/// A dynamic import awaiting resolution from the module registry.
+struct PendingDynamicImport {
+    /// The promise returned to JS.
+    promise: GcRef,
+    /// Resolved registry key (absolute URL) of the requested module.
+    key: String,
+    /// The specifier as written, for diagnostics on failure.
+    specifier: String,
+}
+
+thread_local! {
+    static PENDING_DYNAMIC_IMPORTS: RefCell<Vec<PendingDynamicImport>> =
+        const { RefCell::new(Vec::new()) };
+}
+
+/// Register the `__we_dynamic_import` runtime helper on the VM.
+pub fn init_dynamic_import_api(vm: &mut Vm) {
+    vm.define_native("__we_dynamic_import", dynamic_import_native);
+}
+
+/// `__we_dynamic_import(specifier)` → Promise<namespace>.
+///
+/// Coerces the specifier to a string, resolves it against the document base
+/// URL, and returns a pending promise queued for settlement by the event loop.
+fn dynamic_import_native(args: &[Value], ctx: &mut NativeContext) -> Result<Value, RuntimeError> {
+    let specifier = args
+        .first()
+        .map(|v| v.to_js_string(ctx.gc))
+        .unwrap_or_default();
+    let key = crate::fetch::resolve_module_specifier(&specifier);
+
+    let promise = create_promise_object_pub(ctx.gc, ctx.shapes);
+    PENDING_DYNAMIC_IMPORTS.with(|q| {
+        q.borrow_mut().push(PendingDynamicImport {
+            promise,
+            key,
+            specifier,
+        });
+    });
+    Ok(Value::Object(promise))
+}
+
+/// Whether any dynamic import is awaiting settlement. Keeps the event loop
+/// alive until queued imports are drained.
+pub fn has_pending_dynamic_imports() -> bool {
+    PENDING_DYNAMIC_IMPORTS.with(|q| !q.borrow().is_empty())
+}
+
+/// GC roots for in-flight dynamic-import promises so they survive collection
+/// between registration and settlement.
+pub fn dynamic_import_gc_roots() -> Vec<GcRef> {
+    PENDING_DYNAMIC_IMPORTS.with(|q| q.borrow().iter().map(|p| p.promise).collect())
+}
+
+/// Clear queued dynamic imports. Intended for test isolation.
+pub fn reset_dynamic_import_state() {
+    PENDING_DYNAMIC_IMPORTS.with(|q| q.borrow_mut().clear());
+}
+
+/// Look up a module namespace in the `__we_modules` registry by resolved key.
+fn registry_namespace(vm: &Vm, key: &str) -> Option<Value> {
+    let registry = vm.get_global(MODULE_REGISTRY)?.clone();
+    let reg_ref = registry.gc_ref()?;
+    let HeapObject::Object(data) = vm.gc.get(reg_ref)? else {
+        return None;
+    };
+    data.get_property(key, &vm.shapes).map(|p| p.value)
+}
+
+/// Settle every queued dynamic import against the current module registry.
+///
+/// Resolves each promise with the requested module's namespace object when it
+/// is present in `__we_modules`; otherwise rejects it. Runs once per call —
+/// imports queued by reaction callbacks are serviced on the next event-loop
+/// turn. Microtasks are drained after each settlement so dependent `.then`
+/// reactions observe the result promptly.
+pub fn drain_dynamic_imports(vm: &mut Vm) -> Result<(), RuntimeError> {
+    let pending: Vec<PendingDynamicImport> =
+        PENDING_DYNAMIC_IMPORTS.with(|q| std::mem::take(&mut *q.borrow_mut()));
+
+    for entry in pending {
+        match registry_namespace(vm, &entry.key) {
+            Some(ns) => {
+                resolve_promise_internal(&mut vm.gc, &mut vm.shapes, entry.promise, ns);
+            }
+            None => {
+                let reason = Value::String(format!(
+                    "Failed to fetch dynamically imported module: {}",
+                    entry.specifier
+                ));
+                reject_promise_internal(&mut vm.gc, &mut vm.shapes, entry.promise, reason);
+            }
+        }
+        vm.drain_microtasks()?;
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::compiler;
+    use crate::module;
+    use crate::parser::Parser;
+
+    /// Run `src` as a classic script in `vm`, returning its completion value.
+    fn run(vm: &mut Vm, src: &str) -> Value {
+        let ast = Parser::parse(src).expect("parse");
+        let func = compiler::compile(&ast).expect("compile");
+        vm.execute(&func).expect("execute")
+    }
+
+    /// Build a VM with module linkage + dynamic import installed, and register a
+    /// module under `key` exporting `export const value = <n>`.
+    fn vm_with_module(key: &str, n: i32) -> Vm {
+        let mut vm = Vm::new();
+        reset_dynamic_import_state();
+        module::init_module_linkage(&mut vm);
+        init_dynamic_import_api(&mut vm);
+
+        let src = format!("export const value = {n};");
+        let program = Parser::parse_module(&src).expect("parse module");
+        let func = module::compile_module(&program, key, &Default::default()).expect("compile mod");
+        vm.execute(&func).expect("execute module");
+        vm
+    }
+
+    #[test]
+    fn dynamic_import_resolves_with_namespace() {
+        let key = "https://example.com/m.js";
+        let mut vm = vm_with_module(key, 42);
+
+        run(
+            &mut vm,
+            &format!("__r = null; import('{key}').then(function(ns) {{ __r = ns.value; }});"),
+        );
+        // Before the event loop runs, the import is still pending.
+        assert!(has_pending_dynamic_imports());
+        assert!(matches!(run(&mut vm, "__r;"), Value::Null));
+
+        vm.run_event_loop(100).expect("event loop");
+
+        assert!(!has_pending_dynamic_imports());
+        assert!(matches!(run(&mut vm, "__r;"), Value::Number(n) if n == 42.0));
+    }
+
+    #[test]
+    fn dynamic_import_returns_a_promise() {
+        let mut vm = vm_with_module("https://example.com/m.js", 1);
+        let t = run(&mut vm, "typeof import('https://example.com/m.js').then;");
+        assert!(matches!(t, Value::String(s) if s == "function"));
+    }
+
+    #[test]
+    fn dynamic_import_of_unloaded_module_rejects() {
+        let mut vm = vm_with_module("https://example.com/m.js", 7);
+        run(
+            &mut vm,
+            "__err = null; import('https://example.com/missing.js').catch(function(e) { __err = String(e); });",
+        );
+        vm.run_event_loop(100).expect("event loop");
+
+        match run(&mut vm, "__err;") {
+            Value::String(s) => {
+                assert!(s.contains("Failed to fetch dynamically imported module"));
+                assert!(s.contains("missing.js"));
+            }
+            other => panic!("expected rejection string, got {other:?}"),
+        }
+    }
+}
diff --git a/crates/js/src/fetch.rs b/crates/js/src/fetch.rs
index 80b7690..9ebb4cd 100644
--- a/crates/js/src/fetch.rs
+++ b/crates/js/src/fetch.rs
@@ -352,6 +352,15 @@ fn parse_credentials_mode(mode: &str) -> we_net::cors::CredentialsMode {
     }
 }
 
+/// Resolve a module specifier the same way `fetch()` resolves a relative input:
+/// against the current document base URL, returning a serialized absolute URL
+/// (or the input unchanged when there is no usable base). Dynamic `import()`
+/// uses this so its registry key matches the key the static module loader
+/// publishes under (the dependency's resolved absolute URL).
+pub fn resolve_module_specifier(input: &str) -> String {
+    resolve_fetch_url(input.trim())
+}
+
 fn resolve_fetch_url(input: &str) -> String {
     if we_url::Url::parse(input).is_ok() {
         return input.to_string();
diff --git a/crates/js/src/lib.rs b/crates/js/src/lib.rs
index 713e840..c910b1f 100644
--- a/crates/js/src/lib.rs
+++ b/crates/js/src/lib.rs
@@ -10,6 +10,7 @@ pub mod cache_api;
 pub mod compiler;
 pub mod compression_streams;
 pub mod dom_bridge;
+pub mod dynamic_import;
 pub mod eventsource;
 pub mod fetch;
 pub mod gc;
diff --git a/crates/js/src/module.rs b/crates/js/src/module.rs
index 534ca6c..b3969ad 100644
--- a/crates/js/src/module.rs
+++ b/crates/js/src/module.rs
@@ -22,15 +22,19 @@
 //! resolves specifiers to absolute URLs, and executes modules in dependency
 //! order so a module's exports are published before any dependent imports them.
 //!
+//! Dynamic `import()` is handled separately in [`crate::dynamic_import`]; the
+//! loader preloads statically-discoverable `import("<literal>")` targets via
+//! [`dynamic_import_specifiers`] so the runtime resolves them from this same
+//! registry.
+//!
 //! Not yet handled here (tracked as follow-up sub-steps of the document-level
-//! ES module work): bare-specifier resolution via import maps, dynamic
-//! `import()`, `export * from`, and live (mutable) binding semantics — imports
-//! observe the exporter's value at link time, which is correct for the common
-//! acyclic case.
+//! ES module work): bare-specifier resolution via import maps, `export * from`,
+//! and live (mutable) binding semantics — imports observe the exporter's value
+//! at link time, which is correct for the common acyclic case.
 
 use crate::ast::{
-    ExportDecl, Expr, ExprKind, ImportSpecifier, Pattern, PatternKind, Program, SourceType, Stmt,
-    StmtKind, VarDeclarator, VarKind,
+    ArrayElement, ArrowBody, ExportDecl, Expr, ExprKind, ForInit, ImportSpecifier, Pattern,
+    PatternKind, Program, SourceType, Stmt, StmtKind, VarDeclarator, VarKind,
 };
 use crate::bytecode::Function;
 use crate::compiler;
@@ -322,6 +326,242 @@ pub fn module_dependencies(program: &Program) -> Vec<String> {
     deps
 }
 
+/// The runtime helper that the parser routes dynamic `import(...)` to.
+const DYNAMIC_IMPORT_HELPER: &str = "__we_dynamic_import";
+
+/// Collect the string-literal specifiers of `import("<literal>")` calls in a
+/// program, in source order and de-duplicated.
+///
+/// The document-level module loader uses this to eagerly fetch and execute
+/// statically-discoverable dynamic-import targets so a later `import()` resolves
+/// from the populated module registry ("resolved off the same loader").
+///
+/// Discovery is best-effort: only string-literal specifiers are found, and the
+/// traversal covers the common statement/expression containers. A specifier
+/// computed at runtime (or nested somewhere this walk does not reach) is simply
+/// not preloaded — the runtime `import()` then rejects rather than crashing.
+pub fn dynamic_import_specifiers(program: &Program) -> Vec<String> {
+    let mut out = Vec::new();
+    for stmt in &program.body {
+        collect_dyn_imports_stmt(stmt, &mut out);
+    }
+    out
+}
+
+fn push_unique(out: &mut Vec<String>, s: &str) {
+    if !out.iter().any(|e| e == s) {
+        out.push(s.to_string());
+    }
+}
+
+fn collect_dyn_imports_stmt(stmt: &Stmt, out: &mut Vec<String>) {
+    match &stmt.kind {
+        StmtKind::Expr(e) | StmtKind::Throw(e) => collect_dyn_imports_expr(e, out),
+        StmtKind::Block(stmts) | StmtKind::Try { block: stmts, .. } => {
+            for s in stmts {
+                collect_dyn_imports_stmt(s, out);
+            }
+            if let StmtKind::Try {
+                handler, finalizer, ..
+            } = &stmt.kind
+            {
+                if let Some(c) = handler {
+                    for s in &c.body {
+                        collect_dyn_imports_stmt(s, out);
+                    }
+                }
+                if let Some(f) = finalizer {
+                    for s in f {
+                        collect_dyn_imports_stmt(s, out);
+                    }
+                }
+            }
+        }
+        StmtKind::VarDecl { declarators, .. } => {
+            for d in declarators {
+                if let Some(init) = &d.init {
+                    collect_dyn_imports_expr(init, out);
+                }
+            }
+        }
+        StmtKind::FunctionDecl(def) => {
+            for s in &def.body {
+                collect_dyn_imports_stmt(s, out);
+            }
+        }
+        StmtKind::If {
+            test,
+            consequent,
+            alternate,
+        } => {
+            collect_dyn_imports_expr(test, out);
+            collect_dyn_imports_stmt(consequent, out);
+            if let Some(alt) = alternate {
+                collect_dyn_imports_stmt(alt, out);
+            }
+        }
+        StmtKind::For {
+            init,
+            test,
+            update,
+            body,
+        } => {
+            match init {
+                Some(ForInit::Expr(e)) => collect_dyn_imports_expr(e, out),
+                Some(ForInit::VarDecl { declarators, .. }) => {
+                    for d in declarators {
+                        if let Some(init) = &d.init {
+                            collect_dyn_imports_expr(init, out);
+                        }
+                    }
+                }
+                None => {}
+            }
+            if let Some(t) = test {
+                collect_dyn_imports_expr(t, out);
+            }
+            if let Some(u) = update {
+                collect_dyn_imports_expr(u, out);
+            }
+            collect_dyn_imports_stmt(body, out);
+        }
+        StmtKind::ForIn { right, body, .. } | StmtKind::ForOf { right, body, .. } => {
+            collect_dyn_imports_expr(right, out);
+            collect_dyn_imports_stmt(body, out);
+        }
+        StmtKind::While { test, body } | StmtKind::DoWhile { body, test } => {
+            collect_dyn_imports_expr(test, out);
+            collect_dyn_imports_stmt(body, out);
+        }
+        StmtKind::Switch {
+            discriminant,
+            cases,
+        } => {
+            collect_dyn_imports_expr(discriminant, out);
+            for case in cases {
+                if let Some(t) = &case.test {
+                    collect_dyn_imports_expr(t, out);
+                }
+                for s in &case.consequent {
+                    collect_dyn_imports_stmt(s, out);
+                }
+            }
+        }
+        StmtKind::Return(Some(e)) => collect_dyn_imports_expr(e, out),
+        StmtKind::Labeled { body, .. } => collect_dyn_imports_stmt(body, out),
+        StmtKind::With { object, body } => {
+            collect_dyn_imports_expr(object, out);
+            collect_dyn_imports_stmt(body, out);
+        }
+        _ => {}
+    }
+}
+
+fn collect_dyn_imports_expr(expr: &Expr, out: &mut Vec<String>) {
+    match &expr.kind {
+        ExprKind::Call { callee, arguments } => {
+            if let ExprKind::Identifier(name) = &callee.kind {
+                if name == DYNAMIC_IMPORT_HELPER {
+                    if let Some(Expr {
+                        kind: ExprKind::String(spec),
+                        ..
+                    }) = arguments.first()
+                    {
+                        push_unique(out, spec);
+                    }
+                }
+            }
+            collect_dyn_imports_expr(callee, out);
+            for a in arguments {
+                collect_dyn_imports_expr(a, out);
+            }
+        }
+        ExprKind::New { callee, arguments } => {
+            collect_dyn_imports_expr(callee, out);
+            for a in arguments {
+                collect_dyn_imports_expr(a, out);
+            }
+        }
+        ExprKind::Array(elems) => {
+            for el in elems.iter().flatten() {
+                match el {
+                    ArrayElement::Expr(e) | ArrayElement::Spread(e) => {
+                        collect_dyn_imports_expr(e, out)
+                    }
+                }
+            }
+        }
+        ExprKind::Object(props) => {
+            for p in props {
+                if let Some(v) = &p.value {
+                    collect_dyn_imports_expr(v, out);
+                }
+            }
+        }
+        ExprKind::Function(def) => {
+            for s in &def.body {
+                collect_dyn_imports_stmt(s, out);
+            }
+        }
+        ExprKind::Arrow { body, .. } => match body {
+            ArrowBody::Expr(e) => collect_dyn_imports_expr(e, out),
+            ArrowBody::Block(stmts) => {
+                for s in stmts {
+                    collect_dyn_imports_stmt(s, out);
+                }
+            }
+        },
+        ExprKind::Unary { argument, .. }
+        | ExprKind::Update { argument, .. }
+        | ExprKind::Spread(argument)
+        | ExprKind::Await(argument)
+        | ExprKind::OptionalChain { base: argument }
+        | ExprKind::OptionalChainExpr { chain: argument } => {
+            collect_dyn_imports_expr(argument, out)
+        }
+        ExprKind::Binary { left, right, .. }
+        | ExprKind::Logical { left, right, .. }
+        | ExprKind::Assignment { left, right, .. } => {
+            collect_dyn_imports_expr(left, out);
+            collect_dyn_imports_expr(right, out);
+        }
+        ExprKind::Conditional {
+            test,
+            consequent,
+            alternate,
+        } => {
+            collect_dyn_imports_expr(test, out);
+            collect_dyn_imports_expr(consequent, out);
+            collect_dyn_imports_expr(alternate, out);
+        }
+        ExprKind::Member {
+            object, property, ..
+        } => {
+            collect_dyn_imports_expr(object, out);
+            collect_dyn_imports_expr(property, out);
+        }
+        ExprKind::TemplateLiteral { expressions, .. } => {
+            for e in expressions {
+                collect_dyn_imports_expr(e, out);
+            }
+        }
+        ExprKind::TaggedTemplate { tag, quasi } => {
+            collect_dyn_imports_expr(tag, out);
+            collect_dyn_imports_expr(quasi, out);
+        }
+        ExprKind::Sequence(exprs) => {
+            for e in exprs {
+                collect_dyn_imports_expr(e, out);
+            }
+        }
+        ExprKind::Yield {
+            argument: Some(arg),
+            ..
+        } => collect_dyn_imports_expr(arg, out),
+        _ => {}
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -472,4 +712,21 @@ mod tests {
         let deps = module_dependencies(&program);
         assert_eq!(deps, vec!["./a.js", "b", "./c.js"]);
     }
+
+    #[test]
+    fn dynamic_import_specifiers_finds_literals() {
+        let program = Parser::parse_module(
+            r#"
+            import("./eager.js");
+            const p = cond ? import("./a.js") : import("./b.js");
+            function lazy() { return import("./a.js").then(function(m) { return m; }); }
+            for (var i = 0; i < 1; i++) { import("./loop.js"); }
+            import(runtimeComputed);
+            "#,
+        )
+        .unwrap();
+        let specs = dynamic_import_specifiers(&program);
+        // De-duplicated, source order, literal-only (the computed one is skipped).
+        assert_eq!(specs, vec!["./eager.js", "./a.js", "./b.js", "./loop.js"]);
+    }
 }
diff --git a/crates/js/src/parser.rs b/crates/js/src/parser.rs
index 31089cc..cb254e6 100644
--- a/crates/js/src/parser.rs
+++ b/crates/js/src/parser.rs
@@ -2106,12 +2106,25 @@ impl Parser {
                 })
             }
             TokenKind::Import => {
-                // import() call expression
                 self.advance();
-                Ok(Expr {
-                    kind: ExprKind::Identifier("import".into()),
-                    span: self.span_from(start),
-                })
+                if self.at(&TokenKind::Dot) {
+                    // `import.meta` — leave as a bare identifier so the member
+                    // access evaluates against the (currently absent) global,
+                    // yielding `undefined` rather than a dynamic import.
+                    Ok(Expr {
+                        kind: ExprKind::Identifier("import".into()),
+                        span: self.span_from(start),
+                    })
+                } else {
+                    // Dynamic `import(specifier)`. The trailing `(...)` is parsed
+                    // by the call-expression suffix logic, producing a call to
+                    // the `__we_dynamic_import` runtime helper which returns a
+                    // Promise for the imported module namespace.
+                    Ok(Expr {
+                        kind: ExprKind::Identifier("__we_dynamic_import".into()),
+                        span: self.span_from(start),
+                    })
+                }
             }
             _ => Err(self.error(format!("unexpected token {:?}", self.peek_kind()))),
         }
diff --git a/crates/js/src/vm.rs b/crates/js/src/vm.rs
index 635b145..f2153ab 100644
--- a/crates/js/src/vm.rs
+++ b/crates/js/src/vm.rs
@@ -2202,6 +2202,7 @@ impl Vm {
     pub fn pump_event_loop(&mut self) -> Result<(), RuntimeError> {
         self.drain_due_timers()?;
         self.drain_completed_fetches()?;
+        crate::dynamic_import::drain_dynamic_imports(self)?;
         crate::fetch::drain_fetch_body_streams(self)?;
         crate::xml_http_request::drain_xhr_events(self)?;
         crate::indexeddb::drain_idb_events(self)?;
@@ -2221,6 +2222,7 @@ impl Vm {
         while crate::timers::has_pending_timers()
             || crate::fetch::has_pending_fetches()
             || crate::fetch::has_live_fetch_body_streams()
+            || crate::dynamic_import::has_pending_dynamic_imports()
             || crate::xml_http_request::has_pending_xhrs()
             || crate::indexeddb::has_pending_idb_events()
             || crate::eventsource::has_live_event_sources()
@@ -2234,6 +2236,7 @@ impl Vm {
             }
             self.drain_due_timers()?;
             self.drain_completed_fetches()?;
+            crate::dynamic_import::drain_dynamic_imports(self)?;
             crate::fetch::drain_fetch_body_streams(self)?;
             crate::xml_http_request::drain_xhr_events(self)?;
             crate::indexeddb::drain_idb_events(self)?;
@@ -3331,6 +3334,9 @@ impl Vm {
         roots.extend(crate::timers::timer_gc_roots());
         // Pending fetch promises must be GC roots.
         roots.extend(crate::fetch::fetch_gc_roots());
+        // Pending dynamic-import promises must stay rooted between `import()`
+        // and the event-loop tick that settles them.
+        roots.extend(crate::dynamic_import::dynamic_import_gc_roots());
         // Pending XHR completions hold their handler functions as own
         // properties; the XHR objects themselves must stay rooted between
         // `send()` and the drain tick.
-- 
2.51.2