mini_racer_rs 1.0.0 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 41191c7e0a6bf53c0371de7ba31f7067b3d83b0095579d6955a75a9021c4a5b0
-  data.tar.gz: 7b0424bbabd9fcd45122dc81b6b449e3c30d7ffb218ec43eff973ae4d8c70772
+  metadata.gz: 1b53466394528b78785dc0cac7e884a5b59f0200ca037d405c95375152a12d72
+  data.tar.gz: 06b9b34066ec568f0a41186f5f7c533c3a17f7acb90a625ec8e9fff22b3069f5
 SHA512:
-  metadata.gz: b864cac2b4d1f3108deea75e4bc5a10de16c94ce73be5c5824f7443922a86d94f6d1ff933a1008632c971f1eafdef57a452631661bc82807799b339ff7e15ca5
-  data.tar.gz: '0391a874e20db2b91f6c1916efa0c39f05178b68e9223dc2709aeb2fa6ad6026de9bba898f8bea5f8764193df36c0291fb8af8afab738029db3ef4a537354bb4'
+  metadata.gz: 7e9f4ee092b37374b56a701831bd4ba868af74de863c220a9f58aae583505cc3c4000106107cfe8c8e709552863d5b484b8715cd016306ecb06241f2d84fe759
+  data.tar.gz: d5dc38c171b8d11683d53840d6c671cbf90ae042dba02f1a46e9786f343e555356808e41e2fb460b00a440c326a2da23f737b1149ab96d359b4e2269981c8b36

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [1.0.2](https://github.com/andymai/mini_racer_rs/compare/v1.0.1...v1.0.2) (2026-10-18)
+
+
+### Performance
+
+* **engine:** share one copy of a large repeated source across contexts ([#85](https://github.com/andymai/mini_racer_rs/issues/85)) ([9fe050a](https://github.com/andymai/mini_racer_rs/commit/9fe050a7a612314264e255f9bcc40ca146e93571))
+
+## [1.0.1](https://github.com/andymai/mini_racer_rs/compare/v1.0.0...v1.0.1) (2026-10-18)
+
+
+### Performance
+
+* **engine:** build small call arguments in the runner and write primitive results directly ([#83](https://github.com/andymai/mini_racer_rs/issues/83)) ([76afcbd](https://github.com/andymai/mini_racer_rs/commit/76afcbd7bb5df36da6797b95d8dae7049ee80f53))
+
 ## 1.0.0 (2026-10-18)
 
 

data/COMPATIBILITY.md

@@ -4,7 +4,7 @@
 
 | Engine | Done | Planned | Deviation |
 |---|---|---|---|
-| CRuby | 54 | 0 | 25 |
+| CRuby | 54 | 0 | 26 |
 | TruffleRuby | 58 | 0 | 0 |
 
 ## Surface
@@ -180,6 +180,12 @@ mini_racer_rs supports glibc Linux on x86_64 and aarch64, plus macOS on arm64 an
 
 Approved 2026-10-16.
 
+### `behavior:shared-source-heap-stats@ruby`
+
+`Context#heap_stats` can report large source text differently from mini_racer 0.22.1. When a context evaluates a source of 1 MiB or more that the process has evaluated before under the same file name and startup snapshot, mini_racer_rs gives V8 one copy shared by every such context and held outside V8's heap. It reports that source in `:external_memory` and omits it from `:used_heap_size`. V8 counts the shared source by its length in characters, so two-byte text reports half its bytes. mini_racer 0.22.1 reports `:external_memory` as 0 and counts each context's own copy in `:used_heap_size`. JavaScript sees the same source text in both gems. Contexts using `max_memory:` and sources that are not valid UTF-8 retain individual copies. Setting `MINI_RACER_RS_CODE_CACHE=off` before creating the first context disables sharing and makes `heap_stats` count every source as mini_racer does.
+
+Approved 2026-10-18.
+
 ### `behavior:snapshot-filter-context@ruby`
 
 mini_racer_rs returns the same filtered results from a snapshot-based context as from a context without a snapshot. In a context made from `MiniRacer::Snapshot.new("Object.getOwnPropertyDescriptors = () => ({})")`, `({a: 1, f() {}})` returns `{"a" => 1}`, and `[1, function() {}]` returns `[1]`. mini_racer 0.22.1 returns `nil` for both. Both gems copy results that V8 refuses to serialize as is through a filter in a separate safe context. mini_racer_rs keeps an untouched context in each snapshot blob and uses it for that filter, while mini_racer 0.22.1 builds the safe context from the snapshot, exposing the filter's built-ins to snapshot code. User code still sees the replacement in both gems: `Object.getOwnPropertyDescriptors({a: 1})` returns `{}`.

data/Cargo.lock

@@ -458,7 +458,7 @@ checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
 
 [[package]]
 name = "mini_racer_engine"
-version = "1.0.0"
+version = "1.0.2"
 dependencies = [
  "deno_core_icudata",
  "libc",
@@ -470,7 +470,7 @@ dependencies = [
 
 [[package]]
 name = "mini_racer_rs"
-version = "1.0.0"
+version = "1.0.2"
 dependencies = [
  "magnus",
  "mini_racer_engine",
@@ -481,7 +481,7 @@ dependencies = [
 
 [[package]]
 name = "mini_racer_sync"
-version = "1.0.0"
+version = "1.0.2"
 dependencies = [
  "loom",
  "thiserror",
@@ -489,7 +489,7 @@ dependencies = [
 
 [[package]]
 name = "mini_racer_wire"
-version = "1.0.0"
+version = "1.0.2"
 dependencies = [
  "proptest",
  "thiserror",

data/Cargo.toml

@@ -14,7 +14,7 @@ license = "MIT"
 publish = false
 repository = "https://github.com/andymai/mini_racer_rs"
 rust-version = "1.91"
-version = "1.0.0"
+version = "1.0.2"
 
 [workspace.dependencies]
 deno_core_icudata = "=0.78.0"

data/README.md

@@ -17,7 +17,7 @@ A drop-in replacement for mini_racer, implemented in Rust on V8 15.2.
 
 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.
 
-> **Pre-release:** Nothing is published to RubyGems.org yet, and the release workflow is held. Install from the repository until the first release. mini_racer_rs is an independent project and is not affiliated with the Discourse staff who maintain mini_racer.
+> mini_racer_rs is an independent project and is not affiliated with the Discourse staff who maintain mini_racer.
 
 ## Highlights
 
@@ -46,7 +46,7 @@ The package switch is one Gemfile line:
 
 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.
 
-Until the first release publishes native gems, build from a checkout as described in [CONTRIBUTING.md](CONTRIBUTING.md). Run `bin/setup`. Source builds require Rust 1.91 or newer and libclang. Once published, installing a native gem will compile nothing.
+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`.
 
 ## Quick start
 
@@ -143,8 +143,6 @@ See [COMPATIBILITY.md](COMPATIBILITY.md) for every difference.
 
 - 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 need a gem from RubyGems.org today. mini_racer_rs is pre-release, while mini_racer is the established gem maintained by Discourse staff.
-
 - 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.
 
 ### Gems that depend on mini_racer
@@ -185,7 +183,7 @@ bundle exec ruby bench/run.rb --cpus 0-7
 
 | Engine | Done | Planned | Deviation |
 |---|---|---|---|
-| CRuby | 54 | 0 | 25 |
+| CRuby | 54 | 0 | 26 |
 | TruffleRuby | 58 | 0 | 0 |
 
 See [COMPATIBILITY.md](COMPATIBILITY.md).

data/crates/mini_racer_engine/src/context.rs

@@ -8,7 +8,9 @@ use mini_racer_sync::{
     Channel, ChannelError, DispatchKind, Inherited, Interrupt, Phase, Side, TermError, ToRuby, lock,
 };
 
-use crate::control::{CallbackReply, ContextConfig, ControlBlock, Depth, JsText, Request, Wire};
+use crate::control::{
+    CallRequest, CallbackReply, ContextConfig, ControlBlock, Depth, JsText, Request, Wire,
+};
 use crate::notify::NotifyFd;
 use crate::process::fork::{self, Generation};
 use crate::process::platform::Mode;
@@ -287,16 +289,14 @@ impl ContextHandle {
         )
     }
 
-    /// `request` is the wire form `mini_racer` sends: one array holding the
-    /// function's dotted path, then its arguments.
-    pub fn call(&self, request: Vec<u8>, host: &mut impl Host) -> Result<Vec<u8>, EngineError> {
+    pub fn call(&self, request: CallRequest, host: &mut impl Host) -> Result<Vec<u8>, EngineError> {
         self.invoke(request, false, host)
     }
 
     /// `call`, then awaits a promise result, as `eval_await` does.
     pub fn call_await(
         &self,
-        request: Vec<u8>,
+        request: CallRequest,
         host: &mut impl Host,
     ) -> Result<Vec<u8>, EngineError> {
         self.invoke(request, true, host)
@@ -304,7 +304,7 @@ impl ContextHandle {
 
     fn invoke(
         &self,
-        request: Vec<u8>,
+        request: CallRequest,
         awaited: bool,
         host: &mut impl Host,
     ) -> Result<Vec<u8>, EngineError> {
@@ -784,6 +784,11 @@ fn adopt(inherited: &ControlBlock, carried: Inherited) -> Held {
     let block = Arc::new(ControlBlock::with_tasks(inherited.config.clone(), tasks));
     *lock(&block.custody) = Some(isolate);
     block.term.adopt(carried);
+    // The isolate keeps whatever termination V8 still held for it.
+    block.termination_requested.store(
+        inherited.termination_requested.load(Ordering::Acquire),
+        Ordering::Release,
+    );
     match start(&block, generation, Start::Adopted) {
         Ok(()) => Held::Block(block),
         Err(_) => orphaned(true, false),

data/crates/mini_racer_engine/src/control.rs

@@ -1,3 +1,4 @@
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex, OnceLock};
 use std::time::{Duration, Instant};
 
@@ -66,6 +67,17 @@ impl From<&str> for JsText {
     }
 }
 
+/// A call in the wire form `mini_racer` sends: one array holding the
+/// function's dotted path, then its arguments.
+///
+/// `objects` and `properties` count the objects the arguments hold and their
+/// properties in all, which decide whether the runner builds the arguments.
+pub struct CallRequest {
+    pub bytes: Vec<u8>,
+    pub objects: usize,
+    pub properties: usize,
+}
+
 pub enum Request {
     Init {
         depth: Depth,
@@ -78,7 +90,7 @@ pub enum Request {
         awaited: bool,
     },
     Call {
-        request: Vec<u8>,
+        request: CallRequest,
         depth: Depth,
         awaited: bool,
     },
@@ -117,13 +129,15 @@ pub enum Request {
 pub struct IsolateTerminator {
     handle: v8::IsolateHandle,
     tasks: Arc<Tasks>,
+    requested: Arc<AtomicBool>,
 }
 
 impl IsolateTerminator {
-    pub fn new(handle: v8::IsolateHandle, tasks: &Arc<Tasks>) -> Self {
+    pub fn new(block: &ControlBlock, handle: v8::IsolateHandle) -> Self {
         Self {
             handle,
-            tasks: Arc::clone(tasks),
+            tasks: Arc::clone(&block.tasks),
+            requested: Arc::clone(&block.termination_requested),
         }
     }
 }
@@ -132,12 +146,14 @@ impl Terminator for IsolateTerminator {
     // A runner awaiting a promise sleeps until a task is due; the ring wakes
     // it to find the termination.
     fn terminate(&self) {
+        self.requested.store(true, Ordering::Release);
         self.handle.terminate_execution();
         self.tasks.ring();
     }
 
     fn cancel(&self) {
         self.handle.cancel_terminate_execution();
+        self.requested.store(false, Ordering::Release);
     }
 }
 
@@ -178,6 +194,10 @@ pub struct ControlBlock {
     // V8's foreground tasks for this context's isolate, which the runner runs
     // while awaiting a promise or pumping.
     pub tasks: Arc<Tasks>,
+    /// Set before anything asks V8 to terminate this context's script, and
+    /// cleared only once V8 has cancelled every such request, so a runner
+    /// building values itself knows when V8's own reader would stop instead.
+    pub termination_requested: Arc<AtomicBool>,
     pub phase: RunnerPhase,
     pub isolate: OnceLock<v8::IsolateHandle>,
     // The isolate a snapshot is being built in on this runner, if any.
@@ -230,6 +250,7 @@ impl ControlBlock {
             timer: Mutex::default(),
             notify: NotifyFd::default(),
             tasks: Arc::new(tasks),
+            termination_requested: Arc::default(),
             phase: RunnerPhase::default(),
             isolate: OnceLock::new(),
             building: Mutex::new(None),

data/crates/mini_racer_engine/src/lib.rs

@@ -4,6 +4,7 @@ mod error;
 mod fast_calls;
 mod notify;
 pub mod process;
+mod request;
 mod runner;
 mod serialize;
 mod snapshot;
@@ -15,6 +16,6 @@ mod spin;
 mod sys;
 
 pub use context::{ContextHandle, Host, Unparker, WaitHandle, WaitOutcome};
-pub use control::{CallbackReply, ContextConfig, JsText};
+pub use control::{CallRequest, CallbackReply, ContextConfig, JsText};
 pub use error::{EngineError, FlagError, InvalidSnapshot, JsError, JsErrorKind, TerminationCause};
 pub use snapshot::{SnapshotBlob, WeakSnapshotBlob};

data/crates/mini_racer_engine/src/process/code_cache.rs

@@ -77,15 +77,26 @@ impl Drop for Building {
 
 /// How the runner compiles a large script.
 pub(crate) enum Plan {
-    /// From source: a first sighting, a key being built elsewhere, a refused
-    /// cache, or the cache is off.
-    Compile,
+    /// From source: a first sighting or the cache is off, or with its key, a
+    /// key being built elsewhere or a refused cache.
+    Compile(Option<Key>),
     /// From source, then a cache made once the dispatch is over.
     Make(Building),
     /// From the entry, falling back to source if V8 refuses it.
     Consume(Arc<Entry>, Key),
 }
 
+impl Plan {
+    /// The key of a script the process has seen before.
+    pub(crate) const fn key(&self) -> Option<&Key> {
+        match self {
+            Self::Compile(key) => key.as_ref(),
+            Self::Make(building) => Some(&building.key),
+            Self::Consume(_, key) => Some(key),
+        }
+    }
+}
+
 impl CodeCache {
     pub(crate) fn plan(
         &'static self,
@@ -94,7 +105,7 @@ impl CodeCache {
         snapshot: Option<u64>,
     ) -> Plan {
         if !enabled() {
-            return Plan::Compile;
+            return Plan::Compile(None);
         }
         let sighting = self.sighting(filename, source, snapshot);
         let seen = touch(&self.sightings, sighting, MAX_SIGHTINGS);
@@ -103,7 +114,7 @@ impl CodeCache {
             .iter()
             .any(|entry| entry.key.sighting == sighting);
         if !seen && !cached {
-            return Plan::Compile;
+            return Plan::Compile(None);
         }
         let key = Key {
             filename: filename.clone(),
@@ -121,9 +132,10 @@ impl CodeCache {
         }
         drop(entries);
         if lock(&self.refused).contains(&key) {
-            return Plan::Compile;
+            return Plan::Compile(Some(key));
         }
-        self.begin(key).map_or(Plan::Compile, Plan::Make)
+        self.begin(key.clone())
+            .map_or(Plan::Compile(Some(key)), Plan::Make)
     }
 
     /// Claims `key` for this context to build, unless another is building it.
@@ -300,7 +312,7 @@ mod tests {
         let cache = cache();
         assert!(matches!(
             cache.plan(&name(), &source(1), None),
-            Plan::Compile
+            Plan::Compile(None)
         ));
         cached(cache, &source(1), Box::from(&b"compiled"[..]));
         assert!(matches!(
@@ -309,11 +321,11 @@ mod tests {
         ));
         assert!(matches!(
             cache.plan(&name(), &source(1), Some(7)),
-            Plan::Compile
+            Plan::Compile(None)
         ));
         assert!(matches!(
             cache.plan(&JsText::from("other.js"), &source(1), None),
-            Plan::Compile
+            Plan::Compile(None)
         ));
     }
 
@@ -355,10 +367,9 @@ mod tests {
         let _ = cache.plan(&name(), &source(3), None);
         let first = cache.plan(&name(), &source(3), None);
         assert!(matches!(first, Plan::Make(..)));
-        assert!(matches!(
-            cache.plan(&name(), &source(3), None),
-            Plan::Compile
-        ));
+        let elsewhere = cache.plan(&name(), &source(3), None);
+        assert!(matches!(elsewhere, Plan::Compile(Some(_))));
+        assert!(elsewhere.key() == first.key());
         drop(first);
         assert!(matches!(
             cache.plan(&name(), &source(3), None),
@@ -402,7 +413,7 @@ mod tests {
         assert_eq!(cache.stored(), 1);
         assert!(matches!(
             cache.plan(&name(), &source(7), None),
-            Plan::Compile
+            Plan::Compile(Some(_))
         ));
         assert!(matches!(
             cache.plan(&name(), &source(6), None),

data/crates/mini_racer_engine/src/process/fork.rs

@@ -7,6 +7,7 @@ use mini_racer_sync::{ForkGate, Phase, lock};
 
 use crate::control::ControlBlock;
 use crate::process::code_cache::CodeCache;
+use crate::process::sources::Sources;
 use crate::process::tasks::TaskRegistry;
 use crate::process::watchdog::Watchdog;
 use crate::process::workers::Workers;
@@ -51,13 +52,14 @@ pub struct Generation {
     watchdog: Mutex<Option<Arc<Watchdog>>>,
     workers: Workers,
     code_cache: CodeCache,
+    sources: Sources,
     next: OnceLock<Box<Self>>,
 }
 
 static ROOT: OnceLock<Generation> = OnceLock::new();
 
 impl Generation {
-    fn new(epoch: u64, quiesced: bool, code_cache: CodeCache) -> Self {
+    fn new(epoch: u64, quiesced: bool, code_cache: CodeCache, sources: Sources) -> Self {
         Self {
             epoch,
             quiesced,
@@ -69,6 +71,7 @@ impl Generation {
             watchdog: Mutex::new(None),
             workers: Workers::default(),
             code_cache,
+            sources,
             next: OnceLock::new(),
         }
     }
@@ -94,6 +97,11 @@ impl Generation {
         &self.code_cache
     }
 
+    #[must_use]
+    pub const fn sources(&self) -> &Sources {
+        &self.sources
+    }
+
     pub fn register(&self, block: &Arc<ControlBlock>) {
         let mut blocks = lock(&self.blocks);
         blocks.retain(|block| block.strong_count() > 0);
@@ -115,7 +123,8 @@ impl Generation {
 
 pub fn current() -> &'static Generation {
     let epoch = epoch();
-    let mut generation = ROOT.get_or_init(|| Generation::new(epoch, true, CodeCache::default()));
+    let mut generation =
+        ROOT.get_or_init(|| Generation::new(epoch, true, CodeCache::default(), Sources::default()));
     while generation.epoch != epoch {
         let quiesced = generation.quiesced && generation.prepared.load(Ordering::SeqCst);
         let next = generation.epoch.saturating_add(1);
@@ -125,6 +134,7 @@ pub fn current() -> &'static Generation {
                 next,
                 quiesced,
                 parent.code_cache.inherited(),
+                parent.sources.inherited(),
             ))
         });
     }