mini_racer 0.21.3 → 0.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e370b2c6cdb60e5081d5f97840cff28489119f0225a3c9a74ed7f6859caf40e
-  data.tar.gz: 7405ed87278cbaa1d155bc72f8c99d8e8c744df743252eb4128b9ae9ff899d07
+  metadata.gz: 7a20d79f246e2bd3f9aa86cdf19c83413d2b782b7738f0bfc13017227e2c20f7
+  data.tar.gz: b1c6d7b75c8bbc7520f0722ed255d042e70e4e606bb627a59926523135640921
 SHA512:
-  metadata.gz: 3c9f53c6a9052cca6a5129d023ecece59613c40c17f4c7666c728f8f6327200e34d707557ea4dcd9b626aed332b327c6c3e3f90e365c630adbec0b2d02c4b1c1
-  data.tar.gz: 4dc0348a006f7620c4c9688c0b877f2bd9500b7ece37fba4fa6e868006af1517e4279537693fd87b2f18c2b0602067084e2332e2bf9fa862504ebaab4ddbbcfc
+  metadata.gz: 9c828f6078e1d6f48503bf9870cab6ced783e853decf679c0534735d7c3a9a8d6efb3c06ed7528f88f1ea8f90ddf5e2c8d50c73e89d8e7672d5b03ad7b85e3ef
+  data.tar.gz: 62eb803f2a6aea12b7a80cc6385858631a60dadb61c2eb409e1f5ecf79cfa969f3d9350519377c0a169bf0ffd15987c06635da2d3aaa84f3017183d51b5216bb

data/CHANGELOG

@@ -1,3 +1,14 @@
+- 0.22.0 - 12-08-2026
+  - Add `Context#call_await` and `Context#eval_await`: like `call`/`eval` but block until a returned Promise settles and return the settled value; rejections raise `MiniRacer::RuntimeError`
+  - Fix a `call` or `eval` made from a Ruby callback taking the timeout or `stop` meant for the evaluation around it, which then kept running
+  - Fix a timeout that fires just after its own evaluation ends, where it would stop the next evaluation instead
+  - Fix a race introduced in 0.21.4 where a request sent right after a nested dispatch (e.g. `perform_microtask_checkpoint` or a nested `call` from an attached callback) could be dropped, deadlocking the context
+
+- 0.21.4 - 24-06-2026
+  - Fix stale V8 termination state after interrupts/timeouts so contexts remain usable after cancelled evaluations
+  - Let Ruby interrupts wake MiniRacer calls without immediately terminating V8, allowing signal traps and nested callbacks to unwind safely
+  - Add benchmark suite covering eval, serialization/deserialization, and transpilation workloads
+
 - 0.21.3 - 18-06-2026
   - Fix `:single_threaded` contexts inherited across `fork` by recovering idle reusable native runners in the child process without falling back to per-dispatch native thread spawning
   - Avoid intermittent heap corruption during `:single_threaded` context finalization, especially when forked children exit normally after touching inherited contexts

data/README.md

@@ -348,6 +348,40 @@ 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
 
+### Promises: call_await and eval_await
+
+`call_await` and `eval_await` work like `call` and `eval`, but when the result is a
+Promise they block until it settles and return the settled value. A rejected
+promise raises `MiniRacer::RuntimeError`, just like a synchronous `throw`:
+
+```ruby
+context = MiniRacer::Context.new
+context.eval("async function f(x) { await Promise.resolve(); return x * 2 }")
+context.call_await("f", 21)
+# => 42
+
+context.eval_await("(async () => 6 * 7)()")
+# => 42
+
+context.eval("async function boom() { throw new Error('kaboom') }")
+context.call_await("boom")
+# => raises MiniRacer::RuntimeError (Error: kaboom)
+```
+
+Non-Promise results pass through unchanged, so `call_await` is a drop-in
+superset of `call` (same for `eval_await`/`eval`).
+
+A promise that never settles blocks forever, just like an infinite loop. The
+`timeout:` option and `Context#stop` both interrupt it, raising
+`MiniRacer::ScriptTerminatedError`.
+
+Calling `call_await` or `eval_await` recursively on the same context from an
+attached Ruby callback is not supported and raises `MiniRacer::RuntimeError`.
+V8 cannot run the nested microtask checkpoint needed to settle such a call.
+Synchronous nested `call` and `eval` remain supported.
+
+`call_await` and `eval_await` are not currently supported on TruffleRuby.
+
 ### 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":

data/ext/mini_racer_extension/mini_racer_extension.c

@@ -137,6 +137,8 @@ typedef struct Context
     VALUE procs;       // array of js -> ruby callbacks
     VALUE exception;   // pending exception or Qnil
     Buf req, res;      // ruby->v8 request/response, mediated by |mtx| and |cv|
+    Buf v8_req;        // stable v8-side copy of a request returned by v8_roundtrip
+    int res_ready;     // protected by |mtx|; response may be filled before ready
     Buf snapshot;
     pthread_t single_threaded_thr;
     pid_t single_threaded_pid;
@@ -150,7 +152,8 @@ typedef struct Context
     struct {
         pthread_mutex_t mtx;
         pthread_cond_t cv;
-        int cancel;
+        int active; // dispatch thread only
+        int cancel; // protected by |mtx|
     } wd; // watchdog
     Barrier early_init, late_init;
 } Context;
@@ -230,6 +233,8 @@ struct rendezvous_nogvl
     Context *context;
     Buf *req, *res;
     atomic_int active;
+    atomic_int interrupted;
+    int started, finished, has_rr_mtx;
 };
 
 struct rendezvous_des
@@ -768,7 +773,7 @@ static void *v8_watchdog(void *arg)
         if (c->wd.cancel)
             break;
         if (deadline_exceeded(deadline)) {
-            v8_terminate_execution(c->pst);
+            v8_terminate_watchdog(c->pst);
             break;
         }
     }
@@ -782,8 +787,14 @@ static void v8_timedwait(Context *c, const uint8_t *p, size_t n,
     pthread_t thr;
     int r;
 
-    r = -1;
-    if (c->timeout > 0 && (r = pthread_create(&thr, NULL, v8_watchdog, c))) {
+    if (c->timeout <= 0 || c->wd.active) {
+        func(c->pst, p, n);
+        return;
+    }
+    c->wd.active = 1;
+    r = pthread_create(&thr, NULL, v8_watchdog, c);
+    if (r) {
+        c->wd.active = 0;
         fprintf(stderr, "mini_racer: watchdog: pthread_create: %s\n", strerror(r));
         fflush(stderr);
     }
@@ -795,7 +806,9 @@ static void v8_timedwait(Context *c, const uint8_t *p, size_t n,
     pthread_cond_signal(&c->wd.cv);
     pthread_mutex_unlock(&c->wd.mtx);
     pthread_join(thr, NULL);
+    v8_cancel_watchdog_termination(c->pst);
     c->wd.cancel = 0;
+    c->wd.active = 0;
 }
 
 static void dispatch1(Context *c, const uint8_t *p, size_t n)
@@ -806,7 +819,9 @@ static void dispatch1(Context *c, const uint8_t *p, size_t n)
     switch (*p) {
     case 'A': return v8_attach(c->pst, p+1, n-1);
     case 'C': return v8_timedwait(c, p+1, n-1, v8_call);
+    case 'D': return v8_timedwait(c, p+1, n-1, v8_call_await);
     case 'E': return v8_timedwait(c, p+1, n-1, v8_eval);
+    case 'F': return v8_timedwait(c, p+1, n-1, v8_eval_await);
     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);
@@ -822,11 +837,28 @@ static void dispatch1(Context *c, const uint8_t *p, size_t n)
     fflush(stderr);
 }
 
-static void dispatch(Context *c)
+static void dispatch_buf(Context *c, Buf *req)
 {
+    Buf local_req;
+
+    // Called with Context.mtx held. Release it while V8 runs so an rb_nogvl
+    // UBF can wake the Ruby thread to process interrupts with
+    // rb_thread_check_ints(), without forcing termination first. Move the
+    // request out first so cancellation cannot free a buffer V8 is reading.
+    buf_move(req, &local_req);
     buf_reset(&c->res);
-    dispatch1(c, c->req.buf, c->req.len);
-    buf_reset(&c->req);
+    c->res_ready = 0;
+    pthread_mutex_unlock(&c->mtx);
+    dispatch1(c, local_req.buf, local_req.len);
+    pthread_mutex_lock(&c->mtx);
+    buf_reset(&local_req);
+    c->res_ready = 1;
+    pthread_cond_signal(&c->cv);
+}
+
+static void dispatch(Context *c)
+{
+    dispatch_buf(c, &c->req);
 }
 
 // called by v8_isolate_and_context
@@ -859,19 +891,22 @@ void v8_thread_main(Context *c, struct State *pst)
     }
 }
 
-// called by v8_thread_main and from mini_racer_v8.cc,
-// in all cases with Context.mtx held
+// called by v8_thread_main and from mini_racer_v8.cc
 void v8_dispatch(Context *c)
 {
-    dispatch1(c, c->req.buf, c->req.len);
-    buf_reset(&c->req);
+    pthread_mutex_lock(&c->mtx);
+    dispatch_buf(c, &c->v8_req);
+    pthread_mutex_unlock(&c->mtx);
 }
 
-// called from mini_racer_v8.cc with Context.mtx held
-// only called when inside v8_call, v8_eval, or v8_pump_message_loop
+// only called when inside v8_call, v8_eval (and their await variants),
+// or v8_pump_message_loop
 void v8_roundtrip(Context *c, const uint8_t **p, size_t *n)
 {
-    buf_reset(&c->req);
+    pthread_mutex_lock(&c->mtx);
+    buf_reset(&c->v8_req);
+    if (c->res.len)
+        c->res_ready = 1;
     pthread_cond_signal(&c->cv);
     while (!c->req.len && !atomic_load(&c->quit))
         pthread_cond_wait(&c->cv, &c->mtx);
@@ -879,17 +914,22 @@ void v8_roundtrip(Context *c, const uint8_t **p, size_t *n)
         static const uint8_t disposed[] = "edisposed context";
         *p = disposed;
         *n = sizeof(disposed) - 1;
+        pthread_mutex_unlock(&c->mtx);
         return;
     }
     buf_reset(&c->res);
-    *p = c->req.buf;
-    *n = c->req.len;
+    c->res_ready = 0;
+    buf_move(&c->req, &c->v8_req);
+    *p = c->v8_req.buf;
+    *n = c->v8_req.len;
+    pthread_mutex_unlock(&c->mtx);
 }
 
-// called from mini_racer_v8.cc with Context.mtx held
 void v8_reply(Context *c, const uint8_t *p, size_t n)
 {
+    pthread_mutex_lock(&c->mtx);
     buf_put(&c->res, p, n);
+    pthread_mutex_unlock(&c->mtx);
 }
 
 static void v8_once_init(void)
@@ -1059,6 +1099,19 @@ static int single_threaded_runner_start(Context *c)
     return r;
 }
 
+static void rendezvous_release(struct rendezvous_nogvl *a)
+{
+    Context *c;
+
+    atomic_store(&a->active, 0);
+    if (!a->has_rr_mtx)
+        return;
+    c = a->context;
+    c->depth--;
+    a->has_rr_mtx = 0;
+    pthread_mutex_unlock(&c->rr_mtx);
+}
+
 static inline void *rendezvous_nogvl(void *arg)
 {
     struct rendezvous_nogvl *a;
@@ -1067,62 +1120,77 @@ static inline void *rendezvous_nogvl(void *arg)
 
     a = arg;
     c = a->context;
-    if (single_threaded && (r = single_threaded_recover_after_fork(c)))
-        return (void *)(intptr_t)r;
-    pthread_mutex_lock(&c->rr_mtx);
-    atomic_store(&a->active, 1);
-    if (c->depth > 0 && c->depth%50 == 0) { // TODO stop steep recursion
-        fprintf(stderr, "mini_racer: deep js->ruby->js recursion, depth=%d\n", c->depth);
-        fflush(stderr);
+    if (!a->started) {
+        if (single_threaded && (r = single_threaded_recover_after_fork(c)))
+            return (void *)(intptr_t)r;
+        pthread_mutex_lock(&c->rr_mtx);
+        a->has_rr_mtx = 1;
+        if (c->depth > 0 && c->depth%50 == 0) { // TODO stop steep recursion
+            fprintf(stderr, "mini_racer: deep js->ruby->js recursion, depth=%d\n", c->depth);
+            fflush(stderr);
+        }
+        c->depth++;
+        a->started = 1;
     }
-    c->depth++;
+
 next:
+    atomic_store(&a->active, 1);
     pthread_mutex_lock(&c->mtx);
     if (atomic_load(&c->quit)) {
         buf_reset(a->req);
         pthread_mutex_unlock(&c->mtx);
-        c->depth--;
-        atomic_store(&a->active, 0);
-        pthread_mutex_unlock(&c->rr_mtx);
+        a->finished = 1;
+        rendezvous_release(a);
         return (void *)(intptr_t)ECANCELED;
     }
-    assert(c->req.len == 0);
-    assert(c->res.len == 0);
-    buf_move(a->req, &c->req); // v8 thread takes ownership of req
-    if (single_threaded) {
-        r = single_threaded_runner_start(c);
-        if (r) {
-            buf_move(&c->req, a->req);
-            pthread_mutex_unlock(&c->mtx);
-            c->depth--;
-            atomic_store(&a->active, 0);
-            pthread_mutex_unlock(&c->rr_mtx);
-            return (void *)(intptr_t)r;
+    if (a->req->len) {
+        assert(c->req.len == 0);
+        assert(!c->res_ready);
+        buf_move(a->req, &c->req); // v8 thread takes ownership of req
+        if (single_threaded) {
+            r = single_threaded_runner_start(c);
+            if (r) {
+                buf_move(&c->req, a->req);
+                pthread_mutex_unlock(&c->mtx);
+                a->finished = 1;
+                rendezvous_release(a);
+                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);
+    }
+    while (!c->res_ready && !atomic_load(&a->interrupted) && !atomic_load(&c->quit))
+        pthread_cond_wait(&c->cv, &c->mtx);
+    if (!c->res_ready && atomic_load(&a->interrupted)) {
+        atomic_store(&a->active, 0);
+        pthread_mutex_unlock(&c->mtx);
+        return (void *)(intptr_t)EINTR;
+    }
+    if (!c->res_ready && atomic_load(&c->quit)) {
+        buf_reset(a->req);
+        pthread_mutex_unlock(&c->mtx);
+        a->finished = 1;
+        rendezvous_release(a);
+        return (void *)(intptr_t)ECANCELED;
     }
     buf_move(&c->res, a->res);
+    c->res_ready = 0;
     pthread_cond_broadcast(&c->cv);
     pthread_mutex_unlock(&c->mtx);
+    atomic_store(&a->active, 0);
     if (*a->res->buf == 'c') { // js -> ruby callback?
         rb_thread_call_with_gvl(rendezvous_callback, a);
         buf_reset(a->res);
         if (atomic_load(&c->quit)) {
             buf_reset(a->req);
-            c->depth--;
-            atomic_store(&a->active, 0);
-            pthread_mutex_unlock(&c->rr_mtx);
+            a->finished = 1;
+            rendezvous_release(a);
             return (void *)(intptr_t)ECANCELED;
         }
         goto next;
     }
-    c->depth--;
-    atomic_store(&a->active, 0);
-    pthread_mutex_unlock(&c->rr_mtx);
+    a->finished = 1;
+    rendezvous_release(a);
     return NULL;
 }
 
@@ -1134,9 +1202,8 @@ static void rendezvous_ubf(void *arg)
     a = arg;
     if (!atomic_load(&a->active))
         return;
+    atomic_store(&a->interrupted, 1);
     c = a->context;
-    if (c->pst)
-        v8_terminate_execution(c->pst);
     pthread_cond_broadcast(&c->cv);
 }
 
@@ -1150,9 +1217,82 @@ static void terminate_ubf(void *arg)
     pthread_cond_broadcast(&c->cv);
 }
 
+static void *rendezvous_cancel_nogvl(void *arg)
+{
+    // Reply to any pending JS->Ruby callback with an 'e' marker plus message
+    // so V8 throws, unwinds, and reaches its normal termination cleanup.
+    static const uint8_t terminated[] = "eterminated";
+    struct rendezvous_nogvl *a;
+    Context *c;
+
+    a = arg;
+    c = a->context;
+    atomic_store(&a->active, 0);
+    if (c->pst)
+        v8_terminate_execution(c->pst);
+    pthread_mutex_lock(&c->mtx);
+    pthread_cond_broadcast(&c->cv);
+    while (!atomic_load(&c->quit)) {
+        while (!c->res_ready && !atomic_load(&c->quit))
+            pthread_cond_wait(&c->cv, &c->mtx);
+        if (!c->res_ready)
+            break;
+        if (c->res.len && *c->res.buf != 'c')
+            break;
+        buf_reset(&c->res);
+        c->res_ready = 0;
+        buf_reset(&c->req);
+        buf_put(&c->req, terminated, sizeof(terminated) - 1);
+        pthread_cond_signal(&c->cv);
+    }
+    buf_reset(&c->req);
+    buf_reset(&c->res);
+    buf_reset(&c->v8_req);
+    c->res_ready = 0;
+    pthread_cond_broadcast(&c->cv);
+    pthread_mutex_unlock(&c->mtx);
+    if (c->pst)
+        v8_cancel_terminate_execution(c->pst);
+    a->finished = 1;
+    rendezvous_release(a);
+    return NULL;
+}
+
+static VALUE rendezvous_no_des_body(VALUE arg)
+{
+    struct rendezvous_nogvl *a;
+    void *r;
+
+    a = (void *)arg;
+    for (;;) {
+        // Let the UBF wake this wait without deciding why Ruby interrupted it.
+        // Back under the GVL, rb_thread_check_ints() runs signal traps and
+        // raises real asynchronous exceptions (Timeout, Thread#raise, kill).
+        atomic_store(&a->interrupted, 0);
+        atomic_store(&a->active, 1);
+        r = rb_nogvl(rendezvous_nogvl, a, rendezvous_ubf, a, RB_NOGVL_INTR_FAIL);
+        atomic_store(&a->active, 0);
+        if (a->finished || (r && (int)(intptr_t)r != EINTR))
+            return LONG2NUM((long)(intptr_t)r);
+        rb_thread_check_ints();
+    }
+}
+
+static VALUE rendezvous_no_des_ensure(VALUE arg)
+{
+    struct rendezvous_nogvl *a;
+
+    a = (void *)arg;
+    if (a->started && !a->finished)
+        rb_nogvl(rendezvous_cancel_nogvl, a, NULL, NULL, 0);
+    buf_reset(a->req);
+    return Qnil;
+}
+
 static void rendezvous_no_des(Context *c, Buf *req, Buf *res)
 {
     void *r;
+    VALUE rv;
     struct rendezvous_nogvl a;
 
     if (atomic_load(&c->quit)) {
@@ -1163,7 +1303,15 @@ static void rendezvous_no_des(Context *c, Buf *req, Buf *res)
     a.req = req;
     a.res = res;
     atomic_init(&a.active, 0);
-    r = rb_nogvl(rendezvous_nogvl, &a, rendezvous_ubf, &a, 0);
+    atomic_init(&a.interrupted, 0);
+    a.started = 0;
+    a.finished = 0;
+    a.has_rr_mtx = 0;
+    rv = rb_ensure(rendezvous_no_des_body, (VALUE)&a,
+                   rendezvous_no_des_ensure, (VALUE)&a);
+    r = (void *)(intptr_t)NUM2LONG(rv);
+    if ((int)(intptr_t)r == ECANCELED)
+        rb_raise(context_disposed_error, "disposed context");
     if (r)
         rb_raise(runtime_error, "single-threaded runner: %s", strerror((int)(intptr_t)r));
 }
@@ -1283,6 +1431,7 @@ static VALUE context_alloc(VALUE klass)
     buf_init(&c->snapshot);
     buf_init(&c->req);
     buf_init(&c->res);
+    buf_init(&c->v8_req);
     cause = "pthread_condattr_init";
     if ((r = pthread_condattr_init(&cattr)))
         goto fail0;
@@ -1387,6 +1536,7 @@ static void context_abandon(Context *c)
     buf_reset(&c->snapshot);
     buf_reset(&c->req);
     buf_reset(&c->res);
+    buf_reset(&c->v8_req);
     ruby_xfree(c);
 }
 
@@ -1402,6 +1552,7 @@ static void context_destroy(Context *c)
     buf_reset(&c->snapshot);
     buf_reset(&c->req);
     buf_reset(&c->res);
+    buf_reset(&c->v8_req);
     ruby_xfree(c);
 }
 
@@ -1515,7 +1666,7 @@ static VALUE context_stop(VALUE self)
     return Qnil;
 }
 
-static VALUE context_call(int argc, VALUE *argv, VALUE self)
+static VALUE context_call_common(int argc, VALUE *argv, VALUE self, char op)
 {
     VALUE name, args;
     VALUE a, e;
@@ -1526,8 +1677,8 @@ static VALUE context_call(int argc, VALUE *argv, VALUE self)
     rb_scan_args(argc, argv, "1*", &name, &args);
     Check_Type(name, T_STRING);
     rb_ary_unshift(args, name);
-    // request is (C)all, [name, args...] array
-    ser_init1(&s, 'C');
+    // request is (C)all or (D) call_await, [name, args...] array
+    ser_init1(&s, op);
     if (serialize(&s, args)) {
         ser_reset(&s);
         rb_raise(runtime_error, "Context.call: %s", s.err);
@@ -1539,7 +1690,17 @@ static VALUE context_call(int argc, VALUE *argv, VALUE self)
     return rb_ary_pop(a);
 }
 
-static VALUE context_eval(int argc, VALUE *argv, VALUE self)
+static VALUE context_call(int argc, VALUE *argv, VALUE self)
+{
+    return context_call_common(argc, argv, self, 'C');
+}
+
+static VALUE context_call_await(int argc, VALUE *argv, VALUE self)
+{
+    return context_call_common(argc, argv, self, 'D');
+}
+
+static VALUE context_eval_common(int argc, VALUE *argv, VALUE self, char op)
 {
     VALUE a, e, source, filename, kwargs;
     Context *c;
@@ -1554,8 +1715,8 @@ static VALUE context_eval(int argc, VALUE *argv, VALUE self)
     if (NIL_P(filename))
         filename = rb_str_new_cstr("<eval>");
     Check_Type(filename, T_STRING);
-    // request is (E)val, [filename, source] array
-    ser_init1(&s, 'E');
+    // request is (E)val or (F) eval_await, [filename, source] array
+    ser_init1(&s, op);
     ser_array_begin(&s, 2);
     add_string(&s, filename);
     add_string(&s, source);
@@ -1567,6 +1728,16 @@ static VALUE context_eval(int argc, VALUE *argv, VALUE self)
     return rb_ary_pop(a);
 }
 
+static VALUE context_eval(int argc, VALUE *argv, VALUE self)
+{
+    return context_eval_common(argc, argv, self, 'E');
+}
+
+static VALUE context_eval_await(int argc, VALUE *argv, VALUE self)
+{
+    return context_eval_common(argc, argv, self, 'F');
+}
+
 static VALUE context_heap_stats(VALUE self)
 {
     VALUE a, h, k, v;
@@ -2007,7 +2178,9 @@ void Init_mini_racer_extension(void)
     rb_define_method(c, "dispose", context_dispose, 0);
     rb_define_method(c, "stop", context_stop, 0);
     rb_define_method(c, "call", context_call, -1);
+    rb_define_method(c, "call_await", context_call_await, -1);
     rb_define_method(c, "eval", context_eval, -1);
+    rb_define_method(c, "eval_await", context_eval_await, -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);