rusty_racer 0.2.4 → 0.2.6

data/ext/rusty_racer/src/ops.rs

@@ -29,18 +29,40 @@ macro_rules! marshalled {
     ($tc:expr, $value:expr) => {{
         let tc = $tc;
         let out = js_to_jsval(tc, $value);
-        let exc = tc.exception();
-        if exc.is_none() {
+        if tc.has_caught() {
+            Err(caught!(tc))
+        } else {
             Ok(out)
-        } else if tc.has_terminated() {
-            Err(VmError::Terminated)
+        }
+    }};
+}
+
+// The failure a TryCatch holds once a JS step came back empty: a termination, or
+// the exception with its stack (and the thrown value kept — `keep_thrown`).
+macro_rules! caught {
+    ($tc:expr) => {{
+        let tc = $tc;
+        if tc.has_terminated() {
+            VmError::Terminated
         } else {
+            let exc = tc.exception();
             let stack = tc.stack_trace();
-            Err(capture_js_error(tc, exc, stack))
+            capture_js_error(tc, exc, stack)
         }
     }};
 }
 
+// What an eval hands back of its completion value: all of it, marshalled; nothing (`Void`: a statement list run for its
+// EFFECT still has one — the last statement's value — and marshalling it can throw, an accessor or a Proxy trap, or walk
+// a huge graph, for a value the caller discards); or a primitive alone (`Primitive`: an object's never walked, undefined
+// in its place — for a caller that wants a string or a number of it, as a javascript: URL's evaluation does).
+#[derive(Clone, Copy)]
+pub(crate) enum Completion {
+    Value,
+    Void,
+    Primitive,
+}
+
 // One VM operation, built by a magnus method and run inline by Core::run ->
 // service_request -> dispatch_one. |context_id| selects which realm the op runs
 // in: 0 = the main realm (Context's own globalThis, swappable by reset_realm),
@@ -51,11 +73,7 @@ pub(crate) enum Request {
         source: String,
         filename: String,
         timeout_ms: u64,
-        // void = don't marshal the completion value (see Call's |void|). A
-        // statement-list eval run for its EFFECT still has one — the last
-        // statement's value — and marshalling it can throw (an accessor, a
-        // Proxy trap) or walk a huge graph, for a value the caller discards.
-        void: bool,
+        completion: Completion,
     },
     // Resolve a dotted function path on globalThis and invoke it with marshalled
     // args (v8::Function::call), preserving the holder as `this`. Distinct from
@@ -69,6 +87,22 @@ pub(crate) enum Request {
         void: bool,
         timeout_ms: u64,
     },
+    // Context#function: resolve the path as Call does, once, and keep the
+    // function and its holder (FunctionReg); replies with the handle's id.
+    ResolveFunction {
+        context_id: i32,
+        path: String,
+        timeout_ms: u64,
+    },
+    // Function#call: invoke a resolved handle as Call invokes what it resolves,
+    // with no path walk and no property name made.
+    CallFunction {
+        context_id: i32,
+        function_id: u64,
+        args: Vec<JsVal>,
+        void: bool,
+        timeout_ms: u64,
+    },
     // Drain the isolate's microtask queue once (no auto event loop).
     DrainMicrotasks {
         timeout_ms: u64,
@@ -76,14 +110,14 @@ pub(crate) enum Request {
     Attach {
         context_id: i32,
         name: String,
-        host_fn_id: usize,
+        host_fn: HostFnKey,
         timeout_ms: u64,
     },
-    // Batch attach: install many (name, host_fn_id) host fns in one round-trip
+    // Batch attach: install many (name, key) host fns in one round-trip
     // (a fresh realm needs ~dozens). Same semantics as Attach, applied in order.
     AttachMany {
         context_id: i32,
-        entries: Vec<(String, usize)>,
+        entries: Vec<(String, HostFnKey)>,
         timeout_ms: u64,
     },
     // reset: swap globalThis for a fresh v8::Context, reusing the same warm
@@ -123,6 +157,10 @@ pub(crate) enum Request {
     EvaluateModule {
         module_id: i32,
         timeout_ms: u64,
+        // The name of a function on the module's context's global that reports its evaluation's rejection — HTML "run
+        // a module script": upon rejection, report the exception — now or as a top-level-await module settles; none:
+        // the rejection is the op's error, as far as the drain gets.
+        report: Option<String>,
     },
     ModuleNamespace {
         module_id: i32,
@@ -137,9 +175,6 @@ pub(crate) enum Request {
     ModuleGraphAsync {
         module_id: i32,
     },
-    DisposeModule {
-        module_id: i32,
-    },
     // Classic <script> primitives (V8 ScriptCompiler::CompileUnboundScript): an
     // unbound script, compiled in a context, runnable repeatedly, with the same
     // bytecode-cache options as modules. Addressed by id like a module.
@@ -158,9 +193,6 @@ pub(crate) enum Request {
         timeout_ms: u64,
         void: bool,
     },
-    DisposeScript {
-        script_id: i32,
-    },
     // Serialize a bytecode cache from a compiled handle's CURRENT compile state
     // (Script#create_code_cache / Module#create_code_cache). Called after run/
     // evaluate, it captures the inner functions V8 lazily compiled while running
@@ -234,102 +266,104 @@ pub(crate) fn run_source(
     scope: &mut v8::PinScope<'_, '_>,
     source: &str,
     filename: &str,
-    void: bool,
+    completion: Completion,
 ) -> Result<JsVal, VmError> {
     v8::tc_scope!(let tc, scope);
     // Compile and run as distinct phases so a compile failure maps to
     // ParseError and a thrown exception to RuntimeError (csim rescues both).
     let Some(code) = v8::String::new(tc, source) else {
-        return Err(VmError::Parse("source too large".into()));
+        return Err(VmError::Parse("source too large".into(), None));
     };
     let origin = script_origin(tc, filename);
     let script = match v8::Script::compile(tc, code, Some(&origin)) {
         Some(script) => script,
         None if tc.has_terminated() => return Err(VmError::Terminated),
         None => {
-            let msg = tc
-                .exception()
-                .map(|e| e.to_rust_string_lossy(tc))
-                .unwrap_or_else(|| "parse error".to_string());
-            // Append the location V8 recorded; always name the file, add the
-            // line when V8 reports one.
-            let message = tc.message();
-            let res = message
-                .and_then(|m| m.get_script_resource_name(tc))
-                .filter(|v| v.is_string())
-                .map(|v| v.to_rust_string_lossy(tc))
-                .unwrap_or_else(|| filename.to_string());
-            let loc = match message.and_then(|m| m.get_line_number(tc)) {
-                Some(line) => format!(" at {res}:{line}"),
-                None => format!(" at {res}"),
-            };
-            return Err(VmError::Parse(format!("{msg}{loc}")));
+            let (exc, message) = (tc.exception(), tc.message());
+            return Err(parse_error(tc, exc, message, filename, "parse error"));
         }
     };
     match script.run(tc) {
-        Some(_) if void => Ok(JsVal::Undefined),
-        Some(value) => marshalled!(tc, value),
-        None if tc.has_terminated() => Err(VmError::Terminated),
-        None => {
-            let exc = tc.exception();
-            let stack = tc.stack_trace();
-            Err(capture_js_error(tc, exc, stack))
-        }
+        Some(value) => match completion {
+            Completion::Value => marshalled!(tc, value),
+            Completion::Primitive if value.is_object() || value.is_symbol() => Ok(JsVal::Undefined),
+            Completion::Primitive => marshalled!(tc, value),
+            Completion::Void => Ok(JsVal::Undefined),
+        },
+        None => Err(caught!(tc)),
     }
 }
 
-// Resolve a dotted property path on globalThis to a function and invoke it via
-// v8::Function::call, with the property's holder as `this` (so `a.b.f` gets the
-// right receiver). Args/result marshal through the ref-preserving paths.
-fn call_function(
-    scope: &mut v8::PinScope<'_, '_>,
-    name: &str,
-    args: Vec<JsVal>,
-    void: bool,
-) -> Result<JsVal, VmError> {
-    v8::tc_scope!(let tc, scope);
-    let context = tc.get_current_context();
-    let global = context.global(tc);
-    let mut recv: v8::Local<v8::Value> = global.into();
+// Resolve a dotted property path on the current realm's globalThis to a
+// function and the holder it was read off — its `this`, so `a.b.f` gets the right
+// receiver. Each segment is an ordinary [[Get]], so a getter or Proxy trap on the
+// path runs; when one throws, the error is Err(None): the caller's TryCatch holds
+// it (`caught!`).
+fn resolve_function<'s>(
+    scope: &mut v8::PinScope<'s, '_>,
+    path: &str,
+) -> Result<(v8::Local<'s, v8::Function>, v8::Local<'s, v8::Value>), Option<VmError>> {
+    let global = scope.get_current_context().global(scope);
+    let mut holder: v8::Local<v8::Value> = global.into();
     let mut target: v8::Local<v8::Value> = global.into();
-    for part in name.split('.') {
-        let Some(obj) = target.to_object(tc) else {
+    for part in path.split('.') {
+        let Some(obj) = target.to_object(scope) else {
             // The holder of `part` (a preceding segment) was null/undefined, so
             // there's nothing to read `part` from — name the holder, not `part`.
-            return Err(VmError::Runtime(format!(
-                "`{name}`: cannot read `{part}` (a preceding path segment is not an object)"
-            )));
+            return Err(Some(VmError::Runtime(format!(
+                "`{path}`: cannot read `{part}` (a preceding path segment is not an object)"
+            ))));
         };
-        let Some(key) = v8::String::new(tc, part) else {
-            return Err(VmError::Runtime("property name too large".into()));
+        let Some(key) = v8::String::new(scope, part) else {
+            return Err(Some(VmError::Runtime("property name too large".into())));
         };
-        let Some(next) = obj.get(tc, key.into()) else {
-            if tc.has_terminated() {
-                return Err(VmError::Terminated);
-            }
-            let msg = tc
-                .exception()
-                .map(|e| e.to_rust_string_lossy(tc))
-                .unwrap_or_else(|| format!("cannot read `{part}` of `{name}`"));
-            return Err(VmError::Runtime(msg));
+        let Some(next) = obj.get(scope, key.into()) else {
+            return Err(None);
         };
-        recv = target;
+        holder = target;
         target = next;
     }
-    let Ok(func) = v8::Local::<v8::Function>::try_from(target) else {
-        return Err(VmError::Runtime(format!("`{name}` is not a function")));
+    match v8::Local::<v8::Function>::try_from(target) {
+        Ok(function) => Ok((function, holder)),
+        Err(_) => Err(Some(VmError::Runtime(format!(
+            "`{path}` is not a function"
+        )))),
+    }
+}
+
+// Context#call: resolve |name| (above), then call what it names.
+fn call_function(
+    scope: &mut v8::PinScope<'_, '_>,
+    name: &str,
+    args: Vec<JsVal>,
+    void: bool,
+) -> Result<JsVal, VmError> {
+    let (function, receiver) = {
+        v8::tc_scope!(let tc, scope);
+        match resolve_function(tc, name) {
+            Ok(resolved) => resolved,
+            Err(failure) => return Err(failure.unwrap_or_else(|| caught!(tc))),
+        }
     };
+    call_resolved(scope, function, receiver, args, void)
+}
+
+// Invoke |function| via v8::Function::call with |receiver| as `this`.
+// Args/result marshal through the ref-preserving paths.
+fn call_resolved(
+    scope: &mut v8::PinScope<'_, '_>,
+    function: v8::Local<v8::Function>,
+    receiver: v8::Local<v8::Value>,
+    args: Vec<JsVal>,
+    void: bool,
+) -> Result<JsVal, VmError> {
+    v8::tc_scope!(let tc, scope);
     let argv: Vec<v8::Local<v8::Value>> = args.into_iter().map(|a| jsval_to_js(tc, a)).collect();
-    match func.call(tc, recv, &argv) {
+    match function.call(tc, receiver, &argv) {
         // void: skip marshalling the return so a huge/cyclic result is never walked.
         Some(_) if void => Ok(JsVal::Undefined),
         Some(value) => marshalled!(tc, value),
-        None if tc.has_terminated() => Err(VmError::Terminated),
-        None => {
-            let exc = tc.exception();
-            let stack = tc.stack_trace();
-            Err(capture_js_error(tc, exc, stack))
-        }
+        None => Err(caught!(tc)),
     }
 }
 
@@ -413,6 +447,7 @@ pub(crate) fn service_request(
     // (the graveyard repoint inside) requires that.
     if outermost {
         flush_retiring(scope);
+        forget_released_handles(scope);
     }
     reply
 }
@@ -423,6 +458,8 @@ fn request_realm(state: &IsolateState, request: &Request) -> Option<i32> {
     match request {
         Request::Eval { context_id, .. }
         | Request::Call { context_id, .. }
+        | Request::ResolveFunction { context_id, .. }
+        | Request::CallFunction { context_id, .. }
         | Request::Attach { context_id, .. }
         | Request::AttachMany { context_id, .. }
         | Request::CompileModule { context_id, .. }
@@ -441,8 +478,6 @@ fn request_realm(state: &IsolateState, request: &Request) -> Option<i32> {
         | Request::DisposeContext { .. }
         | Request::ModuleStatus { .. }
         | Request::ModuleGraphAsync { .. }
-        | Request::DisposeModule { .. }
-        | Request::DisposeScript { .. }
         | Request::ScriptCodeCache { .. }
         | Request::ModuleCodeCache { .. }
         | Request::HeapStatistics
@@ -465,9 +500,9 @@ fn dispatch_one(
             source,
             filename,
             timeout_ms,
-            void,
+            completion,
         } => op_eval(
-            scope, context_id, source, filename, timeout_ms, void, outermost,
+            scope, context_id, source, filename, timeout_ms, completion, outermost,
         ),
         Request::Call {
             context_id,
@@ -476,13 +511,33 @@ fn dispatch_one(
             void,
             timeout_ms,
         } => op_call(scope, context_id, name, args, void, timeout_ms, outermost),
+        Request::ResolveFunction {
+            context_id,
+            path,
+            timeout_ms,
+        } => op_resolve_function(scope, context_id, path, timeout_ms, outermost),
+        Request::CallFunction {
+            context_id,
+            function_id,
+            args,
+            void,
+            timeout_ms,
+        } => op_call_function(
+            scope,
+            context_id,
+            function_id,
+            args,
+            void,
+            timeout_ms,
+            outermost,
+        ),
         Request::DrainMicrotasks { timeout_ms } => op_drain_microtasks(scope, timeout_ms),
         Request::Attach {
             context_id,
             name,
-            host_fn_id,
+            host_fn,
             timeout_ms,
-        } => op_attach(scope, context_id, name, host_fn_id, timeout_ms, outermost),
+        } => op_attach(scope, context_id, name, host_fn, timeout_ms, outermost),
         Request::AttachMany {
             context_id,
             entries,
@@ -511,11 +566,11 @@ fn dispatch_one(
         Request::EvaluateModule {
             module_id,
             timeout_ms,
-        } => op_evaluate_module(scope, module_id, timeout_ms, outermost),
+            report,
+        } => op_evaluate_module(scope, module_id, timeout_ms, report, outermost),
         Request::ModuleNamespace { module_id } => op_module_namespace(scope, module_id),
         Request::ModuleStatus { module_id } => op_module_status(scope, module_id),
         Request::ModuleGraphAsync { module_id } => op_module_graph_async(scope, module_id),
-        Request::DisposeModule { module_id } => op_dispose_module(scope, module_id),
         Request::CompileScript {
             context_id,
             source,
@@ -537,7 +592,6 @@ fn dispatch_one(
             timeout_ms,
             void,
         } => op_run_script(scope, script_id, timeout_ms, void, outermost),
-        Request::DisposeScript { script_id } => op_dispose_script(scope, script_id),
         // Serialize the script's CURRENT compile state. The stored handle is
         // the UnboundScript, which V8 fills in with inner-function bytecode as
         // run() lazily compiles them — so calling this after run() captures
@@ -619,7 +673,7 @@ fn op_eval(
     source: String,
     filename: String,
     timeout_ms: u64,
-    void: bool,
+    completion: Completion,
     outermost: bool,
 ) -> VmReply {
     let outcome = run_js_bracketed(scope, outermost, timeout_ms, "eval", |scope, outermost| {
@@ -628,7 +682,7 @@ fn op_eval(
             Some(ctx) => {
                 let context = v8::Local::new(scope, &ctx);
                 let scope = &mut v8::ContextScope::new(scope, context);
-                let out = run_source(scope, &source, &filename, void);
+                let out = run_source(scope, &source, &filename, completion);
                 auto_drain(scope, outermost);
                 (true, out)
             }
@@ -672,6 +726,132 @@ fn op_call(
     VmReply::Done(outcome)
 }
 
+fn op_resolve_function(
+    scope: &mut v8::PinScope<'_, '_, ()>,
+    context_id: i32,
+    path: String,
+    timeout_ms: u64,
+    outermost: bool,
+) -> VmReply {
+    // The id this resolve registered, for a terminate after it (in the drain, or
+    // the watchdog's verdict over the bracket) to take back: a failed resolve hands
+    // Ruby no wrapper, so nothing else would ever release it.
+    let mut registered = None;
+    let outcome = run_js_bracketed(
+        scope,
+        outermost,
+        timeout_ms,
+        "function",
+        |scope, outermost| {
+            let Some(ctx) = context_for(istate!(scope), context_id) else {
+                return (false, Err(VmError::Disposed(REALM_GONE.into())));
+            };
+            let context = v8::Local::new(scope, &ctx);
+            let scope = &mut v8::ContextScope::new(scope, context);
+            let resolved = {
+                v8::tc_scope!(let tc, scope);
+                match resolve_function(tc, &path) {
+                    Ok((function, receiver)) => {
+                        Ok((v8::Global::new(tc, function), v8::Global::new(tc, receiver)))
+                    }
+                    Err(failure) => Err(failure.unwrap_or_else(|| caught!(tc))),
+                }
+            };
+            let out = resolved.map(|(function, receiver)| {
+                let functions = &mut istate!(scope).functions;
+                let id = functions.next_id;
+                functions.next_id += 1;
+                functions.by_id.insert(
+                    id,
+                    FunctionEntry {
+                        function,
+                        receiver,
+                        context_id,
+                    },
+                );
+                registered = Some(id);
+                JsVal::Int(id as i64)
+            });
+            auto_drain(scope, outermost);
+            (true, out)
+        },
+    );
+    if let (Err(_), Some(id)) = (&outcome, registered) {
+        istate!(scope).functions.by_id.remove(&id);
+    }
+    VmReply::Done(outcome)
+}
+
+// What a call or a resolve of a handle whose realm is gone raises.
+const REALM_GONE: &str = "function's realm was reset or disposed";
+
+// Remove the handles whose Ruby wrappers were disposed or collected
+// (Core.released) from their registries: a wrapper could not drop its Globals
+// itself. At the outermost request boundary, and only when one was released — a
+// flag read, not a lock, on every other op.
+fn forget_released_handles(scope: &mut v8::PinScope<'_, '_, ()>) {
+    let core = istate!(scope).core_ptr;
+    if core.is_null() {
+        return;
+    }
+    let core = unsafe { &*core };
+    if !core.handles_released.swap(false, Ordering::Relaxed) {
+        return;
+    }
+    let released = std::mem::take(&mut *core.released.lock().unwrap());
+    let state = istate!(scope);
+    for handle in released {
+        match handle {
+            Released::Function(id) => {
+                state.functions.by_id.remove(&id);
+            }
+            Released::Module(id) => {
+                state.modules.by_id.remove(&id);
+            }
+            Released::Script(id) => {
+                state.scripts.by_id.remove(&id);
+            }
+        }
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn op_call_function(
+    scope: &mut v8::PinScope<'_, '_, ()>,
+    context_id: i32,
+    function_id: u64,
+    args: Vec<JsVal>,
+    void: bool,
+    timeout_ms: u64,
+    outermost: bool,
+) -> VmReply {
+    let outcome = run_js_bracketed(scope, outermost, timeout_ms, "call", |scope, outermost| {
+        let Some(ctx) = context_for(istate!(scope), context_id) else {
+            return (false, Err(VmError::Disposed(REALM_GONE.into())));
+        };
+        let context = v8::Local::new(scope, &ctx);
+        let scope = &mut v8::ContextScope::new(scope, context);
+        // Locals straight off the registry's Globals: a shared borrow of the slot
+        // beside the shared one Local::new takes, so nothing is cloned per call.
+        let target = scope
+            .get_slot::<IsolateState>()
+            .and_then(|state| state.functions.by_id.get(&function_id))
+            .map(|entry| {
+                (
+                    v8::Local::new(scope, &entry.function),
+                    v8::Local::new(scope, &entry.receiver),
+                )
+            });
+        let Some((function, receiver)) = target else {
+            return (false, Err(VmError::Disposed(REALM_GONE.into())));
+        };
+        let out = call_resolved(scope, function, receiver, args, void);
+        auto_drain(scope, outermost);
+        (true, out)
+    });
+    VmReply::Done(outcome)
+}
+
 fn op_drain_microtasks(scope: &mut v8::PinScope<'_, '_, ()>, timeout_ms: u64) -> VmReply {
     // A microtask may call an attached host fn (a Promise .then ->
     // ruby), which runs inline via host_fn_callback — no routing
@@ -699,7 +879,7 @@ fn op_attach(
     scope: &mut v8::PinScope<'_, '_, ()>,
     context_id: i32,
     name: String,
-    host_fn_id: usize,
+    host_fn: HostFnKey,
     timeout_ms: u64,
     outermost: bool,
 ) -> VmReply {
@@ -719,7 +899,7 @@ fn op_attach(
                 Some(ctx) => {
                     let context = v8::Local::new(scope, &ctx);
                     let scope = &mut v8::ContextScope::new(scope, context);
-                    let external = v8::External::new(scope, host_fn_id as *mut c_void);
+                    let external = v8::External::new(scope, host_fn.to_external());
                     let out = match v8::Function::builder(host_fn_callback)
                         .data(external.into())
                         .build(scope)
@@ -747,7 +927,7 @@ fn op_attach(
 fn op_attach_many(
     scope: &mut v8::PinScope<'_, '_, ()>,
     context_id: i32,
-    entries: Vec<(String, usize)>,
+    entries: Vec<(String, HostFnKey)>,
     timeout_ms: u64,
     outermost: bool,
 ) -> VmReply {
@@ -769,8 +949,8 @@ fn op_attach_many(
                     let context = v8::Local::new(scope, &ctx);
                     let scope = &mut v8::ContextScope::new(scope, context);
                     let mut out = Ok(JsVal::Undefined);
-                    for (name, host_fn_id) in &entries {
-                        let external = v8::External::new(scope, *host_fn_id as *mut c_void);
+                    for (name, host_fn) in &entries {
+                        let external = v8::External::new(scope, host_fn.to_external());
                         out = match v8::Function::builder(host_fn_callback)
                             .data(external.into())
                             .build(scope)
@@ -938,13 +1118,13 @@ fn op_compile_module(
                             };
                             let hash = module.get_identity_hash().get();
                             let g = v8::Global::new(tc, module);
+                            let weak = v8::Weak::new(tc, module);
                             let id = {
                                 let m = &mut istate!(tc).modules;
                                 let id = m.next_id;
                                 m.next_id += 1;
-                                m.by_id
-                                    .insert(id, (g.clone(), filename.clone(), context_id));
-                                m.by_hash.entry(hash).or_default().push((g, id));
+                                m.by_id.insert(id, (g, context_id));
+                                m.add_url(hash, weak, filename.clone());
                                 id
                             };
                             Ok(Compiled {
@@ -957,21 +1137,14 @@ fn op_compile_module(
                         // A module compile failure is a parse error
                         // (compile-time), not a thrown exception.
                         None => {
-                            let msg = tc
-                                .exception()
-                                .map(|e| e.to_rust_string_lossy(tc))
-                                .unwrap_or_else(|| "module parse error".to_string());
-                            let message = tc.message();
-                            let res = message
-                                .and_then(|m| m.get_script_resource_name(tc))
-                                .filter(|v| v.is_string())
-                                .map(|v| v.to_rust_string_lossy(tc))
-                                .unwrap_or_else(|| filename.clone());
-                            let loc = match message.and_then(|m| m.get_line_number(tc)) {
-                                Some(line) => format!(" at {res}:{line}"),
-                                None => format!(" at {res}"),
-                            };
-                            Err(VmError::Parse(format!("{msg}{loc}")))
+                            let (exc, message) = (tc.exception(), tc.message());
+                            Err(parse_error(
+                                tc,
+                                exc,
+                                message,
+                                &filename,
+                                "module parse error",
+                            ))
                         }
                     }
                 }
@@ -1013,10 +1186,9 @@ fn op_instantiate_module(scope: &mut v8::PinScope<'_, '_, ()>, module_id: i32) -
                         | v8::ModuleStatus::Evaluated => Ok(JsVal::Undefined),
                         // V8 CHECK-aborts on instantiating an errored
                         // module; surface its exception instead.
-                        v8::ModuleStatus::Errored => Err(VmError::JsError {
-                            message: module.get_exception().to_rust_string_lossy(scope),
-                            backtrace: vec![],
-                        }),
+                        v8::ModuleStatus::Errored => {
+                            Err(rejected_with(scope, module.get_exception()))
+                        }
                         _ => {
                             v8::tc_scope!(let tc, scope);
                             match module.instantiate_module(tc, resolve_imported) {
@@ -1047,6 +1219,7 @@ fn op_evaluate_module(
     scope: &mut v8::PinScope<'_, '_, ()>,
     module_id: i32,
     timeout_ms: u64,
+    report: Option<String>,
     outermost: bool,
 ) -> VmReply {
     // Top-level module code (and, under :auto, the microtasks its
@@ -1081,17 +1254,25 @@ fn op_evaluate_module(
                         // must not override their real outcome to Terminated.
                         let mut did_eval = false;
                         // V8 CHECK-aborts the process if evaluate runs on a
-                        // module that isn't exactly Instantiated, so guard
-                        // status explicitly rather than crash.
+                        // module that is not instantiated yet (Uninstantiated /
+                        // Instantiating), so guard status explicitly rather than
+                        // crash.
                         let out = match module.get_status() {
-                            v8::ModuleStatus::Errored => Err(VmError::JsError {
-                                message: module.get_exception().to_rust_string_lossy(scope),
-                                backtrace: vec![],
-                            }),
-                            v8::ModuleStatus::Evaluated => Ok(JsVal::Undefined),
-                            v8::ModuleStatus::Instantiated => {
+                            // (…one evaluated already, with no reporter: nothing more to do, or its error again)
+                            v8::ModuleStatus::Errored if report.is_none() => {
+                                Err(rejected_with(scope, module.get_exception()))
+                            }
+                            v8::ModuleStatus::Evaluated if report.is_none() => Ok(JsVal::Undefined),
+                            // (…and with one, Evaluate again, as HTML runs every script element's record — V8 hands back
+                            // the same evaluation promise, rejected with its error or still pending its top-level
+                            // await — so each run reports)
+                            v8::ModuleStatus::Instantiated
+                            | v8::ModuleStatus::Evaluated
+                            | v8::ModuleStatus::Errored => {
                                 did_eval = true;
                                 v8::tc_scope!(let tc, scope);
+                                let reporter =
+                                    report.as_deref().and_then(|name| global_function(tc, name));
                                 match module.evaluate(tc) {
                                     // A synchronous top-level throw yields a
                                     // *rejected* promise (not None); a pending
@@ -1099,12 +1280,27 @@ fn op_evaluate_module(
                                     // re-checked after the drain.
                                     Some(value) => {
                                         match v8::Local::<v8::Promise>::try_from(value) {
+                                            // (…its rejection the reporter's: a synchronous throw's at once, before
+                                            // whatever its script's runner does next — its element's `load`, Chrome —
+                                            // the top-level await's as it settles, a microtask)
+                                            Ok(p) if reporter.is_some() => {
+                                                if let Some(reporter) = reporter {
+                                                    if p.state() == v8::PromiseState::Rejected {
+                                                        p.mark_as_handled();
+                                                        let (receiver, reason) = (
+                                                            v8::undefined(tc).into(),
+                                                            p.result(tc),
+                                                        );
+                                                        reporter.call(tc, receiver, &[reason]);
+                                                    } else {
+                                                        p.catch(tc, reporter);
+                                                    }
+                                                }
+                                                Ok(JsVal::Undefined)
+                                            }
                                             Ok(p) if p.state() == v8::PromiseState::Rejected => {
                                                 let reason = p.result(tc);
-                                                Err(VmError::JsError {
-                                                    message: reason.to_rust_string_lossy(tc),
-                                                    backtrace: vec![],
-                                                })
+                                                Err(rejected_with(tc, reason))
                                             }
                                             Ok(p) => {
                                                 eval_promise = Some(v8::Global::new(tc, p));
@@ -1113,12 +1309,7 @@ fn op_evaluate_module(
                                             _ => Ok(JsVal::Undefined),
                                         }
                                     }
-                                    None if tc.has_terminated() => Err(VmError::Terminated),
-                                    None => {
-                                        let exc = tc.exception();
-                                        let stack = tc.stack_trace();
-                                        Err(capture_js_error(tc, exc, stack))
-                                    }
+                                    None => Err(caught!(tc)),
                                 }
                             }
                             _ => Err(VmError::Runtime(
@@ -1132,10 +1323,7 @@ fn op_evaluate_module(
                             let p = v8::Local::new(scope, &g);
                             if p.state() == v8::PromiseState::Rejected {
                                 let reason = p.result(scope);
-                                Err(VmError::JsError {
-                                    message: reason.to_rust_string_lossy(scope),
-                                    backtrace: vec![],
-                                })
+                                Err(rejected_with(scope, reason))
                             } else {
                                 out
                             }
@@ -1151,6 +1339,16 @@ fn op_evaluate_module(
     VmReply::Done(outcome)
 }
 
+// The function the current context's global has under `name`, or None.
+fn global_function<'s>(
+    scope: &mut v8::PinScope<'s, '_>,
+    name: &str,
+) -> Option<v8::Local<'s, v8::Function>> {
+    let key = v8::String::new(scope, name)?;
+    let global = scope.get_current_context().global(scope);
+    v8::Local::<v8::Function>::try_from(global.get(scope, key.into())?).ok()
+}
+
 // get_module_namespace and is_graph_async both CHECK-abort (a release check, so
 // it kills the process) below Instantiated, so both ask this first. Everything
 // from Instantiated up is admissible, Errored included: a module that fails to
@@ -1179,10 +1377,7 @@ fn op_module_namespace(scope: &mut v8::PinScope<'_, '_, ()>, module_id: i32) ->
                 // never initialized — and the useful answer is WHY it errored,
                 // the same one instantiate and evaluate give.
                 if module.get_status() == v8::ModuleStatus::Errored {
-                    Err(VmError::JsError {
-                        message: module.get_exception().to_rust_string_lossy(scope),
-                        backtrace: vec![],
-                    })
+                    Err(rejected_with(scope, module.get_exception()))
                 } else {
                     match require_instantiated(module, "namespace") {
                         Err(e) => Err(e),
@@ -1244,15 +1439,6 @@ fn op_module_graph_async(scope: &mut v8::PinScope<'_, '_, ()>, module_id: i32) -
     VmReply::Done(outcome)
 }
 
-fn op_dispose_module(scope: &mut v8::PinScope<'_, '_, ()>, module_id: i32) -> VmReply {
-    let m = &mut istate!(scope).modules;
-    m.by_id.remove(&module_id);
-    for bucket in m.by_hash.values_mut() {
-        bucket.retain(|(_, id)| *id != module_id);
-    }
-    VmReply::Done(Ok(JsVal::Undefined))
-}
-
 #[allow(clippy::too_many_arguments)]
 fn op_compile_script(
     scope: &mut v8::PinScope<'_, '_, ()>,
@@ -1306,21 +1492,14 @@ fn op_compile_script(
                         None if tc.has_terminated() => Err(VmError::Terminated),
                         // Compile failure = a parse error (with location).
                         None => {
-                            let msg = tc
-                                .exception()
-                                .map(|e| e.to_rust_string_lossy(tc))
-                                .unwrap_or_else(|| "script parse error".to_string());
-                            let message = tc.message();
-                            let res = message
-                                .and_then(|m| m.get_script_resource_name(tc))
-                                .filter(|v| v.is_string())
-                                .map(|v| v.to_rust_string_lossy(tc))
-                                .unwrap_or_else(|| filename.clone());
-                            let loc = match message.and_then(|m| m.get_line_number(tc)) {
-                                Some(line) => format!(" at {res}:{line}"),
-                                None => format!(" at {res}"),
-                            };
-                            Err(VmError::Parse(format!("{msg}{loc}")))
+                            let (exc, message) = (tc.exception(), tc.message());
+                            Err(parse_error(
+                                tc,
+                                exc,
+                                message,
+                                &filename,
+                                "script parse error",
+                            ))
                         }
                     }
                 }
@@ -1361,12 +1540,7 @@ fn op_run_script(
                             match script.run(tc) {
                                 Some(_) if void => Ok(JsVal::Undefined),
                                 Some(value) => marshalled!(tc, value),
-                                None if tc.has_terminated() => Err(VmError::Terminated),
-                                None => {
-                                    let exc = tc.exception();
-                                    let stack = tc.stack_trace();
-                                    Err(capture_js_error(tc, exc, stack))
-                                }
+                                None => Err(caught!(tc)),
                             }
                         };
                         auto_drain(scope, outermost);
@@ -1379,11 +1553,6 @@ fn op_run_script(
     VmReply::Done(outcome)
 }
 
-fn op_dispose_script(scope: &mut v8::PinScope<'_, '_, ()>, script_id: i32) -> VmReply {
-    istate!(scope).scripts.by_id.remove(&script_id);
-    VmReply::Done(Ok(JsVal::Undefined))
-}
-
 fn op_script_code_cache(scope: &mut v8::PinScope<'_, '_, ()>, script_id: i32) -> VmReply {
     let handle = script_handle(istate!(scope), script_id);
     let outcome = match handle {