mini_racer 0.21.4 → 0.22.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2e290a77bd6b38286dc4e4224d71579a1e8e41bbb8fd70029584f518383ba7f
-  data.tar.gz: 479d9793ade9c46075986dd53c0a7ebacf62e1afb199fc6983e5b7c4fb4e0faa
+  metadata.gz: 522742f60d9062d656ffab6c1eb7ead5ceb0eabb6918b9582e9eec32f1f8a4c8
+  data.tar.gz: 404097b19b0e243bcd995e54f2560dd8fa5097dcc94a9488b435242350bc6719
 SHA512:
-  metadata.gz: dc69216098ec6076dc90cf731fc5fd229526a4c21d3383fdb94448aace72068f36fc6bf6910cb09d8f42bf57c6926bf1527a2fd0871c11c5b08df820643cc23e
-  data.tar.gz: b7b4b851b4cbc9ad35c56e39db1d5c7ccc19b23dabd9dd87f084ba37f0a59fb584c833128827d58ecdb0c99f75969383333d3b304d00f816ba544e83e5436639
+  metadata.gz: 723b3777cf8085b76662a3f4ede9fcdd8d4d8b31c31346ed0a87af1092b6a0323579b4dd6c3ec45a3c06f6cecedda7a30b8e807e69ecceaf5c3bf2ab9ceabc07
+  data.tar.gz: 36e1ce3f381f3d4017c10d811805320af94fd026a81eca8bdc71e6fa0cecd58a23f4668883de3cf8810ce57e41e33e9e4560810d4621b9825104a22dd2076e6b

data/CHANGELOG

@@ -1,3 +1,14 @@
+- 0.22.1 - 27-08-2026
+  - Fix building with Clang 22+ and big-endian bigint serialization by making bigint serialization byte-oriented instead of relying on native `uint64_t`/`unsigned long` representations
+  - Fix Ruby integers at or above 512 bits being silently truncated when passed to JavaScript, and large JavaScript bigints producing an invalid internal value when returned to Ruby
+  - Support Ruby and JavaScript bigints up to a 16 MiB magnitude, using allocation-free conversion for common sizes and bounded dynamic storage for larger values
+
+- 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

data/README.md

@@ -60,6 +60,10 @@ puts context.eval("array_and_hash()")
 # => {"a" => 1, "b" => [1, {"a" => 1}]}
 ```
 
+Ruby `Integer` and JavaScript `BigInt` values are converted exactly up to a
+16 MiB magnitude (about 134 million bits). Larger individual values are
+rejected with a serialization error rather than truncated.
+
 ### Return binary data from Ruby to JavaScript
 
 Attached Ruby functions can return binary data as `Uint8Array` using `MiniRacer::Binary`:
@@ -348,6 +352,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":
@@ -484,6 +522,25 @@ gcc >= 12.2 and Xcode >= 13 are, at the time of writing, known to work.
 * Concurrent cause .... JRuby
 * Supports execjs
 
+## Community
+
+Libraries and integrations built with MiniRacer:
+
+- [Humid](https://github.com/thoughtbot/humid) — JavaScript server-side rendering helpers for Rails.
+- [ExecJS](https://github.com/rails/execjs) — A common interface for executing JavaScript from Ruby, with a MiniRacer runtime.
+- [Opal](https://github.com/opal/opal) — A Ruby-to-JavaScript compiler with a MiniRacer CLI runner.
+- [Handlebars::Engine](https://github.com/gi/handlebars-ruby) — A complete Ruby interface to Handlebars.js.
+- [Minibars](https://github.com/combinaut/minibars) — A lightweight Handlebars.rb replacement built on MiniRacer.
+- [Rtlcss](https://github.com/discourse/rtlcss) — Runs rtlcss from Ruby to convert stylesheets between LTR and RTL.
+- [MessageFormat](https://github.com/discourse/messageformat) — Compiles MessageFormat messages from Ruby using `@messageformat/core`.
+- [feelin](https://github.com/ekzo-dev/ruby-feelin) — Evaluates DMN FEEL expressions from Ruby.
+- [parse-css](https://github.com/camertron/parse-css) — Parses CSS, including nested CSS, through the JavaScript parse-css library.
+
+### Notable users
+
+- [Discourse](https://github.com/discourse/discourse) — A large Rails application using MiniRacer for JavaScript compilation, processing, and sandboxed evaluation.
+- [rack-mini-profiler](https://github.com/MiniProfiler/rack-mini-profiler) — Uses MiniRacer in its JavaScript build tooling.
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/rubyjs/mini_racer. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

data/ext/mini_racer_extension/mini_racer_extension.c

@@ -62,6 +62,8 @@ static inline void rb_thread_lock_native_thread(void)
 
 #define countof(x)  (sizeof(x) / sizeof(*(x)))
 #define endof(x)    ((x) + countof(x))
+#define BIGINT_STACK_WORDS 64
+#define BIGINT_MAX_BYTES (16 * 1024 * 1024)
 
 // mostly RO: assigned once by platform_set_flag1 while holding |flags_mtx|,
 // from then on read-only and accessible without holding locks
@@ -152,7 +154,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;
@@ -352,33 +355,32 @@ static void des_date(void *arg, double v)
     put(arg, rb_time_new(sec, usec));
 }
 
-// note: v8 stores bigints in 1's complement, ruby in 2's complement,
-// so we have to take additional steps to ensure correct conversion
+// note: v8 stores bigints as a sign plus little-endian 64-bit magnitude words
 static void des_bigint(void *arg, const void *p, size_t n, int sign)
 {
     VALUE v;
-    size_t i;
     DesCtx *c;
-    unsigned long *a, t, limbs[65]; // +1 to suppress sign extension
+    int flags;
 
     c = arg;
     if (*c->err)
         return;
-    if (n > sizeof(limbs) - sizeof(*limbs)) {
+    if (n % sizeof(uint64_t)) {
+        snprintf(c->err, sizeof(c->err), "bad bigint");
+        return;
+    }
+    if (n > BIGINT_MAX_BYTES) {
         snprintf(c->err, sizeof(c->err), "bigint too big");
         return;
     }
-    a = limbs;
-    t = 0;
-    for (i = 0; i < n; a++, i += sizeof(*a)) {
-        memcpy(a, (char *)p + i, sizeof(*a));
-        t = *a;
+    if (n == 0) {
+        v = INT2FIX(0);
+    } else {
+        flags = INTEGER_PACK_LITTLE_ENDIAN;
+        if (sign < 0)
+            flags |= INTEGER_PACK_NEGATIVE;
+        v = rb_integer_unpack(p, n/sizeof(uint64_t), sizeof(uint64_t), 0, flags);
     }
-    if (t >> 63)
-        *a++ = 0; // suppress sign extension
-    v = rb_big_unpack(limbs, a-limbs);
-    if (sign < 0)
-        v = rb_funcall(v, rb_intern("-@"), 0);
     put(c, v);
 }
 
@@ -579,12 +581,42 @@ static void add_string(Ser *s, VALUE v)
     return ser_string(s, p, n);
 }
 
+// Keep small values allocation-free while allowing large values up to a
+// deliberate per-value limit that bounds temporary conversion storage.
+static int serialize_bigint(Ser *s, VALUE v)
+{
+    uint64_t stack_words[BIGINT_STACK_WORDS];
+    uint64_t *words;
+    size_t nwords, nbytes;
+    int packed;
+
+    nwords = rb_absint_numwords(v, 64, NULL);
+    if (nwords == (size_t)-1 || nwords > BIGINT_MAX_BYTES/sizeof(*words))
+        return bail(&s->err, "bigint too big");
+    nbytes = nwords * sizeof(*words);
+    words = stack_words;
+    if (nwords > countof(stack_words)) {
+        words = malloc(nbytes);
+        if (!words)
+            return bail(&s->err, "out of memory");
+    }
+    packed = rb_integer_pack(v, words, nwords, sizeof(*words), 0,
+                             INTEGER_PACK_LITTLE_ENDIAN);
+    if (packed < -1 || packed > 1) {
+        if (words != stack_words)
+            free(words);
+        return bail(&s->err, "bigint too big");
+    }
+    ser_bigint(s, words, nbytes, packed < 0 ? -1 : 1);
+    if (words != stack_words)
+        free(words);
+    return *s->err ? -1 : 0;
+}
+
 static int serialize1(Ser *s, VALUE refs, VALUE v)
 {
-    unsigned long limbs[64];
     VALUE a, t, id;
     size_t i, n;
-    int sign;
 
     if (*s->err)
         return -1;
@@ -669,15 +701,7 @@ static int serialize1(Ser *s, VALUE refs, VALUE v)
         ser_bool(s, 0);
         break;
     case T_BIGNUM:
-        // note: v8 stores bigints in 1's complement, ruby in 2's complement,
-        // so we have to take additional steps to ensure correct conversion
-        memset(limbs, 0, sizeof(limbs));
-        sign = rb_big_sign(v) ? 1 : -1;
-        if (sign < 0)
-            v = rb_big_mul(v, LONG2FIX(-1));
-        rb_big_pack(v, limbs, countof(limbs));
-        ser_bigint(s, limbs, countof(limbs), sign);
-        break;
+        return serialize_bigint(s, v);
     case T_FIXNUM:
         ser_int(s, FIX2LONG(v));
         break;
@@ -772,7 +796,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;
         }
     }
@@ -786,8 +810,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);
     }
@@ -799,7 +829,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)
@@ -810,7 +842,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);
@@ -888,12 +922,12 @@ void v8_dispatch(Context *c)
     pthread_mutex_unlock(&c->mtx);
 }
 
-// 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)
 {
     pthread_mutex_lock(&c->mtx);
     buf_reset(&c->v8_req);
-    buf_reset(&c->req);
     if (c->res.len)
         c->res_ready = 1;
     pthread_cond_signal(&c->cv);
@@ -947,6 +981,8 @@ static VALUE deserialize1(DesCtx *d, const uint8_t *p, size_t n)
 
     if (des(&err, p, n, d))
         rb_raise(runtime_error, "%s", err);
+    if (*d->err)
+        rb_raise(runtime_error, "%s", d->err);
     if (d->tos != d->stack) // should not happen
         rb_raise(runtime_error, "parse stack not empty");
     return d->tos->a;
@@ -1009,7 +1045,7 @@ static void *rendezvous_callback(void *arg)
         goto fail;
     }
     ser_init1(&s, 'c'); // callback reply
-    if (serialize(&s, r)) { // should not happen
+    if (serialize(&s, r)) {
         c->exception = rb_exc_new_cstr(internal_error, s.err);
         ser_reset(&s);
         goto fail;
@@ -1655,7 +1691,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;
@@ -1666,8 +1702,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);
@@ -1679,7 +1715,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;
@@ -1694,8 +1740,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);
@@ -1707,6 +1753,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;
@@ -2147,7 +2203,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);