mini_racer 0.21.2 → 0.21.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70ca9828687a7fcdb44048eb1a3e9ad2fe3f38082492504fc22563fe94fa524a
-  data.tar.gz: 61719146ed1430235269e80a21a60ef59b98f22f470cda13820074f9cecea818
+  metadata.gz: f2e290a77bd6b38286dc4e4224d71579a1e8e41bbb8fd70029584f518383ba7f
+  data.tar.gz: 479d9793ade9c46075986dd53c0a7ebacf62e1afb199fc6983e5b7c4fb4e0faa
 SHA512:
-  metadata.gz: 944e4a0e403b134e0206c6d6381efa3d9f120af9cfce18f61fc85c3eef5e6a077c64a457142d347041059a6b76f24990dbd15c17691bbcb3306ff1ea877983a4
-  data.tar.gz: f3003a61146634c76ad28ab99be4d6e96b34490522edb13607b03fcf9354fce135844947af3d23f9d37cc012a26ba4c280c8d4b19d410d47bcebc753cdc6c34f
+  metadata.gz: dc69216098ec6076dc90cf731fc5fd229526a4c21d3383fdb94448aace72068f36fc6bf6910cb09d8f42bf57c6926bf1527a2fd0871c11c5b08df820643cc23e
+  data.tar.gz: b7b4b851b4cbc9ad35c56e39db1d5c7ccc19b23dabd9dd87f084ba37f0a59fb584c833128827d58ecdb0c99f75969383333d3b304d00f816ba544e83e5436639

data/CHANGELOG

@@ -1,3 +1,15 @@
+- 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
+  - Avoid finalizer hangs when a forked child garbage-collects a non-idle inherited `:single_threaded` context
+  - Allow Ruby thread interrupts, process shutdown, and cross-thread `Context#dispose` to terminate busy `:single_threaded` JavaScript execution instead of hanging
+  - Make `Context#dispose` while an attached Ruby callback is active either terminate safely or raise instead of deadlocking
+
 - 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

data/ext/mini_racer_extension/mini_racer_extension.c

@@ -5,6 +5,7 @@
 #include <string.h>
 #include <pthread.h>
 #include <unistd.h>
+#include <errno.h>
 #include <math.h>
 
 #if defined(__linux__) && !defined(__GLIBC__)
@@ -136,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;
@@ -159,6 +162,7 @@ typedef struct Snapshot {
 } Snapshot;
 
 static void context_destroy(Context *c);
+static void context_abandon(Context *c);
 static void context_free(void *arg);
 static void context_mark(void *arg);
 static size_t context_size(const void *arg);
@@ -227,6 +231,9 @@ struct rendezvous_nogvl
 {
     Context *context;
     Buf *req, *res;
+    atomic_int active;
+    atomic_int interrupted;
+    int started, finished, has_rr_mtx;
 };
 
 struct rendezvous_des
@@ -819,11 +826,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
@@ -856,31 +880,45 @@ 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
 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);
-    while (!c->req.len)
+    while (!c->req.len && !atomic_load(&c->quit))
         pthread_cond_wait(&c->cv, &c->mtx);
+    if (!c->req.len && atomic_load(&c->quit)) {
+        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)
@@ -1007,6 +1045,33 @@ static void *single_threaded_runner(void *arg)
     return NULL;
 }
 
+static int single_threaded_recover_after_fork(Context *c)
+{
+    pthread_condattr_t cattr;
+    pid_t pid;
+    int r;
+
+    pid = getpid();
+    if (!c->single_threaded_thr_started || c->single_threaded_pid == pid)
+        return 0;
+    if (c->depth || c->req.len || c->res.len)
+        return EBUSY;
+
+    if ((r = pthread_condattr_init(&cattr)))
+        return r;
+#ifndef __APPLE__
+    pthread_condattr_setclock(&cattr, CLOCK_MONOTONIC);
+#endif
+    r = pthread_cond_init(&c->cv, &cattr);
+    pthread_condattr_destroy(&cattr);
+    if (r)
+        return r;
+
+    c->single_threaded_thr_started = 0;
+    c->single_threaded_pid = pid;
+    return 0;
+}
+
 static int single_threaded_runner_start(Context *c)
 {
     pid_t pid;
@@ -1023,6 +1088,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;
@@ -1031,56 +1109,200 @@ static inline void *rendezvous_nogvl(void *arg)
 
     a = arg;
     c = a->context;
-    pthread_mutex_lock(&c->rr_mtx);
-    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);
-    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--;
-            pthread_mutex_unlock(&c->rr_mtx);
-            return (void *)(intptr_t)r;
+    if (atomic_load(&c->quit)) {
+        buf_reset(a->req);
+        pthread_mutex_unlock(&c->mtx);
+        a->finished = 1;
+        rendezvous_release(a);
+        return (void *)(intptr_t)ECANCELED;
+    }
+    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);
+            a->finished = 1;
+            rendezvous_release(a);
+            return (void *)(intptr_t)ECANCELED;
+        }
         goto next;
     }
-    c->depth--;
-    pthread_mutex_unlock(&c->rr_mtx);
+    a->finished = 1;
+    rendezvous_release(a);
+    return NULL;
+}
+
+static void rendezvous_ubf(void *arg)
+{
+    struct rendezvous_nogvl *a;
+    Context *c;
+
+    a = arg;
+    if (!atomic_load(&a->active))
+        return;
+    atomic_store(&a->interrupted, 1);
+    c = a->context;
+    pthread_cond_broadcast(&c->cv);
+}
+
+static void terminate_ubf(void *arg)
+{
+    Context *c;
+
+    c = arg;
+    if (c->pst)
+        v8_terminate_execution(c->pst);
+    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)) {
         buf_reset(req);
         rb_raise(context_disposed_error, "disposed context");
     }
-    r = rb_nogvl(rendezvous_nogvl, &(struct rendezvous_nogvl){c, req, res},
-                 NULL, NULL, 0);
+    a.context = c;
+    a.req = req;
+    a.res = res;
+    atomic_init(&a.active, 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, "pthread_create: %s", strerror((int)(intptr_t)r));
+        rb_raise(runtime_error, "single-threaded runner: %s", strerror((int)(intptr_t)r));
 }
 
 // send request to & receive reply from v8 thread; takes ownership of |req|
@@ -1096,7 +1318,8 @@ static VALUE rendezvous1(Context *c, Buf *req, DesCtx *d)
     c->exception = Qnil;
     // if js land didn't handle exception from ruby callback, re-raise it now
     if (res.len == 1 && *res.buf == 'e') {
-        assert(!NIL_P(r));
+        if (NIL_P(r))
+            rb_raise(context_disposed_error, "disposed context");
         rb_exc_raise(r);
     }
     r = rb_protect(deserialize, (VALUE)&(struct rendezvous_des){d, &res}, &exc);
@@ -1197,6 +1420,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;
@@ -1251,11 +1475,19 @@ fail0:
     return Qnil; // pacify compiler
 }
 
-static void *context_free_thread_do(void *arg)
+static void *context_free_do(void *arg)
 {
     Context *c;
 
     c = arg;
+    if (single_threaded && single_threaded_recover_after_fork(c)) {
+        // The child forked while this inherited context was not idle. There is
+        // no live runner thread to join and the inherited V8/pthread state is
+        // not safe to tear down. A finalizer must not hang here; let the OS
+        // reclaim the abandoned V8 state when the child exits.
+        context_abandon(c);
+        return NULL;
+    }
     if (single_threaded && c->single_threaded_thr_started && c->single_threaded_pid == getpid()) {
         pthread_mutex_lock(&c->mtx);
         atomic_store(&c->quit, 2);
@@ -1270,31 +1502,16 @@ static void *context_free_thread_do(void *arg)
     return NULL;
 }
 
-static void context_free_thread(Context *c)
-{
-    pthread_t thr;
-    int r;
-
-    // dispose on another thread so we don't block when trying to
-    // enter an isolate that's in a stuck state; that *should* be
-    // impossible but apparently it happened regularly before the
-    // rewrite and I'm carrying it over out of an abundance of caution
-    if ((r = pthread_create(&thr, NULL, context_free_thread_do, c))) {
-        fprintf(stderr, "mini_racer: pthread_create: %s", strerror(r));
-        fflush(stderr);
-        context_free_thread_do(c);
-    } else {
-        pthread_detach(thr);
-    }
-}
-
 static void context_free(void *arg)
 {
     Context *c;
 
     c = arg;
     if (single_threaded) {
-        context_free_thread(c);
+        // Free synchronously. A detached cleanup thread can race normal Ruby
+        // process shutdown and trip glibc malloc corruption checks while V8 is
+        // tearing down single-threaded contexts.
+        context_free_do(c);
     } else {
         pthread_mutex_lock(&c->mtx);
         c->quit = 2; // 2 = v8 thread frees
@@ -1303,6 +1520,15 @@ static void context_free(void *arg)
     }
 }
 
+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);
+}
+
 static void context_destroy(Context *c)
 {
     pthread_mutex_unlock(&c->mtx);
@@ -1315,6 +1541,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);
 }
 
@@ -1360,8 +1587,25 @@ static VALUE context_attach(VALUE self, VALUE name, VALUE proc)
 static void *context_dispose_do(void *arg)
 {
     Context *c;
+    int r;
 
     c = arg;
+    if (single_threaded) {
+        if ((r = single_threaded_recover_after_fork(c)))
+            return (void *)(intptr_t)r;
+    }
+    if (c->depth > 0) {
+        r = pthread_mutex_trylock(&c->rr_mtx);
+        if (!r) {
+            pthread_mutex_unlock(&c->rr_mtx);
+            return (void *)(intptr_t)EBUSY;
+        }
+        if (r != EBUSY)
+            return (void *)(intptr_t)r;
+        if (c->pst)
+            v8_terminate_execution(c->pst);
+        pthread_cond_broadcast(&c->cv);
+    }
     if (single_threaded) {
         pthread_mutex_lock(&c->mtx);
         while (c->req.len || c->res.len)
@@ -1389,9 +1633,12 @@ static void *context_dispose_do(void *arg)
 static VALUE context_dispose(VALUE self)
 {
     Context *c;
+    void *r;
 
     TypedData_Get_Struct(self, Context, &context_type, c);
-    rb_thread_call_without_gvl(context_dispose_do, c, NULL, NULL);
+    r = rb_thread_call_without_gvl(context_dispose_do, c, terminate_ubf, c);
+    if (r)
+        rb_raise(runtime_error, "context dispose: %s", strerror((int)(intptr_t)r));
     return Qnil;
 }
 

data/ext/mini_racer_extension/mini_racer_v8.cc

@@ -1014,6 +1014,14 @@ extern "C" void v8_terminate_execution(State *pst)
     pst->isolate->TerminateExecution();
 }
 
+// called from ruby thread
+extern "C" void v8_cancel_terminate_execution(State *pst)
+{
+    // TerminateExecution can race with V8 completing and queue a termination
+    // for the next entry without IsExecutionTerminating() becoming true.
+    pst->isolate->CancelTerminateExecution();
+}
+
 extern "C" void v8_single_threaded_enter(State *pst, Context *c, void (*f)(Context *c))
 {
     State& st = *pst;

data/ext/mini_racer_extension/mini_racer_v8.h

@@ -48,6 +48,7 @@ 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);
 void v8_low_memory_notification(struct State *pst);
 void v8_terminate_execution(struct State *pst); // called from ruby or watchdog thread
+void v8_cancel_terminate_execution(struct State *pst); // called from ruby thread
 void v8_single_threaded_enter(struct State *pst, struct Context *c, void (*f)(struct Context *c));
 void v8_single_threaded_dispose(struct State *pst);
 

data/lib/mini_racer/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module MiniRacer
-  VERSION = "0.21.2"
+  VERSION = "0.21.4"
   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.2
+  version: 0.21.4
 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.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
+  changelog_uri: https://github.com/discourse/mini_racer/blob/v0.21.4/CHANGELOG
+  documentation_uri: https://www.rubydoc.info/gems/mini_racer/0.21.4
+  source_code_uri: https://github.com/discourse/mini_racer/tree/v0.21.4
 rdoc_options: []
 require_paths:
 - lib