mini_racer-csim 0.21.1.0 → 0.21.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c0d4cbd8123f6177c8411ad1d9e32ff4e8a1a0de0515eb5f030672dd11f3f44
-  data.tar.gz: faba5c80bf42ca1638d37c20f5f7849cd406e10fe5f00bc926fd696824237cdf
+  metadata.gz: 8674864924ab7e282736f327fc6bda583750e6cd3e61df57d4dd09005966812b
+  data.tar.gz: 6e98c37b07f580c5b9ad2d5af887ec0a420ec95b2c4f58f929eb8aae031ca5ac
 SHA512:
-  metadata.gz: c0d8f9dcc469cd52b999e31e2c677a205aabe343804b70990a7978b2302d2df505c595a38b5de1db16e70358fabea42c950f2ff3b2509f9a94f87f178b0df229
-  data.tar.gz: 5dc7c4ff2147e0a8815eb63d024350db82b2eaade805bb8c5d4834deff7a950a8f44b73cb9d3943f948ce1fda51c82aba464f2384a4e333c5bcfbabad5f6ca6c
+  metadata.gz: 72b2991b309086e5e089a1bb9e3a07517a417c6435444e457d1b5ca42ab095290b2c13f1559ac0c8c384794b240acaf063ca0691724dc9bd3647677bb8c88261
+  data.tar.gz: 4b7ffa6b04dcca1c2771ef3993095a36210638a120b341eddde6e3615d9bccd3845d98c92271f58cd3d9671ba364442689df0792179963c8efab9815046e30db

data/CHANGELOG

@@ -1,4 +1,11 @@
-- (Unreleased)
+- 0.21.1.1 - 07-06-2026
+  - Drop the TruffleRuby backend: mini_racer-csim is now a hard fork targeting CRuby/V8 only (the GraalJS/TruffleRuby shims and their tests are removed)
+  - Add per-frame realms via `Context#create_realm`, returning a `MiniRacer::Realm` (multiple V8 realms in one isolate, browser-iframe semantics) with `Realm#eval` / `call` / `attach` / `dispose` / `disposed?`
+    - all realms share one security token so they can reach each other's globals (same-origin iframe model)
+    - `__mr_realmGlobal(id)` returns a realm's live `globalThis` cross-realm; `__mr_realmOf(fn)` reports the realm a callback was created in ([[Realm]]) for WebIDL-style error attribution
+    - unhandled promise rejections are tracked and delivered per realm via `globalThis.__mr_emitUnhandledRejection(reason, promise)`; the queue is purged when a realm is disposed or reset so a stale rejection never fires against a fresh realm
+
+- 0.21.1.0 - 06-06-2026
   - Add `Context#perform_microtask_checkpoint` to synchronously drain the V8 microtask queue, useful for spec-compliant `dispatchEvent` sequencing inside Ruby callbacks
   - Expose V8 ScriptCompiler::CachedData via Context#compile / MiniRacer::Script (#411)
     - script = ctx.compile(src, filename:, cached_data:, produce_cache:) → Script handle

data/README.md

@@ -31,7 +31,7 @@ The fork is periodically rebased on upstream `mini_racer` to pick up V8 / `libv8
 
 ## Supported Ruby Versions & Troubleshooting
 
-MiniRacer only supports non-EOL versions of Ruby. See [Ruby Maintenance Branches](https://www.ruby-lang.org/en/downloads/branches/) for the list of non-EOL Rubies. If you require support for older versions of Ruby install an older version of the gem. [TruffleRuby](https://github.com/oracle/truffleruby) is also supported.
+MiniRacer only supports non-EOL versions of Ruby. See [Ruby Maintenance Branches](https://www.ruby-lang.org/en/downloads/branches/) for the list of non-EOL Rubies. If you require support for older versions of Ruby install an older version of the gem. (The `mini_racer-csim` fork is CRuby/V8 only — the TruffleRuby backend that upstream supports has been removed.)
 
 MiniRacer **does not support**
 
@@ -228,10 +228,6 @@ Notes:
   reuse still works under `:single_threaded`. If you need both cross-process
   reuse and `:single_threaded` (e.g. for fork-safety reasons), disable
   `:single_threaded` for the path that produces / consumes the cache.
-- On TruffleRuby, `Script` is implemented as source replay (GraalJS has no
-  equivalent per-script bytecode cache reachable from `Polyglot::InnerContext`),
-  so `cached_data` and `produce_cache` are silently ignored and `cached_data`
-  always returns `nil`, and `MiniRacer::V8_CACHED_DATA_VERSION_TAG` is `0`.
 
 ### Fork Safety
 
@@ -501,7 +497,7 @@ context.eval("log")
 # => ["before", "microtask", "after"]
 ```
 
-`host_namespace:` accepts a String (the global name to use — it must be a valid JavaScript identifier), `true` (the default name `"MiniRacer"`), or `nil`/`false` (the default — inject nothing). The namespace object is defined non-enumerable so it does not appear in `Object.keys(globalThis)`, while its methods are ordinary properties discoverable via `Object.keys(MiniRacer)`. Like `perform_microtask_checkpoint`, `drainMicrotasks()` is a no-op while a microtask checkpoint is already in progress, and it lets watchdog/out-of-memory termination propagate to the enclosing `eval`/`call`. (The host namespace is V8-only; it is not installed on the TruffleRuby backend.)
+`host_namespace:` accepts a String (the global name to use — it must be a valid JavaScript identifier), `true` (the default name `"MiniRacer"`), or `nil`/`false` (the default — inject nothing). The namespace object is defined non-enumerable so it does not appear in `Object.keys(globalThis)`, while its methods are ordinary properties discoverable via `Object.keys(MiniRacer)`. Like `perform_microtask_checkpoint`, `drainMicrotasks()` is a no-op while a microtask checkpoint is already in progress, and it lets watchdog/out-of-memory termination propagate to the enclosing `eval`/`call`.
 
 ### ES modules
 
@@ -570,9 +566,6 @@ Notes:
   accumulate handles until `Context#dispose` clears them.
 - Top-level await is not yet supported; `evaluate` raises if the
   module's evaluation promise stays pending after the microtask drain.
-- On TruffleRuby, `Context#compile_module` raises `NotImplementedError`
-  — GraalJS has its own module-loading mechanism that doesn't map onto
-  this handle-based API. PRs to bridge are welcome.
 
 ## Performance
 

data/ext/mini_racer_extension/extconf.rb

@@ -2,11 +2,6 @@ require 'mkmf'
 
 $srcs = ["mini_racer_extension.c", "mini_racer_v8.cc"]
 
-if RUBY_ENGINE == "truffleruby"
-  File.write("Makefile", dummy_makefile($srcdir).join(""))
-  return
-end
-
 require_relative '../../lib/mini_racer/version'
 gem 'libv8-node', MiniRacer::LIBV8_NODE_VERSION
 require 'libv8-node'

data/ext/mini_racer_extension/mini_racer_extension.c

@@ -204,6 +204,15 @@ typedef struct Script {
     int     disposed;
 } Script;
 
+// A per-frame realm (extra v8::Context in the same isolate); see
+// Context#create_realm. Like Script/Module, the C++ realm is freed eagerly via
+// Realm#dispose or at Context teardown — realm_free can't send a dispose RPC.
+typedef struct Realm {
+    VALUE   context;      // parent Context VALUE (kept alive via mark)
+    int32_t id;           // realm id (0 = main, never wrapped as a Realm)
+    int     disposed;
+} Realm;
+
 static void context_destroy(Context *c);
 static void context_free(void *arg);
 static void context_mark(void *arg);
@@ -257,6 +266,19 @@ static const rb_data_type_t module_type = {
     },
 };
 
+static void realm_free(void *arg);
+static void realm_mark(void *arg);
+static size_t realm_size(const void *arg);
+
+static const rb_data_type_t realm_type = {
+    .wrap_struct_name   =  "mini_racer/realm",
+    .function           = {
+        .dfree = realm_free,
+        .dmark = realm_mark,
+        .dsize = realm_size,
+    },
+};
+
 static VALUE platform_init_error;
 static VALUE context_disposed_error;
 static VALUE parse_error;
@@ -270,6 +292,7 @@ static VALUE context_class;
 static VALUE snapshot_class;
 static VALUE script_class;
 static VALUE module_class;
+static VALUE realm_class;
 static VALUE date_time_class;
 static VALUE binary_class;
 static VALUE js_function_class;
@@ -885,6 +908,7 @@ static void dispatch1(Context *c, const uint8_t *p, size_t n)
     assert(n > 0);
     switch (*p) {
     case 'A': return v8_attach(c->pst, p+1, n-1);
+    case 'B': return v8_create_realm(c->pst);               // (B)uild realm
     case 'C': return v8_timedwait(c, p+1, n-1, v8_call);
     case 'D': return v8_dispose_script(c->pst, p+1, n-1);
     case 'E': return v8_timedwait(c, p+1, n-1, v8_eval);
@@ -903,6 +927,8 @@ static void dispatch1(Context *c, const uint8_t *p, size_t n)
     case 'U': return v8_module_status(c->pst, p+1, n-1);    // (U) module status — non-blocking
     case 'V': return v8_timedwait(c, p+1, n-1, v8_evaluate_module); // e(V)aluate
     case 'W': return v8_warmup(c->pst, p+1, n-1);
+    case 'X': return v8_dispose_realm(c->pst, p+1, n-1);    // e(X)punge realm
+    case '@': return v8_timedwait(c, p+1, n-1, v8_realm_dispatch); // realm-scoped op
     case 'Z': return v8_dispose_module(c->pst, p+1, n-1);   // (Z) dispose module handle
     case 'L':
         b = 0;
@@ -1896,6 +1922,197 @@ static VALUE context_reset_realm(VALUE self)
     return Qnil;
 }
 
+// -- MiniRacer::Realm (per-frame realm = extra v8::Context in this isolate) --
+
+static void realm_free(void *arg)
+{
+    // Like module_free: no dispose RPC from a finalizer. State::~State()
+    // tears every realm down at Context teardown; use Realm#dispose to free
+    // a realm eagerly mid-lifetime.
+    ruby_xfree(arg);
+}
+
+static void realm_mark(void *arg)
+{
+    Realm *r = arg;
+    rb_gc_mark(r->context);
+}
+
+static size_t realm_size(const void *arg)
+{
+    (void)arg;
+    return sizeof(Realm);
+}
+
+static VALUE realm_alloc(VALUE klass)
+{
+    Realm *r;
+    return TypedData_Make_Struct(klass, Realm, &realm_type, r);
+}
+
+static VALUE realm_initialize(int argc, VALUE *argv, VALUE self)
+{
+    (void)argc; (void)argv; (void)self;
+    rb_raise(runtime_error, "MiniRacer::Realm must be created via Context#create_realm");
+}
+
+// Resolve the parent Context, raising if the realm or its context is disposed.
+static Context *realm_live_context(VALUE self, Realm **out)
+{
+    Realm *r;
+    Context *c;
+
+    TypedData_Get_Struct(self, Realm, &realm_type, r);
+    if (r->disposed)
+        rb_raise(runtime_error, "disposed realm");
+    TypedData_Get_Struct(r->context, Context, &context_type, c);
+    if (atomic_load(&c->quit))
+        rb_raise(context_disposed_error, "disposed context");
+    *out = r;
+    return c;
+}
+
+// Wrap an inner request (built with ser_init1(op)...) as a realm-scoped request
+// '@' + id(4 raw bytes) + inner, and dispatch it. Frees |inner|; the reply has
+// the same shape as the inner op's reply.
+static VALUE realm_rendezvous(Context *c, int32_t id, Ser *inner)
+{
+    Buf req;
+    buf_init(&req);
+    buf_putc(&req, '@');
+    buf_put(&req, &id, sizeof(id));        // same process => host endianness ok
+    buf_put(&req, inner->b.buf, inner->b.len);
+    ser_reset(inner);                      // release the inner buffer
+    return rendezvous(c, &req);            // takes ownership of |req|
+}
+
+static VALUE realm_id(VALUE self)
+{
+    Realm *r;
+    TypedData_Get_Struct(self, Realm, &realm_type, r);
+    return INT2NUM(r->id);
+}
+
+static VALUE realm_disposed_p(VALUE self)
+{
+    Realm *r;
+    TypedData_Get_Struct(self, Realm, &realm_type, r);
+    return r->disposed ? Qtrue : Qfalse;
+}
+
+static VALUE realm_eval(int argc, VALUE *argv, VALUE self)
+{
+    VALUE a, e, source, filename, kwargs;
+    Realm *r;
+    Context *c = realm_live_context(self, &r);
+    Ser s;
+
+    filename = Qnil;
+    rb_scan_args(argc, argv, "1:", &source, &kwargs);
+    Check_Type(source, T_STRING);
+    if (!NIL_P(kwargs))
+        filename = rb_hash_aref(kwargs, rb_id2sym(rb_intern("filename")));
+    if (NIL_P(filename))
+        filename = rb_str_new_cstr("<eval>");
+    Check_Type(filename, T_STRING);
+    ser_init1(&s, 'E');
+    ser_array_begin(&s, 2);
+    add_string(&s, filename);
+    add_string(&s, source);
+    ser_array_end(&s, 2);
+    a = realm_rendezvous(c, r->id, &s);
+    e = rb_ary_pop(a);
+    handle_exception(e);
+    return rb_ary_pop(a);
+}
+
+static VALUE realm_call(int argc, VALUE *argv, VALUE self)
+{
+    VALUE name, args, a, e;
+    Realm *r;
+    Context *c = realm_live_context(self, &r);
+    Ser s;
+
+    rb_scan_args(argc, argv, "1*", &name, &args);
+    Check_Type(name, T_STRING);
+    rb_ary_unshift(args, name);
+    ser_init1(&s, 'C');
+    if (serialize(&s, args)) {
+        ser_reset(&s);
+        rb_raise(runtime_error, "Realm#call: %s", s.err);
+    }
+    a = realm_rendezvous(c, r->id, &s);
+    e = rb_ary_pop(a);
+    handle_exception(e);
+    return rb_ary_pop(a);
+}
+
+static VALUE realm_attach(VALUE self, VALUE name, VALUE proc)
+{
+    VALUE e;
+    Realm *r;
+    Context *c = realm_live_context(self, &r);
+    Ser s;
+
+    ser_init1(&s, 'A');
+    ser_array_begin(&s, 2);
+    add_string(&s, name);
+    ser_int(&s, RARRAY_LENINT(c->procs));
+    ser_array_end(&s, 2);
+    rb_ary_push(c->procs, proc);
+    e = realm_rendezvous(c, r->id, &s);
+    handle_exception(e);
+    return Qnil;
+}
+
+static VALUE realm_dispose(VALUE self)
+{
+    Realm *r;
+    Context *c;
+    Ser s;
+
+    TypedData_Get_Struct(self, Realm, &realm_type, r);
+    if (r->disposed)
+        return Qnil;
+    TypedData_Get_Struct(r->context, Context, &context_type, c);
+    // Mark disposed before the rendezvous: once we have committed to expunging
+    // the realm, disposed? must report true even if the rendezvous below raises
+    // (e.g. the context is concurrently disposed). The realm is unusable either
+    // way, and leaving the flag clear would re-send the request on a retry.
+    r->disposed = 1;
+    if (!atomic_load(&c->quit)) {
+        ser_init1(&s, 'X');    // e(X)punge realm, payload [id]
+        ser_int(&s, r->id);
+        rendezvous(c, &s.b);   // reply is an empty string; ignore
+    }
+    return Qnil;
+}
+
+static VALUE context_create_realm(VALUE self)
+{
+    Context *c;
+    VALUE a, e, result, realm_v;
+    Realm *r;
+    Buf b;
+
+    TypedData_Get_Struct(self, Context, &context_type, c);
+    if (atomic_load(&c->quit))
+        rb_raise(context_disposed_error, "disposed context");
+    buf_init(&b);
+    buf_putc(&b, 'B');     // (B)uild realm, returns [id, err]
+    a = rendezvous(c, &b); // takes ownership of |b|
+    e = rb_ary_pop(a);
+    handle_exception(e);
+    result = rb_ary_pop(a);
+
+    realm_v = rb_obj_alloc(realm_class); // skip the raising initialize
+    TypedData_Get_Struct(realm_v, Realm, &realm_type, r);
+    r->context = self;
+    r->id = NUM2INT(result);
+    r->disposed = 0;
+    return realm_v;
+}
+
 static VALUE context_pump_message_loop(VALUE self)
 {
     Context *c;
@@ -2855,6 +3072,7 @@ void Init_mini_racer_extension(void)
     rb_define_method(c, "heap_snapshot", context_heap_snapshot, 0);
     rb_define_method(c, "perform_microtask_checkpoint", context_perform_microtask_checkpoint, 0);
     rb_define_method(c, "reset_realm", context_reset_realm, 0);
+    rb_define_method(c, "create_realm", context_create_realm, 0);
     rb_define_method(c, "pump_message_loop", context_pump_message_loop, 0);
     rb_define_method(c, "low_memory_notification", context_low_memory_notification, 0);
     rb_define_method(c, "dynamic_import_resolver", context_get_dynamic_import_resolver, 0);
@@ -2882,6 +3100,16 @@ void Init_mini_racer_extension(void)
     rb_define_method(c, "disposed?", module_disposed_p, 0);
     rb_define_alloc_func(c, module_alloc);
 
+    c = realm_class = rb_define_class_under(m, "Realm", rb_cObject);
+    rb_define_method(c, "initialize", realm_initialize, -1);
+    rb_define_method(c, "id", realm_id, 0);
+    rb_define_method(c, "eval", realm_eval, -1);
+    rb_define_method(c, "call", realm_call, -1);
+    rb_define_method(c, "attach", realm_attach, 2);
+    rb_define_method(c, "dispose", realm_dispose, 0);
+    rb_define_method(c, "disposed?", realm_disposed_p, 0);
+    rb_define_alloc_func(c, realm_alloc);
+
     c = snapshot_class = rb_define_class_under(m, "Snapshot", rb_cObject);
     rb_define_method(c, "initialize", snapshot_initialize, -1);
     rb_define_method(c, "warmup!", snapshot_warmup, 1);