capybara-simulated 0.5.0 → 0.6.0

data/lib/capybara/simulated/quickjs_runtime.rb

@@ -225,11 +225,19 @@ module Capybara
       # introduce a NoMethodError window for any stray post-close call (eval/call
       # don't all nil-guard `@vm`) with no leak benefit.
 
-      # bridge.js patches `Intl.DateTimeFormat`; rusty_racer ships ICU
-      # built-in but QuickJS gates it behind a polyfill flag. Other JS
-      # surfaces bridge.js touches (URL / TextEncoder / atob/btoa /
-      # crypto) are already routed through Ruby-side host fns, so
-      # POLYFILL_INTL is the only one we strictly need.
+      # bridge.js patches `Intl.DateTimeFormat`; rusty_racer ships ICU built-in but
+      # QuickJS gates it behind a polyfill flag (other surfaces bridge.js touches —
+      # URL / TextEncoder / atob/btoa / crypto — already route through Ruby host fns,
+      # so POLYFILL_INTL is the only one we strictly need).
+      #
+      # PERF (rule 3): quickjs is pinned to `~> 0.18.0` in the Gemfile. quickjs 0.19
+      # both split the Intl polyfills into a separate quickjs-polyfill-intl gem (which
+      # eval's them per VM at ~226 ms — vs this single bundled flag's ~140 ms) AND
+      # regressed interpreter execution ~2.8× (measured: the QuickJS spec suite ran
+      # 5.6 min on 0.18 vs 15.5 min on 0.19 with an equivalent Intl set). The 0.19
+      # migration is recorded in the cross-window / quickjs-CI memory; re-migrate to
+      # 0.19 + quickjs-polyfill-intl once that upstream perf regression is fixed.
+      INTL_FEATURES = [Quickjs::POLYFILL_INTL].freeze
       #
       # `max_stack_size: 0` — `JS_SetMaxStackSize` measures C stack
       # delta from runtime construction; Ruby callers reach QuickJS
@@ -245,7 +253,7 @@ module Capybara
       # handler returns `elapsed >= limit_ms`, so 0 fires on the first
       # check), so practical no-limit.
       VM_OPTIONS = {
-        features:       [Quickjs::POLYFILL_INTL].freeze,
+        features:       INTL_FEATURES,
         max_stack_size: 0,
         # quickjs.rb's 128 MB default trips "out of memory in regexp
         # execution" on class-attribute-heavy polls and the heaviest
@@ -353,6 +361,9 @@ module Capybara
         # flip doesn't race main's `polling?` gate. See v8_runtime's
         # build_worker for the long-form rationale.
         vm.define_function('__setTimersActive') {|_flag| nil }
+        # importScripts runs a classic script at top-level scope so its top-level
+        # const/let/class share the realm's global lexical env (see v8_runtime).
+        vm.define_function('__csim_workerImportEval') {|src| vm.eval_code(src.to_s); nil }
         vm.eval_code('__csim_installWorkerScope();')
         vm.drain_jobs!
         WorkerRuntime.new(

data/lib/capybara/simulated/runtime_shared.rb

@@ -49,6 +49,10 @@ module Capybara
         # realm id). Deferred + applied by re-navigating the owning iframe, so a
         # frame's `location.href = …` navigates the frame, not the top page.
         '__csimFrameNavigate'        => ->(b, *a) { b.frame_navigate_self(a[0], a[1].to_i); nil },
+        # A same-origin window realm (window.open in this isolate) navigating itself
+        # (a[0] = url, a[1] = the window's realm id). Deferred + applied by reloading
+        # that realm's document in place — see Browser#window_realm_navigate_self.
+        '__csimWindowRealmNavigate'  => ->(b, *a) { b.window_realm_navigate_self(a[0], a[1].to_i); nil },
         # A nested browsing context reloading its OWN location (a[0] = the frame's
         # realm id). Deferred + applied by re-navigating the owning iframe to its
         # current document — see Browser#frame_reload_self.
@@ -57,6 +61,7 @@ module Capybara
         # initiating frame's realm id). Deferred + applied against that realm,
         # like __csimFrameNavigate — see Browser#frame_submit_self.
         '__csimFrameSubmit'          => ->(b, *a) { b.frame_submit_self(a[0].to_i); nil },
+        '__csimFrameHistoryGo'       => ->(b, *a) { b.frame_history_go(a[0].to_i, a[1].to_i); nil },
         '__setTimersActive'          => ->(b, *a) { b.timers_active = !!a[0]; nil },
         '__setCurrentUrl'            => ->(b, *a) { b.history_state(a[0], a[1]); nil },
         '__pushHistoryEntry'         => ->(b, *a) { b.history_push(a[0], a[1]); nil },
@@ -83,20 +88,37 @@ module Capybara
         '__csim_wsClose'             => ->(b, *a) { b.ws_close(a[0], a[1], a[2]); nil },
         '__csim_rackFetchAsync'      => ->(b, *a) { b.rack_fetch_async(a[0], a[1], a[2], a[3]) },
         '__csim_rackFetchAsyncAbort' => ->(b, *a) { b.rack_fetch_async_abort(a[0]); nil },
-        # Cross-window references (window.open / opener / postMessage). Each
-        # window is a separate VM, so these forward to the Driver to route to
-        # the target window's Browser.
-        '__csimWindowOpen'           => ->(b, *a) { b.open_child_window(a[0], a[1]) },
+        # Cross-window references (window.open / opener / postMessage). A separate-VM
+        # aux window forwards to the Driver; a same-origin window realm lives in this
+        # isolate. a[2] is the opener's realm id (for wiring window.opener).
+        '__csimWindowOpen'           => ->(b, *a) { b.open_child_window(a[0], a[1], a[2]) },
+        # A `target=_blank`/named link/area activation from a frame or window realm:
+        # open a new auxiliary window (the realm's VM isn't rebuilt — a fresh window
+        # is). `opener` = rel=opener (target=_blank defaults to noopener); the Driver
+        # forces noopener for a cross-partition blob: target.
+        '__csimOpenAuxFromRealm'     => ->(b, *a) { b.open_aux_from_realm(a[0], a[1], a[2]); nil },
         '__csimWindowPostMessage'    => ->(b, *a) { b.post_message_to_window(a[0], a[1], a[2]); nil },
-        '__csimBroadcast'            => ->(b, *a) { b.broadcast_to_windows(a[0], a[1]); nil },
+        '__csimBroadcast'            => ->(b, *a) { b.broadcast_to_windows(a[0], a[1], a[2].to_i); nil },
         '__csimWindowGet'            => ->(b, *a) { b.window_get(a[0], a[1]) },
         '__csimWindowDocGet'         => ->(b, *a) { b.window_doc_get(a[0], a[1]) },
+        # Cross-window remote-ref RPC: route an opener's node/object proxy op to
+        # the target window's VM (a[0]=window handle, a[1]=ref id, a[2]=prop/method).
+        '__csimWindowRefGet'         => ->(b, *a) { b.window_ref_get(a[0], a[1], a[2]) },
+        '__csimWindowRefSet'         => ->(b, *a) { b.window_ref_set(a[0], a[1], a[2], a[3]); nil },
+        '__csimWindowRefCall'        => ->(b, *a) { b.window_ref_call(a[0], a[1], a[2], a[3]) },
         '__csimWindowLocation'       => ->(b, *a) { b.window_location_of(a[0]) },
         '__csimWindowSetLocation'    => ->(b, *a) { b.set_window_location(a[0], a[1]); nil },
+        '__csimWindowHistoryGo'      => ->(b, *a) { b.window_history_go(a[0], a[1]) },
         '__csimWindowClosed'         => ->(b, *a) { b.window_closed?(a[0]) },
         '__csimWindowClose'          => ->(b, *a) { b.close_child_window(a[0]); nil },
         '__csimWindowOpener'         => ->(b, *_) { b.opener_handle },
+        # Fire an aux window's OWN `load` event (in its VM) — deferred by the
+        # opener so a child `window.onload` runs after the opener's current task.
+        '__csimFireAuxWindowLoad'    => ->(b, *a) { b.fire_aux_window_load(a[0]); nil },
         '__csim_workerSpawn'         => ->(b, *a) { b.worker_spawn(a[0], shared: !!a[1]) },
+        # navigator.serviceWorker.register (universal-server only) — spawn a worker
+        # running the SW script as an executor context. Returns its handle.
+        '__csim_serviceWorkerRegister' => ->(b, *a) { b.worker_spawn(a[0], service: true) },
         '__csim_workerPostToWorker'  => ->(b, *a) { b.worker_post_to_worker(a[0], a[1]); nil },
         '__csim_workerTerminate'     => ->(b, *a) { b.worker_terminate(a[0]); nil },
         '__csim_decodeImage'         => ->(b, *a) { b.decode_image(a[0], a[1], a[2]) },
@@ -116,6 +138,11 @@ module Capybara
         '__csim_transferFetch'       => ->(b, *a) { b.transfer_buffer_fetch_for_js(a[0]) },
         # Zero-copy postMessage transfer-token bookkeeping (see Browser#drop_pending_transfers).
         '__csim_transferIssued'      => ->(b, *a) { b.transfer_token_issued(a[0]); nil },
+        # Universal-server context (WPT runner)? Gates cross-origin eager frame
+        # building: only there is a cross-origin iframe's content served locally,
+        # so an ordinary app leaves cross-origin frames lazy (= baseline) and never
+        # eager-@app.calls a foreign URL (side effects: extra visit / log row).
+        '__csim_allHostsLocal'       => ->(b, *a) { b.send(:all_hosts_local?) },
         '__csim_decodeVideoFrame'    => ->(b, *a) { b.decode_video_frame(a[0]) },
         '__csim_encodeImage'         => ->(b, *a) { b.encode_image(a[0], a[1], a[2], a[3], a[4]) },
         # WebAuthn create / get raise `WebauthnState::Error` carrying

data/lib/capybara/simulated/v8_runtime.rb

@@ -106,18 +106,8 @@ module Capybara
           @ctx        = @iso.context
           @attached   = []
           @generation = 0
-          # rusty's heap-accounting API (heap_statistics / low_memory_notification)
-          # landed in 0.1.9. Probe the real Isolate once here — the Ctx wrapper
-          # delegates these unconditionally, so a `respond_to?` on the wrapper
-          # would always be true and never gate the version. Cached so the
-          # per-visit pressure check (rule 3) is an ivar read, not a dispatch.
-          @heap_accounting = @iso.respond_to?(:heap_statistics)
         end
 
-        # True iff the underlying rusty Isolate exposes the 0.1.9 heap-accounting
-        # API. Drives `relieve_heap_pressure`'s version gate.
-        def heap_accounting? = @heap_accounting
-
         # ── Context surface ─────────────────────────────────────────
         # rusty drains microtasks at call-depth zero (V8's default kAuto
         # policy), so a returned eval/call has already run its end-of-script
@@ -162,8 +152,8 @@ module Capybara
         def terminate                        = @iso.terminate
         def dispose                          = @iso.dispose
         def perform_microtask_checkpoint     = @iso.perform_microtask_checkpoint
-        # rusty >= 0.1.9: V8 heap accounting + a forced full GC. Used by the
-        # per-visit heap-pressure relief in `rebuild_ctx` (see there).
+        # V8 heap accounting + a forced full GC (rusty >= 0.1.9, the gem's
+        # floor). Used by the per-visit heap-pressure relief in `rebuild_ctx`.
         def heap_statistics                  = @iso.heap_statistics
         def low_memory_notification          = @iso.low_memory_notification
 
@@ -374,6 +364,10 @@ module Capybara
       # Browser's `@current_realm_id` may still point at it; the Browser uses
       # this to raise a stale-element instead of running a frame handle op
       # against the main registry.
+      # Ids of every live frame / window realm in this isolate (excludes the main
+      # realm, id 0). Used to fan a BroadcastChannel post out to sibling realms.
+      def frame_realm_ids = frame_realms.keys
+
       def frame_realm_alive?(realm_id)
         !(realm_id.nil? || realm_id.zero?) && frame_realms.key?(realm_id)
       end
@@ -410,9 +404,29 @@ module Capybara
       # nothing else would ever free them.
       def frame_realms = (@frame_realms ||= {})
 
+      # Parent realm id per frame realm, captured at `create_frame_realm` time
+      # (parallel to `@frame_realm_depths`). Lets a form/navigation that reaches a
+      # frame via `contentWindow` (so it never entered `within_frame` and has no
+      # `@frame_stack` entry) recover the realm that OWNS the iframe element, to
+      # rebuild + rebind it. 0/nil = the main realm.
+      def frame_realm_parents = (@frame_realm_parents ||= {})
+
+      def frame_realm_parent(realm_id)
+        return 0 if realm_id.nil? || realm_id.zero?
+        frame_realm_parents[realm_id] || 0
+      end
+
+      # Per-window-realm metadata (opener id + window.name) captured at create time so a
+      # window's self-navigation (which builds a fresh realm via `reload_window_realm`)
+      # can carry them across, the way a real popup keeps `window.opener` / `window.name`
+      # through its own navigation.
+      def window_realm_meta = (@window_realm_meta ||= {})
+
       def dispose_frame_realms
         @realm_module_handles&.clear
         @frame_realm_depths&.clear
+        @frame_realm_parents&.clear
+        @window_realm_meta&.clear
         return if @frame_realms.nil?
         @frame_realms.each_value {|fr| fr.dispose rescue nil }
         @frame_realms.clear
@@ -430,6 +444,18 @@ module Capybara
         create_frame_realm(ctx, url, body, content_type, parent_id)
       end
 
+      # Navigate a window realm (`win.location = …`): a FRESH realm for the new
+      # document, like reload_frame_realm — an in-place `__csimLoadDocument` on an
+      # already-loaded realm does NOT re-run inline scripts, but a fresh realm does.
+      # Returns the new realm's context id. (The opener's WindowProxy, keyed by the
+      # old id, goes stale across this — acceptable while no window.open test scripts
+      # the window after navigating it; a stable WindowProxy is future work.)
+      def reload_window_realm(old_id, url, body, content_type)
+        meta = window_realm_meta[old_id] || {}
+        dispose_frame_realm(old_id)
+        create_window_realm(url, body, content_type, opener_id: meta[:opener_id], window_name: meta[:window_name])
+      end
+
       # Tear down a single frame realm (e.g. a descendant frame destroyed when an
       # ancestor frame re-navigates). No-op for nil/0/unknown ids.
       def dispose_frame_realm(id)
@@ -439,6 +465,14 @@ module Capybara
         @browser.revoke_realm_blobs(id) rescue nil
         @realm_module_handles&.delete(id)
         @frame_realm_depths&.delete(id)
+        @frame_realm_parents&.delete(id)
+        @window_realm_meta&.delete(id)
+        # Evict from the main realm's child-realm set so `drainChildRealms` stops
+        # stepping a disposed context. A FRAME realm is also evicted via the DOM
+        # unregister path (its iframe element going away), but a WINDOW realm has no
+        # element — this is its only eviction, and it covers the reload (dispose +
+        # recreate) path too, where the old id would otherwise leak in the set.
+        ctx.eval("globalThis.__csimChildRealmIds && globalThis.__csimChildRealmIds.delete(#{id.to_i});") rescue nil
         fr = frame_realms.delete(id)
         fr.dispose rescue nil if fr
         nil
@@ -577,10 +611,10 @@ module Capybara
       # the GC itself only fires once a multi-visit spec has actually piled up
       # dead realms — measured at ~once per 25-50 iframe-heavy visits, reclaiming
       # native contexts back to 1 and the heap to baseline — so the amortized
-      # cost is negligible while memory stays bounded. No-op on rusty < 0.1.9
-      # (no heap_statistics) or when disabled.
+      # cost is negligible while memory stays bounded. No-op when disabled
+      # (GC_PRESSURE_MB <= 0).
       def relieve_heap_pressure
-        return unless GC_PRESSURE_MB.positive? && @ctx.heap_accounting?
+        return unless GC_PRESSURE_MB.positive?
         s    = @ctx.heap_statistics
         over = (s[:used_heap_size].to_i + s[:external_memory].to_i) > GC_PRESSURE_MB * 1_048_576
         if HEAP_DIAG
@@ -596,8 +630,8 @@ module Capybara
                       a[:used_heap_size].to_i >> 20, a[:number_of_native_contexts].to_i))
         end
       rescue StandardError
-        # Older rusty without the diagnostics API, or a transient read failure —
-        # heap relief is best-effort, never fail a visit over it.
+        # A transient read failure — heap relief is best-effort, never fail a
+        # visit over it.
       end
 
       # Built lazily on first use, on the calling (main) thread. There is no
@@ -726,6 +760,23 @@ module Capybara
 
       def frame_realm_depths = (@frame_realm_depths ||= {})
 
+      # Bring a freshly-created realm context up to a runnable bridge, shared by the
+      # frame and window realm constructors. Re-evaling the snapshot source would
+      # redefine snapshot globals (e.g. the `scrollX` accessor) and throw, so only
+      # eval it on a bare no-snapshot dev ctx where the realm boots empty. The
+      # replayed `__csim_runScriptCached` / `__csim_evalEsmEntry` close over the MAIN
+      # ctx they were first attached to, so a realm script routing through them
+      # (leading-lexical, ≥64KB, or `type=module`) would run against the main
+      # document — rebind realm-executing variants on top, then reseed per-realm JS.
+      def seed_realm_bridge(realm)
+        has_bridge = realm.eval("typeof __csimLoadDocument === 'function'")
+        realm.eval(RuntimeShared.snapshot_src) unless has_bridge
+        attach_run_script_with_cache(realm)
+        attach_realm_esm_entry(realm)
+        reseed_realm_js(realm)
+        realm
+      end
+
       def create_frame_realm(parent_ctx, url, body, content_type, parent_id = 0, frame_name = nil, frame_doc_origin = nil, frame_location_origin = nil, js_url_source = nil)
         depth = (frame_realm_depths[parent_id] || 0) + 1
         if depth > MAX_FRAME_DEPTH
@@ -738,21 +789,9 @@ module Capybara
         # (their create_frame_realm looks up this realm's depth as their parent's),
         # so it must already be set or the nested depth undercounts and the cap
         # never trips.
-        frame_realm_depths[realm.id] = depth
-        # Re-evaling the snapshot source would redefine snapshot globals (e.g.
-        # the `scrollX` accessor) and throw — re-entrantly. Only eval the
-        # source on a bare no-snapshot dev ctx, where the realm boots empty.
-        # Host fns are replayed onto the realm by `Ctx#create_context`.
-        has_bridge = realm.eval("typeof __csimLoadDocument === 'function'")
-        realm.eval(RuntimeShared.snapshot_src) unless has_bridge
-        # The replayed `__csim_runScriptCached` / `__csim_runScriptEval` /
-        # `__csim_evalEsmEntry` close over the context they EXECUTE in (the
-        # main ctx) — left as-is, a frame script that routes through them
-        # (leading-lexical, ≥64KB, or `type=module`) would run against the
-        # PARENT realm's document. Rebind realm-executing variants on top.
-        attach_run_script_with_cache(realm)
-        attach_realm_esm_entry(realm)
-        reseed_realm_js(realm)
+        frame_realm_depths[realm.id]  = depth
+        frame_realm_parents[realm.id] = parent_id.to_i   # owning realm, for contentWindow-reached rebuilds
+        seed_realm_bridge(realm)
         # Wire `parent` / `top` to the realm that owns this iframe (its context
         # id passed from `__csimFrameWindow`), BEFORE the frame's scripts run —
         # `top` propagates up the chain (the main realm's `top` is itself). A
@@ -836,6 +875,86 @@ module Capybara
         nil
       end
 
+      # Build a same-origin auxiliary WINDOW (window.open / open_new_window) as a
+      # realm in THIS isolate — like an iframe's frame realm, but top-level: `parent`
+      # === `top` === the window itself (the bridge default, so unlike
+      # create_frame_realm we don't wire them to a container), and `window.opener`
+      # points at the opener realm's WindowProxy. Tracked in `frame_realms` so
+      # realm_call / drainChildRealms / dispose_frame_realms cover it for free.
+      # Returns the new realm's context id; the opener-side `window.open` wraps it in
+      # a native `__csimFrameWindowProxyFor`, so `popup.document` is a real
+      # same-isolate Document (cross-window adoptNode works). The single isolate also
+      # makes a same-origin window far cheaper than today's isolate-per-window.
+      def create_window_realm(url, body, content_type, opener_id: nil, window_name: nil, doc_origin: nil, location_origin: nil)
+        realm = seed_realm_bridge(ctx.create_context)
+        # Mark it a top-level window realm so its location setter routes to
+        # __csimWindowRealmNavigate (reload THIS realm) rather than the frame-nav or
+        # top-page path — top === self here, so neither default branch fits. Also give
+        # it the window-lifecycle surface a popup needs but a frame realm doesn't:
+        # `window.closed` (flag-backed) and `window.close()` (marks closed; the realm
+        # lingers inert until the Browser tears the isolate down — matching a real
+        # closed window whose proxy stays valid and reports closed === true).
+        realm.eval(<<~JS)
+          globalThis.__csimIsWindowRealm = true;
+          globalThis.__csimWindowClosedFlag = false;
+          try {
+            Object.defineProperty(globalThis, 'closed', {
+              configurable: true,
+              get() { return !!globalThis.__csimWindowClosedFlag; }
+            });
+          } catch (_) {}
+          globalThis.close = function () { globalThis.__csimWindowClosedFlag = true; };
+        JS
+        # window.opener → a WindowProxy for the opener realm. opener_id is the opener's
+        # context id (0 = the main realm, a VALID opener); nil means "no opener", so the
+        # guard is on nil, not on 0 (0 is falsy but real here). Assigning globalThis.opener
+        # routes through the bridge's opener setter (stores the override the getter returns).
+        unless opener_id.nil?
+          realm.eval(<<~JS)
+            if (typeof globalThis.__csimFrameWindowProxyFor === 'function') {
+              var __op = globalThis.__csimFrameWindowProxyFor(#{opener_id.to_i});
+              if (__op) globalThis.opener = __op;
+            }
+          JS
+        end
+        realm.call('__csimUpdateLocation', url.to_s)        unless url.to_s.empty?
+        realm.call('__csimSetWindowName', window_name.to_s) unless window_name.nil?
+        realm.call('__csimSetDocumentOrigin', doc_origin.to_s)         unless doc_origin.nil?
+        realm.call('__csimSetLocationOrigin', location_origin.to_s)    unless location_origin.nil?
+        # Register the realm as alive BEFORE its document loads: its inline scripts run
+        # synchronously inside __csimLoadDocument and may post to a BroadcastChannel the
+        # opener listens on (a blob popup that posts then self.close()s). The delivery
+        # path gates on `frame_realm_alive?`, so the realm must already be tracked or its
+        # own load-time post is dropped. Mirrors create_frame_realm seeding its depth /
+        # parent maps before the load for the same reason.
+        frame_realms[realm.id]        = realm
+        frame_realm_parents[realm.id] = 0   # top-level (no parent frame)
+        # Register with the opener (main) realm's child-realm set so `drainChildRealms`
+        # steps THIS realm's event loop too — otherwise its queued tasks (e.g. a
+        # BroadcastChannel delivery from a blob document) never fire.
+        ctx.eval("(globalThis.__csimChildRealmIds || (globalThis.__csimChildRealmIds = new Set())).add(#{realm.id});")
+        # Remember the window's opener / name so a self-navigation (reload_window_realm
+        # builds a FRESH realm) can carry them across — a real popup keeps window.opener
+        # and window.name through its own navigation.
+        window_realm_meta[realm.id] = {opener_id: opener_id, window_name: window_name}
+        realm.call('__csimLoadDocument', body.to_s, content_type.to_s)
+        realm.call('__csimFireWindowLoad') rescue nil
+        realm.id
+      rescue StandardError => e
+        @browser.log_console('warn', "window realm load failed: #{e.message}")
+        if realm
+          # The realm is registered (frame_realms / parents / __csimChildRealmIds)
+          # BEFORE the document loads, so a load-time throw must roll all of that back
+          # — otherwise frame_realm_alive? and drainChildRealms keep treating a
+          # disposed context as live. dispose_frame_realm unwinds the registries (and
+          # disposes if registered); the explicit dispose is the backstop for a throw
+          # that happened before registration.
+          dispose_frame_realm(realm.id)
+          realm.dispose rescue nil
+        end
+        nil
+      end
+
       # `target` is the context the module graph compiles + evaluates in,
       # `handles` its module-handle cache — the main ctx + `native_module_handles`
       # by default, or a frame realm + its realm-local cache (Module handles are
@@ -1199,6 +1318,12 @@ module Capybara
         # pending XHRs the moment the worker's queue empties. The settle
         # loop already polls `worker_pending?` for worker thread activity.
         c.attach('__setTimersActive', ->(_flag) { nil })
+        # `importScripts` runs a classic script at the worker's TOP-LEVEL script scope,
+        # so its top-level `const`/`let`/`class` (dispatcher.js's `const send`/`receive`)
+        # join the realm's shared global lexical environment where later code sees them.
+        # `(0, eval)` would block-scope them to the eval and they'd vanish. `c.eval` is
+        # the top-level-script path (same as the worker's own body eval).
+        c.attach('__csim_workerImportEval', ->(src) { c.eval(src.to_s); nil })
         c.eval('__csim_installWorkerScope();')
         WorkerRuntime.new(
           eval_fn:           ->(s)     { c.eval(s.to_s) },

data/lib/capybara/simulated/version.rb

@@ -2,6 +2,6 @@
 
 module Capybara
   module Simulated
-    VERSION = '0.5.0'
+    VERSION = '0.6.0'
   end
 end