rusty_racer 0.1.16 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65667fe42e623b8ca26d70810029cc49de133a7c127e2a829c897359c510ef79
-  data.tar.gz: 4b82947a2404a0cea7ee14dc9a80f88a3abbd28c79c788d24b6f8b5f7524af65
+  metadata.gz: f26a45e0afbed589acb2749fc1817e7d8508622c81a70fc378dc4af4a0f54714
+  data.tar.gz: 718074b8d9f468b9ab3da144391ecbeff1d00db347812e5209cd11d866f78f6e
 SHA512:
-  metadata.gz: '084d1145e469c8d3422ec2402293e15d1e0fde2dd9d7436f16d5ec9655709207c809ca3e4d89f310ab5c91ae8b1449a5f4d80d2168d33f9c63217d2f14f09571'
-  data.tar.gz: ccfa7cd5c2d2e4cb847e15079a44bac3b1757410e2bf3f450ecf44524b8c0445b14c94d45f32d74688b4daec1cebe4decc74fb8c39455fc04bf02f4791a22c60
+  metadata.gz: 03b227aa3eba1f597b34bca826f947c4345a8c16accebce84f267d5fcb3df2e9c72e3343e261be857387ada97000769dfca0b449130c9056bc8c6aceb569cd03
+  data.tar.gz: fbe970e400edf1041271954df3ba7f3be5d1f8f3775ca29d09398065b85d9b813bc9ca8b9ae8302bd32757884f8c47af5ba9953937ca6de0486af8bd7e50959b

data/README.md

@@ -79,6 +79,12 @@ rescue RustyRacer::RuntimeError => e
 end
 ```
 
+Everything the binding raises descends from `RustyRacer::Error`, so one rescue
+covers the library. Under it: `ParseError`, `RuntimeError`,
+`ScriptTerminatedError` and `V8OutOfMemoryError` for what the JS did;
+`DisposedError` for using an isolate (or anything it handed out) after
+disposing it; `WrongThreadError` for reaching an isolate from the wrong thread.
+
 ES modules (the embedder owns the URL→module registry):
 
 ```ruby
@@ -86,10 +92,19 @@ dep = ctx.compile_module("export const x = 21;", filename: "/dep.js")
 app = ctx.compile_module('import {x} from "./dep.js"; export const r = x * 2;',
                          filename: "/app.js")
 app.instantiate { |specifier, referrer| dep if specifier == "./dep.js" }
+app.graph_async?                         # => false
 app.evaluate
 app.namespace["r"]                       # => 42
 ```
 
+`graph_async?` asks whether top-level `await` appears anywhere in the *linked*
+graph, so an `await` in a dependency counts — which is why it needs an
+instantiated module and raises before then. `false` is the answer that carries a
+guarantee: `evaluate` ran the whole graph to completion. Since there is no event
+loop here (see below), a `true` graph whose `await` never settles returns from
+`evaluate` with the module body still suspended, and `status` reports
+`:evaluated` either way — so `graph_async?` is what distinguishes the two.
+
 Classic `<script>`s work the same way: `ctx.compile("1 + 1").run` # => 2.
 
 ### Resource limits

data/ext/rusty_racer/Cargo.toml

@@ -5,7 +5,7 @@
 # links and loads with no custom archive.
 [package]
 name = "rusty_racer"
-version = "0.1.16"
+version = "0.2.0"
 edition = "2024"
 publish = false
 

data/ext/rusty_racer/src/lib.rs

@@ -326,13 +326,21 @@ fn current_ruby_thread() -> usize {
 // that class carrying the message. Must be called with the GVL held.
 fn error_to_exception(e: &Error) -> Option<Exception> {
     let v = e.value()?;
-    if let Ok(exc) = Exception::try_convert(v) {
-        return Some(exc);
-    }
+    // ExceptionClass FIRST. Error::new(class, msg) stores the CLASS, and
+    // Exception::try_convert would happily accept it — it falls back to calling
+    // #exception on the value, which hands back a fresh instance carrying only
+    // the class name, silently dropping our message.
     if let Ok(class) = ExceptionClass::try_convert(v) {
-        return class.new_instance((e.to_string(),)).ok();
+        // magnus renders such an Error as "Class: message"; the instance carries
+        // the class already, so strip it rather than say it twice.
+        let text = e.to_string();
+        let message = text
+            .strip_prefix(&format!("{class}: "))
+            .unwrap_or(&text)
+            .to_owned();
+        return class.new_instance((message,)).ok();
     }
-    None
+    Exception::try_convert(v).ok()
 }
 
 // JS called a host function. We are on the owner thread with the GVL RELEASED
@@ -351,8 +359,20 @@ fn host_fn_callback(
         Err(_) => return,
     };
     let mut js_args = Vec::with_capacity(args.length() as usize);
-    for i in 0..args.length() {
-        js_args.push(js_to_jsval(scope, args.get(i)));
+    {
+        // Marshalling an argument RUNS JS — accessors, Proxy traps — and a throw
+        // there has to fail the host call, not hand the Ruby proc a value that
+        // was never read. Without a TryCatch of our own the exception simply
+        // rides along until something happens to clear it, so whether the caller
+        // ever saw it came down to whether the proc re-entered V8.
+        v8::tc_scope!(let tc, scope);
+        for i in 0..args.length() {
+            js_args.push(js_to_jsval(tc, args.get(i)));
+        }
+        if tc.has_caught() {
+            tc.rethrow();
+            return;
+        }
     }
     // Reach the owning Core through the slot back-pointer (the callback holds
     // only a scope). Null only before wiring, which is before any JS can run.
@@ -924,19 +944,22 @@ fn resolve_imported<'s>(
     // import's auto-link (None -> dynamic_import_resolver, with the initiating
     // realm so it can resolve per-realm).
     let instantiate = istate!(scope).instantiate_resolve.as_ref().map(|r| r.get());
+    let mut dynamic_err = None;
     let dep_id = match instantiate {
         Some(resolve) => {
+            // The error conversion happens INSIDE with_gvl: error_to_exception
+            // calls into Ruby (so it can allocate, so it can GC) and BoxValue::new
+            // registers a GC root — neither is safe with the GVL released.
             match with_gvl(|| {
                 resolve_module_via_ruby(unsafe { &*core_ptr }, resolve, &spec, &ref_url, None)
+                    .map_err(|e| error_to_exception(&e).map(BoxValue::new))
             }) {
                 Ok(id) => id,
                 // Stash the resolver's own raised exception (GC-rooted) so the
                 // InstantiateModule op can re-raise it with its original class
                 // instead of a generic "failed to link".
-                Err(e) => {
-                    if let Some(exc) = error_to_exception(&e) {
-                        istate!(scope).instantiate_resolve_err = Some(BoxValue::new(exc));
-                    }
+                Err(exc) => {
+                    istate!(scope).instantiate_resolve_err = exc;
                     None
                 }
             }
@@ -949,7 +972,7 @@ fn resolve_imported<'s>(
                 .as_ref()
                 .map(|r| r.get());
             match resolver {
-                Some(p) => with_gvl(|| {
+                Some(p) => match with_gvl(|| {
                     resolve_module_via_ruby(
                         unsafe { &*core_ptr },
                         p,
@@ -957,23 +980,81 @@ fn resolve_imported<'s>(
                         &ref_url,
                         Some(here.unwrap_or(0)),
                     )
-                })
-                .unwrap_or(None),
+                    // Rendering the message reads the Ruby exception, so it too
+                    // stays inside with_gvl.
+                    .map_err(|e| e.to_string())
+                }) {
+                    Ok(id) => id,
+                    // Unlike the static branch there is no Ruby frame waiting to
+                    // re-raise into — this failure becomes the import()'s promise
+                    // rejection — so the resolver's own message has to travel out
+                    // as the JS error or it is lost.
+                    Err(why) => {
+                        dynamic_err = Some(why);
+                        None
+                    }
+                },
                 None => None,
             }
         }
     };
-    let dep_id = dep_id?;
+    // From here on, every exit that isn't a module throws first. V8 has no
+    // channel for "why" — it just sees an empty return, installs no error of its
+    // own and resets the graph — so without a thrown exception the failure
+    // reaches Ruby as a bare "unexpected failure" naming neither the import nor
+    // where it came from, which is the single most common module wiring mistake.
+    // (The two bails above stay silent: both are broken internal state, not
+    // anything the caller did.) The one path that must also stay silent is a
+    // STATIC resolver that raised — its own Ruby exception is already stashed
+    // for instantiate_module to re-raise, and ours would mask it. The dynamic
+    // branch has no such frame, so it carries its message in dynamic_err.
+    let raised = istate!(scope).instantiate_resolve_err.is_some();
+    let fail = |scope: &mut v8::PinScope<'_, '_>, message: String| {
+        if !raised {
+            throw_js_error(scope, &message);
+        }
+        None
+    };
+    let import = format!("{spec:?} imported from {ref_url}");
+    let Some(dep_id) = dep_id else {
+        return match dynamic_err {
+            Some(why) => fail(scope, format!("{why} (resolving {import})")),
+            None => fail(
+                scope,
+                format!("failed to resolve module specifier {import}"),
+            ),
+        };
+    };
     // The dep must live in the context actually being linked — the auto-link of
     // a dynamic import runs in whatever realm import() fired in, which kAuto can
     // detach from the request that started it. A foreign-context module would
     // V8-CHECK-abort.
-    let g = {
-        let (g, _, cid) = istate!(scope).modules.by_id.get(&dep_id)?;
-        if Some(*cid) != here {
-            return None;
+    let found = istate!(scope)
+        .modules
+        .by_id
+        .get(&dep_id)
+        .map(|(g, _, cid)| (g.clone(), *cid));
+    let g = match (here, found) {
+        (Some(here), Some((g, cid))) if cid == here => g,
+        (Some(_), Some(_)) => {
+            return fail(
+                scope,
+                format!("resolver returned a module from another realm for {import}"),
+            );
+        }
+        // The realm being linked is gone. Not reachable while a module is
+        // linking (see |here| above), but reporting it as a realm mismatch
+        // would name the wrong cause.
+        (None, _) => return fail(scope, format!("the realm being linked is gone ({import})")),
+        // Only reachable if the module went away between the resolver handing it
+        // over and this lookup; to the caller that reads the same as never
+        // having resolved it.
+        (_, None) => {
+            return fail(
+                scope,
+                format!("failed to resolve module specifier {import}"),
+            );
         }
-        g.clone()
     };
     Some(v8::Local::new(scope, &g))
 }
@@ -2104,7 +2185,7 @@ impl Core {
         }
         if self.shared.lock().unwrap().disposed {
             return Err(Error::new(
-                ruby.exception_runtime_error(),
+                err_class(ruby, "DisposedError"),
                 "disposed context",
             ));
         }
@@ -2280,7 +2361,7 @@ impl Core {
                 // isolate (every later op refuses) rather than risk using it.
                 self.shared.lock().unwrap().disposed = true;
                 Err(Error::new(
-                    ruby.exception_runtime_error(),
+                    err_class(ruby, "InternalError"),
                     "internal error: operation panicked; the isolate has been disposed",
                 ))
             }
@@ -2302,7 +2383,7 @@ impl Core {
             }
             VmReply::Done(Err(e)) => Err(vm_err(ruby, e)),
             _ => Err(Error::new(
-                ruby.exception_runtime_error(),
+                err_class(ruby, "InternalError"),
                 "internal: unexpected reply kind",
             )),
         }
@@ -2402,7 +2483,7 @@ impl Core {
         let reply = self.run(ruby, Request::HeapStatistics)?;
         let VmReply::Heap(s) = reply else {
             return Err(Error::new(
-                ruby.exception_runtime_error(),
+                err_class(ruby, "InternalError"),
                 "internal: unexpected heap reply",
             ));
         };
@@ -2576,7 +2657,7 @@ impl Core {
             VmReply::ModuleCompiled(Ok(cm)) => Ok(cm),
             VmReply::ModuleCompiled(Err(e)) => Err(vm_err(ruby, e)),
             _ => Err(Error::new(
-                ruby.exception_runtime_error(),
+                err_class(ruby, "InternalError"),
                 "internal: unexpected compile reply",
             )),
         }
@@ -2649,6 +2730,11 @@ impl Core {
         self.reply_value(ruby, reply)
     }
 
+    fn module_graph_async(&self, ruby: &Ruby, module_id: i32) -> Result<Value, Error> {
+        let reply = self.run(ruby, Request::ModuleGraphAsync { module_id })?;
+        self.reply_value(ruby, reply)
+    }
+
     fn dispose_module(&self, ruby: &Ruby, module_id: i32) -> Result<(), Error> {
         let reply = self.run(ruby, Request::DisposeModule { module_id })?;
         self.reply_value(ruby, reply).map(|_| ())
@@ -2681,7 +2767,7 @@ impl Core {
             VmReply::ScriptCompiled(Ok(cs)) => Ok(cs),
             VmReply::ScriptCompiled(Err(e)) => Err(vm_err(ruby, e)),
             _ => Err(Error::new(
-                ruby.exception_runtime_error(),
+                err_class(ruby, "InternalError"),
                 "internal: unexpected compile reply",
             )),
         }
@@ -2794,7 +2880,7 @@ impl Core {
             // and SEGV — refuse it, leaving the isolate usable.
             if self.depth.load(Ordering::SeqCst) != 0 {
                 return Err(Error::new(
-                    ruby.exception_runtime_error(),
+                    err_class(ruby, "Error"),
                     "RustyRacer: cannot dispose an isolate from within a running op or host callback",
                 ));
             }
@@ -2915,7 +3001,7 @@ impl Context {
         // id 0's lifetime is the isolate's; extras also track their own dispose.
         if self.disposed.load(Ordering::SeqCst) || self.core.is_disposed() {
             return Err(Error::new(
-                ruby.exception_runtime_error(),
+                err_class(ruby, "DisposedError"),
                 "disposed context",
             ));
         }
@@ -3112,7 +3198,7 @@ impl JsModule {
         // iso.dispose is a use-after-free.
         if self.disposed.load(Ordering::SeqCst) || self.core.is_disposed() {
             return Err(Error::new(
-                ruby.exception_runtime_error(),
+                err_class(ruby, "DisposedError"),
                 "disposed module",
             ));
         }
@@ -3140,6 +3226,19 @@ impl JsModule {
         rb_self.check_live(ruby)?;
         rb_self.core.module_status(ruby, rb_self.module_id)
     }
+    // True when top-level await appears anywhere in the module's LINKED import
+    // graph (v8::Module::IsGraphAsync) — a dependency's await counts, which is
+    // why no check on the source text alone can stand in for this. FALSE is the
+    // load-bearing answer: V8 guarantees the evaluation promise is settled, so
+    // #evaluate returning means the whole graph ran. True and it may have
+    // returned with the body still suspended, while #status reads :evaluated
+    // regardless (V8 folds its internal kEvaluatingAsync into kEvaluated).
+    // Raises RustyRacer::RuntimeError unless the module is instantiated: before
+    // linking there is no graph to walk.
+    fn graph_async(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        rb_self.check_live(ruby)?;
+        rb_self.core.module_graph_async(ruby, rb_self.module_id)
+    }
     // The bytecode cache produced at compile (produce_cache: true), as a binary
     // String, or nil. Persist it cross-process and pass back via cached_data:.
     fn cached_data(ruby: &Ruby, rb_self: &Self) -> Value {
@@ -3176,7 +3275,7 @@ impl Script {
         // Also refuse once the isolate is disposed (see JsModule::check_live).
         if self.disposed.load(Ordering::SeqCst) || self.core.is_disposed() {
             return Err(Error::new(
-                ruby.exception_runtime_error(),
+                err_class(ruby, "DisposedError"),
                 "disposed script",
             ));
         }
@@ -3231,7 +3330,7 @@ fn code_cache_from_reply(ruby: &Ruby, reply: VmReply) -> Result<Option<Vec<u8>>,
         VmReply::CodeCache(Ok(bytes)) => Ok(bytes),
         VmReply::CodeCache(Err(e)) => Err(vm_err(ruby, e)),
         _ => Err(Error::new(
-            ruby.exception_runtime_error(),
+            err_class(ruby, "InternalError"),
             "internal: unexpected code-cache reply",
         )),
     }
@@ -3367,7 +3466,7 @@ fn resolve_module_via_ruby(
     })?;
     if !std::ptr::eq(Arc::as_ptr(&obj.core), core as *const Core) {
         return Err(Error::new(
-            ruby.exception_runtime_error(),
+            err_class(&ruby, "Error"),
             "module resolver returned a Module from a different Context",
         ));
     }
@@ -3444,6 +3543,7 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     jsmodule.define_method("evaluate", method!(JsModule::evaluate, 0))?;
     jsmodule.define_method("namespace", method!(JsModule::namespace, 0))?;
     jsmodule.define_method("_status", method!(JsModule::status, 0))?;
+    jsmodule.define_method("graph_async?", method!(JsModule::graph_async, 0))?;
     jsmodule.define_method("cached_data", method!(JsModule::cached_data, 0))?;
     jsmodule.define_method("cache_rejected?", method!(JsModule::cache_rejected, 0))?;
     jsmodule.define_method("create_code_cache", method!(JsModule::create_code_cache, 0))?;

data/ext/rusty_racer/src/marshal.rs

@@ -149,7 +149,7 @@ fn js_container_id(
     // First sighting but too deep: truncate WITHOUT registering, so no later
     // Ref can target a container that was never emitted.
     if depth >= MAX_MARSHAL_DEPTH {
-        return Err(JsVal::Str(value.to_rust_string_lossy(scope)));
+        return Err(JsVal::Str(stringify(scope, value)));
     }
     let id = seen.next_id;
     seen.next_id += 1;
@@ -342,7 +342,7 @@ fn js_to_jsval_d(
                 let Some(key) = names.get_index(scope, i) else {
                     continue;
                 };
-                let key_str = key.to_rust_string_lossy(scope);
+                let key_str = stringify(scope, key);
                 let val = obj
                     .get(scope, key)
                     .unwrap_or_else(|| v8::undefined(scope).into());
@@ -350,8 +350,43 @@ fn js_to_jsval_d(
             }
             return JsVal::Obj { id, entries };
         }
+        // Enumeration THREW — a module namespace whose bindings aren't
+        // initialized yet, a Proxy with a hostile ownKeys trap. Falling through
+        // to the stringify below would hand the caller a plausible-looking
+        // "[object Object]" for an object we never actually read. Leave the
+        // pending exception alone instead and let the op's TryCatch report it —
+        // and give back the id, or a sibling Ref to this same object would point
+        // at a container that is never emitted.
+        unregister_container(seen, obj, id);
+        return JsVal::Undefined;
+    }
+    JsVal::Str(stringify(scope, value))
+}
+
+// The escape hatch for values with no structural representation — Function,
+// Date, RegExp, Symbol. to_rust_string_lossy is Value::ToString, which THROWS on
+// a Symbol, and a Symbol sitting anywhere in a graph (every React element has
+// one) would then leave a pending exception behind and fail the whole op over a
+// value that marshalled fine. to_detail_string is V8's no-side-effects renderer
+// and cannot throw, so Symbols go through it.
+fn stringify(scope: &mut v8::PinScope<'_, '_>, value: v8::Local<v8::Value>) -> String {
+    if value.is_symbol() {
+        return value
+            .to_detail_string(scope)
+            .map(|s| s.to_rust_string_lossy(scope))
+            .unwrap_or_default();
+    }
+    value.to_rust_string_lossy(scope)
+}
+
+// Undo js_container_id's registration for a container we end up NOT emitting.
+// The id is always the last one pushed to its bucket, since nothing else can
+// register while we are inside this object.
+fn unregister_container(seen: &mut JsSeen, obj: v8::Local<v8::Object>, id: u32) {
+    let hash = obj.get_identity_hash().get();
+    if let Some(bucket) = seen.map.get_mut(&hash) {
+        bucket.retain(|(_, existing)| *existing != id);
     }
-    JsVal::Str(value.to_rust_string_lossy(scope))
 }
 
 // Owned-by-value (not &JsVal): a JsVal::Bytes hands its Vec straight to V8's

data/ext/rusty_racer/src/ops.rs

@@ -18,6 +18,29 @@ use crate::istate;
 use crate::marshal::{JsVal, js_to_jsval, jsval_to_js};
 use crate::*;
 
+// Marshal an op's result, treating a throw on the way out as the op's outcome.
+// Marshalling RUNS JS — accessors, Proxy traps, toString — and an exception
+// raised there is as real as one from the script itself, but it lands after the
+// call has already succeeded, so nothing else looks at it: the TryCatch drops it
+// on unwind and the caller keeps a value that no longer means anything (an
+// object whose enumeration threw marshals to undefined). A macro rather than a
+// fn because the tc_scope! binding has no nameable type here.
+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() {
+            Ok(out)
+        } else if tc.has_terminated() {
+            Err(VmError::Terminated)
+        } else {
+            let stack = tc.stack_trace();
+            Err(capture_js_error(tc, exc, stack))
+        }
+    }};
+}
+
 // 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),
@@ -104,6 +127,11 @@ pub(crate) enum Request {
     ModuleStatus {
         module_id: i32,
     },
+    // Whether top-level await appears anywhere in the module's linked import
+    // graph (v8::Module::IsGraphAsync), as a bool.
+    ModuleGraphAsync {
+        module_id: i32,
+    },
     DisposeModule {
         module_id: i32,
     },
@@ -224,7 +252,7 @@ pub(crate) fn run_source(
         }
     };
     match script.run(tc) {
-        Some(value) => Ok(js_to_jsval(tc, value)),
+        Some(value) => marshalled!(tc, value),
         None if tc.has_terminated() => Err(VmError::Terminated),
         None => {
             let exc = tc.exception();
@@ -279,7 +307,7 @@ fn call_function(
     match func.call(tc, recv, &argv) {
         // void: skip marshalling the return so a huge/cyclic result is never walked.
         Some(_) if void => Ok(JsVal::Undefined),
-        Some(value) => Ok(js_to_jsval(tc, value)),
+        Some(value) => marshalled!(tc, value),
         None if tc.has_terminated() => Err(VmError::Terminated),
         None => {
             let exc = tc.exception();
@@ -396,6 +424,7 @@ fn request_realm(state: &IsolateState, request: &Request) -> Option<i32> {
         | Request::CreateContext
         | Request::DisposeContext { .. }
         | Request::ModuleStatus { .. }
+        | Request::ModuleGraphAsync { .. }
         | Request::DisposeModule { .. }
         | Request::DisposeScript { .. }
         | Request::ScriptCodeCache { .. }
@@ -465,6 +494,7 @@ fn dispatch_one(
         } => 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::ModuleGraphAsync { module_id } => op_module_graph_async(scope, module_id),
         Request::DisposeModule { module_id } => op_dispose_module(scope, module_id),
         Request::CompileScript {
             context_id,
@@ -1065,6 +1095,20 @@ fn op_evaluate_module(
     VmReply::Done(outcome)
 }
 
+// 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
+// LINK is reset to Uninstantiated by V8's ResetGraph, so Errored can only mean
+// "linked, then evaluation failed" — the graph is still there to read.
+fn require_instantiated(module: v8::Local<v8::Module>, what: &str) -> Result<(), VmError> {
+    match module.get_status() {
+        v8::ModuleStatus::Uninstantiated | v8::ModuleStatus::Instantiating => Err(
+            VmError::Runtime(format!("module must be instantiated before {what}")),
+        ),
+        _ => Ok(()),
+    }
+}
+
 fn op_module_namespace(scope: &mut v8::PinScope<'_, '_, ()>, module_id: i32) -> VmReply {
     let handle = module_handle(istate!(scope), module_id);
     let outcome = match handle {
@@ -1075,15 +1119,27 @@ fn op_module_namespace(scope: &mut v8::PinScope<'_, '_, ()>, module_id: i32) ->
                 let context = v8::Local::new(scope, &cx);
                 let scope = &mut v8::ContextScope::new(scope, context);
                 let module = v8::Local::new(scope, &g);
-                // 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()),
-                    ),
-                    _ => {
-                        let ns = module.get_module_namespace();
-                        Ok(js_to_jsval(scope, ns))
+                // An errored module's namespace is unreadable — its bindings
+                // 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![],
+                    })
+                } else {
+                    match require_instantiated(module, "namespace") {
+                        Err(e) => Err(e),
+                        Ok(()) => {
+                            let ns = module.get_module_namespace();
+                            // Reading the namespace RUNS JS: every export is an
+                            // accessor, and one whose binding is still
+                            // uninitialized throws. Unwatched, that throw made
+                            // enumeration fail and the caller silently got the
+                            // stringified object in place of their exports.
+                            v8::tc_scope!(let tc, scope);
+                            marshalled!(tc, ns)
+                        }
                     }
                 }
             }
@@ -1112,6 +1168,26 @@ fn op_module_status(scope: &mut v8::PinScope<'_, '_, ()>, module_id: i32) -> VmR
     VmReply::Done(outcome)
 }
 
+// Does top-level await appear anywhere in this module's import graph? V8 walks
+// the linked graph from here, so an `await` in a dependency counts too — which
+// is why no amount of looking at one source text can answer it, and why it needs
+// an instantiated module: before linking there is no graph to walk. What V8
+// guarantees is the false case — "if IsGraphAsync() is false, the returned
+// Promise is settled" — i.e. false means #evaluate ran the whole graph to
+// completion. No context is entered: the walk reads module slots, runs no JS.
+fn op_module_graph_async(scope: &mut v8::PinScope<'_, '_, ()>, module_id: i32) -> VmReply {
+    let handle = module_handle(istate!(scope), module_id);
+    let outcome = match handle {
+        None => Err(VmError::Runtime("unknown module".into())),
+        Some((g, _cid)) => {
+            let module = v8::Local::new(scope, &g);
+            require_instantiated(module, "graph_async?")
+                .map(|()| JsVal::Bool(module.is_graph_async()))
+        }
+    };
+    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);
@@ -1226,7 +1302,7 @@ fn op_run_script(
                         let out = {
                             v8::tc_scope!(let tc, scope);
                             match script.run(tc) {
-                                Some(value) => Ok(js_to_jsval(tc, value)),
+                                Some(value) => marshalled!(tc, value),
                                 None if tc.has_terminated() => Err(VmError::Terminated),
                                 None => {
                                     let exc = tc.exception();

data/lib/rusty_racer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RustyRacer
-  VERSION = "0.1.16"
+  VERSION = "0.2.0"
 end

data/lib/rusty_racer.rb

@@ -42,6 +42,19 @@ module RustyRacer
   class SnapshotError < Error; end
   class PlatformAlreadyInitialized < Error; end
 
+  # Raised when a disposed Isolate, Context, Module or Script is used — or one
+  # whose Isolate has been disposed, which takes everything it handed out with
+  # it. Disposal is deliberate, so this says "you used it after you released
+  # it", not "something went wrong".
+  class DisposedError < Error; end
+
+  # A broken invariant inside the binding rather than anything the caller did:
+  # an unexpected reply kind, or an operation that panicked. Reaching one is a
+  # bug in rusty_racer and worth reporting. It exists so that EVERY error the
+  # extension raises is a RustyRacer::Error, and one rescue can cover the
+  # library.
+  class InternalError < Error; end
+
   # Raised when an Isolate (or a Context/Module/Script it handed out) is used
   # from a thread other than the one that created it. An isolate is
   # thread-confined: every operation must run on its owner thread. The lone

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rusty_racer
 version: !ruby/object:Gem::Version
-  version: 0.1.16
+  version: 0.2.0
 platform: ruby
 authors:
 - Keita Urashima
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-07-28 00:00:00.000000000 Z
+date: 2026-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys