mini_racer_rs 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ed46336604ed832bdf22770d4c57d3ce98757187a901b1a762d8732bb4a8007
-  data.tar.gz: 8e7bd77bf38d9ac5e59663e26f7e56fb9dc8642ad5cd1bd2d85e014d015f5b3a
+  metadata.gz: 1cd380b3e8e2ba2c09a4e389bac31dfe9b6c1557660df3d9cadfd32f48e42648
+  data.tar.gz: 1bd9456a98bfce434951619a3e5eaf47dc39fd9b7825f8476e02656f8e5d4a5a
 SHA512:
-  metadata.gz: ad1576874e3a13acdcf373ebb7dfaa22254f1a3320c7774241c9ad830c033c12ad514c86164a24ff0a63ca495bc6f1bb57104fafd58b923929d76c8fae0a1725
-  data.tar.gz: c3b8ebccb0dc686242ee8b257712b11c81d4986e92b25470f33e8fb8505e34dd9fbc60e98869dde424b060e147474cefa7a210bc6a8496ffd66b9590a5a05c18
+  metadata.gz: 7975cc80b2c3d1be558d518da06144c5f06783ff71fe82fd032964bf97012e844e113c26a4237fb0d3810e91089eab544c91ccc64f4f1400ec30a4d205644877
+  data.tar.gz: 36361b28bc1d112ed6074c9a5026e4b1e70926ba8eec19e533f9b052d8ae9f4b8fce1f235df2c8ae04ca220a91a65dbacf9f1351f00714739dcec5286140624a

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [1.1.1](https://github.com/andymai/mini_racer_rs/compare/v1.1.0...v1.1.1) (2026-10-21)
+
+
+### Performance
+
+* **ext:** park at once for contexts whose answers outlast the spin budget ([#105](https://github.com/andymai/mini_racer_rs/issues/105)) ([66af89b](https://github.com/andymai/mini_racer_rs/commit/66af89b8d22ebe0c4dd28c877155131e3d7e5738))
+* **wire:** add criterion benches for decoding, writing and transcoding ([#106](https://github.com/andymai/mini_racer_rs/issues/106)) ([42fc2b5](https://github.com/andymai/mini_racer_rs/commit/42fc2b50dba2a4a6437456293fbe61aa5d29aef8))
+
 ## [1.1.0](https://github.com/andymai/mini_racer_rs/compare/v1.0.6...v1.1.0) (2026-10-19)
 
 

data/Cargo.lock

@@ -17,6 +17,27 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "alloca"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5a7d05ea6aea7e9e64d25b9156ba2fee3fdd659e34e41063cd2fc7cd020d7f4"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "anes"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
+
+[[package]]
+name = "anstyle"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
+
 [[package]]
 name = "autocfg"
 version = "1.5.1"
@@ -59,6 +80,12 @@ dependencies = [
  "displaydoc",
 ]
 
+[[package]]
+name = "cast"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
+
 [[package]]
 name = "cc"
 version = "1.8.0"
@@ -95,6 +122,33 @@ dependencies = [
  "rand_core",
 ]
 
+[[package]]
+name = "ciborium"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e"
+dependencies = [
+ "ciborium-io",
+ "ciborium-ll",
+ "serde",
+]
+
+[[package]]
+name = "ciborium-io"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757"
+
+[[package]]
+name = "ciborium-ll"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
+dependencies = [
+ "ciborium-io",
+ "half",
+]
+
 [[package]]
 name = "clang-sys"
 version = "1.9.1"
@@ -106,6 +160,31 @@ dependencies = [
  "libloading",
 ]
 
+[[package]]
+name = "clap"
+version = "4.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa8876b300ab35ba921adea3dfd70157a46249b33f95c9084ae5709785478946"
+dependencies = [
+ "clap_builder",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0797fb7aeb1406c84efac526901f7ec3ead2124f946b494e72879d4b54704d"
+dependencies = [
+ "anstyle",
+ "clap_lex",
+]
+
+[[package]]
+name = "clap_lex"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c133bc6a41be0d194c306b5506d15e6feeea7b1d6604bd3f8310dfb2ca96486"
+
 [[package]]
 name = "core_detect"
 version = "1.0.0"
@@ -139,6 +218,45 @@ dependencies = [
  "cfg-if",
 ]
 
+[[package]]
+name = "criterion"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "950046b2aa2492f9a536f5f4f9a3de7b9e2476e575e05bd6c333371add4d98f3"
+dependencies = [
+ "alloca",
+ "anes",
+ "cast",
+ "ciborium",
+ "clap",
+ "criterion-plot",
+ "itertools",
+ "num-traits",
+ "oorandom",
+ "page_size",
+ "regex",
+ "serde",
+ "serde_json",
+ "tinytemplate",
+ "walkdir",
+]
+
+[[package]]
+name = "criterion-plot"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8d80a2f4f5b554395e47b5d8305bc3d27813bacb73493eb1001e8f76dae29ea"
+dependencies = [
+ "cast",
+ "itertools",
+]
+
+[[package]]
+name = "crunchy"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
+
 [[package]]
 name = "deno_core_icudata"
 version = "0.78.0"
@@ -262,6 +380,17 @@ dependencies = [
  "crc32fast",
 ]
 
+[[package]]
+name = "half"
+version = "2.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
+dependencies = [
+ "cfg-if",
+ "crunchy",
+ "zerocopy",
+]
+
 [[package]]
 name = "home"
 version = "0.5.12"
@@ -464,7 +593,7 @@ checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
 
 [[package]]
 name = "mini_racer_engine"
-version = "1.1.0"
+version = "1.1.1"
 dependencies = [
  "deno_core_icudata",
  "libc",
@@ -477,7 +606,7 @@ dependencies = [
 
 [[package]]
 name = "mini_racer_rs"
-version = "1.1.0"
+version = "1.1.1"
 dependencies = [
  "magnus",
  "mini_racer_engine",
@@ -488,7 +617,7 @@ dependencies = [
 
 [[package]]
 name = "mini_racer_sourcemap"
-version = "1.1.0"
+version = "1.1.1"
 dependencies = [
  "memchr",
  "serde",
@@ -498,7 +627,7 @@ dependencies = [
 
 [[package]]
 name = "mini_racer_sync"
-version = "1.1.0"
+version = "1.1.1"
 dependencies = [
  "loom",
  "thiserror",
@@ -506,8 +635,9 @@ dependencies = [
 
 [[package]]
 name = "mini_racer_wire"
-version = "1.1.0"
+version = "1.1.1"
 dependencies = [
+ "criterion",
  "proptest",
  "thiserror",
 ]
@@ -561,6 +691,22 @@ version = "1.21.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
+[[package]]
+name = "oorandom"
+version = "11.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
+
+[[package]]
+name = "page_size"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30d5b2194ed13191c1999ae0704b7839fb18384fa22e49b57eeaa97d79ce40da"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
 [[package]]
 name = "paste"
 version = "1.0.15"
@@ -753,6 +899,15 @@ version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
 
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
 [[package]]
 name = "scoped-tls"
 version = "1.0.1"
@@ -975,6 +1130,16 @@ dependencies = [
  "zerovec",
 ]
 
+[[package]]
+name = "tinytemplate"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
 [[package]]
 name = "tracing"
 version = "0.1.44"
@@ -1059,6 +1224,16 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
 
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
 [[package]]
 name = "which"
 version = "6.0.3"
@@ -1087,6 +1262,15 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
+[[package]]
+name = "winapi-util"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "winapi-x86_64-pc-windows-gnu"
 version = "0.4.0"
@@ -1225,6 +1409,26 @@ dependencies = [
  "synstructure",
 ]
 
+[[package]]
+name = "zerocopy"
+version = "0.8.63"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5fe1f8f1b06191a00962174c61aa5005e0bb391a6d80d07e24d115c01a92ed8"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.63"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "863ad3ac83293fb4d740aedbfdc9240dd8d1a50c1099acd76ce80ce7c7230c7f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "zerofrom"
 version = "0.1.8"

data/Cargo.toml

@@ -15,9 +15,10 @@ license = "MIT"
 publish = false
 repository = "https://github.com/andymai/mini_racer_rs"
 rust-version = "1.91"
-version = "1.1.0"
+version = "1.1.1"
 
 [workspace.dependencies]
+criterion = {version = "0.8", default-features = false, features = ["cargo_bench_support"]}
 deno_core_icudata = "=0.78.0"
 libc = "0.2"
 loom = "0.7.2"

data/README.md

@@ -15,42 +15,42 @@ A drop-in replacement for mini_racer, implemented in Rust on V8 15.2.
 
 </div>
 
-mini_racer_rs implements the `MiniRacer` Ruby API from mini_racer 0.22.1, with faster Ruby and JavaScript round trips, V8 15.2, prebuilt native gems, fiber scheduler support, and safer handling of difficult values. It defines the `MiniRacer` namespace and ships `lib/mini_racer.rb`, so `require "mini_racer"` and ExecJS continue to work.
+mini_racer_rs implements the `MiniRacer` API from mini_racer 0.22.1. It defines `MiniRacer` and ships `lib/mini_racer.rb`, so `require "mini_racer"` and ExecJS keep working.
 
 > mini_racer_rs is an independent project and is not affiliated with the Discourse staff who maintain mini_racer.
 
 ## Highlights
 
-- **JavaScript round trips are 5 to 9 times faster.** An eval takes 1.09 µs against 6.91 µs, a call takes 0.72 µs against 6.51 µs, and a callback takes 1.12 µs against 6.12 µs. A call on a context with `timeout:` takes 0.76 µs instead of 20.48 µs because one watchdog serves the process.
-- **A Babel transform through ExecJS is 1.95x faster.** It takes 5.15 ms instead of 10.05 ms. Babel itself takes 5.3 ms inside V8 15.2, against 10.3 ms inside V8 13.6, while Terser and React rendering take about the same time in both gems.
-- **A 44 MB production server rendering bundle loads 4.6x faster.** It loads into a new context in 215 ms against 983 ms, measured at commit `2513a48`, and scripts of 1 MB or more compile from a process-wide V8 code cache. At commit `220bfe7`, the 8.2 MB MUI bundle loads and renders once in 105 ms against 167 ms, while startup plus Babel takes 13.3 ms against 44.4 ms.
-- **A context holding the MUI bundle uses 44 MB instead of 110 MB.** At commit `220bfe7`, a context holding Babel uses 15.2 MB against 28.5 MB, and contexts loading the same large script read one shared copy of its source. A context holding the 44 MB production bundle used 136 MB against 301 MB at commit `2513a48`, before sources were shared. When 20,000 contexts are left to Ruby's garbage collector, resident memory peaks at 102 MB against 2,920 MB.
-- **Forks pause worker work, and children use their own threads.** For forks made through Ruby's `fork`, `IO.popen("-")`, or `Process.daemon`, mini_racer_rs waits for context runners, pauses its worker pool, and waits for running tasks; an async `WebAssembly.compile` in a new default-mode child completes on the child's own pool. On Ubuntu 24.04 with glibc 2.39, 20 of 20 mini_racer children aborted with signal 6 after loading and rendering React, while 20 of 20 mini_racer_rs children exited cleanly. On Fedora, mini_racer children hung within the first 50 forks of `test/stress/fork_busy.rb`, while mini_racer_rs completed 300 forks per run on Fedora and Ubuntu.
-- **V8 15.2.124.1.** mini_racer 0.22.1 uses V8 13.6.233.17.
-- **No compiler at release install.** Native gems cover glibc Linux on x86_64 and aarch64, plus macOS on arm64 and x86_64. Each carries extensions for Ruby 3.3, 3.4, and 4.0. mini_racer 0.22.1 ships as source and compiles C++ against libv8-node.
-- **Fiber scheduler support.** A fiber waiting on JavaScript lets other fibers on its thread run. Three 100 ms busy loops in separate contexts and fibers finish in 100 ms, against 300 ms when mini_racer blocks the thread.
-- **171 of 174 upstream tests pass.** The mini_racer suite runs unmodified, with its other 3 tests skipped by mini_racer itself. ExecJS passes 197 of 198 tests on its MiniRacer runtime, with 1 skipped.
-- **Difficult values return safely.** A `Map` with a function key returns an error Hash instead of aborting the process with SIGABRT. `Object(1n)` returns `1`, and an offset typed array returns its buffer as a binary String.
-- **Four checked layers.** A script enforces crate boundaries, `unsafe` is confined to four fenced modules, loom model-checks the thread handoff, fuzzing covers the wire codec, sanitizers run nightly, and results are differentially tested against mini_racer. The release pipeline runs the full suites for every released extension.
+- **Round trips:** 5 to 9 times faster (0.72 µs vs 6.51 µs per call).
+- **Babel through ExecJS:** 1.95x faster (5.15 ms vs 10.05 ms).
+- **Bundle load:** 4.6x faster for a 44 MB production server rendering bundle (215 ms vs 983 ms).
+- **Memory:** A context holding the MUI bundle uses 44 MB vs 110 MB.
+- **Forks:** After loading and rendering React: 20 of 20 clean mini_racer_rs exits vs 20 of 20 mini_racer aborts.
+- **V8:** V8 15.2.124.1 vs V8 13.6.233.17 in mini_racer 0.22.1.
+- **No compiler:** Native gems cover glibc Linux and macOS, both architectures, with Ruby 3.3, 3.4 and 4.0 extensions.
+- **Fiber scheduler:** Three 100 ms loops in separate contexts and fibers finish in 100 ms vs 300 ms.
+- **Upstream suites:** mini_racer passes 171 of 174 with 3 skipped by itself; ExecJS passes 197 of 198 with 1 skipped.
+- **Difficult values:** A `Map` with a function key returns an error Hash instead of aborting with SIGABRT.
+- **Checks:** Script-enforced crate boundaries, four fenced `unsafe` modules, loom, wire-codec fuzzing, nightly sanitizers and mini_racer differential tests.
 
-All performance numbers compare mini_racer_rs with mini_racer 0.22.1 on Ruby 3.4.2 and Linux on an AMD Ryzen 9 7950X3D, with both gems pinned to the same eight cores and the `performance` governor.
+These numbers compare with mini_racer 0.22.1. See [Benchmarks](#benchmarks) for the method.
 
 ## Install
 
-The package switch is one Gemfile line:
+Switch packages with one Gemfile line:
 
 ```diff
 - gem "mini_racer"
 + gem "mini_racer_rs"
 ```
 
-Run `bundle install`. Bundler is required because RubyGems may otherwise activate the original `mini_racer` first. Loading both gems raises a `LoadError` that names the conflict. Reverse the Gemfile change to switch back.
+Run `bundle install`. Bundler is required because RubyGems may activate the original `mini_racer` first. Loading both gems raises a `LoadError` naming the conflict. Reverse the Gemfile change to switch back.
 
-On x86_64-linux-gnu, aarch64-linux-gnu, arm64-darwin, and x86_64-darwin, `bundle install` installs a native gem and compiles nothing. Elsewhere, the source gem builds the extension and requires Rust 1.91 or newer and libclang. To build from a checkout, follow [CONTRIBUTING.md](CONTRIBUTING.md) and run `bin/setup`.
+On x86_64-linux-gnu, aarch64-linux-gnu, arm64-darwin, and x86_64-darwin, `bundle install` installs a native gem without compiling. Elsewhere, the source gem requires Rust 1.91 or newer and libclang to build the extension. For a checkout, follow [CONTRIBUTING.md](CONTRIBUTING.md) and run `bin/setup`.
 
 ## Quick start
 
-This example was run against both gems and produced exactly the outputs shown:
+Both gems produced exactly these outputs:
 
 ```ruby check
 require "mini_racer"
@@ -112,31 +112,35 @@ ExecJS.eval("[1, 2].map(x => x * 2)")         # => [2, 4]
 | `ensure_gc_after_idle:` | Idle milliseconds before one full garbage collection. `0` disables it. |
 | `snapshot:` | A `MiniRacer::Snapshot` used to initialize the context. |
 
-Errors are `MiniRacer::ParseError`, `MiniRacer::RuntimeError` with JavaScript frames in its backtrace, `MiniRacer::ScriptTerminatedError`, `MiniRacer::V8OutOfMemoryError`, `MiniRacer::ContextDisposedError`, `MiniRacer::SnapshotError`, and `MiniRacer::PlatformAlreadyInitialized`. All descend from `MiniRacer::Error`.
+Errors are `MiniRacer::ParseError`, `MiniRacer::RuntimeError`, `MiniRacer::ScriptTerminatedError`, `MiniRacer::V8OutOfMemoryError`, `MiniRacer::ContextDisposedError`, `MiniRacer::SnapshotError`, and `MiniRacer::PlatformAlreadyInitialized`. `MiniRacer::RuntimeError` includes JavaScript frames in its backtrace. All descend from `MiniRacer::Error`.
 
-**Source maps.** The bundle must be a UTF-8 String of at least 1,024 bytes, and the map must be a JSON String in source map v3 format. When a context evaluates a UTF-8 source containing that bundle, `MiniRacer::RuntimeError` backtraces replace V8 positions inside it with mapped original file, line, and column positions while retaining V8 function names. Async frames, frames after the tenth, `eval` or `new Function` code, frames outside the bundle, positions the map does not cover, and stacks reformatted by JavaScript keep V8 positions. Detailed stack capture makes creating and throwing errors in affected contexts more expensive, while measured React and MUI server renders were unchanged. Registration is process wide and holds at most eight bundles, and a map cannot be removed; registering a bundle again replaces its map. Trust bundles and maps like application code because source names appear in Ruby backtraces.
+**Source maps.** Bundles must be UTF-8 Strings of at least 1,024 bytes. Maps must be JSON Strings in source map v3 format. When a context evaluates UTF-8 source containing a registered bundle, mini_racer_rs rewrites `MiniRacer::RuntimeError` backtraces. V8 positions inside the bundle become mapped original file, line, and column positions. V8 function names remain.
+
+V8 positions remain for async frames and frames after the tenth. They also remain for `eval`, `new Function`, uncovered positions, and frames outside the bundle. JavaScript-reformatted stacks also keep V8 positions.
+
+Detailed stack capture makes creating and throwing errors more expensive in affected contexts. Measured React and MUI server renders were unchanged. Registration is process wide and holds at most eight bundles. Maps cannot be removed. Registering a bundle again replaces its map. Trust bundles and maps like application code because source names appear in Ruby backtraces.
 
 ## Switching from mini_racer
 
 ### What changes
 
-The public API and require path stay the same. The main changes are native installation, faster small calls and Babel transforms, fiber-aware waiting, newer V8 behavior, and safer conversion of difficult values. Applications that make many small calls gain the most. See [Highlights](#highlights) for measurements.
+The public API and require path stay the same. Changes include native installation, faster calls and Babel transforms, fiber-aware waiting, newer V8 behavior, and safer value conversion. `Object(1n)` returns `1`, and an offset typed array returns its buffer as a binary String. Applications making many small calls gain the most. See [Highlights](#highlights) for measurements.
 
 ### Check before you ship
 
-- You're affected if your tests or code compare exact JavaScript error messages or locale-formatted text. V8 15.2 can word them differently from V8 13.6.
+- You're affected if tests or code compare exact JavaScript errors or locale-formatted text. V8 15.2 may differ from V8 13.6.
 
-- You're affected if an attached Ruby callback calls back into its own context from another fiber, such as inside `Enumerator#next`. mini_racer_rs raises `ThreadError`; mini_racer allows it.
+- You're affected if an attached callback reenters its context from another fiber, including inside `Enumerator#next`. mini_racer_rs raises `ThreadError`; mini_racer allows it.
 
-- You're affected if a callback exits by `throw`, returns out of a proc, or is stopped by `Thread#kill`. The script ends with `Error: terminated`, then the jump continues after `eval` returns. mini_racer hangs.
+- You're affected if a callback exits by `throw`, returns from a proc, or receives `Thread#kill`. The script ends with `Error: terminated`. The jump continues after `eval` returns. mini_racer hangs.
 
-- You're affected if JavaScript reads a non-ASCII message from a callback exception. mini_racer_rs passes UTF-8, such as `"café"`, while mini_racer passes `"café"`.
+- You're affected if JavaScript reads a callback exception's non-ASCII message. mini_racer_rs passes UTF-8, such as `"café"`; mini_racer passes `"café"`.
 
-- You're affected if `fork`, `IO.popen("-")`, or `Process.daemon` runs after V8 starts. Both modes wait up to 500 ms for runners, interrupting JavaScript after 50 ms; both then pause the worker pool and wait up to 100 ms for running tasks. Uninterruptible operations and workers can outlast these best-effort waits, and the fork proceeds. Default children reject inherited contexts; new contexts run worker work on the child's own threads, but are best effort after either wait expires. `:single_threaded` children take over idle inherited contexts, reject busy ones (all after runner timeout), and accept new contexts.
+- You're affected if `fork`, `IO.popen("-")`, or `Process.daemon` runs after V8 starts. Both modes wait up to 500 ms for runners and interrupt JavaScript after 50 ms. They pause the worker pool and wait up to 100 ms for running tasks. Uninterruptible work may outlast these best-effort waits, and the fork proceeds. Default children reject inherited contexts. New contexts use the child's threads, but are best effort after either timeout. `:single_threaded` children take over idle inherited contexts and reject busy ones. After a runner timeout, they reject all inherited contexts. They accept new contexts.
 
-- You're affected if, with `:single_threaded`, you fork in a way that bypasses Ruby's `fork`, such as a C-level `fork()`. Inherited contexts are unusable in the child.
+- You're affected if `:single_threaded` forks bypass Ruby's `fork`, such as a C-level `fork()`. Inherited contexts are unusable in the child.
 
-- You're affected if another thread calls `dispose` while a call is running. It returns after the call finishes and the isolate is gone. mini_racer returns immediately and frees the isolate later.
+- You're affected if another thread calls `dispose` during a call. It returns after the call finishes and the isolate is gone. mini_racer returns immediately and frees the isolate later.
 
 - You're affected if your code references `MiniRacer::Loader`. It does not exist in mini_racer_rs.
 
@@ -144,26 +148,28 @@ See [COMPATIBILITY.md](COMPATIBILITY.md) for every difference.
 
 ### Stay on mini_racer if
 
-- You deploy on musl-based Linux such as Alpine. mini_racer supports it through libv8-node's musl gems, while mini_racer_rs does not install there. Neither gem supports Windows.
+- You deploy on musl-based Linux such as Alpine. mini_racer supports it through libv8-node's musl gems; mini_racer_rs does not. Neither supports Windows.
 
-- Download size matters more than compile time. The largest mini_racer_rs native gem is 65.6 MB because it includes extensions for three Ruby versions. The mini_racer download on x86_64 Linux is 47.1 MB, followed by compilation.
+- Download size matters more than compile time. The largest native gem is 65.6 MB because it contains three Ruby extensions. mini_racer downloads 47.1 MB on x86_64 Linux, then compiles.
 
 ### Gems that depend on mini_racer
 
-If another gem brings in `mini_racer`, point Bundler at the repository's shim. It is an empty gem named `mini_racer`, version 0.22.1, that depends on the `mini_racer_rs` version from the same checkout.
+If another gem adds `mini_racer`, point Bundler to the repository's shim. This empty `mini_racer` gem is version 0.22.1. It depends on the `mini_racer_rs` version from the same checkout.
 
 ```ruby
 gem "mini_racer_rs"
 gem "mini_racer", github: "andymai/mini_racer_rs", tag: "vX.Y.Z", glob: "shim/*.gemspec"
 ```
 
-The repository tests shim resolution with `path:` sources and rtlcss in `test/consumers/transitive/`. The `github:` form has not been run end to end. A dependency whose `mini_racer` requirement excludes version 0.22.1 cannot use the shim.
+The repository tests `path:` shim resolution with rtlcss in `test/consumers/transitive/`. The `github:` form has not run end to end. A dependency excluding `mini_racer` 0.22.1 cannot use the shim.
 
 ### Forking servers such as Puma
 
-Prime the process-wide V8 code cache before forking by evaluating each bundle of 1 MB or more twice in the master, using exactly the source text and file name the renderer uses, then dispose those contexts. The second evaluation builds the cache, later matching evaluations compile from it, and forked children inherit it. For Babel's 2.3 MB bundle at commit `5e13c1c`, a forked child's first load took, as medians across 5 trials, 60.8 ms when the parent had not loaded it, 65.5 ms after one load, and 25.0 ms after two loads. You can prime a `react-rails` app by building its server renderer twice. Parent contexts are not used in children. Only the cache carries over.
+Before forking, evaluate each bundle of 1 MB or more twice in the master, then dispose those contexts. Use the renderer's exact source text and file name. The second evaluation builds the process-wide V8 code cache. Matching evaluations compile from it, and forked children inherit it. For Babel's 2.3 MB bundle at commit `5e13c1c`, a forked child's first load took 60.8 ms without a parent load. It took 65.5 ms after one load and 25.0 ms after two. These are medians across 5 trials. Prime a `react-rails` app by building its server renderer twice. Children do not use parent contexts. Only the cache carries over.
+
+For Ruby's `fork`, `IO.popen("-")`, or `Process.daemon`, mini_racer_rs waits for context runners, pauses its worker pool and waits for running tasks. An async `WebAssembly.compile` in a new default-mode child completes on the child's own pool. On Ubuntu 24.04 with glibc 2.39, 20 of 20 mini_racer children aborted with signal 6 after React rendering; all mini_racer_rs children exited cleanly. On Fedora, mini_racer hung within 50 `test/stress/fork_busy.rb` forks; mini_racer_rs completed 300 per run on Fedora and Ubuntu.
 
-With `mini_racer` 0.22.1, each worker compiles the bundle from source on its first load because there is no code cache.
+With `mini_racer` 0.22.1, each worker compiles the bundle from source on its first load because it has no code cache.
 
 ## Benchmarks
 
@@ -179,13 +185,28 @@ With `mini_racer` 0.22.1, each worker compiles the bundle from source on its fir
 | MUI in a new context: load the 8.2 MB bundle and render once, through ExecJS | 167 ms | 105 ms | 1.6x |
 | Load a 44 MB production server rendering bundle into a new context, through ExecJS | 983 ms | 215 ms | 4.6x |
 
-Results are medians of 5 runs, with every workload producing identical output in both gems. The eight library workloads use the release build of commit `220bfe7`, and the 44 MB production server rendering bundle load uses commit `2513a48`. Measurements ran on Ruby 3.4.2 and Linux on an AMD Ryzen 9 7950X3D, with the CPU governor set to `performance` and both gems pinned to CPUs 0 through 7.
+Results are medians of 5 runs. Every workload produced identical output in both gems. The eight library workloads use the release build of commit `220bfe7`. The 44 MB production bundle load uses commit `2513a48`. Benchmarks ran on Ruby 3.4.2 and Linux with an AMD Ryzen 9 7950X3D. The governor was `performance`. Both gems were pinned to CPUs 0 through 7.
+
+The per-call and memory figures below were measured on the same machine. Startup plus Babel, Babel context and MUI context figures come from commit `220bfe7`. One watchdog thread serves the whole process, making a call with `timeout:` fast. Scripts of 1 MB or more use a process-wide V8 code cache. Contexts loading the same large script share one source copy.
+
+| Measure | mini_racer 0.22.1 | mini_racer_rs |
+|---|---:|---:|
+| eval round trip | 6.91 µs | 1.09 µs |
+| call round trip | 6.51 µs | 0.72 µs |
+| callback round trip | 6.12 µs | 1.12 µs |
+| call on a context with `timeout:` | 20.48 µs | 0.76 µs |
+| Babel inside V8 | 10.3 ms | 5.3 ms |
+| startup plus Babel | 44.4 ms | 13.3 ms |
+| context holding Babel | 28.5 MB | 15.2 MB |
+| context holding the 8.2 MB MUI bundle | 110 MB | 44 MB |
+| context holding the 44 MB production bundle, at commit `2513a48` before sources were shared | 301 MB | 136 MB |
+| peak resident memory with 20,000 contexts left to Ruby's garbage collector | 2,920 MB | 102 MB |
 
 ```sh
 bundle exec ruby bench/run.rb --cpus 0-7
 ```
 
-[BENCHMARKS.md](BENCHMARKS.md) describes the method, per-call costs, memory results, and mini_racer's own `benchmark/serde` suite.
+[BENCHMARKS.md](BENCHMARKS.md) covers the method, per-call costs, memory results, and mini_racer's `benchmark/serde` suite.
 
 <!-- compat-table:start -->
 ## Compatibility
@@ -200,7 +221,7 @@ See [COMPATIBILITY.md](COMPATIBILITY.md).
 
 ## How it works
 
-mini_racer_rs uses the `v8` crate, rusty_v8 152.2.0, with Ruby bindings through magnus and rb-sys. Each context owns a V8 isolate and a native runner thread with a stack of at least 2 MiB, so V8 frames never use a Ruby thread's stack. A per-context lock permits one dispatch at a time.
+mini_racer_rs uses the `v8` crate, rusty_v8 152.2.0, with magnus and rb-sys Ruby bindings. Each context owns a V8 isolate and native runner thread. Its stack is at least 2 MiB, keeping V8 frames off Ruby thread stacks. A per-context lock allows one dispatch at a time.
 
 ```text
  Ruby thread                          runner thread (one per context)
@@ -216,34 +237,36 @@ mini_racer_rs uses the `v8` crate, rusty_v8 152.2.0, with Ruby bindings through
  result
 ```
 
-A waiting Ruby thread first spins briefly with the GVL held, then spins without it, then parks with the GVL released. Under a fiber scheduler, only the waiting fiber parks. Values use V8's serialization format and decode directly into Ruby objects without an intermediate tree. Repeated objects retain their identity.
+A waiting Ruby thread spins with the GVL held, then without it. It then parks with the GVL released. After enough consecutive answers arrive beyond the spin budget, that context skips spinning and parks at once until an answer arrives within the budget. Under a fiber scheduler, only the waiting fiber parks. Values use V8's serialization format and decode directly into Ruby objects. There is no intermediate tree. Repeated objects keep their identity.
 
-One watchdog thread per process enforces every context's `timeout:`. In `:single_threaded` mode, a fork quiesces the runners, the child takes over contexts that were idle, and contexts in use raise there. In every process, mini_racer_rs points V8's platform at a copied vtable whose worker-thread slots post to a pool it owns. V8's platform has one worker thread, which never receives a task. A fork pauses the pool, and the parent resumes it when the fork returns; inherited contexts raise in the child in the default multi-threaded mode.
+One watchdog thread per process enforces every context's `timeout:`. In `:single_threaded` mode, forks quiesce runners. Children take over idle contexts; contexts in use raise there. mini_racer_rs gives V8 a copied platform vtable in each process. Worker-thread slots post to its own pool. V8's platform has one worker thread, which receives no tasks. Forking pauses the pool. The parent resumes it afterward. Default multi-threaded children reject inherited contexts.
 
-The implementation is split into four crates:
+The implementation has four crates:
 
 - `mini_racer_wire`: the wire codec, with no unsafe code.
 - `mini_racer_sync`: the thread protocol, with no unsafe code and loom checking.
-- `mini_racer_engine`: V8 process state and runners, and the only crate that names `v8`.
-- `mini_racer_rs`: the Ruby extension, and the only crate that names magnus or rb-sys.
+- `mini_racer_engine`: V8 process state and runners, and the only crate naming `v8`.
+- `mini_racer_rs`: the Ruby extension, and the only crate naming magnus or rb-sys.
+
+The release pipeline runs the full suites for every released extension.
 
-[ARCHITECTURE.md](ARCHITECTURE.md) follows a call end to end and covers the design in depth.
+[ARCHITECTURE.md](ARCHITECTURE.md) follows a call end to end and explains the design.
 
 ## Scope
 
-mini_racer_rs deliberately does not:
+mini_racer_rs does not:
 
-- Run on Windows or musl-based Linux such as Alpine. Supported platforms are glibc Linux on x86_64 and aarch64, plus macOS on arm64 and x86_64.
+- Run on Windows or musl-based Linux such as Alpine. It supports glibc Linux on x86_64 and aarch64, and macOS on arm64 and x86_64.
 
-- Provide Node.js APIs. JavaScript runs in plain V8 without file system, network, or process access. JavaScript can reach only the Ruby callables you `attach`.
+- Provide Node.js APIs. JavaScript runs in plain V8 without file system, network, or process access. It can reach only Ruby callables you `attach`.
 
 - Work reliably without Bundler. RubyGems may activate the original mini_racer first.
 
-- Satisfy a dependency that pins a `mini_racer` version other than 0.22.1. This includes minibars with its `~> 0.6.4` requirement.
+- Satisfy dependencies pinning `mini_racer` versions other than 0.22.1. This includes minibars and its `~> 0.6.4` requirement.
 
-- Extend the `MiniRacer` API beyond mini_racer 0.22.1. Deliberate differences are recorded in [COMPATIBILITY.md](COMPATIBILITY.md).
+- Extend the `MiniRacer` API beyond mini_racer 0.22.1. [COMPATIBILITY.md](COMPATIBILITY.md) records deliberate differences.
 
-Supported Ruby implementations are CRuby 3.3, 3.4, and 4.0, plus TruffleRuby through mini_racer's unchanged TruffleRuby backend.
+Supported implementations are CRuby 3.3, 3.4, and 4.0, plus TruffleRuby through mini_racer's unchanged TruffleRuby backend.
 
 ## Documentation
 

data/crates/mini_racer_wire/Cargo.toml

@@ -12,7 +12,12 @@ version.workspace = true
 thiserror.workspace = true
 
 [dev-dependencies]
+criterion.workspace = true
 proptest.workspace = true
 
+[[bench]]
+harness = false
+name = "wire"
+
 [lints]
 workspace = true

data/crates/mini_racer_wire/benches/wire.rs

@@ -0,0 +1,293 @@
+//! Decoding, writing and transcoding V8's wire format, without V8 or Ruby, on
+//! the shapes the extension sees: seeded server rendering props, and runs of
+//! numbers and strings. Strings take the forms V8's serializer gives them.
+
+use std::convert::Infallible;
+use std::hint::black_box;
+
+use criterion::{Criterion, Throughput, criterion_group, criterion_main};
+use mini_racer_wire::{Begun, Container, Limits, Scalar, Visitor, Writer, decode_value, text};
+
+const WORDS: [&str; 12] = [
+    "alpha", "beta", "gamma", "delta", "epsilon", "zeta", "theta", "kappa", "lambda", "sigma",
+    "omega", "omicron",
+];
+const INTL: [&str; 5] = ["café", "naïve", "Zürich", "東京", "😀 party"];
+// The words of INTL that V8 keeps one byte a character.
+const LATIN1: [&str; 3] = ["café", "naïve", "Zürich"];
+
+/// Reads every value and keeps nothing, so the decoder's own work is what
+/// is measured.
+struct Discard;
+
+impl Visitor for Discard {
+    type Value = ();
+    type Frame = ();
+    type Error = Infallible;
+
+    fn scalar(&mut self, scalar: Scalar<'_>) -> Result<(), Infallible> {
+        black_box(scalar);
+        Ok(())
+    }
+
+    fn begin(&mut self, container: Container) -> Result<Begun<(), ()>, Infallible> {
+        black_box(container);
+        Ok(Begun {
+            frame: (),
+            value: None,
+        })
+    }
+
+    fn push(&mut self, (): &mut (), (): ()) -> Result<(), Infallible> {
+        Ok(())
+    }
+
+    fn insert(&mut self, (): &mut (), (): (), (): ()) -> Result<(), Infallible> {
+        Ok(())
+    }
+
+    fn end(&mut self, (): ()) -> Result<(), Infallible> {
+        Ok(())
+    }
+
+    fn register(&mut self, id: u32, (): ()) -> Result<(), Infallible> {
+        black_box(id);
+        Ok(())
+    }
+
+    fn back_ref(&mut self, id: u32) -> Result<(), Infallible> {
+        black_box(id);
+        Ok(())
+    }
+}
+
+enum Node {
+    Int(i64),
+    Number(f64),
+    Bool(bool),
+    Latin1(Vec<u8>),
+    Utf16(Vec<u16>),
+    Object(Vec<(Vec<u8>, Self)>),
+    Array(Vec<Self>),
+}
+
+impl Node {
+    fn text(text: &str) -> Self {
+        let latin1: Option<Vec<u8>> = text
+            .chars()
+            .map(|c| u8::try_from(u32::from(c)).ok())
+            .collect();
+        latin1.map_or_else(|| Self::Utf16(text.encode_utf16().collect()), Self::Latin1)
+    }
+
+    fn object(entries: Vec<(&str, Self)>) -> Self {
+        Self::Object(
+            entries
+                .into_iter()
+                .map(|(key, value)| (key.as_bytes().to_vec(), value))
+                .collect(),
+        )
+    }
+
+    fn write(&self, writer: &mut Writer<'_>) {
+        match self {
+            Self::Int(n) => writer.integer(*n),
+            Self::Number(n) => writer.number(*n),
+            Self::Bool(b) => writer.bool(*b),
+            Self::Latin1(bytes) => writer.latin1(bytes),
+            Self::Utf16(units) => writer.utf16_aligned(units),
+            Self::Object(entries) => {
+                writer.begin_object();
+                for (key, value) in entries {
+                    writer.latin1(key);
+                    value.write(writer);
+                }
+                writer.end_object(count(entries.len()));
+            }
+            Self::Array(items) => {
+                writer.begin_array(count(items.len()));
+                for item in items {
+                    item.write(writer);
+                }
+                writer.end_array(count(items.len()));
+            }
+        }
+    }
+
+    fn bytes(&self) -> Vec<u8> {
+        let mut out = Vec::new();
+        self.write(&mut Writer::versioned(&mut out, 15));
+        out
+    }
+}
+
+fn count(len: usize) -> u32 {
+    u32::try_from(len).unwrap_or(u32::MAX)
+}
+
+/// xorshift64, so the payload is the same on every machine.
+struct Seeded(u64);
+
+impl Seeded {
+    const fn next(&mut self) -> u64 {
+        self.0 ^= self.0 << 13;
+        self.0 ^= self.0 >> 7;
+        self.0 ^= self.0 << 17;
+        self.0
+    }
+
+    fn below(&mut self, bound: usize) -> usize {
+        usize::try_from(self.next()).unwrap_or(0) % bound
+    }
+
+    fn words(&mut self, count: usize) -> Node {
+        self.words_from(count, &INTL)
+    }
+
+    fn words_from(&mut self, count: usize, intl: &[&str]) -> Node {
+        let words: Vec<&str> = (0..count)
+            .map(|_| {
+                if self.below(10) == 0 {
+                    intl[self.below(intl.len())]
+                } else {
+                    WORDS[self.below(WORDS.len())]
+                }
+            })
+            .collect();
+        Node::text(&words.join(" "))
+    }
+
+    fn cents(&mut self) -> f64 {
+        f64::from(u32::try_from(self.below(100_000)).unwrap_or(0)) / 100.0
+    }
+}
+
+/// About 1 MB of props, the size the end-to-end benchmark sends.
+fn props() -> Node {
+    let mut seeded = Seeded(42);
+    let items = (0..5_000)
+        .map(|id| {
+            let length = 3 + seeded.below(6);
+            Node::object(vec![
+                ("id", Node::Int(id)),
+                (
+                    "sku",
+                    Node::text(&format!("SKU-{}", seeded.below(1_000_000))),
+                ),
+                ("title", seeded.words(length)),
+                ("price", Node::Number(seeded.cents())),
+                ("rating", Node::Number(seeded.cents() / 200.0)),
+                ("inStock", Node::Bool(seeded.below(4) != 0)),
+                (
+                    "tags",
+                    Node::Array(vec![seeded.words(1), seeded.words(1), seeded.words(1)]),
+                ),
+                (
+                    "seller",
+                    Node::object(vec![
+                        ("name", seeded.words(2)),
+                        (
+                            "reviews",
+                            Node::Int(i64::try_from(seeded.below(5_000)).unwrap_or(0)),
+                        ),
+                    ]),
+                ),
+            ])
+        })
+        .collect();
+    Node::object(vec![
+        (
+            "page",
+            Node::object(vec![
+                ("title", Node::text("Products")),
+                ("locale", Node::text("en-US")),
+            ]),
+        ),
+        ("items", Node::Array(items)),
+    ])
+}
+
+fn numbers() -> Node {
+    let mut seeded = Seeded(7);
+    Node::Array((0..10_000).map(|_| Node::Number(seeded.cents())).collect())
+}
+
+fn latin1_strings() -> Node {
+    let mut seeded = Seeded(9);
+    Node::Array((0..10_000).map(|_| seeded.words_from(2, &LATIN1)).collect())
+}
+
+fn two_byte_strings() -> Node {
+    Node::Array(
+        (0..1_000)
+            .map(|n| Node::text(&format!("東京の天気は晴れです {n}")))
+            .collect(),
+    )
+}
+
+fn decode(c: &mut Criterion) {
+    let mut group = c.benchmark_group("decode");
+    for (name, node) in [
+        ("ssr_props", props()),
+        ("dense_numbers", numbers()),
+        ("latin1_strings", latin1_strings()),
+        ("two_byte_strings", two_byte_strings()),
+    ] {
+        let bytes = node.bytes();
+        group.throughput(Throughput::Bytes(
+            bytes.len().try_into().unwrap_or(u64::MAX),
+        ));
+        group.bench_function(name, |b| {
+            b.iter(|| decode_value(black_box(&bytes), Limits::default(), &mut Discard));
+        });
+    }
+    group.finish();
+}
+
+fn write(c: &mut Criterion) {
+    let node = props();
+    let mut out = Vec::new();
+    node.write(&mut Writer::new(&mut out));
+    let mut group = c.benchmark_group("write");
+    group.throughput(Throughput::Bytes(out.len().try_into().unwrap_or(u64::MAX)));
+    group.bench_function("ssr_props", |b| {
+        b.iter(|| {
+            let mut writer = Writer::new(&mut out);
+            black_box(&node).write(&mut writer);
+        });
+    });
+    group.finish();
+}
+
+fn transcode(c: &mut Criterion) {
+    let latin1: Vec<u8> = "Le café de la naïveté à Zürich, déjà vu. "
+        .chars()
+        .filter_map(|ch| u8::try_from(u32::from(ch)).ok())
+        .cycle()
+        .take(64 << 10)
+        .collect();
+    let utf16: Vec<u8> = "東京の天気は晴れです。"
+        .encode_utf16()
+        .cycle()
+        .take(32 << 10)
+        .flat_map(u16::to_le_bytes)
+        .collect();
+    let mut out = vec![0; 192 << 10];
+    let mut group = c.benchmark_group("transcode");
+    group.throughput(Throughput::Bytes(
+        latin1.len().try_into().unwrap_or(u64::MAX),
+    ));
+    group.bench_function("latin1_to_utf8", |b| {
+        b.iter(|| text::latin1_to_utf8_into(black_box(&latin1), &mut out));
+    });
+    group.throughput(Throughput::Bytes(
+        utf16.len().try_into().unwrap_or(u64::MAX),
+    ));
+    group.bench_function("utf16le_to_utf8", |b| {
+        b.iter(|| text::utf16le_to_utf8_into(black_box(&utf16), &mut out));
+    });
+    group.finish();
+}
+
+criterion_group!(benches, decode, write, transcode);
+criterion_main!(benches);

data/ext/mini_racer_rs/src/host.rs

@@ -1,7 +1,6 @@
 use std::cell::Cell;
 use std::os::fd::{AsRawFd, IntoRawFd};
-use std::sync::OnceLock;
-use std::time::Duration;
+use std::time::Instant;
 
 use magnus::error::ErrorType;
 use magnus::gc::Marker;
@@ -14,32 +13,9 @@ use mini_racer_engine::{
 
 use crate::encode;
 use crate::gc_root::OwnedRoot;
+use crate::spin::{self, History};
 use crate::{context, decode, errors, rb_raw};
 
-struct SpinBudget {
-    gvl: Duration,
-    nogvl: Duration,
-}
-
-// Unstable tuning knob: MINI_RACER_RS_SPIN_US=<with GVL>,<without GVL>.
-fn budget() -> &'static SpinBudget {
-    static BUDGET: OnceLock<SpinBudget> = OnceLock::new();
-    BUDGET.get_or_init(|| {
-        let setting = std::env::var("MINI_RACER_RS_SPIN_US").unwrap_or_default();
-        let parts: Vec<Option<u64>> = setting
-            .split(',')
-            .map(|part| part.trim().parse().ok())
-            .collect();
-        let at = |i: usize, default: u64| {
-            Duration::from_micros(parts.get(i).copied().flatten().unwrap_or(default))
-        };
-        SpinBudget {
-            gvl: at(0, 20),
-            nogvl: at(1, 50),
-        }
-    })
-}
-
 /// What a context's callbacks run: its attached callables by id, and where
 /// the exception the latest callback raised is kept, as `mini_racer` keeps one
 /// per context and clears it after every dispatch, nested ones included.
@@ -69,6 +45,7 @@ pub struct RubyHost<'r> {
 pub struct Waiter {
     io: OwnedRoot<Value>,
     epoch: Cell<u64>,
+    history: History,
 }
 
 impl Waiter {
@@ -268,28 +245,44 @@ fn message(ruby: &Ruby, exception: Exception) -> JsText {
 
 impl Host for RubyHost<'_> {
     fn wait(&mut self, wait: &WaitHandle<'_>) -> WaitOutcome {
-        let budget = budget();
-        if wait.spin(budget.gvl) {
-            return WaitOutcome::Ready;
+        let budget = spin::budget();
+        let history = self.waiter.map(|waiter| &waiter.history);
+        let spins = history.is_none_or(History::spins);
+        // A wait that does not spin times itself to tell whether spinning
+        // would have caught the answer.
+        let started = (!spins).then(Instant::now);
+        let answered = |spun: bool| {
+            if let Some(history) = history {
+                history.record(started.map_or(spun, |at| at.elapsed() <= budget.total()));
+            }
+            WaitOutcome::Ready
+        };
+        if spins && wait.spin(budget.gvl) {
+            return answered(true);
         }
         if rb_raw::fiber_scheduler(self.ruby)
             && let Some(outcome) = self.wait_in_fiber(wait)
         {
-            return outcome;
+            return match outcome {
+                WaitOutcome::Ready => answered(false),
+                WaitOutcome::Cancel => outcome,
+            };
         }
         let unparker = wait.unparker();
         loop {
             let parked = rb_raw::nogvl(
                 self.ruby,
                 || {
-                    if !wait.spin(budget.nogvl) {
+                    let spun = spins && wait.spin(budget.nogvl);
+                    if !spun {
                         wait.park();
                     }
+                    spun
                 },
                 &move || unparker.unpark(),
             );
             if wait.ready() {
-                return WaitOutcome::Ready;
+                return answered(matches!(parked, Some(Ok(true))));
             }
             if parked.as_ref().is_some_and(Result::is_err) {
                 self.pending = Some(errors::internal(self.ruby, "panic while waiting"));

data/ext/mini_racer_rs/src/lib.rs

@@ -19,6 +19,7 @@ mod platform;
 mod rb_raw;
 mod snapshot;
 mod source_maps;
+mod spin;
 
 use magnus::{Error, Module, Ruby};
 

data/ext/mini_racer_rs/src/spin.rs

@@ -0,0 +1,123 @@
+use std::cell::Cell;
+use std::sync::OnceLock;
+use std::time::Duration;
+
+/// How long a Ruby thread spins for a runner's answer before it gives up the
+/// GVL, and then before it parks.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Budget {
+    pub gvl: Duration,
+    pub nogvl: Duration,
+}
+
+impl Budget {
+    fn parse(setting: &str) -> Self {
+        let parts: Vec<Option<u64>> = setting
+            .split(',')
+            .map(|part| part.trim().parse().ok())
+            .collect();
+        let at = |i: usize, default: u64| {
+            Duration::from_micros(parts.get(i).copied().flatten().unwrap_or(default))
+        };
+        Self {
+            gvl: at(0, 20),
+            nogvl: at(1, 50),
+        }
+    }
+
+    pub const fn total(&self) -> Duration {
+        self.gvl.saturating_add(self.nogvl)
+    }
+}
+
+// Unstable tuning knob: MINI_RACER_RS_SPIN_US=<with GVL>,<without GVL>.
+pub fn budget() -> &'static Budget {
+    static BUDGET: OnceLock<Budget> = OnceLock::new();
+    BUDGET
+        .get_or_init(|| Budget::parse(&std::env::var("MINI_RACER_RS_SPIN_US").unwrap_or_default()))
+}
+
+// A context whose answers outlast the budget, such as one rendering pages,
+// gains nothing from spinning: each wait burns the whole budget on the
+// caller's CPU, the first part holding the GVL from other threads, and then
+// parks anyway. A few in a row are enough to tell it from a one-off.
+const STREAK: u8 = 3;
+
+/// One context's recent waits: after `STREAK` in a row outlast the budget its
+/// waits park at once, until one is answered within the budget.
+#[derive(Debug, Default)]
+pub struct History {
+    slow: Cell<u8>,
+}
+
+impl History {
+    pub const fn spins(&self) -> bool {
+        self.slow.get() < STREAK
+    }
+
+    pub fn record(&self, within_budget: bool) {
+        let slow = if within_budget {
+            0
+        } else {
+            self.slow.get().saturating_add(1).min(STREAK)
+        };
+        self.slow.set(slow);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn the_budget_defaults_and_reads_the_knob() {
+        let us = Duration::from_micros;
+        assert_eq!(
+            Budget::parse(""),
+            Budget {
+                gvl: us(20),
+                nogvl: us(50)
+            }
+        );
+        assert_eq!(
+            Budget::parse("0,0"),
+            Budget {
+                gvl: us(0),
+                nogvl: us(0)
+            }
+        );
+        assert_eq!(
+            Budget::parse("5, x"),
+            Budget {
+                gvl: us(5),
+                nogvl: us(50)
+            }
+        );
+        assert_eq!(Budget::parse("").total(), us(70));
+    }
+
+    #[test]
+    fn a_streak_of_slow_answers_stops_spinning() {
+        let history = History::default();
+        for _ in 1..STREAK {
+            history.record(false);
+            assert!(history.spins());
+        }
+        history.record(false);
+        assert!(!history.spins());
+        history.record(false);
+        assert!(!history.spins());
+    }
+
+    #[test]
+    fn one_answer_within_the_budget_brings_spinning_back() {
+        let history = History::default();
+        for _ in 0..STREAK {
+            history.record(false);
+        }
+        history.record(true);
+        assert!(history.spins());
+        history.record(false);
+        assert!(history.spins());
+    }
+}

data/lib/mini_racer_rs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MiniRacerRs
-  VERSION = "1.1.0"
+  VERSION = "1.1.1"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: mini_racer_rs
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Andy Aragon
 bindir: bin
 cert_chain: []
-date: 2026-10-19 00:00:00.000000000 Z
+date: 2026-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -82,6 +82,7 @@ files:
 - crates/mini_racer_sync/src/termination.rs
 - crates/mini_racer_sync/src/workers.rs
 - crates/mini_racer_wire/Cargo.toml
+- crates/mini_racer_wire/benches/wire.rs
 - crates/mini_racer_wire/src/decode.rs
 - crates/mini_racer_wire/src/lib.rs
 - crates/mini_racer_wire/src/marker.rs
@@ -104,6 +105,7 @@ files:
 - ext/mini_racer_rs/src/rb_raw.rs
 - ext/mini_racer_rs/src/snapshot.rs
 - ext/mini_racer_rs/src/source_maps.rs
+- ext/mini_racer_rs/src/spin.rs
 - ext/mini_racer_rs/v8-archives.sha256
 - lib/mini_racer.rb
 - lib/mini_racer/shared.rb