mini_racer 0.21.0 → 0.21.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7cd44fe0925a58e264712d933d805af54b517d31cdbefc26455e7e139e234279
-  data.tar.gz: 17190bc083b885c838b0dfc3424c3fc08fb02df354972a3007a292ddf70afc22
+  metadata.gz: 70ca9828687a7fcdb44048eb1a3e9ad2fe3f38082492504fc22563fe94fa524a
+  data.tar.gz: 61719146ed1430235269e80a21a60ef59b98f22f470cda13820074f9cecea818
 SHA512:
-  metadata.gz: 9cdd4cdf20f9be0e3ceb34daa48f7f1eeb93c4c11eada10c23e2c3e3dbd82cf7a13c8102e67140cc15c028c51a468c6e74ac518c76050cadceb33aa99fd71b7d
-  data.tar.gz: c7110aabb771e18bccd85283696e8f811970cf8d03bb0ef1f573a84f2fa7da2ef1014b5138513b09d80825de96ddebe7e6316f79efbe8adecbd1ff202b14e4d5
+  metadata.gz: 944e4a0e403b134e0206c6d6381efa3d9f120af9cfce18f61fc85c3eef5e6a077c64a457142d347041059a6b76f24990dbd15c17691bbcb3306ff1ea877983a4
+  data.tar.gz: f3003a61146634c76ad28ab99be4d6e96b34490522edb13607b03fcf9354fce135844947af3d23f9d37cc012a26ba4c280c8d4b19d410d47bcebc753cdc6c34f

data/CHANGELOG

@@ -1,3 +1,15 @@
+- 0.21.2 - 11-06-2026
+  - Add `Context#perform_microtask_checkpoint` to synchronously drain the V8 microtask queue, useful for spec-compliant `dispatchEvent` sequencing inside Ruby callbacks
+  - Fix native memory leaks in `Context#heap_snapshot`/`Context#write_heap_snapshot`; thanks to Pranjali Thakur from depthfirst.com
+  - Fix large integral JavaScript numbers wrapping to negative Ruby integers; thanks to Pranjali Thakur from depthfirst.com
+  - Fix Ruby callback exceptions with embedded NUL bytes permanently deadlocking a context; thanks to Pranjali Thakur from depthfirst.com
+  - Preserve embedded NUL bytes in JavaScript exception messages and attached function names, and reject unsafe V8 flags containing NUL bytes or overly long values
+
+- 0.21.1 - 25-05-2026
+  - Run `:single_threaded` V8 dispatches on a reusable mini_racer-owned native thread so V8 does not execute on Ruby-owned threads
+  - Stop and join the reusable `:single_threaded` runner when contexts are disposed
+  - Document `:single_threaded` fork-safety requirements for pre-fork contexts
+
 - 0.21.0 - 16-04-2026
   - Add MiniRacer::Binary for returning Uint8Array to JavaScript from attached Ruby callbacks
 

data/README.md

@@ -139,6 +139,15 @@ Since 0.6.1 mini_racer does support V8 single threaded platform mode which shoul
 MiniRacer::Platform.set_flags!(:single_threaded)
 ```
 
+When using pre-fork `MiniRacer::Context` objects in `:single_threaded` mode,
+ensure the process only forks while MiniRacer is quiescent: no thread may be
+evaluating JavaScript, calling into a context, disposing/freeing a context,
+running a Ruby callback from JavaScript, or otherwise using MiniRacer at the
+instant of `fork`. In multi-threaded applications, guard all MiniRacer context
+operations and the `fork` itself with the same application-level lock. Forking
+while a MiniRacer operation is in progress can leave inherited pthread mutexes
+in an unusable state in the child process.
+
 If you want to ensure your application does not leak memory after fork either:
 
 1. Ensure no `MiniRacer::Context` objects are created in the master process; or
@@ -339,6 +348,38 @@ Performance is slightly better than running `context.eval("hello('George')")` si
 * compilation of eval'd string is avoided
 * function arguments don't need to be converted to JSON
 
+### Microtask checkpoints
+
+V8 drains its microtask queue (e.g. callbacks queued via `Promise.resolve().then(...)`) automatically when script execution returns to the embedder, so most code "just works":
+
+```ruby
+context = MiniRacer::Context.new
+context.eval(<<~JS)
+  let x = 0;
+  Promise.resolve().then(() => x = 99);
+JS
+context.eval("x")
+# => 99
+```
+
+When JavaScript invokes a Ruby callback synchronously and you need queued microtasks to drain mid-execution — e.g. for spec-compliant ordering across a chain of synchronous `dispatchEvent` listeners — call `context.perform_microtask_checkpoint` from the callback:
+
+```ruby
+context = MiniRacer::Context.new
+context.attach("drain", -> { context.perform_microtask_checkpoint })
+context.eval(<<~JS)
+  globalThis.log = [];
+  Promise.resolve().then(() => log.push("microtask"));
+  log.push("before");
+  drain();
+  log.push("after");
+JS
+context.eval("log")
+# => ["before", "microtask", "after"]
+```
+
+Without `drain()` the order would be `["before", "after", "microtask"]` because the microtask only runs once the outermost script returns. `perform_microtask_checkpoint` is a thin wrapper over V8's `MicrotasksScope::PerformCheckpoint`.
+
 ## Performance
 
 The `bench` folder contains benchmark.

data/ext/mini_racer_extension/mini_racer_extension.c

@@ -4,6 +4,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <pthread.h>
+#include <unistd.h>
 #include <math.h>
 
 #if defined(__linux__) && !defined(__GLIBC__)
@@ -136,6 +137,9 @@ typedef struct Context
     VALUE exception;   // pending exception or Qnil
     Buf req, res;      // ruby->v8 request/response, mediated by |mtx| and |cv|
     Buf snapshot;
+    pthread_t single_threaded_thr;
+    pid_t single_threaded_pid;
+    int single_threaded_thr_started;
     // |rr_mtx| stands for "recursive ruby mutex"; it's used to exclude
     // other ruby threads but allow reentrancy from the same ruby thread
     // (think ruby->js->ruby->js calls)
@@ -312,13 +316,19 @@ static void des_bool(void *arg, int v)
 
 static void des_int(void *arg, int64_t v)
 {
-    put(arg, LONG2FIX(v));
+    put(arg, LL2NUM((LONG_LONG)v));
 }
 
 static void des_num(void *arg, double v)
 {
-    if (isfinite(v) && v == trunc(v) && v >= INT64_MIN && v <= INT64_MAX) {
-        put(arg, LONG2FIX(v));
+    if (isfinite(v) && v == trunc(v)) {
+        // INT64_MAX is not exactly representable as a double: it rounds up to
+        // 2^63, which would let 2^63 through and make the cast undefined.
+        if (v >= -0x1p63 && v < 0x1p63) {
+            put(arg, LL2NUM((LONG_LONG)v));
+        } else {
+            put(arg, rb_dbl2big(v));
+        }
     } else {
         put(arg, DBL2NUM(v));
     }
@@ -360,19 +370,8 @@ static void des_bigint(void *arg, const void *p, size_t n, int sign)
     if (t >> 63)
         *a++ = 0; // suppress sign extension
     v = rb_big_unpack(limbs, a-limbs);
-    if (sign < 0) {
-        // rb_big_unpack returns T_FIXNUM for smallish bignums
-        switch (TYPE(v)) {
-        case T_BIGNUM:
-            v = rb_big_mul(v, LONG2FIX(-1));
-            break;
-        case T_FIXNUM:
-            v = LONG2FIX(-1 * FIX2LONG(v));
-            break;
-        default:
-            abort();
-        }
-    }
+    if (sign < 0)
+        v = rb_funcall(v, rb_intern("-@"), 0);
     put(c, v);
 }
 
@@ -806,6 +805,7 @@ static void dispatch1(Context *c, const uint8_t *p, size_t n)
     case 'C': return v8_timedwait(c, p+1, n-1, v8_call);
     case 'E': return v8_timedwait(c, p+1, n-1, v8_eval);
     case 'H': return v8_heap_snapshot(c->pst);
+    case 'M': return v8_perform_microtask_checkpoint(c->pst);
     case 'P': return v8_pump_message_loop(c->pst);
     case 'S': return v8_heap_stats(c->pst);
     case 'T': return v8_snapshot(c->pst, p+1, n-1);
@@ -868,18 +868,10 @@ void v8_dispatch(Context *c)
 // only called when inside v8_call, v8_eval, or v8_pump_message_loop
 void v8_roundtrip(Context *c, const uint8_t **p, size_t *n)
 {
-    struct rendezvous_nogvl *args;
-
     buf_reset(&c->req);
-    if (single_threaded) {
-        assert(*c->res.buf == 'c'); // js -> ruby callback
-        args = &(struct rendezvous_nogvl){c, &c->req, &c->res};
-        rb_thread_call_with_gvl(rendezvous_callback, args);
-    } else {
-        pthread_cond_signal(&c->cv);
-        while (!c->req.len)
-            pthread_cond_wait(&c->cv, &c->mtx);
-    }
+    pthread_cond_signal(&c->cv);
+    while (!c->req.len)
+        pthread_cond_wait(&c->cv, &c->mtx);
     buf_reset(&c->res);
     *p = c->req.buf;
     *n = c->req.len;
@@ -940,6 +932,7 @@ static VALUE rendezvous_callback_do(VALUE arg)
     Context *c;
     DesCtx d;
     Buf *b;
+    long id;
 
     a = (void *)arg;
     b = a->res;
@@ -949,7 +942,12 @@ static VALUE rendezvous_callback_do(VALUE arg)
     DesCtx_init(&d);
     args = deserialize1(&d, b->buf+1, b->len-1); // skip 'c' marker
     func = rb_ary_pop(args); // callback id
-    func = rb_ary_entry(c->procs, FIX2LONG(func));
+    if (!RB_INTEGER_TYPE_P(func))
+        rb_raise(runtime_error, "bad callback id");
+    id = NUM2LONG(func);
+    if (id < 0 || id >= RARRAY_LEN(c->procs))
+        rb_raise(runtime_error, "bad callback id");
+    func = rb_ary_entry(c->procs, id);
     return rb_funcall2(func, rb_intern("call"), RARRAY_LENINT(args), RARRAY_PTR(args));
 }
 
@@ -985,16 +983,51 @@ fail:
     ser_init0(&s);   // ruby exception pending
     w_byte(&s, 'e'); // send ruby error message to v8 thread
     r = rb_funcall(c->exception, rb_intern("to_s"), 0);
-    err = StringValueCStr(r);
+    err = StringValuePtr(r);
     if (err)
-        w(&s, err, strlen(err));
+        w(&s, err, RSTRING_LEN(r));
     goto out;
 }
 
+static void *single_threaded_runner(void *arg)
+{
+    Context *c;
+
+    c = arg;
+    pthread_mutex_lock(&c->mtx);
+    for (;;) {
+        while (!c->req.len && atomic_load(&c->quit) < 1)
+            pthread_cond_wait(&c->cv, &c->mtx);
+        if (atomic_load(&c->quit) >= 1)
+            break;
+        v8_single_threaded_enter(c->pst, c, dispatch);
+        pthread_cond_signal(&c->cv);
+    }
+    pthread_mutex_unlock(&c->mtx);
+    return NULL;
+}
+
+static int single_threaded_runner_start(Context *c)
+{
+    pid_t pid;
+    int r;
+
+    pid = getpid();
+    if (c->single_threaded_thr_started && c->single_threaded_pid == pid)
+        return 0;
+    c->single_threaded_thr_started = 0;
+    c->single_threaded_pid = pid;
+    r = pthread_create(&c->single_threaded_thr, NULL, single_threaded_runner, c);
+    if (!r)
+        c->single_threaded_thr_started = 1;
+    return r;
+}
+
 static inline void *rendezvous_nogvl(void *arg)
 {
     struct rendezvous_nogvl *a;
     Context *c;
+    int r;
 
     a = arg;
     c = a->context;
@@ -1010,7 +1043,16 @@ next:
     assert(c->res.len == 0);
     buf_move(a->req, &c->req); // v8 thread takes ownership of req
     if (single_threaded) {
-        v8_single_threaded_enter(c->pst, c, dispatch);
+        r = single_threaded_runner_start(c);
+        if (r) {
+            buf_move(&c->req, a->req);
+            pthread_mutex_unlock(&c->mtx);
+            c->depth--;
+            pthread_mutex_unlock(&c->rr_mtx);
+            return (void *)(intptr_t)r;
+        }
+        pthread_cond_signal(&c->cv);
+        do pthread_cond_wait(&c->cv, &c->mtx); while (!c->res.len);
     } else {
         pthread_cond_signal(&c->cv);
         do pthread_cond_wait(&c->cv, &c->mtx); while (!c->res.len);
@@ -1019,6 +1061,7 @@ next:
     pthread_mutex_unlock(&c->mtx);
     if (*a->res->buf == 'c') { // js -> ruby callback?
         rb_thread_call_with_gvl(rendezvous_callback, a);
+        buf_reset(a->res);
         goto next;
     }
     c->depth--;
@@ -1028,12 +1071,16 @@ next:
 
 static void rendezvous_no_des(Context *c, Buf *req, Buf *res)
 {
+    void *r;
+
     if (atomic_load(&c->quit)) {
         buf_reset(req);
         rb_raise(context_disposed_error, "disposed context");
     }
-    rb_nogvl(rendezvous_nogvl, &(struct rendezvous_nogvl){c, req, res},
-             NULL, NULL, 0);
+    r = rb_nogvl(rendezvous_nogvl, &(struct rendezvous_nogvl){c, req, res},
+                 NULL, NULL, 0);
+    if (r)
+        rb_raise(runtime_error, "pthread_create: %s", strerror((int)(intptr_t)r));
 }
 
 // send request to & receive reply from v8 thread; takes ownership of |req|
@@ -1070,16 +1117,35 @@ static VALUE rendezvous(Context *c, Buf *req)
     return rendezvous1(c, req, &d);
 }
 
+static void raise_exception_with_message(VALUE klass, VALUE e)
+{
+    long n;
+    VALUE message;
+
+    if (NIL_P(e))
+        return;
+    e = StringValue(e);
+    n = RSTRING_LEN(e);
+    if (n == 0 || RSTRING_PTR(e)[0] == NO_ERROR)
+        return;
+    message = rb_str_subseq(e, 1, n - 1);
+    rb_exc_raise(rb_exc_new_str(klass, message));
+}
+
 static void handle_exception(VALUE e)
 {
     const char *s;
     VALUE klass;
+    long n;
 
     if (NIL_P(e))
         return;
     e = StringValue(e);
-    s = StringValueCStr(e);
-    switch (*s) {
+    n = RSTRING_LEN(e);
+    if (n == 0)
+        return;
+    s = RSTRING_PTR(e);
+    switch ((unsigned char)*s) {
     case NO_ERROR:
         return;
     case INTERNAL_ERROR:
@@ -1098,9 +1164,9 @@ static void handle_exception(VALUE e)
         klass = terminated_error;
         break;
     default:
-        rb_raise(internal_error, "bad error class %02x", *s);
+        rb_raise(internal_error, "bad error class %02x", (unsigned char)*s);
     }
-    rb_enc_raise(rb_enc_get(e), klass, "%s", s+1);
+    raise_exception_with_message(klass, e);
 }
 
 static VALUE context_alloc(VALUE klass)
@@ -1190,7 +1256,16 @@ static void *context_free_thread_do(void *arg)
     Context *c;
 
     c = arg;
-    v8_single_threaded_dispose(c->pst);
+    if (single_threaded && c->single_threaded_thr_started && c->single_threaded_pid == getpid()) {
+        pthread_mutex_lock(&c->mtx);
+        atomic_store(&c->quit, 2);
+        pthread_cond_signal(&c->cv);
+        pthread_mutex_unlock(&c->mtx);
+        pthread_join(c->single_threaded_thr, NULL);
+    }
+    if (c->pst)
+        v8_single_threaded_dispose(c->pst);
+    pthread_mutex_lock(&c->mtx);
     context_destroy(c);
     return NULL;
 }
@@ -1263,13 +1338,17 @@ static VALUE context_attach(VALUE self, VALUE name, VALUE proc)
     Context *c;
     VALUE e;
     Ser s;
+    long id;
 
     TypedData_Get_Struct(self, Context, &context_type, c);
+    id = RARRAY_LEN(c->procs);
+    if (id > INT32_MAX)
+        rb_raise(runtime_error, "too many callbacks");
     // request is (A)ttach, [name, id] array
     ser_init1(&s, 'A');
     ser_array_begin(&s, 2);
     add_string(&s, name);
-    ser_int(&s, RARRAY_LENINT(c->procs));
+    ser_int(&s, id);
     ser_array_end(&s, 2);
     rb_ary_push(c->procs, proc);
     // response is an exception or undefined
@@ -1284,8 +1363,18 @@ static void *context_dispose_do(void *arg)
 
     c = arg;
     if (single_threaded) {
+        pthread_mutex_lock(&c->mtx);
+        while (c->req.len || c->res.len)
+            pthread_cond_wait(&c->cv, &c->mtx);
         atomic_store(&c->quit, 1);   // disposed
-        // intentionally a no-op for now
+        if (c->single_threaded_thr_started && c->single_threaded_pid == getpid()) {
+            pthread_cond_signal(&c->cv);
+            pthread_mutex_unlock(&c->mtx);
+            pthread_join(c->single_threaded_thr, NULL);
+            pthread_mutex_lock(&c->mtx);
+            c->single_threaded_thr_started = 0;
+        }
+        pthread_mutex_unlock(&c->mtx);
     } else {
         pthread_mutex_lock(&c->mtx);
         while (c->req.len || c->res.len)
@@ -1393,6 +1482,20 @@ static VALUE context_heap_stats(VALUE self)
     return h;
 }
 
+static VALUE buf_reset_ensure(VALUE arg)
+{
+    buf_reset((Buf *)arg);
+    return Qnil;
+}
+
+static VALUE heap_snapshot_to_str(VALUE arg)
+{
+    Buf *res;
+
+    res = (Buf *)arg;
+    return rb_utf8_str_new((char *)res->buf, res->len);
+}
+
 static VALUE context_heap_snapshot(VALUE self)
 {
     Buf req, res;
@@ -1402,7 +1505,19 @@ static VALUE context_heap_snapshot(VALUE self)
     buf_init(&req);
     buf_putc(&req, 'H');              // (H)eap snapshot, returns plain bytes
     rendezvous_no_des(c, &req, &res); // takes ownership of |req|
-    return rb_utf8_str_new((char *)res.buf, res.len);
+    return rb_ensure(heap_snapshot_to_str, (VALUE)&res,
+                     buf_reset_ensure, (VALUE)&res);
+}
+
+static VALUE context_perform_microtask_checkpoint(VALUE self)
+{
+    Context *c;
+    Buf b;
+
+    TypedData_Get_Struct(self, Context, &context_type, c);
+    buf_init(&b);
+    buf_putc(&b, 'M');        // (M)icrotask checkpoint, returns nil
+    return rendezvous(c, &b); // takes ownership of |b|
 }
 
 static VALUE context_pump_message_loop(VALUE self)
@@ -1425,12 +1540,14 @@ static VALUE context_low_memory_notification(VALUE self)
     buf_init(&req);
     buf_putc(&req, 'L');              // (L)ow memory notification, returns nothing
     rendezvous_no_des(c, &req, &res); // takes ownership of |req|
+    buf_reset(&res);
     return Qnil;
 }
 
 static int platform_set_flag1(VALUE k, VALUE v)
 {
-    char *p, *q, buf[256];
+    char *p, *q, *r, buf[256];
+    long pn, vn, len;
     int ok;
 
     k = rb_funcall(k, rb_intern("to_s"), 0);
@@ -1440,12 +1557,40 @@ static int platform_set_flag1(VALUE k, VALUE v)
         Check_Type(v, T_STRING);
     }
     p = RSTRING_PTR(k);
-    if (!strncmp(p, "--", 2))
+    pn = RSTRING_LEN(k);
+    if (memchr(p, '\0', pn))
+        rb_raise(rb_eArgError, "flag contains NUL byte");
+    if (pn >= 2 && p[0] == '-' && p[1] == '-') {
         p += 2;
+        pn -= 2;
+    }
     if (NIL_P(v)) {
-        snprintf(buf, sizeof(buf), "--%s", p);
+        len = 2 + pn;
+        if (len >= (long)sizeof(buf))
+            rb_raise(rb_eArgError, "flag too long");
+        q = buf;
+        *q++ = '-';
+        *q++ = '-';
+        memcpy(q, p, pn);
+        q += pn;
+        *q = '\0';
     } else {
-        snprintf(buf, sizeof(buf), "--%s=%s", p, RSTRING_PTR(v));
+        q = RSTRING_PTR(v);
+        vn = RSTRING_LEN(v);
+        if (memchr(q, '\0', vn))
+            rb_raise(rb_eArgError, "flag contains NUL byte");
+        len = 3 + pn + vn;
+        if (len >= (long)sizeof(buf))
+            rb_raise(rb_eArgError, "flag too long");
+        r = buf;
+        *r++ = '-';
+        *r++ = '-';
+        memcpy(r, p, pn);
+        r += pn;
+        *r++ = '=';
+        memcpy(r, q, vn);
+        r += vn;
+        *r = '\0';
     }
     p = buf;
     pthread_mutex_lock(&flags_mtx);
@@ -1658,8 +1803,7 @@ static VALUE snapshot_initialize(int argc, VALUE *argv, VALUE self)
     a = rendezvous1(c, &s.b, &d);
     e = rb_ary_pop(a);
     context_dispose(cv);
-    if (*RSTRING_PTR(e))
-        rb_raise(snapshot_error, "%s", RSTRING_PTR(e)+1);
+    raise_exception_with_message(snapshot_error, e);
     ss->blob = rb_ary_pop(a);
     return Qnil;
 }
@@ -1689,8 +1833,7 @@ static VALUE snapshot_warmup(VALUE self, VALUE arg)
     a = rendezvous1(c, &s.b, &d);
     e = rb_ary_pop(a);
     context_dispose(cv);
-    if (*RSTRING_PTR(e))
-        rb_raise(snapshot_error, "%s", RSTRING_PTR(e)+1);
+    raise_exception_with_message(snapshot_error, e);
     ss->blob = rb_ary_pop(a);
     return self;
 }
@@ -1760,6 +1903,7 @@ void Init_mini_racer_extension(void)
     rb_define_method(c, "eval", context_eval, -1);
     rb_define_method(c, "heap_stats", context_heap_stats, 0);
     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, "pump_message_loop", context_pump_message_loop, 0);
     rb_define_method(c, "low_memory_notification", context_low_memory_notification, 0);
     rb_define_alloc_func(c, context_alloc);

data/ext/mini_racer_extension/mini_racer_v8.cc

@@ -5,11 +5,12 @@
 #include <memory>
 #include <vector>
 #include <cassert>
+#include <cstdarg>
 #include <cstdio>
 #include <cstdint>
 #include <cstdlib>
 #include <cstring>
-#include <vector>
+#include <limits>
 
 // note: the filter function gets called inside the safe context,
 // i.e., the context that has not been tampered with by user JS
@@ -123,6 +124,106 @@ struct Serialized
     }
 };
 
+void append_bytes(std::vector<char>& out, const char *p, size_t n)
+{
+    out.insert(out.end(), p, p + n);
+}
+
+void append_literal(std::vector<char>& out, const char *s)
+{
+    append_bytes(out, s, strlen(s));
+}
+
+bool append_utf8(std::vector<char>& out, const v8::String::Utf8Value& s)
+{
+    if (!*s) return false;
+    append_bytes(out, *s, s.length());
+    return true;
+}
+
+void append_format(std::vector<char>& out, const char *fmt, ...)
+{
+    char buf[128];
+    va_list ap;
+    va_start(ap, fmt);
+    int n = vsnprintf(buf, sizeof(buf), fmt, ap);
+    va_end(ap);
+    if (n <= 0) return;
+    if (static_cast<size_t>(n) < sizeof(buf)) {
+        append_bytes(out, buf, n);
+        return;
+    }
+
+    std::vector<char> tmp(static_cast<size_t>(n) + 1);
+    va_start(ap, fmt);
+    vsnprintf(tmp.data(), tmp.size(), fmt, ap);
+    va_end(ap);
+    append_bytes(out, tmp.data(), n);
+}
+
+v8::Local<v8::String> string_from_bytes(v8::Isolate *isolate, const std::vector<char>& bytes)
+{
+    v8::Local<v8::String> s;
+    auto type = v8::NewStringType::kNormal;
+    if (bytes.size() <= static_cast<size_t>(std::numeric_limits<int>::max()) &&
+        v8::String::NewFromUtf8(isolate, bytes.data(), type,
+                                static_cast<int>(bytes.size())).ToLocal(&s)) {
+        return s;
+    }
+
+    char fallback[] = {
+        bytes.empty() ? static_cast<char>(INTERNAL_ERROR) : bytes[0],
+        'u', 'n', 'e', 'x', 'p', 'e', 'c', 't', 'e', 'd', ' ', 'e', 'r', 'r', 'o', 'r'
+    };
+    if (v8::String::NewFromUtf8(isolate, fallback, type, static_cast<int>(sizeof(fallback))).ToLocal(&s)) return s;
+    return v8::String::Empty(isolate);
+}
+
+void set_error_message(std::vector<char>& out, int cause, const char *message)
+{
+    out.clear();
+    out.push_back(static_cast<char>(cause));
+    append_literal(out, message);
+}
+
+bool set_error_message(std::vector<char>& out, int cause, const v8::String::Utf8Value& message)
+{
+    out.clear();
+    out.push_back(static_cast<char>(cause));
+    return append_utf8(out, message);
+}
+
+void set_fallback_error(State& st, v8::TryCatch *try_catch, int cause,
+                        std::vector<char>& out)
+{
+    v8::String::Utf8Value s(st.isolate, try_catch->Exception());
+    const char *message = *s ? nullptr : "unexpected failure";
+    if (cause == MEMORY_ERROR) message = "out of memory";
+    if (cause == TERMINATED_ERROR) message = "terminated";
+    if (message) {
+        set_error_message(out, cause, message);
+    } else if (!set_error_message(out, cause, s)) {
+        set_error_message(out, cause, "unexpected failure");
+    }
+}
+
+bool read_path_key(State& st, const char *&p, const char *pe,
+                   v8::Local<v8::String> *key, bool *last)
+{
+    const char *dot;
+    size_t n;
+
+    if (p > pe) return false;
+    dot = static_cast<const char*>(memchr(p, '.', pe - p));
+    *last = (dot == nullptr);
+    n = *last ? static_cast<size_t>(pe - p) : static_cast<size_t>(dot - p);
+    if (n > static_cast<size_t>(std::numeric_limits<int>::max())) return false;
+    auto type = v8::NewStringType::kNormal;
+    if (!v8::String::NewFromUtf8(st.isolate, p, type, static_cast<int>(n)).ToLocal(key)) return false;
+    p = *last ? pe : dot + 1;
+    return true;
+}
+
 bool bubble_up_ruby_exception(State& st, v8::TryCatch *try_catch)
 {
     auto exception = try_catch->Exception();
@@ -249,35 +350,40 @@ v8::Local<v8::Value> sanitize(State& st, v8::Local<v8::Value> v)
 
 v8::Local<v8::String> to_error(State& st, v8::TryCatch *try_catch, int cause)
 {
-    v8::Local<v8::Value> t;
-    char buf[1024];
+    std::vector<char> buf;
 
-    *buf = '\0';
     if (cause == NO_ERROR) {
-        // nothing to do
+        return v8::String::Empty(st.isolate);
     } else if (cause == PARSE_ERROR) {
         auto message = try_catch->Message();
         v8::String::Utf8Value s(st.isolate, message->Get());
         v8::String::Utf8Value name(st.isolate, message->GetScriptResourceName());
-        if (!*s || !*name) goto fallback;
-        auto line = message->GetLineNumber(st.context).FromMaybe(0);
-        auto column = message->GetStartColumn(st.context).FromMaybe(0);
-        snprintf(buf, sizeof(buf), "%c%s at %s:%d:%d", cause, *s, *name, line, column);
-    } else if (try_catch->StackTrace(st.context).ToLocal(&t)) {
-        v8::String::Utf8Value s(st.isolate, t);
-        if (!*s) goto fallback;
-        snprintf(buf, sizeof(buf), "%c%s", cause, *s);
+        if (*s && *name) {
+            buf.push_back(static_cast<char>(cause));
+            append_utf8(buf, s);
+            append_literal(buf, " at ");
+            append_utf8(buf, name);
+            auto line = message->GetLineNumber(st.context).FromMaybe(0);
+            auto column = message->GetStartColumn(st.context).FromMaybe(0);
+            append_format(buf, ":%d:%d", line, column);
+        } else {
+            set_fallback_error(st, try_catch, cause, buf);
+        }
     } else {
-    fallback:
-        v8::String::Utf8Value s(st.isolate, try_catch->Exception());
-        const char *message = *s ? *s : "unexpected failure";
-        if (cause == MEMORY_ERROR) message = "out of memory";
-        if (cause == TERMINATED_ERROR) message = "terminated";
-        snprintf(buf, sizeof(buf), "%c%s", cause, message);
+        v8::Local<v8::Value> t;
+        if (try_catch->StackTrace(st.context).ToLocal(&t)) {
+            v8::String::Utf8Value s(st.isolate, t);
+            if (*s) {
+                buf.push_back(static_cast<char>(cause));
+                append_utf8(buf, s);
+            } else {
+                set_fallback_error(st, try_catch, cause, buf);
+            }
+        } else {
+            set_fallback_error(st, try_catch, cause, buf);
+        }
     }
-    v8::Local<v8::String> s;
-    if (v8::String::NewFromUtf8(st.isolate, buf).ToLocal(&s)) return s;
-    return v8::String::Empty(st.isolate);
+    return string_from_bytes(st.isolate, buf);
 }
 
 extern "C" void v8_global_init(void)
@@ -445,23 +551,19 @@ extern "C" void v8_attach(State *pst, const uint8_t *p, size_t n)
         v8::Local<v8::String> name;
         if (!name_v->ToString(st.context).ToLocal(&name)) goto fail;
         int32_t id;
-        if (!id_v->Int32Value(st.context).To(&id)) goto fail;
-        Callback *cb = new Callback{pst, id};
-        st.callbacks.push_back(cb);
-        v8::Local<v8::External> ext = v8::External::New(st.isolate, cb);
-        v8::Local<v8::Function> function;
-        if (!v8::Function::New(st.context, v8_api_callback, ext).ToLocal(&function)) goto fail;
+        if (!id_v->IsInt32()) goto fail;
+        id = id_v.As<v8::Int32>()->Value();
         // support foo.bar.baz paths
         v8::String::Utf8Value path(st.isolate, name);
         if (!*path) goto fail;
+        const char *p = *path;
+        const char *pe = p + path.length();
         v8::Local<v8::Object> obj = st.context->Global();
         v8::Local<v8::String> key;
-        for (const char *p = *path;;) {
-            size_t n = strcspn(p, ".");
-            auto type = v8::NewStringType::kNormal;
-            if (!v8::String::NewFromUtf8(st.isolate, p, type, n).ToLocal(&key)) goto fail;
-            if (p[n] == '\0') break;
-            p += n + 1;
+        for (;;) {
+            bool last;
+            if (!read_path_key(st, p, pe, &key, &last)) goto fail;
+            if (last) break;
             v8::Local<v8::Value> val;
             if (!obj->Get(st.context, key).ToLocal(&val)) goto fail;
             if (!val->IsObject() && !val->IsFunction()) {
@@ -470,6 +572,11 @@ extern "C" void v8_attach(State *pst, const uint8_t *p, size_t n)
             }
             obj = val.As<v8::Object>();
         }
+        std::unique_ptr<Callback> cb(new Callback{pst, id});
+        v8::Local<v8::External> ext = v8::External::New(st.isolate, cb.get());
+        v8::Local<v8::Function> function;
+        if (!v8::Function::New(st.context, v8_api_callback, ext).ToLocal(&function)) goto fail;
+        st.callbacks.push_back(cb.release());
         if (!obj->Set(st.context, key, function).FromMaybe(false)) goto fail;
     }
     cause = NO_ERROR;
@@ -504,14 +611,14 @@ extern "C" void v8_call(State *pst, const uint8_t *p, size_t n)
         // support foo.bar.baz paths
         v8::String::Utf8Value path(st.isolate, name);
         if (!*path) goto fail;
+        const char *p = *path;
+        const char *pe = p + path.length();
         v8::Local<v8::Object> obj = st.context->Global();
         v8::Local<v8::String> key;
-        for (const char *p = *path;;) {
-            size_t n = strcspn(p, ".");
-            auto type = v8::NewStringType::kNormal;
-            if (!v8::String::NewFromUtf8(st.isolate, p, type, n).ToLocal(&key)) goto fail;
-            if (p[n] == '\0') break;
-            p += n + 1;
+        for (;;) {
+            bool last;
+            if (!read_path_key(st, p, pe, &key, &last)) goto fail;
+            if (last) break;
             v8::Local<v8::Value> val;
             if (!obj->Get(st.context, key).ToLocal(&val)) goto fail;
             if (!val->ToObject(st.context).ToLocal(&obj)) goto fail;
@@ -659,9 +766,22 @@ extern "C" void v8_heap_snapshot(State *pst)
     auto snapshot = st.isolate->GetHeapProfiler()->TakeHeapSnapshot();
     OutputStream os;
     snapshot->Serialize(&os, v8::HeapSnapshot::kJSON);
+    const_cast<v8::HeapSnapshot*>(snapshot)->Delete();
     v8_reply(st.ruby_context, os.buf.data(), os.buf.size()); // not serialized because big
 }
 
+extern "C" void v8_perform_microtask_checkpoint(State *pst)
+{
+    // Leave any termination active so the enclosing v8_call/v8_eval frame
+    // surfaces OOM (set by v8_gc_callback) or watchdog termination to Ruby.
+    State& st = *pst;
+    v8::TryCatch try_catch(st.isolate);
+    try_catch.SetVerbose(st.verbose_exceptions);
+    v8::HandleScope handle_scope(st.isolate);
+    v8::MicrotasksScope::PerformCheckpoint(st.isolate);
+    reply_retry(st, v8::Undefined(st.isolate));
+}
+
 extern "C" void v8_pump_message_loop(State *pst)
 {
     State& st = *pst;
@@ -691,7 +811,7 @@ fail:
 int snapshot(bool is_warmup, bool verbose_exceptions,
              const v8::String::Utf8Value& code,
              v8::StartupData blob, v8::StartupData *result,
-             char (*errbuf)[512])
+             std::vector<char> *errbuf)
 {
     // SnapshotCreator takes ownership of isolate
     v8::Isolate *isolate = v8::Isolate::Allocate();
@@ -715,7 +835,8 @@ int snapshot(bool is_warmup, bool verbose_exceptions,
         auto type = v8::NewStringType::kNormal;
         if (!v8::String::NewFromUtf8(isolate, *code, type, code.length()).ToLocal(&source)) {
             v8::String::Utf8Value s(isolate, try_catch.Exception());
-            if (*s) snprintf(*errbuf, sizeof(*errbuf), "%c%s", cause, *s);
+            if (!set_error_message(*errbuf, cause, s))
+                set_error_message(*errbuf, cause, "unexpected failure");
             goto fail;
         }
         v8::ScriptOrigin origin(filename);
@@ -732,8 +853,16 @@ int snapshot(bool is_warmup, bool verbose_exceptions,
             v8::String::Utf8Value name(isolate, m->GetScriptResourceName());
             auto line = m->GetLineNumber(context).FromMaybe(0);
             auto column = m->GetStartColumn(context).FromMaybe(0);
-            snprintf(*errbuf, sizeof(*errbuf), "%c%s\n%s:%d:%d",
-                     cause, *s, *name, line, column);
+            if (*s && *name) {
+                errbuf->clear();
+                errbuf->push_back(static_cast<char>(cause));
+                append_utf8(*errbuf, s);
+                append_literal(*errbuf, "\n");
+                append_utf8(*errbuf, name);
+                append_format(*errbuf, ":%d:%d", line, column);
+            } else {
+                set_error_message(*errbuf, cause, "unexpected failure");
+            }
             goto fail;
         }
         cause = INTERNAL_ERROR;
@@ -764,7 +893,7 @@ extern "C" void v8_snapshot(State *pst, const uint8_t *p, size_t n)
     v8::Local<v8::Value> result;
     v8::StartupData blob{nullptr, 0};
     int cause = INTERNAL_ERROR;
-    char errbuf[512] = {0};
+    std::vector<char> errbuf;
     {
         v8::Local<v8::Value> code_v;
         if (!des.ReadValue(st.context).ToLocal(&code_v)) goto fail;
@@ -793,10 +922,8 @@ fail:
     if (!cause && try_catch.HasCaught()) cause = RUNTIME_ERROR;
     if (cause) result = v8::Undefined(st.isolate);
     v8::Local<v8::Value> err;
-    if (*errbuf) {
-        if (!v8::String::NewFromUtf8(st.isolate, errbuf).ToLocal(&err)) {
-            err = v8::String::NewFromUtf8Literal(st.isolate, "unexpected error");
-        }
+    if (!errbuf.empty()) {
+        err = string_from_bytes(st.isolate, errbuf);
     } else {
         err = to_error(st, &try_catch, cause);
     }
@@ -818,7 +945,7 @@ extern "C" void v8_warmup(State *pst, const uint8_t *p, size_t n)
     v8::Local<v8::Value> result;
     v8::StartupData blob{nullptr, 0};
     int cause = INTERNAL_ERROR;
-    char errbuf[512] = {0};
+    std::vector<char> errbuf;
     {
         v8::Local<v8::Value> request_v;
         if (!des.ReadValue(st.context).ToLocal(&request_v)) goto fail;
@@ -865,10 +992,8 @@ fail:
     if (!cause && try_catch.HasCaught()) cause = RUNTIME_ERROR;
     if (cause) result = v8::Undefined(st.isolate);
     v8::Local<v8::Value> err;
-    if (*errbuf) {
-        if (!v8::String::NewFromUtf8(st.isolate, errbuf).ToLocal(&err)) {
-            err = v8::String::NewFromUtf8Literal(st.isolate, "unexpected error");
-        }
+    if (!errbuf.empty()) {
+        err = string_from_bytes(st.isolate, errbuf);
     } else {
         err = to_error(st, &try_catch, cause);
     }
@@ -919,6 +1044,7 @@ State::~State()
     {
         v8::Locker locker(isolate);
         v8::Isolate::Scope isolate_scope(isolate);
+        persistent_safe_context_function.Reset();
         persistent_safe_context.Reset();
         persistent_context.Reset();
         ruby_exception.Reset();

data/ext/mini_racer_extension/mini_racer_v8.h

@@ -42,6 +42,7 @@ void v8_call(struct State *pst, const uint8_t *p, size_t n);
 void v8_eval(struct State *pst, const uint8_t *p, size_t n);
 void v8_heap_stats(struct State *pst);
 void v8_heap_snapshot(struct State *pst);
+void v8_perform_microtask_checkpoint(struct State *pst);
 void v8_pump_message_loop(struct State *pst);
 void v8_snapshot(struct State *pst, const uint8_t *p, size_t n);
 void v8_warmup(struct State *pst, const uint8_t *p, size_t n);

data/ext/mini_racer_extension/serde.c

@@ -278,7 +278,7 @@ static void ser_int(Ser *s, int64_t v)
         if (v > INT64_MIN/1024)
             if (v <= INT64_MAX/1024)
                 return ser_num(s, v);
-        t = v < 0 ? -v : v;
+        t = v < 0 ? (uint64_t)(-(v + 1)) + 1 : (uint64_t)v;
         sign = v < 0 ? -1 : 1;
         ser_bigint(s, &t, sizeof(t), sign);
     } else {

data/lib/mini_racer/truffleruby.rb

@@ -77,9 +77,13 @@ module MiniRacer
         raise "TruffleRuby #{RUBY_ENGINE_VERSION} does not have support for inner contexts, use a more recent version"
       end
 
+
+      if TruffleRuby.native?
+        raise "You need the TruffleRuby JVM Standalone for mini_racer because it is not possible to install the js component in the the Native standalone"
+      end
+
       unless Polyglot.languages.include? "js"
-        raise "The language 'js' is not available, you likely need to `export TRUFFLERUBYOPT='--jvm --polyglot'`\n" \
-          "You also need to install the 'js' component, see https://github.com/oracle/truffleruby/blob/master/doc/user/polyglot.md#installing-other-languages"
+        raise "The language 'js' is not available, you need to install the 'js' component.\nSee https://github.com/oracle/truffleruby/blob/master/doc/user/polyglot.md#installing-other-languages"
       end
 
       @context = Polyglot::InnerContext.new(on_cancelled: -> { 
@@ -102,20 +106,37 @@ module MiniRacer
       else
         @snapshot = nil
       end
-      @is_object_or_array_func, @is_map_func, @is_map_iterator_func, @is_time_func, @js_date_to_time_func, @is_symbol_func, @js_symbol_to_symbol_func, @js_new_date_func, @js_new_array_func, @js_new_uint8array_func = eval_in_context <<-CODE
-        [
-          (x) => { return (x instanceof Object || x instanceof Array) && !(x instanceof Date) && !(x instanceof Function) },
-          (x) => { return x instanceof Map },
-          (x) => { return x[Symbol.toStringTag] === 'Map Iterator' },
-          (x) => { return x instanceof Date },
-          (x) => { return x.getTime(x) },
-          (x) => { return typeof x === 'symbol' },
-          (x) => { var r = x.description; return r === undefined ? 'undefined' : r },
-          (x) => { return new Date(x) },
-          (x) => { return new Array(x) },
-          (x) => { return new Uint8Array(x) },
-        ]
-      CODE
+
+      @is_object_or_array_func = eval_in_context "(x) => { return (x instanceof Object || x instanceof Array) && !(x instanceof Date) && !(x instanceof Function) }"
+      @is_map_func = eval_in_context "(x) => { return x instanceof Map }"
+      @is_map_iterator_func = eval_in_context "(x) => { return x[Symbol.toStringTag] === 'Map Iterator' }"
+      @is_time_func = eval_in_context "(x) => { return x instanceof Date }"
+      @is_symbol_func = eval_in_context "(x) => { return typeof x === 'symbol' }"
+      @is_uint8_array_func = eval_in_context "(x) => { return x instanceof Uint8Array }"
+
+      @js_date_to_time_func = eval_in_context "(x) => { return x.getTime(x) }"
+      @js_symbol_to_symbol_func = eval_in_context "(x) => { var r = x.description; return r === undefined ? 'undefined' : r }"
+      @js_new_date_func = eval_in_context "(x) => { return new Date(x) }"
+      @js_new_array_func = eval_in_context "(x) => { return new Array(x) }"
+      # looks up a (dotted) function name as properties from globalThis,
+      # instead of evaluating the name as source code, so that names with
+      # embedded NUL bytes or other invalid syntax resolve correctly
+      @js_lookup_call_target_func = eval_in_context <<~JS
+        (name) => {
+          let target = globalThis;
+          for (const key of name.split(".")) {
+            if (target == null) {
+              throw new ReferenceError(name + " is not defined");
+            }
+            target = target[key];
+          }
+          if (target === undefined) {
+            throw new ReferenceError(name + " is not defined");
+          }
+          return target;
+        }
+      JS
+      @js_new_uint8array_func = eval_in_context "(x) => { return new Uint8Array(x) }"
     end
 
     def dispose_unsafe
@@ -171,7 +192,7 @@ module MiniRacer
       raise RuntimeError, "TruffleRuby does not support call after stop" if @stopped
       begin
         translate do
-          function = eval_in_context(function_name)
+          function = @js_lookup_call_target_func.call(convert_ruby_to_js(encode(function_name)))
           function.call(*convert_ruby_to_js(arguments))
         end
       rescue Polyglot::ForeignException => e
@@ -222,8 +243,11 @@ module MiniRacer
 
     def convert_js_to_ruby(value)
       case value
-      when true, false, Integer, Float
+      when true, false, Integer
         value
+      when Float
+        # match the C extension: integral doubles convert to Ruby Integers
+        value.finite? && value == value.truncate ? value.to_i : value
       else
         if value.nil?
           nil
@@ -232,6 +256,10 @@ module MiniRacer
         elsif value.respond_to?(:to_str)
           value.to_str.dup
         elsif value.respond_to?(:to_ary)
+          if uint8_array?(value)
+            return value.to_a.pack('C*')
+          end
+
           value.to_ary.map do |e|
             if e.respond_to?(:call)
               nil
@@ -281,15 +309,19 @@ module MiniRacer
       @is_time_func.call(value)
     end
 
+    def symbol?(value)
+      @is_symbol_func.call(value)
+    end
+
+    def uint8_array?(value)
+      @is_uint8_array_func.call(value)
+    end
+
     def js_date_to_time(value)
       millis = @js_date_to_time_func.call(value)
       Time.at(Rational(millis, 1000))
     end
 
-    def symbol?(value)
-      @is_symbol_func.call(value)
-    end
-
     def js_symbol_to_symbol(value)
       @js_symbol_to_symbol_func.call(value).to_s.to_sym
     end
@@ -359,6 +391,10 @@ module MiniRacer
   class Platform
     def self.set_flag_as_str!(flag)
       raise TypeError, "wrong type argument #{flag.class} (should be a string)" unless flag.is_a?(String)
+      raise ArgumentError, "flag contains NUL byte" if flag.include?("\0")
+      # the C extension normalizes flags into a 256 byte "--flag" buffer
+      normalized = flag.start_with?("--") ? flag : "--#{flag}"
+      raise ArgumentError, "flag too long" if normalized.bytesize >= 256
       raise MiniRacer::PlatformAlreadyInitialized, "The platform is already initialized." if Context.instance_variable_get(:@context_initialized)
       Context.instance_variable_set(:@use_strict, true) if "--use_strict" == flag
     end

data/lib/mini_racer/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module MiniRacer
-  VERSION = "0.21.0"
+  VERSION = "0.21.2"
   LIBV8_NODE_VERSION = "~> 24.12.0.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mini_racer
 version: !ruby/object:Gem::Version
-  version: 0.21.0
+  version: 0.21.2
 platform: ruby
 authors:
 - Sam Saffron
@@ -136,9 +136,9 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/discourse/mini_racer/issues
-  changelog_uri: https://github.com/discourse/mini_racer/blob/v0.21.0/CHANGELOG
-  documentation_uri: https://www.rubydoc.info/gems/mini_racer/0.21.0
-  source_code_uri: https://github.com/discourse/mini_racer/tree/v0.21.0
+  changelog_uri: https://github.com/discourse/mini_racer/blob/v0.21.2/CHANGELOG
+  documentation_uri: https://www.rubydoc.info/gems/mini_racer/0.21.2
+  source_code_uri: https://github.com/discourse/mini_racer/tree/v0.21.2
 rdoc_options: []
 require_paths:
 - lib
@@ -147,7 +147,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="