rusty_racer 0.1.14 → 0.1.16

data/ext/rusty_racer/src/ops.rs

@@ -15,7 +15,7 @@
 // own modules.
 
 use crate::istate;
-use crate::marshal::{js_to_jsval, jsval_to_js, JsVal};
+use crate::marshal::{JsVal, js_to_jsval, jsval_to_js};
 use crate::*;
 
 // One VM operation, built by a magnus method and run inline by Core::run ->
@@ -188,7 +188,11 @@ pub(crate) enum VmReply {
     Heap(HeapStats),
 }
 
-pub(crate) fn run_source(scope: &mut v8::PinScope<'_, '_>, source: &str, filename: &str) -> Result<JsVal, VmError> {
+pub(crate) fn run_source(
+    scope: &mut v8::PinScope<'_, '_>,
+    source: &str,
+    filename: &str,
+) -> 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).
@@ -297,15 +301,28 @@ fn compile_source<'s>(
     origin: &v8::ScriptOrigin<'s>,
     cached_data: &Option<Vec<u8>>,
     eager: bool,
-) -> (v8::script_compiler::Source, v8::script_compiler::CompileOptions) {
+) -> (
+    v8::script_compiler::Source,
+    v8::script_compiler::CompileOptions,
+) {
     use v8::script_compiler::{CompileOptions, Source};
     match cached_data {
         Some(bytes) => (
-            Source::new_with_cached_data(code, Some(origin), v8::script_compiler::CachedData::new(bytes)),
+            Source::new_with_cached_data(
+                code,
+                Some(origin),
+                v8::script_compiler::CachedData::new(bytes),
+            ),
             CompileOptions::ConsumeCodeCache,
         ),
-        None if eager => (Source::new(code, Some(origin)), CompileOptions::EagerCompile),
-        None => (Source::new(code, Some(origin)), CompileOptions::NoCompileOptions),
+        None if eager => (
+            Source::new(code, Some(origin)),
+            CompileOptions::EagerCompile,
+        ),
+        None => (
+            Source::new(code, Some(origin)),
+            CompileOptions::NoCompileOptions,
+        ),
     }
 }
 
@@ -315,7 +332,11 @@ fn compile_source<'s>(
 // eval/call — works re-entrantly. `outermost` (depth == 0, computed by Core::run
 // before it bumped the depth) owns the terminate-flag cleanup; a nested op
 // passes false.
-pub(crate) fn service_request(scope: &mut v8::PinScope<'_, '_, ()>, request: Request, outermost: bool) -> VmReply {
+pub(crate) fn service_request(
+    scope: &mut v8::PinScope<'_, '_, ()>,
+    request: Request,
+    outermost: bool,
+) -> VmReply {
     // Clear any terminate left over from BEFORE this request. An
     // Isolate#terminate fired while no JS was running arms the isolate-global
     // flag but no watchdog_fired, so the end-of-request sweep would miss it and
@@ -368,7 +389,9 @@ fn request_realm(state: &IsolateState, request: &Request) -> Option<i32> {
         | Request::ModuleNamespace { module_id, .. } => {
             module_handle(state, *module_id).map(|(_, cid)| cid)
         }
-        Request::RunScript { script_id, .. } => script_handle(state, *script_id).map(|(_, cid)| cid),
+        Request::RunScript { script_id, .. } => {
+            script_handle(state, *script_id).map(|(_, cid)| cid)
+        }
         Request::Reset { .. }
         | Request::CreateContext
         | Request::DisposeContext { .. }
@@ -382,7 +405,11 @@ fn request_realm(state: &IsolateState, request: &Request) -> Option<i32> {
     }
 }
 
-fn dispatch_one(scope: &mut v8::PinScope<'_, '_, ()>, request: Request, outermost: bool) -> VmReply {
+fn dispatch_one(
+    scope: &mut v8::PinScope<'_, '_, ()>,
+    request: Request,
+    outermost: bool,
+) -> VmReply {
     // A request-scoped handle scope, so handles created while servicing a
     // nested request don't pile up in the suspended callback's scope.
     v8::scope!(let scope, &mut *scope);
@@ -422,9 +449,20 @@ fn dispatch_one(scope: &mut v8::PinScope<'_, '_, ()>, request: Request, outermos
             cached_data,
             produce_cache,
             eager,
-        } => op_compile_module(scope, context_id, source, filename, cached_data, produce_cache, eager),
+        } => op_compile_module(
+            scope,
+            context_id,
+            source,
+            filename,
+            cached_data,
+            produce_cache,
+            eager,
+        ),
         Request::InstantiateModule { module_id } => op_instantiate_module(scope, module_id),
-        Request::EvaluateModule { module_id, timeout_ms } => op_evaluate_module(scope, module_id, timeout_ms, outermost),
+        Request::EvaluateModule {
+            module_id,
+            timeout_ms,
+        } => op_evaluate_module(scope, module_id, timeout_ms, outermost),
         Request::ModuleNamespace { module_id } => op_module_namespace(scope, module_id),
         Request::ModuleStatus { module_id } => op_module_status(scope, module_id),
         Request::DisposeModule { module_id } => op_dispose_module(scope, module_id),
@@ -435,7 +473,15 @@ fn dispatch_one(scope: &mut v8::PinScope<'_, '_, ()>, request: Request, outermos
             cached_data,
             produce_cache,
             eager,
-        } => op_compile_script(scope, context_id, source, filename, cached_data, produce_cache, eager),
+        } => op_compile_script(
+            scope,
+            context_id,
+            source,
+            filename,
+            cached_data,
+            produce_cache,
+            eager,
+        ),
         Request::RunScript {
             script_id,
             timeout_ms,
@@ -482,7 +528,14 @@ fn op_low_memory_notification(scope: &mut v8::PinScope<'_, '_, ()>) -> VmReply {
     VmReply::Done(Ok(JsVal::Undefined))
 }
 
-fn op_eval(scope: &mut v8::PinScope<'_, '_, ()>, context_id: i32, source: String, filename: String, timeout_ms: u64, outermost: bool) -> VmReply {
+fn op_eval(
+    scope: &mut v8::PinScope<'_, '_, ()>,
+    context_id: i32,
+    source: String,
+    filename: String,
+    timeout_ms: u64,
+    outermost: bool,
+) -> VmReply {
     let outcome = run_js_bracketed(scope, outermost, timeout_ms, "eval", |scope, outermost| {
         let realm = context_for(istate!(scope), context_id);
         match realm {
@@ -493,14 +546,25 @@ fn op_eval(scope: &mut v8::PinScope<'_, '_, ()>, context_id: i32, source: String
                 auto_drain(scope, outermost);
                 (true, out)
             }
-            None => (false, Err(VmError::Runtime("realm disposed or unknown".into()))),
+            None => (
+                false,
+                Err(VmError::Runtime("realm disposed or unknown".into())),
+            ),
         }
     });
     VmReply::Done(outcome)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn op_call(scope: &mut v8::PinScope<'_, '_, ()>, context_id: i32, name: String, args: Vec<JsVal>, void: bool, timeout_ms: u64, outermost: bool) -> VmReply {
+fn op_call(
+    scope: &mut v8::PinScope<'_, '_, ()>,
+    context_id: i32,
+    name: String,
+    args: Vec<JsVal>,
+    void: bool,
+    timeout_ms: u64,
+    outermost: bool,
+) -> VmReply {
     // A host fn invoked by the called function runs inline
     // (host_fn_callback, with_gvl) — no routing setup needed.
     let outcome = run_js_bracketed(scope, outermost, timeout_ms, "call", |scope, outermost| {
@@ -513,7 +577,10 @@ fn op_call(scope: &mut v8::PinScope<'_, '_, ()>, context_id: i32, name: String,
                 auto_drain(scope, outermost);
                 (true, out)
             }
-            None => (false, Err(VmError::Runtime("realm disposed or unknown".into()))),
+            None => (
+                false,
+                Err(VmError::Runtime("realm disposed or unknown".into())),
+            ),
         }
     });
     VmReply::Done(outcome)
@@ -542,80 +609,110 @@ fn op_drain_microtasks(scope: &mut v8::PinScope<'_, '_, ()>, timeout_ms: u64) ->
     VmReply::Done(outcome)
 }
 
-fn op_attach(scope: &mut v8::PinScope<'_, '_, ()>, context_id: i32, name: String, host_fn_id: usize, timeout_ms: u64, outermost: bool) -> VmReply {
+fn op_attach(
+    scope: &mut v8::PinScope<'_, '_, ()>,
+    context_id: i32,
+    name: String,
+    host_fn_id: usize,
+    timeout_ms: u64,
+    outermost: bool,
+) -> VmReply {
     // attach_at_path writes onto globalThis (and walks a dotted
     // path), which can fire a user-defined accessor or Proxy trap —
     // arbitrary JS. So it goes through the same bracket as Eval: a
     // host fn the trap calls routes back, and a looping trap is
     // time-capped.
-    let outcome = run_js_bracketed(scope, outermost, timeout_ms, "attach", |scope, outermost| {
-        let realm = context_for(istate!(scope), context_id);
-        match realm {
-            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 out = match v8::Function::builder(host_fn_callback)
-                    .data(external.into())
-                    .build(scope)
-                {
-                    // A dotted name (e.g. "MiniRacer.foo") attaches
-                    // under a namespace object, creating missing
-                    // intermediates, so host fns needn't pollute the
-                    // bare global.
-                    Some(function) => attach_at_path(scope, context, &name, function),
-                    None => Err(VmError::Runtime("failed to build function".into())),
-                };
-                auto_drain(scope, outermost);
-                (true, out)
+    let outcome = run_js_bracketed(
+        scope,
+        outermost,
+        timeout_ms,
+        "attach",
+        |scope, outermost| {
+            let realm = context_for(istate!(scope), context_id);
+            match realm {
+                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 out = match v8::Function::builder(host_fn_callback)
+                        .data(external.into())
+                        .build(scope)
+                    {
+                        // A dotted name (e.g. "MiniRacer.foo") attaches
+                        // under a namespace object, creating missing
+                        // intermediates, so host fns needn't pollute the
+                        // bare global.
+                        Some(function) => attach_at_path(scope, context, &name, function),
+                        None => Err(VmError::Runtime("failed to build function".into())),
+                    };
+                    auto_drain(scope, outermost);
+                    (true, out)
+                }
+                None => (
+                    false,
+                    Err(VmError::Runtime("realm disposed or unknown".into())),
+                ),
             }
-            None => (false, Err(VmError::Runtime("realm disposed or unknown".into()))),
-        }
-    });
+        },
+    );
     VmReply::Done(outcome)
 }
 
-fn op_attach_many(scope: &mut v8::PinScope<'_, '_, ()>, context_id: i32, entries: Vec<(String, usize)>, timeout_ms: u64, outermost: bool) -> VmReply {
+fn op_attach_many(
+    scope: &mut v8::PinScope<'_, '_, ()>,
+    context_id: i32,
+    entries: Vec<(String, usize)>,
+    timeout_ms: u64,
+    outermost: bool,
+) -> VmReply {
     // Same as Attach (arbitrary JS via accessors/Proxy traps), but
     // installs every entry under one bracket/drain. Applied in order;
     // stops at the first failure and reports its (name-tagged) error.
     // NOT transactional: entries before the failure stay attached —
     // the realm is not rolled back (matches single Attach, which also
     // commits its one write or fails it).
-    let outcome = run_js_bracketed(scope, outermost, timeout_ms, "attach_many", |scope, outermost| {
-        let realm = context_for(istate!(scope), context_id);
-        match realm {
-            Some(ctx) => {
-                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);
-                    out = match v8::Function::builder(host_fn_callback)
-                        .data(external.into())
-                        .build(scope)
-                    {
-                        Some(function) => attach_at_path(scope, context, name, function),
-                        None => Err(VmError::Runtime(format!(
-                            "failed to build function for `{name}`"
-                        ))),
-                    };
-                    if out.is_err() {
-                        break;
+    let outcome = run_js_bracketed(
+        scope,
+        outermost,
+        timeout_ms,
+        "attach_many",
+        |scope, outermost| {
+            let realm = context_for(istate!(scope), context_id);
+            match realm {
+                Some(ctx) => {
+                    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);
+                        out = match v8::Function::builder(host_fn_callback)
+                            .data(external.into())
+                            .build(scope)
+                        {
+                            Some(function) => attach_at_path(scope, context, name, function),
+                            None => Err(VmError::Runtime(format!(
+                                "failed to build function for `{name}`"
+                            ))),
+                        };
+                        if out.is_err() {
+                            break;
+                        }
                     }
+                    auto_drain(scope, outermost);
+                    (true, out)
                 }
-                auto_drain(scope, outermost);
-                (true, out)
+                None => (
+                    false,
+                    Err(VmError::Runtime("realm disposed or unknown".into())),
+                ),
             }
-            None => (false, Err(VmError::Runtime("realm disposed or unknown".into()))),
-        }
-    });
+        },
+    );
     VmReply::Done(outcome)
 }
 
 fn op_reset(scope: &mut v8::PinScope<'_, '_, ()>, context_id: i32) -> VmReply {
-    let known =
-        context_id == 0 || istate!(scope).realms.contexts.contains_key(&context_id);
+    let known = context_id == 0 || istate!(scope).realms.contexts.contains_key(&context_id);
     if istate!(scope).draining {
         // A microtask from ANY realm may be mid-flight on the stack;
         // swapping a v8::Context out from under it corrupts state.
@@ -623,17 +720,14 @@ fn op_reset(scope: &mut v8::PinScope<'_, '_, ()>, context_id: i32) -> VmReply {
             "cannot reset a realm during a microtask checkpoint".into(),
         )))
     } else if !known {
-        VmReply::Done(Err(VmError::Runtime(
-            "context disposed or unknown".into(),
-        )))
+        VmReply::Done(Err(VmError::Runtime("context disposed or unknown".into())))
     } else if istate!(scope).active_realms.contains(&context_id) {
         // Swapping the v8::Context behind a suspended frame would
         // drop its in-flight modules/scripts and let the realm id
         // refer to a different context than the one on the stack
         // (defeating the cross-context import guards).
         VmReply::Done(Err(VmError::Runtime(
-            "cannot reset a realm while a request for it is suspended on the V8 stack"
-                .into(),
+            "cannot reset a realm while a request for it is suspended on the V8 stack".into(),
         )))
     } else {
         let (fresh, fresh_queue) = new_realm(scope);
@@ -646,9 +740,15 @@ fn op_reset(scope: &mut v8::PinScope<'_, '_, ()>, context_id: i32) -> VmReply {
             // entered (nested reset). flush_retiring frees them safely at the next
             // outermost request boundary.
             let (old_ctx, old_queue) = if context_id == 0 {
-                (realms.main_context.replace(fresh), realms.main_queue.replace(fresh_queue))
+                (
+                    realms.main_context.replace(fresh),
+                    realms.main_queue.replace(fresh_queue),
+                )
             } else {
-                (realms.contexts.insert(context_id, fresh), realms.queues.insert(context_id, fresh_queue))
+                (
+                    realms.contexts.insert(context_id, fresh),
+                    realms.queues.insert(context_id, fresh_queue),
+                )
             };
             if let (Some(c), Some(q)) = (old_ctx, old_queue) {
                 realms.retiring.push((c, q));
@@ -682,8 +782,7 @@ fn op_dispose_context(scope: &mut v8::PinScope<'_, '_, ()>, context_id: i32) ->
     } else if istate!(scope).active_realms.contains(&context_id) {
         // Same hazard as Reset: a suspended frame still runs in it.
         VmReply::Done(Err(VmError::Runtime(
-            "cannot dispose a realm while a request for it is suspended on the V8 stack"
-                .into(),
+            "cannot dispose a realm while a request for it is suspended on the V8 stack".into(),
         )))
     } else {
         // Park the context + queue in `retiring` rather than dropping them here:
@@ -705,85 +804,93 @@ fn op_dispose_context(scope: &mut v8::PinScope<'_, '_, ()>, context_id: i32) ->
 }
 
 #[allow(clippy::too_many_arguments)]
-fn op_compile_module(scope: &mut v8::PinScope<'_, '_, ()>, context_id: i32, source: String, filename: String, cached_data: Option<Vec<u8>>, produce_cache: bool, eager: bool) -> VmReply {
+fn op_compile_module(
+    scope: &mut v8::PinScope<'_, '_, ()>,
+    context_id: i32,
+    source: String,
+    filename: String,
+    cached_data: Option<Vec<u8>>,
+    produce_cache: bool,
+    eager: bool,
+) -> VmReply {
     let ctx = context_for(istate!(scope), context_id);
     let outcome = match ctx {
         None => Err(VmError::Runtime("context disposed or unknown".into())),
         Some(cx) => {
-        let context = v8::Local::new(scope, &cx);
-        let scope = &mut v8::ContextScope::new(scope, context);
-        v8::tc_scope!(let tc, scope);
-        match v8::String::new(tc, &source) {
-            None => Err(VmError::Runtime("module source too large".into())),
-            Some(code) => {
-                let origin = module_origin(tc, &filename);
-                // Consume a supplied bytecode cache (skip reparse),
-                // eager-compile every function, or compile fresh
-                // (lazy). cached_data wins: V8 forbids combining
-                // ConsumeCodeCache with EagerCompile.
-                let (mut src, opts) = compile_source(code, &origin, &cached_data, eager);
-                let compiled = v8::script_compiler::compile_module2(
-                    tc,
-                    &mut src,
-                    opts,
-                    v8::script_compiler::NoCacheReason::NoReason,
-                );
-                match compiled {
-                    Some(module) => {
-                        // V8 marks a stale/incompatible supplied cache
-                        // rejected; the embedder recompiles & re-caches.
-                        let cache_rejected = cached_data.is_some()
-                            && src.get_cached_data().is_some_and(|c| c.rejected());
-                        // Produce a fresh cache from the unbound script.
-                        let produced = if produce_cache {
-                            module
-                                .get_unbound_module_script(tc)
-                                .create_code_cache()
-                                .map(|c| c.to_vec())
-                        } else {
-                            None
-                        };
-                        let hash = module.get_identity_hash().get();
-                        let g = v8::Global::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));
-                            id
-                        };
-                        Ok(Compiled {
-                            id,
-                            cached_data: produced,
-                            cache_rejected,
-                        })
-                    }
-                    None if tc.has_terminated() => Err(VmError::Terminated),
-                    // 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 context = v8::Local::new(scope, &cx);
+            let scope = &mut v8::ContextScope::new(scope, context);
+            v8::tc_scope!(let tc, scope);
+            match v8::String::new(tc, &source) {
+                None => Err(VmError::Runtime("module source too large".into())),
+                Some(code) => {
+                    let origin = module_origin(tc, &filename);
+                    // Consume a supplied bytecode cache (skip reparse),
+                    // eager-compile every function, or compile fresh
+                    // (lazy). cached_data wins: V8 forbids combining
+                    // ConsumeCodeCache with EagerCompile.
+                    let (mut src, opts) = compile_source(code, &origin, &cached_data, eager);
+                    let compiled = v8::script_compiler::compile_module2(
+                        tc,
+                        &mut src,
+                        opts,
+                        v8::script_compiler::NoCacheReason::NoReason,
+                    );
+                    match compiled {
+                        Some(module) => {
+                            // V8 marks a stale/incompatible supplied cache
+                            // rejected; the embedder recompiles & re-caches.
+                            let cache_rejected = cached_data.is_some()
+                                && src.get_cached_data().is_some_and(|c| c.rejected());
+                            // Produce a fresh cache from the unbound script.
+                            let produced = if produce_cache {
+                                module
+                                    .get_unbound_module_script(tc)
+                                    .create_code_cache()
+                                    .map(|c| c.to_vec())
+                            } else {
+                                None
+                            };
+                            let hash = module.get_identity_hash().get();
+                            let g = v8::Global::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));
+                                id
+                            };
+                            Ok(Compiled {
+                                id,
+                                cached_data: produced,
+                                cache_rejected,
+                            })
+                        }
+                        None if tc.has_terminated() => Err(VmError::Terminated),
+                        // 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}")))
+                        }
                     }
                 }
             }
         }
-        }
     };
     VmReply::ModuleCompiled(outcome)
 }
@@ -821,9 +928,7 @@ fn op_instantiate_module(scope: &mut v8::PinScope<'_, '_, ()>, module_id: i32) -
                         // 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),
+                            message: module.get_exception().to_rust_string_lossy(scope),
                             backtrace: vec![],
                         }),
                         _ => {
@@ -845,106 +950,118 @@ fn op_instantiate_module(scope: &mut v8::PinScope<'_, '_, ()>, module_id: i32) -
                         }
                     }
                 }
-            }
+            },
         };
         istate!(scope).instantiating = false;
         VmReply::Done(outcome)
     }
 }
 
-fn op_evaluate_module(scope: &mut v8::PinScope<'_, '_, ()>, module_id: i32, timeout_ms: u64, outermost: bool) -> VmReply {
+fn op_evaluate_module(
+    scope: &mut v8::PinScope<'_, '_, ()>,
+    module_id: i32,
+    timeout_ms: u64,
+    outermost: bool,
+) -> VmReply {
     // Top-level module code (and, under :auto, the microtasks its
     // TLA continuation drains) can loop, so it runs in the same
     // watchdog bracket as Eval/Call/RunScript.
-    let outcome = run_js_bracketed(scope, outermost, timeout_ms, "evaluate_module", |scope, outermost| {
-    let handle = module_handle(istate!(scope), module_id);
-    match handle {
-        None => (false, Err(VmError::Runtime("unknown module".into()))),
-        Some((g, cid)) => match context_for(istate!(scope), cid) {
-            None => (false, Err(VmError::Runtime("module's context is gone".into()))),
-            Some(cx) => {
-                let context = v8::Local::new(scope, &cx);
-                let scope = &mut v8::ContextScope::new(scope, context);
-                let module = v8::Local::new(scope, &g);
-                // A top-level-await module's evaluate() returns a
-                // PENDING promise that only settles once the drain
-                // runs its continuation — remember it so we can read
-                // its post-drain state instead of reporting a stale Ok.
-                let mut eval_promise: Option<v8::Global<v8::Promise>> = None;
-                // ran_js is true ONLY for the Instantiated arm that
-                // actually calls evaluate(); the Errored/Evaluated/
-                // non-instantiated arms run no JS, so a raced watchdog
-                // 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.
-                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 => {
-                        did_eval = true;
-                        v8::tc_scope!(let tc, scope);
-                        match module.evaluate(tc) {
-                            // A synchronous top-level throw yields a
-                            // *rejected* promise (not None); a pending
-                            // (TLA) or fulfilled one is remembered and
-                            // re-checked after the drain.
-                            Some(value) => match v8::Local::<v8::Promise>::try_from(value) {
-                                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![],
-                                    })
+    let outcome = run_js_bracketed(
+        scope,
+        outermost,
+        timeout_ms,
+        "evaluate_module",
+        |scope, outermost| {
+            let handle = module_handle(istate!(scope), module_id);
+            match handle {
+                None => (false, Err(VmError::Runtime("unknown module".into()))),
+                Some((g, cid)) => match context_for(istate!(scope), cid) {
+                    None => (
+                        false,
+                        Err(VmError::Runtime("module's context is gone".into())),
+                    ),
+                    Some(cx) => {
+                        let context = v8::Local::new(scope, &cx);
+                        let scope = &mut v8::ContextScope::new(scope, context);
+                        let module = v8::Local::new(scope, &g);
+                        // A top-level-await module's evaluate() returns a
+                        // PENDING promise that only settles once the drain
+                        // runs its continuation — remember it so we can read
+                        // its post-drain state instead of reporting a stale Ok.
+                        let mut eval_promise: Option<v8::Global<v8::Promise>> = None;
+                        // ran_js is true ONLY for the Instantiated arm that
+                        // actually calls evaluate(); the Errored/Evaluated/
+                        // non-instantiated arms run no JS, so a raced watchdog
+                        // 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.
+                        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 => {
+                                did_eval = true;
+                                v8::tc_scope!(let tc, scope);
+                                match module.evaluate(tc) {
+                                    // A synchronous top-level throw yields a
+                                    // *rejected* promise (not None); a pending
+                                    // (TLA) or fulfilled one is remembered and
+                                    // re-checked after the drain.
+                                    Some(value) => {
+                                        match v8::Local::<v8::Promise>::try_from(value) {
+                                            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![],
+                                                })
+                                            }
+                                            Ok(p) => {
+                                                eval_promise = Some(v8::Global::new(tc, p));
+                                                Ok(JsVal::Undefined)
+                                            }
+                                            _ => 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))
+                                    }
                                 }
-                                Ok(p) => {
-                                    eval_promise = Some(v8::Global::new(tc, p));
-                                    Ok(JsVal::Undefined)
-                                }
-                                _ => 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))
                             }
-                        }
-                    }
-                    _ => Err(VmError::Runtime(
-                        "module must be instantiated before evaluate".into(),
-                    )),
-                };
-                auto_drain(scope, outermost);
-                // The drain may have settled a TLA module's promise to
-                // rejected — surface that instead of the provisional Ok.
-                let result = if let (true, Some(g)) = (out.is_ok(), eval_promise) {
-                    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![],
-                        })
-                    } else {
-                        out
+                            _ => Err(VmError::Runtime(
+                                "module must be instantiated before evaluate".into(),
+                            )),
+                        };
+                        auto_drain(scope, outermost);
+                        // The drain may have settled a TLA module's promise to
+                        // rejected — surface that instead of the provisional Ok.
+                        let result = if let (true, Some(g)) = (out.is_ok(), eval_promise) {
+                            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![],
+                                })
+                            } else {
+                                out
+                            }
+                        } else {
+                            out
+                        };
+                        (did_eval, result)
                     }
-                } else {
-                    out
-                };
-                (did_eval, result)
+                },
             }
-        }
-    }
-    });
+        },
+    );
     VmReply::Done(outcome)
 }
 
@@ -961,17 +1078,16 @@ fn op_module_namespace(scope: &mut v8::PinScope<'_, '_, ()>, module_id: i32) ->
                 // get_module_namespace CHECK-aborts unless the module
                 // is at least Instantiated.
                 match module.get_status() {
-                    v8::ModuleStatus::Uninstantiated
-                    | v8::ModuleStatus::Instantiating => Err(VmError::Runtime(
-                        "module must be instantiated before namespace".into(),
-                    )),
+                    v8::ModuleStatus::Uninstantiated | v8::ModuleStatus::Instantiating => Err(
+                        VmError::Runtime("module must be instantiated before namespace".into()),
+                    ),
                     _ => {
                         let ns = module.get_module_namespace();
                         Ok(js_to_jsval(scope, ns))
                     }
                 }
             }
-        }
+        },
     };
     VmReply::Done(outcome)
 }
@@ -1006,7 +1122,15 @@ fn op_dispose_module(scope: &mut v8::PinScope<'_, '_, ()>, module_id: i32) -> Vm
 }
 
 #[allow(clippy::too_many_arguments)]
-fn op_compile_script(scope: &mut v8::PinScope<'_, '_, ()>, context_id: i32, source: String, filename: String, cached_data: Option<Vec<u8>>, produce_cache: bool, eager: bool) -> VmReply {
+fn op_compile_script(
+    scope: &mut v8::PinScope<'_, '_, ()>,
+    context_id: i32,
+    source: String,
+    filename: String,
+    cached_data: Option<Vec<u8>>,
+    produce_cache: bool,
+    eager: bool,
+) -> VmReply {
     let ctx = context_for(istate!(scope), context_id);
     let outcome = match ctx {
         None => Err(VmError::Runtime("context disposed or unknown".into())),
@@ -1074,36 +1198,50 @@ fn op_compile_script(scope: &mut v8::PinScope<'_, '_, ()>, context_id: i32, sour
     VmReply::ScriptCompiled(outcome)
 }
 
-fn op_run_script(scope: &mut v8::PinScope<'_, '_, ()>, script_id: i32, timeout_ms: u64, outermost: bool) -> VmReply {
-    let outcome = run_js_bracketed(scope, outermost, timeout_ms, "run_script", |scope, outermost| {
-        let handle = script_handle(istate!(scope), script_id);
-        match handle {
-            None => (false, Err(VmError::Runtime("unknown script".into()))),
-            Some((g, cid)) => match context_for(istate!(scope), cid) {
-                None => (false, Err(VmError::Runtime("script's context is gone".into()))),
-                Some(cx) => {
-                let context = v8::Local::new(scope, &cx);
-                let scope = &mut v8::ContextScope::new(scope, context);
-                let unbound = v8::Local::new(scope, &g);
-                let script = unbound.bind_to_current_context(scope);
-                let out = {
-                    v8::tc_scope!(let tc, scope);
-                    match script.run(tc) {
-                        Some(value) => Ok(js_to_jsval(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))
-                        }
+fn op_run_script(
+    scope: &mut v8::PinScope<'_, '_, ()>,
+    script_id: i32,
+    timeout_ms: u64,
+    outermost: bool,
+) -> VmReply {
+    let outcome = run_js_bracketed(
+        scope,
+        outermost,
+        timeout_ms,
+        "run_script",
+        |scope, outermost| {
+            let handle = script_handle(istate!(scope), script_id);
+            match handle {
+                None => (false, Err(VmError::Runtime("unknown script".into()))),
+                Some((g, cid)) => match context_for(istate!(scope), cid) {
+                    None => (
+                        false,
+                        Err(VmError::Runtime("script's context is gone".into())),
+                    ),
+                    Some(cx) => {
+                        let context = v8::Local::new(scope, &cx);
+                        let scope = &mut v8::ContextScope::new(scope, context);
+                        let unbound = v8::Local::new(scope, &g);
+                        let script = unbound.bind_to_current_context(scope);
+                        let out = {
+                            v8::tc_scope!(let tc, scope);
+                            match script.run(tc) {
+                                Some(value) => Ok(js_to_jsval(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))
+                                }
+                            }
+                        };
+                        auto_drain(scope, outermost);
+                        (true, out)
                     }
-                };
-                auto_drain(scope, outermost);
-                (true, out)
-                }
+                },
             }
-        }
-    });
+        },
+    );
     VmReply::Done(outcome)
 }