mini_racer-csim 0.21.1.0 → 0.21.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c0d4cbd8123f6177c8411ad1d9e32ff4e8a1a0de0515eb5f030672dd11f3f44
-  data.tar.gz: faba5c80bf42ca1638d37c20f5f7849cd406e10fe5f00bc926fd696824237cdf
+  metadata.gz: 876af5088db34f57853916faa39e0568268bfcce946d44078a263de4f9e45867
+  data.tar.gz: 887bf5d80fd136be29e5f6243bc5fd3185b1020eee67002ae5c03176e75f3a85
 SHA512:
-  metadata.gz: c0d8f9dcc469cd52b999e31e2c677a205aabe343804b70990a7978b2302d2df505c595a38b5de1db16e70358fabea42c950f2ff3b2509f9a94f87f178b0df229
-  data.tar.gz: 5dc7c4ff2147e0a8815eb63d024350db82b2eaade805bb8c5d4834deff7a950a8f44b73cb9d3943f948ce1fda51c82aba464f2384a4e333c5bcfbabad5f6ca6c
+  metadata.gz: 365acff79cbaca1871707ea32e50d1d91dc7f15c23002e260449c1e1a553cb50c211fdb2406bc54b5bb40aa4e5848e915064891943b68dc8b4ca3ac02589a728
+  data.tar.gz: 48dec93bf2a431bedc18c6c7d5b79890d833db748b525bc5f19c22a796adcd6a0e045acf43d5ac9226a5094dbacf4bc5a48a0214dab71983fd993f930d1ce465

data/CHANGELOG

@@ -1,4 +1,18 @@
-- (Unreleased)
+- 0.21.1.2 - 07-06-2026
+  - **Breaking:** move off the `mini_racer` require path / `MiniRacer` namespace to a fork-specific identity so the gem never collides with — and loads deterministically alongside — upstream `mini_racer` in the same bundle
+    - require path: `require 'mini_racer_csim'` (was `require 'mini_racer'`); the `require 'mini_racer-csim'` autorequire shim now points here
+    - Ruby namespace: `MiniRacerCsim` (was `MiniRacer`) — e.g. `MiniRacerCsim::Context`, `MiniRacerCsim::Snapshot`, `MiniRacerCsim::VERSION`
+    - native extensions: `mini_racer_csim_extension` / `mini_racer_csim_loader` (distinct `Init_` symbols and `.so` names)
+    - the JS-side host-namespace brand (`globalThis.MiniRacer` by default) is unchanged — it is embedder-chosen and independent of the Ruby namespace
+
+- 0.21.1.1 - 07-06-2026
+  - Drop the TruffleRuby backend: mini_racer-csim is now a hard fork targeting CRuby/V8 only (the GraalJS/TruffleRuby shims and their tests are removed)
+  - Add per-frame realms via `Context#create_realm`, returning a `MiniRacer::Realm` (multiple V8 realms in one isolate, browser-iframe semantics) with `Realm#eval` / `call` / `attach` / `dispose` / `disposed?`
+    - all realms share one security token so they can reach each other's globals (same-origin iframe model)
+    - `__mr_realmGlobal(id)` returns a realm's live `globalThis` cross-realm; `__mr_realmOf(fn)` reports the realm a callback was created in ([[Realm]]) for WebIDL-style error attribution
+    - unhandled promise rejections are tracked and delivered per realm via `globalThis.__mr_emitUnhandledRejection(reason, promise)`; the queue is purged when a realm is disposed or reset so a stale rejection never fires against a fresh realm
+
+- 0.21.1.0 - 06-06-2026
   - Add `Context#perform_microtask_checkpoint` to synchronously drain the V8 microtask queue, useful for spec-compliant `dispatchEvent` sequencing inside Ruby callbacks
   - Expose V8 ScriptCompiler::CachedData via Context#compile / MiniRacer::Script (#411)
     - script = ctx.compile(src, filename:, cached_data:, produce_cache:) → Script handle

data/README.md

@@ -14,14 +14,14 @@ MiniRacer has an adapter for [execjs](https://github.com/rails/execjs) so it can
 
 This is **`mini_racer-csim`**, a private fork of [`mini_racer`](https://github.com/rubyjs/mini_racer) maintained for [capybara-simulated](https://github.com/ursm/capybara-simulated). It adds browser-fidelity extensions (ES modules, realm reset, …) that capybara-simulated needs but most users do not — **if you are not using capybara-simulated, use upstream `mini_racer`.**
 
-It stays a **drop-in replacement**: the gem is still loaded with `require "mini_racer"` and exposes the `MiniRacer` module, so existing code keeps working. Only the gem name (`mini_racer-csim`) differs.
+It has its **own require path and namespace** so it never collides with — and loads deterministically alongside — upstream `mini_racer` in the same bundle: load it with `require 'mini_racer_csim'` and use the `MiniRacerCsim` module (e.g. `MiniRacerCsim::Context`). The native extensions are `mini_racer_csim_extension` / `mini_racer_csim_loader`. (The JS-side host-namespace brand, `globalThis.MiniRacer` by default, is embedder-chosen and unrelated to the Ruby namespace.)
 
 ### Additions over upstream
 
 | Feature | API | Notes |
 | --- | --- | --- |
 | Bytecode cache | `Context#compile(src, cached_data:, produce_cache:)` → `Script`, `Script#run`, `Script#cache_rejected?` | Cross-process V8 bytecode caching to skip parsing; see [Bytecode cache for repeated script evaluation](#bytecode-cache-for-repeated-script-evaluation) below |
-| ES Module API | `Context#compile_module` → `MiniRacer::Module` (`#instantiate` / `#evaluate` / `#namespace` / `#status` / `#cached_data` / `#dispose`); `Context#dynamic_import_resolver=` | V8's ES module pipeline, `import.meta.url`, dynamic `import()` |
+| ES Module API | `Context#compile_module` → `MiniRacerCsim::Module` (`#instantiate` / `#evaluate` / `#namespace` / `#status` / `#cached_data` / `#dispose`); `Context#dynamic_import_resolver=` | V8's ES module pipeline, `import.meta.url`, dynamic `import()` |
 | Batched module-graph loader | `Context#load_module_graph(resolve:, …)` | Loads an ESM graph in one batched, native (C++) pass; one `Module` per URL shared across every load path |
 | Realm reset | `Context#reset_realm` | Discards the user realm (`globalThis`) while keeping the warm isolate (browser per-navigation model); re-binds attached host functions and the host namespace |
 | Host namespace | `Context.new(host_namespace: "MiniRacer")` → `globalThis.MiniRacer.drainMicrotasks()` | Opt-in JS namespace exposing an inline, rendezvous-free microtask checkpoint |
@@ -31,7 +31,7 @@ The fork is periodically rebased on upstream `mini_racer` to pick up V8 / `libv8
 
 ## Supported Ruby Versions & Troubleshooting
 
-MiniRacer only supports non-EOL versions of Ruby. See [Ruby Maintenance Branches](https://www.ruby-lang.org/en/downloads/branches/) for the list of non-EOL Rubies. If you require support for older versions of Ruby install an older version of the gem. [TruffleRuby](https://github.com/oracle/truffleruby) is also supported.
+MiniRacer only supports non-EOL versions of Ruby. See [Ruby Maintenance Branches](https://www.ruby-lang.org/en/downloads/branches/) for the list of non-EOL Rubies. If you require support for older versions of Ruby install an older version of the gem. (The `mini_racer-csim` fork is CRuby/V8 only — the TruffleRuby backend that upstream supports has been removed.)
 
 MiniRacer **does not support**
 
@@ -55,7 +55,7 @@ If you have a problem installing MiniRacer, please consider the following steps:
 You can simply eval one or many JavaScript snippets in a shared context
 
 ```ruby
-context = MiniRacer::Context.new
+context = MiniRacerCsim::Context.new
 context.eval("var adder = (a,b)=>a+b;")
 puts context.eval("adder(20,22)")
 # => 42
@@ -66,14 +66,14 @@ puts context.eval("adder(20,22)")
 You can attach one or many ruby proc that can be accessed via JavaScript
 
 ```ruby
-context = MiniRacer::Context.new
+context = MiniRacerCsim::Context.new
 context.attach("math.adder", proc{|a,b| a+b})
 puts context.eval("math.adder(20,22)")
 # => 42
 ```
 
 ```ruby
-context = MiniRacer::Context.new
+context = MiniRacerCsim::Context.new
 context.attach("array_and_hash", proc{{a: 1, b: [1, {a: 1}]}})
 puts context.eval("array_and_hash()")
 # => {"a" => 1, "b" => [1, {"a" => 1}]}
@@ -81,14 +81,14 @@ puts context.eval("array_and_hash()")
 
 ### Return binary data from Ruby to JavaScript
 
-Attached Ruby functions can return binary data as `Uint8Array` using `MiniRacer::Binary`:
+Attached Ruby functions can return binary data as `Uint8Array` using `MiniRacerCsim::Binary`:
 
 ```ruby
 require "digest"
 
-context = MiniRacer::Context.new
+context = MiniRacerCsim::Context.new
 context.attach("sha256_raw", ->(data) {
-  MiniRacer::Binary.new(Digest::SHA256.digest(data))
+  MiniRacerCsim::Binary.new(Digest::SHA256.digest(data))
 })
 
 # Inside JavaScript the return value is a Uint8Array
@@ -96,14 +96,14 @@ context.eval("sha256_raw('hello') instanceof Uint8Array") # => true
 context.eval("sha256_raw('hello').length")                 # => 32
 ```
 
-This is useful when you need to pass raw bytes (e.g., cryptographic digests, compressed data, binary file contents) from Ruby to JavaScript. The `MiniRacer::Binary` wrapper tells the bridge to serialize the data as a `Uint8Array` on the JavaScript side rather than a string.
+This is useful when you need to pass raw bytes (e.g., cryptographic digests, compressed data, binary file contents) from Ruby to JavaScript. The `MiniRacerCsim::Binary` wrapper tells the bridge to serialize the data as a `Uint8Array` on the JavaScript side rather than a string.
 
 ### GIL free JavaScript execution
 
 The Ruby Global interpreter lock is released when scripts are executing:
 
 ```ruby
-context = MiniRacer::Context.new
+context = MiniRacerCsim::Context.new
 Thread.new do
   sleep 1
   context.stop
@@ -119,7 +119,7 @@ This allows you to execute multiple scripts in parallel.
 Contexts can specify a default timeout for scripts
 
 ```ruby
-context = MiniRacer::Context.new(timeout: 1000)
+context = MiniRacerCsim::Context.new(timeout: 1000)
 context.eval("while(true){}")
 # => exception is raised after 1 second (1000 ms)
 ```
@@ -130,7 +130,7 @@ Contexts can specify a memory softlimit for scripts
 
 ```ruby
 # terminates script if heap usage exceeds 200mb after V8 garbage collection has run
-context = MiniRacer::Context.new(max_memory: 200_000_000)
+context = MiniRacerCsim::Context.new(max_memory: 200_000_000)
 context.eval("var a = new Array(10000); while(true) {a = a.concat(new Array(10000)) }")
 # => V8OutOfMemoryError is raised
 ```
@@ -140,24 +140,24 @@ context.eval("var a = new Array(10000); while(true) {a = a.concat(new Array(1000
 You can provide `filename:` to `#eval` which will be used in stack traces produced by V8:
 
 ```ruby
-context = MiniRacer::Context.new
+context = MiniRacerCsim::Context.new
 context.eval("var foo = function() {bar();}", filename: "a/foo.js")
 context.eval("bar()", filename: "a/bar.js")
 
-# JavaScript at a/bar.js:1:1: ReferenceError: bar is not defined (MiniRacer::RuntimeError)
+# JavaScript at a/bar.js:1:1: ReferenceError: bar is not defined (MiniRacerCsim::RuntimeError)
 # …
 ```
 
 ### Bytecode cache for repeated script evaluation
 
-`Context#compile` returns a `MiniRacer::Script` handle you can run multiple times,
+`Context#compile` returns a `MiniRacerCsim::Script` handle you can run multiple times,
 and exposes V8's bytecode cache so subsequent Contexts can skip the parse step.
 
 In a single process — e.g. warming a `Context` pool from one canonical compile:
 
 ```ruby
 # Warm the cache once — top-level compile, opt in with produce_cache: true.
-warm    = MiniRacer::Context.new
+warm    = MiniRacerCsim::Context.new
 warmed  = warm.compile(File.read("bundle.js"),
                        filename:      "bundle.js",
                        produce_cache: true)
@@ -165,7 +165,7 @@ warmed.run
 blob = warmed.cached_data   # ASCII-8BIT String, hold onto it in memory
 
 # Subsequent Contexts (e.g. a per-request pool) consume the blob and skip parsing.
-ctx    = MiniRacer::Context.new
+ctx    = MiniRacerCsim::Context.new
 script = ctx.compile(File.read("bundle.js"),
                      filename:    "bundle.js",
                      cached_data: blob)
@@ -180,12 +180,12 @@ blob. Use `Snapshot#dump` / `Snapshot.load` to share canonical bytes:
 
 ```ruby
 # Build the snapshot once, persist its bytes.
-snap_bytes = MiniRacer::Snapshot.new(snapshot_src).dump
+snap_bytes = MiniRacerCsim::Snapshot.new(snapshot_src).dump
 File.binwrite("snapshot.bin", snap_bytes)
 
 # Every process loads the same bytes.
-snap = MiniRacer::Snapshot.load(File.binread("snapshot.bin"))
-ctx  = MiniRacer::Context.new(snapshot: snap)
+snap = MiniRacerCsim::Snapshot.load(File.binread("snapshot.bin"))
+ctx  = MiniRacerCsim::Context.new(snapshot: snap)
 script = ctx.compile(File.read("bundle.js"),
                      filename:    "bundle.js",
                      cached_data: File.binread("bundle.js.cache"))
@@ -198,14 +198,14 @@ callers can skip a redundant copy. When V8 produces a fresh blob (initial compil
 with `produce_cache: true`, or a rejection while `produce_cache: true` was also
 set), it returns the new bytes.
 
-`MiniRacer::V8_CACHED_DATA_VERSION_TAG` exposes V8's
+`MiniRacerCsim::V8_CACHED_DATA_VERSION_TAG` exposes V8's
 `ScriptCompiler::CachedDataVersionTag()` — mix it into your cache key alongside
 the source hash so a libv8-node version bump invalidates stale blobs automatically.
 The constant is populated on first `Context.new` (after `Platform.set_flags!`),
 so read it after constructing at least one Context.
 
 ```ruby
-key = "#{Digest::SHA256.hexdigest(source)}-#{MiniRacer::V8_CACHED_DATA_VERSION_TAG}"
+key = "#{Digest::SHA256.hexdigest(source)}-#{MiniRacerCsim::V8_CACHED_DATA_VERSION_TAG}"
 ```
 
 Notes:
@@ -218,32 +218,28 @@ Notes:
   `Context#dispose` clears them.
 - `produce_cache: true` is only safe at the top level. From inside a host-fn
   callback (i.e., re-entrant compile while a JS → Ruby → JS frame is on the
-  stack) it raises `MiniRacer::RuntimeError`, because V8's `CreateCodeCache`
+  stack) it raises `MiniRacerCsim::RuntimeError`, because V8's `CreateCodeCache`
   walks live isolate state and corrupts the parser when re-entered. Warm the
   cache from the top level once and pass it back via `cached_data:` from your
   callbacks.
-- Cross-process reuse is **incompatible with `MiniRacer::Platform.set_flags!(:single_threaded)`**.
+- Cross-process reuse is **incompatible with `MiniRacerCsim::Platform.set_flags!(:single_threaded)`**.
   V8's single-threaded mode embeds process-local state in the cache blob, so
   every cached_data is rejected when consumed in a fresh process. Same-process
   reuse still works under `:single_threaded`. If you need both cross-process
   reuse and `:single_threaded` (e.g. for fork-safety reasons), disable
   `:single_threaded` for the path that produces / consumes the cache.
-- On TruffleRuby, `Script` is implemented as source replay (GraalJS has no
-  equivalent per-script bytecode cache reachable from `Polyglot::InnerContext`),
-  so `cached_data` and `produce_cache` are silently ignored and `cached_data`
-  always returns `nil`, and `MiniRacer::V8_CACHED_DATA_VERSION_TAG` is `0`.
 
 ### Fork Safety
 
 Some Ruby web servers employ forking (for example unicorn or puma in clustered mode). V8 is not fork safe by default and sadly Ruby does not have support for fork notifications per [#5446](https://bugs.ruby-lang.org/issues/5446).
 
-Since 0.6.1 mini_racer does support V8 single threaded platform mode which should remove most forking related issues. To enable run this before using `MiniRacer::Context`, for example in a Rails initializer:
+Since 0.6.1 mini_racer does support V8 single threaded platform mode which should remove most forking related issues. To enable run this before using `MiniRacerCsim::Context`, for example in a Rails initializer:
 
 ```ruby
-MiniRacer::Platform.set_flags!(:single_threaded)
+MiniRacerCsim::Platform.set_flags!(:single_threaded)
 ```
 
-When using pre-fork `MiniRacer::Context` objects in `:single_threaded` mode,
+When using pre-fork `MiniRacerCsim::Context` objects in `:single_threaded` mode,
 ensure the process only forks while MiniRacer is quiescent: no thread may be
 evaluating JavaScript, calling into a context, disposing/freeing a context,
 running a Ruby callback from JavaScript, or otherwise using MiniRacer at the
@@ -254,14 +250,14 @@ in an unusable state in the child process.
 
 If you want to ensure your application does not leak memory after fork either:
 
-1. Ensure no `MiniRacer::Context` objects are created in the master process; or
-2. Dispose manually of all `MiniRacer::Context` objects prior to forking
+1. Ensure no `MiniRacerCsim::Context` objects are created in the master process; or
+2. Dispose manually of all `MiniRacerCsim::Context` objects prior to forking
 
 ```ruby
 # before fork
 
 require "objspace"
-ObjectSpace.each_object(MiniRacer::Context){|c| c.dispose}
+ObjectSpace.each_object(MiniRacerCsim::Context){|c| c.dispose}
 
 # fork here
 ```
@@ -271,7 +267,7 @@ ObjectSpace.each_object(MiniRacer::Context){|c| c.dispose}
 Context usage is threadsafe
 
 ```ruby
-context = MiniRacer::Context.new
+context = MiniRacerCsim::Context.new
 context.eval("counter=0; plus=()=>counter++;")
 
 (1..10).map do
@@ -289,9 +285,9 @@ puts context.eval("counter")
 Contexts can be created with pre-loaded snapshots:
 
 ```ruby
-snapshot = MiniRacer::Snapshot.new("function hello() { return 'world!'; }")
+snapshot = MiniRacerCsim::Snapshot.new("function hello() { return 'world!'; }")
 
-context = MiniRacer::Context.new(snapshot: snapshot)
+context = MiniRacerCsim::Context.new(snapshot: snapshot)
 
 context.eval("hello()")
 # => "world!"
@@ -313,11 +309,11 @@ Snapshots can come in handy for example if you want your contexts to be pre-load
 Also note that snapshots can be warmed up, using the `warmup!` method, which allows you to call functions which are otherwise lazily compiled to get them to compile right away; any side effect of your warm up code being then dismissed. [More details on warming up here](https://github.com/electron/electron/issues/169#issuecomment-76783481), and a small example:
 
 ```ruby
-snapshot = MiniRacer::Snapshot.new("var counter = 0; function hello() { counter++; return 'world! '; }")
+snapshot = MiniRacerCsim::Snapshot.new("var counter = 0; function hello() { counter++; return 'world! '; }")
 
 snapshot.warmup!("hello()")
 
-context = MiniRacer::Context.new(snapshot: snapshot)
+context = MiniRacerCsim::Context.new(snapshot: snapshot)
 
 context.eval("hello()")
 # => "world! 1"
@@ -329,13 +325,13 @@ Snapshots can also be persisted to disk for faster startup:
 
 ```ruby
 # Save a snapshot to disk
-snapshot = MiniRacer::Snapshot.new('var foo = "bar";')
+snapshot = MiniRacerCsim::Snapshot.new('var foo = "bar";')
 File.binwrite("snapshot.bin", snapshot.dump)
 
 # Load it back in a later process
 blob = File.binread("snapshot.bin")
-snapshot = MiniRacer::Snapshot.load(blob)
-context = MiniRacer::Context.new(snapshot: snapshot)
+snapshot = MiniRacerCsim::Snapshot.load(blob)
+context = MiniRacerCsim::Context.new(snapshot: snapshot)
 context.eval("foo")
 # => "bar"
 ```
@@ -346,26 +342,26 @@ Note that snapshots are architecture and V8-version specific. A snapshot created
 
 ### Garbage collection
 
-You can make the garbage collector more aggressive by defining the context with `MiniRacer::Context.new(ensure_gc_after_idle: 1000)`. Using this will ensure V8 will run a full GC using `context.low_memory_notification` 1 second after the last eval on the context. Low memory notifications ensure long living contexts use minimal amounts of memory.
+You can make the garbage collector more aggressive by defining the context with `MiniRacerCsim::Context.new(ensure_gc_after_idle: 1000)`. Using this will ensure V8 will run a full GC using `context.low_memory_notification` 1 second after the last eval on the context. Low memory notifications ensure long living contexts use minimal amounts of memory.
 
 ### V8 Runtime flags
 
 It is possible to set V8 Runtime flags:
 
 ```ruby
-MiniRacer::Platform.set_flags! :noconcurrent_recompilation, max_inlining_levels: 10
+MiniRacerCsim::Platform.set_flags! :noconcurrent_recompilation, max_inlining_levels: 10
 ```
 
 This can come in handy if you want to use MiniRacer with Unicorn, which doesn't seem to always appreciate V8's liberal use of threading:
 
 ```ruby
-MiniRacer::Platform.set_flags! :noconcurrent_recompilation, :noconcurrent_sweeping
+MiniRacerCsim::Platform.set_flags! :noconcurrent_recompilation, :noconcurrent_sweeping
 ```
 
 Or else to unlock experimental features in V8, for example tail recursion optimization:
 
 ```ruby
-MiniRacer::Platform.set_flags! :harmony
+MiniRacerCsim::Platform.set_flags! :harmony
 
 js = <<-JS
 'use strict';
@@ -379,13 +375,13 @@ var f = function f(n){
 f(1e6);
 JS
 
-context = MiniRacer::Context.new
+context = MiniRacerCsim::Context.new
 
 context.eval js
 # => "foo"
 ```
 
-The same code without the harmony runtime flag results in a `MiniRacer::RuntimeError: RangeError: Maximum call stack size exceeded` exception.
+The same code without the harmony runtime flag results in a `MiniRacerCsim::RuntimeError: RangeError: Maximum call stack size exceeded` exception.
 Please refer to http://node.green/ as a reference on other harmony features.
 
 A list of all V8 runtime flags can be found using `node --v8-options`, or else by perusing [the V8 source code for flags (make sure to use the right version of V8)](https://github.com/v8/v8/blob/master/src/flags/flag-definitions.h).
@@ -404,7 +400,7 @@ Flags:
 When hosting v8 you may want to keep track of memory usage, use `#heap_stats` to get memory usage:
 
 ```ruby
-context = MiniRacer::Context.new
+context = MiniRacerCsim::Context.new
 # use context
 p context.heap_stats
 # {:total_physical_size=>1280640,
@@ -417,11 +413,11 @@ p context.heap_stats
 If you wish to dispose of a context before waiting on the GC use `#dispose`:
 
 ```ruby
-context = MiniRacer::Context.new
+context = MiniRacerCsim::Context.new
 context.eval("let a='testing';")
 context.dispose
 context.eval("a = 2")
-# MiniRacer::ContextDisposedError
+# MiniRacerCsim::ContextDisposedError
 
 # nothing works on the context from now on, it's a shell waiting to be disposed
 ```
@@ -429,7 +425,7 @@ context.eval("a = 2")
 A MiniRacer context can also be dumped in a heapsnapshot file using `#write_heap_snapshot(file_or_io)`
 
 ```ruby
-context = MiniRacer::Context.new
+context = MiniRacerCsim::Context.new
 # use context
 context.write_heap_snapshot("test.heapsnapshot")
 ```
@@ -441,7 +437,7 @@ This file can then be loaded in the "memory" tab of the [Chrome DevTools](https:
 This calls the function passed as first argument:
 
 ```ruby
-context = MiniRacer::Context.new
+context = MiniRacerCsim::Context.new
 context.eval("function hello(name) { return `Hello, ${name}!` }")
 context.call("hello", "George")
 # "Hello, George!"
@@ -457,7 +453,7 @@ Performance is slightly better than running `context.eval("hello('George')")` si
 V8 drains its microtask queue (e.g. callbacks queued via `Promise.resolve().then(...)`) automatically when script execution returns to the embedder, so most code "just works":
 
 ```ruby
-context = MiniRacer::Context.new
+context = MiniRacerCsim::Context.new
 context.eval(<<~JS)
   let x = 0;
   Promise.resolve().then(() => x = 99);
@@ -469,7 +465,7 @@ context.eval("x")
 When JavaScript invokes a Ruby callback synchronously and you need queued microtasks to drain mid-execution — e.g. for spec-compliant ordering across a chain of synchronous `dispatchEvent` listeners — call `context.perform_microtask_checkpoint` from the callback:
 
 ```ruby
-context = MiniRacer::Context.new
+context = MiniRacerCsim::Context.new
 context.attach("drain", -> { context.perform_microtask_checkpoint })
 context.eval(<<~JS)
   globalThis.log = [];
@@ -489,7 +485,7 @@ When the drain has to happen from within JavaScript itself — for example betwe
 It is exposed through an opt-in **host namespace** — a single object (in the spirit of Deno's `Deno` or Bun's `Bun`) that mini_racer hangs its non-standard helpers off. Pass `host_namespace:` to enable it; by default nothing is injected and the global stays clean:
 
 ```ruby
-context = MiniRacer::Context.new(host_namespace: "MiniRacer")
+context = MiniRacerCsim::Context.new(host_namespace: "MiniRacer")
 context.eval(<<~JS)
   globalThis.log = [];
   Promise.resolve().then(() => log.push("microtask"));
@@ -501,7 +497,7 @@ context.eval("log")
 # => ["before", "microtask", "after"]
 ```
 
-`host_namespace:` accepts a String (the global name to use — it must be a valid JavaScript identifier), `true` (the default name `"MiniRacer"`), or `nil`/`false` (the default — inject nothing). The namespace object is defined non-enumerable so it does not appear in `Object.keys(globalThis)`, while its methods are ordinary properties discoverable via `Object.keys(MiniRacer)`. Like `perform_microtask_checkpoint`, `drainMicrotasks()` is a no-op while a microtask checkpoint is already in progress, and it lets watchdog/out-of-memory termination propagate to the enclosing `eval`/`call`. (The host namespace is V8-only; it is not installed on the TruffleRuby backend.)
+`host_namespace:` accepts a String (the global name to use — it must be a valid JavaScript identifier), `true` (the default name `"MiniRacer"`), or `nil`/`false` (the default — inject nothing). The namespace object is defined non-enumerable so it does not appear in `Object.keys(globalThis)`, while its methods are ordinary properties discoverable via `Object.keys(MiniRacer)`. Like `perform_microtask_checkpoint`, `drainMicrotasks()` is a no-op while a microtask checkpoint is already in progress, and it lets watchdog/out-of-memory termination propagate to the enclosing `eval`/`call`.
 
 ### ES modules
 
@@ -511,7 +507,7 @@ syntax), modules can have static imports that resolve to other modules and
 expose named exports through a real Module Namespace Object.
 
 ```ruby
-context = MiniRacer::Context.new
+context = MiniRacerCsim::Context.new
 
 dep  = context.compile_module("export const base = 10", filename: "dep.js")
 main = context.compile_module(<<~JS, filename: "main.js")
@@ -527,18 +523,18 @@ main.namespace  # => {"doubled" => 20}
 ```
 
 * `Context#compile_module(source, filename:)` — parses the source as a
-  module; the returned `MiniRacer::Module` is bound to its Context. The
+  module; the returned `MiniRacerCsim::Module` is bound to its Context. The
   `filename` is also exposed to the module as `import.meta.url`.
 * `Module#instantiate { |specifier, referrer_url| ... }` — walks the static
   import graph. The resolver block is called once per import declaration
   with the raw specifier string and the importing module's filename, so
   relative specifiers (`./foo`, `../bar`) can be resolved against the
-  referrer. It must return another `MiniRacer::Module` (typically from a
+  referrer. It must return another `MiniRacerCsim::Module` (typically from a
   per-Context cache). Imports can also be resolved lazily from inside the
   block via further `Context#compile_module` calls.
 * `Module#evaluate` — runs the module body. Returns the evaluation result
   (`nil` for the typical `export const …` shape). Modules with top-level
-  `await` raise `MiniRacer::RuntimeError` for now.
+  `await` raise `MiniRacerCsim::RuntimeError` for now.
 * `Module#namespace` — returns the Module Namespace Object as a Hash
   (`{ "default" => …, "namedExport" => … }`). Available after
   `instantiate` succeeds; `evaluate` populates the values.
@@ -548,7 +544,7 @@ main.namespace  # => {"doubled" => 20}
   the convention used elsewhere.
 * `Context#dynamic_import_resolver = proc { |specifier, referrer_url| ... }`
   — handler for JS `import(...)` expressions. The proc must return a
-  `MiniRacer::Module` (already instantiated; `evaluate` is driven for you
+  `MiniRacerCsim::Module` (already instantiated; `evaluate` is driven for you
   if pending). Set to `nil` to reject all dynamic imports. Drain the
   microtask queue with `Context#perform_microtask_checkpoint` to see the
   result in a `.then` callback or after `await`.
@@ -570,9 +566,6 @@ Notes:
   accumulate handles until `Context#dispose` clears them.
 - Top-level await is not yet supported; `evaluate` raises if the
   module's evaluation promise stays pending after the microtask drain.
-- On TruffleRuby, `Context#compile_module` raises `NotImplementedError`
-  — GraalJS has its own module-loading mechanism that doesn't map onto
-  this handle-based API. PRs to bridge are welcome.
 
 ## Performance
 

data/ext/{mini_racer_extension → mini_racer_csim_extension}/extconf.rb

@@ -1,14 +1,9 @@
 require 'mkmf'
 
-$srcs = ["mini_racer_extension.c", "mini_racer_v8.cc"]
+$srcs = ["mini_racer_csim_extension.c", "mini_racer_v8.cc"]
 
-if RUBY_ENGINE == "truffleruby"
-  File.write("Makefile", dummy_makefile($srcdir).join(""))
-  return
-end
-
-require_relative '../../lib/mini_racer/version'
-gem 'libv8-node', MiniRacer::LIBV8_NODE_VERSION
+require_relative '../../lib/mini_racer_csim/version'
+gem 'libv8-node', MiniRacerCsim::LIBV8_NODE_VERSION
 require 'libv8-node'
 
 IS_DARWIN = RUBY_PLATFORM =~ /darwin/
@@ -72,4 +67,4 @@ if RUBY_ENGINE == 'ruby'
   $CPPFLAGS += ' -DENGINE_IS_CRUBY '
 end
 
-create_makefile 'mini_racer_extension'
+create_makefile 'mini_racer_csim_extension'