capybara-simulated 0.8.0 → 0.9.0

data/lib/capybara/simulated/node.rb

@@ -138,6 +138,14 @@ module Capybara
         self
       end
 
+      # Capybara's `Element#scroll_to(:current, offset: [dx, dy])` calls this after the position
+      # handling above — a relative scroll from wherever the element is now.
+      def scroll_by(dx, dy)
+        check_stale
+        browser.scroll_by(handle_id, dx, dy)
+        self
+      end
+
       # Capybara's standard rect API. No layout engine — but
       # The element's coarse border-box (viewport-relative), from the layout engine — backs the
       # spatial selectors (`:above`/`:below`/`:near`) and coordinate drag. Deterministic per layout

data/lib/capybara/simulated/quickjs_runtime.rb

@@ -246,14 +246,27 @@ module Capybara
       # already the inter-test reset point.
       def reset_page = rebuild_ctx
 
-      # NOTE: intentionally NO `dispose` — Browser#dispose gates its
-      # `@runtime.dispose` call on `respond_to?(:dispose)`, so QuickJS skips it.
-      # QuickJS VMs aren't pinned by a process-wide registry the way V8 isolates
-      # are in V8Runtime's `@@live`; an aux window's Browser becomes unreferenced
-      # on close and Ruby GC's dfree frees its `@vm` (the same lifecycle
-      # `rebuild_ctx` already relies on). Adding a `@vm = nil` dispose would only
-      # introduce a NoMethodError window for any stray post-close call (eval/call
-      # don't all nil-guard `@vm`) with no leak benefit.
+      # PERMANENTLY drop this runtime. Distinct from `rebuild_ctx` above, which
+      # deliberately does NOT `dispose!` — that runs per visit, on every example,
+      # and `dispose!` blocks on the quickjs GC with the GVL held. Here it runs
+      # once, when a session is dropped for good, and the cost is the point.
+      #
+      # This used to be intentionally absent, on the reasoning that Ruby GC's
+      # dfree would reach an unreferenced `@vm` on its own. Measured, it does not
+      # in time to matter: 30 sessions created and dropped in a loop held 1979 MB
+      # with no dispose and 1971 MB with one, because `Browser#dispose` gates on
+      # `respond_to?(:dispose)` and so did nothing at all here. The suite's peak
+      # RSS is what pays for it.
+      #
+      # The old note's hazard — a stray post-close `eval`/`call` finding `@vm`
+      # nil — is real, so this leaves `@vm` in place and lets the gem's own
+      # freed-VM handling answer; `Driver#disposed?` keeps the live-driver walk
+      # from stepping a dropped runtime in the first place.
+      def dispose
+        @vm&.dispose!
+      rescue StandardError
+        nil
+      end
 
       # bridge.js patches `Intl.DateTimeFormat`; rusty_racer ships ICU built-in but
       # QuickJS gates it behind a polyfill flag (other surfaces bridge.js touches —
@@ -395,6 +408,7 @@ module Capybara
         vm.define_function('__csimBroadcast') {|name, data, _rid, origin| broadcast_out&.call(name, data, origin); nil } if broadcast_out
         # Service-worker → main-thread signals via the outbox (see v8_runtime#build_worker).
         vm.define_function('__csim_swPostToClient') {|client_id, data| sw_hooks[:post_to_client]&.call(client_id, data); nil } if sw_hooks[:post_to_client]
+        vm.define_function('__csim_swFocusClient')  {|client_id|       sw_hooks[:focus_client]&.call(client_id);       nil } if sw_hooks[:focus_client]
         vm.define_function('__csim_swClaim') { sw_hooks[:claim]&.call; nil } if sw_hooks[:claim]
         vm.define_function('__csim_swFetchRespond') {|fetch_id, resp, realm_id| sw_hooks[:fetch_respond]&.call(fetch_id, resp, realm_id); nil } if sw_hooks[:fetch_respond]
         vm.define_function('__csim_swFetchStream') {|fetch_id, kind, payload, realm_id| sw_hooks[:fetch_stream]&.call(fetch_id, kind, payload, realm_id); nil } if sw_hooks[:fetch_stream]

data/lib/capybara/simulated/runtime_shared.rb

@@ -67,8 +67,10 @@ module Capybara
         # isHistoryNavigation. Must run while the outgoing realm (a[0]) is still alive.
         '__csim_recordFrameNav'      => ->(b, *a) { b.record_frame_nav(a[0].to_i, a[1]); 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 },
+        # a[2] is the realm that navigated: a nested browsing context keeps its OWN session
+        # history, so a frame's pushState must not be mirrored onto the top document's.
+        '__setCurrentUrl'            => ->(b, *a) { b.history_state(a[0], a[1], a[2]); nil },
+        '__pushHistoryEntry'         => ->(b, *a) { b.history_push(a[0], a[1], a[2]); nil },
         '__historyGo'                => ->(b, *a) { b.history_go(a[0]); nil },
         '__historyLength'            => ->(b, *_) { b.history_length },
         '__csimReadFilePick'         => ->(b, *a) { b.read_file_pick(a[0], a[1], a[2], a[3]) },
@@ -107,8 +109,9 @@ module Capybara
         '__csim_rackFetchAsyncAbort' => ->(b, *a) { b.rack_fetch_async_abort(a[0]); nil },
         # 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]) },
+        # isolate. a[2] is the opener's realm id (for wiring window.opener); a[3]/a[4] the opener
+        # document's base URL and origin, which an about:blank popup inherits.
+        '__csimWindowOpen'           => ->(b, *a) { b.open_child_window(a[0], a[1], a[2], a[3], a[4]) },
         # 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
@@ -140,7 +143,10 @@ module Capybara
         # 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], creator_key: a[2]) },
+        # a[3] is the CREATING realm (the worker dies when it is discarded); a[4] that context's
+        # CURRENT controller handle, which a DEDICATED worker inherits rather than scope-matching
+        # its own — often opaque (blob:/data:) — script URL. 0 when the creator is uncontrolled.
+        '__csim_workerSpawn'         => ->(b, *a) { b.worker_spawn(a[0], shared: !!a[1], creator_key: a[2], realm_id: a[3].to_i, controller_handle: a[4].to_i) },
         # 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, creator_key: a[1]) },
@@ -151,6 +157,13 @@ module Capybara
         # relay a client-realm port's postMessage to its remote (worker/SW) peer.
         '__csimClientPortEndpoint' => ->(b, *a) { b.port_channel_endpoint_realm(a[0], a[1]); nil },
         '__csimClientPortPost'     => ->(b, *a) { b.client_port_post(a[0], a[1]); nil },
+        # The focus chain moved into this realm's browsing context (a focus() commit, or an
+        # <iframe> focused in its container, which hands focus to the nested context).
+        '__csimNoteFocusedRealm'   => ->(b, *a) { b.note_focused_realm(a[0]); nil },
+        # This realm is a service-worker client: reported at document load and again whenever
+        # control is installed, by the realm, because only it knows its own URL, frame type and
+        # controller. `a[3]` is the controlling worker's handle, 0 when uncontrolled.
+        '__csimNoteClient' => ->(b, *a) { b.sw_note_client(a[0], a[1], a[2], a[3]); nil },
         # A controlled client's fetch → the controlling SW's `fetch` event. Returns false if the SW
         # is gone (client falls back to the network).
         '__csim_serviceWorkerControllerFetch' => ->(b, *a) { b.service_worker_controller_fetch(a[0], a[1], a[2], a[3]) },
@@ -165,6 +178,10 @@ module Capybara
         # local registration (a different iframe registering an already-active scope) can synthesize a
         # registration reflecting the shared active worker instead of installing a duplicate.
         '__csim_swActiveHandleForScope' => ->(b, *a) { b.sw_active_handle_for_scope(a[0]) },
+        # Does this worker still control any client? An incoming worker may only activate once the
+        # outgoing one controls nothing (or skipWaiting is called) — see _scheduleLifecycle.
+        '__csim_swControlsClients'    => ->(b, *a) { b.sw_worker_controls_clients?(a[0]) },
+        '__csim_swNoteActivationParked' => ->(b, *_) { b.sw_note_activation_parked; nil },
         # Navigation Preload state (NavigationPreloadManager), keyed by the registration's active
         # worker handle — reached identically from the client (registration.active._handle) and the
         # worker (__csimWorkerHandle). Get returns {enabled, headerValue}; set leaves a nil field as-is.
@@ -227,34 +244,18 @@ module Capybara
       # Host fns that route to pure stdlib — no Browser surface,
       # nothing to safe_call, no allocation needed for the wrap. Skip
       # the rescue overhead on every per-find / per-event invocation.
-      # Process-wide cascade-rule cache (mirrors the script bytecode cache). The
-      # built {hide, layout} rules are deterministic per (stylesheet-set,
-      # viewport), so the JS side caches the serialized rules keyed by a digest of
-      # the sheet sources and skips the ~12-15 ms css-tree parse + per-rule
-      # specificity + terminalKey rebuild on every per-visit VM rebuild. Lives in
-      # Ruby (not the VM) so it survives `rebuild_ctx`. Key space is tiny (one app
-      # ships one stylesheet set), so the map stays small; no eviction needed.
-      CASCADE_RULE_CACHE       = {}
-      CASCADE_RULE_CACHE_MUTEX = Mutex.new
-
-      # Process-wide PER-SHEET parse cache (companion to CASCADE_RULE_CACHE). The
-      # built whole-cascade is cached above, but it misses whenever a page's inline
-      # `<style>` changes (Avo injects per-page styles), forcing a rebuild that
-      # re-parses every sheet — including unchanged linked bundles (avo.base.css).
-      # `parseSheet` is pure, so the JS side caches its serialized `{hide,layout}`
-      # keyed by (cssText hash, viewport) here, surviving the per-visit VM rebuild
-      # that wipes the in-VM `__sheetCache` — the CSS analogue of the JS bytecode
-      # cache. Keyed by content, so a content change yields a new key. Capped.
+      # Process-wide PER-SHEET parse cache (the CSS analogue of the JS bytecode
+      # cache). `parseSheet` is pure, so the JS side caches its serialized
+      # `{hide,layout}` here keyed by (cssText hash, viewport), surviving the
+      # per-visit VM rebuild that wipes the in-VM `__sheetCache`. A cascade
+      # rebuild then re-parses only sheets it has never seen (content change =
+      # new key). Content-keyed ONLY — never url-keyed — so freshness stays the
+      # asset cache's call. Capped.
       SHEET_PARSE_CACHE       = {}
       SHEET_PARSE_CACHE_MUTEX = Mutex.new
       SHEET_PARSE_CACHE_MAX   = 2048
 
       STDLIB_HOST_FNS = {
-        '__csimCascadeCacheGet' => ->(*a) { CASCADE_RULE_CACHE_MUTEX.synchronize { CASCADE_RULE_CACHE[a[0].to_s] } },
-        '__csimCascadeCachePut' => lambda {|*a|
-          CASCADE_RULE_CACHE_MUTEX.synchronize { CASCADE_RULE_CACHE[a[0].to_s] = a[1].to_s }
-          nil
-        },
         '__csimSheetCacheGet' => ->(*a) { SHEET_PARSE_CACHE_MUTEX.synchronize { SHEET_PARSE_CACHE[a[0].to_s] } },
         '__csimSheetCachePut' => lambda {|*a|
           SHEET_PARSE_CACHE_MUTEX.synchronize {

data/lib/capybara/simulated/v8_runtime.rb

@@ -426,6 +426,12 @@ module Capybara
       # through its own navigation.
       def window_realm_meta = (@window_realm_meta ||= {})
 
+      # Is this realm a TOP-LEVEL browsing context? The main realm is, and so is an auxiliary
+      # window realm — `frame_realm_parents` records 0 for one because it has no parent FRAME,
+      # which is not the same as being nested in the main window. An ancestor walk (the focus
+      # chain, most of all) has to stop here rather than step into the opener.
+      def top_level_realm?(realm_id) = realm_id.to_i.zero? || window_realm_meta.key?(realm_id.to_i)
+
       def dispose_frame_realms
         @realm_module_handles&.clear
         @frame_realm_depths&.clear
@@ -471,7 +477,11 @@ module Capybara
         # Like reload_frame_realm, a re-navigated window discards its child browsing contexts — dispose
         # the descendant frame realms too, not just old_id, so a popup's iframes don't linger.
         dispose_frame_realm_tree(old_id)
-        create_window_realm(url, body, content_type, opener_id: meta[:opener_id], window_name: meta[:window_name])
+        create_window_realm(
+          url, body, content_type,
+          opener_id: meta[:opener_id], window_name: meta[:window_name],
+          about_base: meta[:about_base], about_origin: meta[:about_origin]
+        )
       end
 
       # Tear down a single frame realm (e.g. a descendant frame destroyed when an
@@ -483,6 +493,11 @@ module Capybara
         @browser.revoke_realm_blobs(id) rescue nil
         # Drop it from the SW Client registry so matchAll stops returning a dead client.
         @browser.sw_unregister_client(id) rescue nil
+        # A dedicated worker is owned by the context that created it — discarding the context
+        # terminates it (and unregisters its own client record).
+        @browser.terminate_realm_workers(id) rescue nil
+        # If it held the focus chain, focus returns to the top-level browsing context.
+        @browser.note_realm_discarded(id) rescue nil
         @realm_module_handles&.delete(id)
         @frame_realm_depths&.delete(id)
         @frame_realm_parents&.delete(id)
@@ -753,8 +768,8 @@ module Capybara
       # id (or nil on failure — then the bridge keeps its same-realm fallback).
       # The bridge maps `iframe.contentWindow` to `RustyRacer.contextGlobal(id)`.
       def attach_frame_realm_loader(c)
-        c.attach('__csim_createFrameRealm', ->(url, body, content_type, parent_id = 0, frame_name = nil, frame_doc_origin = nil, frame_location_origin = nil, js_url_source = nil, frame_about_base = nil) {
-          RuntimeShared.safe_call { create_frame_realm(c, url, body, content_type, parent_id, frame_name, frame_doc_origin, frame_location_origin, js_url_source, frame_about_base) }
+        c.attach('__csim_createFrameRealm', ->(url, body, content_type, parent_id = 0, frame_name = nil, frame_doc_origin = nil, frame_location_origin = nil, js_url_source = nil, frame_about_base = nil, frame_viewport = nil) {
+          RuntimeShared.safe_call { create_frame_realm(c, url, body, content_type, parent_id, frame_name, frame_doc_origin, frame_location_origin, js_url_source, frame_about_base, frame_viewport) }
         })
         # Re-navigating an iframe (src/srcdoc reassigned) builds a fresh realm;
         # the bridge calls this to tear down the superseded one so it doesn't
@@ -806,7 +821,7 @@ module Capybara
         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, frame_about_base = nil)
+      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, frame_about_base = nil, frame_viewport = nil)
         depth = (frame_realm_depths[parent_id] || 0) + 1
         if depth > MAX_FRAME_DEPTH
           @browser.log_console('warn', "iframe nesting depth #{depth} exceeds #{MAX_FRAME_DEPTH}; not building #{url}")
@@ -858,6 +873,11 @@ module Capybara
         # loads, so a frame whose load handler reads window.name to identify itself
         # (declarative-shadow declarative-child-frame) sees it.
         realm.call('__csimSetWindowName', frame_name.to_s) unless frame_name.nil?
+        # The frame's viewport is its container's content box, measured by the parent realm. Seed it
+        # BEFORE the document loads so load-time `innerWidth` reads and `@media` evaluation see the
+        # frame's own size rather than the top window's. `nil` = an unrendered container, which is a
+        # 0x0 window — pass it through rather than skipping, or the frame keeps the top-level size.
+        realm.call('__csimFrameViewportChanged', frame_viewport)
         # Seed the frame's document origin (opaque/inherited) BEFORE the document
         # loads, so its load-time scripts read the right self.origin. nil → a
         # real-URL frame whose origin is its own location origin.
@@ -881,21 +901,31 @@ module Capybara
         # (sw_note_realm_controller); recording it BEFORE the load also lets a NESTED frame built during
         # this frame's load inherit the controller.
         opaque = opaque_frame_url?(url)
-        # A sandboxed frame WITHOUT allow-same-origin has an OPAQUE origin (doc origin 'null') and is
-        # cross-origin to its creator, so it does NOT inherit the creator's controller (srcdoc-iframe:
-        # "sandboxed srcdoc should not inherit"). allow-same-origin restores the parent origin → inherits.
-        inheritable = opaque && frame_doc_origin.to_s != 'null'
-        ctrl   = @browser.sw_client_controller_for(url.to_s)
-        ctrl ||= @browser.sw_inherited_controller_for(parent_id) if inheritable
-        if ctrl
-          realm.call('__csim_swSetControllerDirect', *ctrl)
-          # Only an OPAQUE (about:blank / srcdoc) frame is mirrored into the SW's clients.matchAll():
-          # a real-URL frame's registration would fire during its SYNCHRONOUS SW nav-fetch (main thread
-          # blocked on @sw_nav_outbox), perturbing worker timing — the http-src client model is deferred.
-          @browser.sw_note_realm_controller(realm.id, ctrl)
-          @browser.sw_register_client(realm.id, url.to_s, 'window', 'nested', ctrl[0]) if opaque
+        # A sandboxed frame WITHOUT allow-same-origin has an OPAQUE origin (doc origin 'null'), which
+        # is cross-origin to everything — so it is NOT CONTROLLED AT ALL. It inherits no controller
+        # from its creator (srcdoc-iframe: "sandboxed srcdoc should not inherit"), its subresource
+        # fetches never reach the SW, and it is absent from `clients.matchAll()`. Excluding it from
+        # only the client registry would not hold: a controlled frame's first subresource fetch
+        # re-registers it lazily from the fetch event (js/src/workers.js clientFor). The SW does still
+        # answer its NAVIGATION request, because a CSP-header sandbox is knowable only FROM that
+        # response (sandboxed-iframe-fetch-event, "Service worker should NOT control the sandboxed
+        # page"). allow-same-origin restores the parent origin, and a real-URL frame carries no
+        # explicit origin at all (nil = its own location origin) — both are controlled normally.
+        if frame_doc_origin.to_s != 'null'
+          ctrl   = @browser.sw_client_controller_for(url.to_s)
+          ctrl ||= @browser.sw_inherited_controller_for(parent_id) if opaque
+          if ctrl
+            # Wiring the controller is what registers this frame as a client — the realm reports
+            # itself from installController (js/src/sw-client.js), before the document below loads.
+            realm.call('__csim_swSetControllerDirect', *ctrl)
+            @browser.sw_note_realm_controller(realm.id, ctrl)
+          end
         end
         realm.call('__csimLoadDocument', body.to_s, content_type.to_s)
+        # This document now has a URL and any host-wired controller, so it can announce itself
+        # as a service-worker client — an UNCONTROLLED context is still a client of its origin
+        # and must show up in `matchAll({includeUncontrolled: true})`.
+        realm.call('__csim_swReportClient') rescue nil
         # A `javascript:` URL frame: the initial empty document is now loaded and
         # parent/top are wired, so evaluate the URL's script in the realm (global
         # scope). Per HTML, only a STRING result navigates the frame to a new
@@ -944,7 +974,7 @@ module Capybara
       # 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)
+      def create_window_realm(url, body, content_type, opener_id: nil, window_name: nil, doc_origin: nil, location_origin: nil, about_base: nil, about_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
@@ -976,7 +1006,21 @@ module Capybara
             }
           JS
         end
-        realm.call('__csimUpdateLocation', url.to_s)        unless url.to_s.empty?
+        # `window.open()` with no URL opens about:blank — that IS the new document's URL, and a
+        # realm built from the snapshot would otherwise keep reporting the OPENER's (making the
+        # popup a phantom duplicate of its opener everywhere a document URL is read, the service-
+        # worker client set included). Its ORIGIN and its BASE url are inherited from the opener,
+        # exactly as an empty <iframe>'s are (create_frame_realm's frame_about_base): the origin
+        # so the popup isn't cross-origin to the window that opened it, the base so relative
+        # resolution inside it still targets the opener's document.
+        if url.to_s.empty?
+          realm.call('__csimUpdateLocation', 'about:blank')
+          realm.call('__csimSetAboutBaseURL', about_base.to_s)   unless about_base.to_s.empty?
+          doc_origin      ||= about_origin unless about_origin.to_s.empty?
+          location_origin ||= about_origin unless about_origin.to_s.empty?
+        else
+          realm.call('__csimUpdateLocation', url.to_s)
+        end
         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?
@@ -995,8 +1039,10 @@ module Capybara
         # 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}
+        window_realm_meta[realm.id] = {opener_id: opener_id, window_name: window_name, about_base: about_base, about_origin: about_origin}
         realm.call('__csimLoadDocument', body.to_s, content_type.to_s)
+        # As in create_frame_realm: an auxiliary window is a client of its origin too.
+        realm.call('__csim_swReportClient') rescue nil
         realm.call('__csimFireWindowLoad') rescue nil
         realm.id
       rescue StandardError => e
@@ -1375,7 +1421,10 @@ module Capybara
         # deliver_worker_messages): client.postMessage, clients.claim (set the client's controller),
         # and a controlled fetch's respondWith result. See run_worker for the closures.
         c.attach('__csim_swPostToClient', ->(client_id, data) { sw_hooks[:post_to_client]&.call(client_id, data); nil }) if sw_hooks[:post_to_client]
+        c.attach('__csim_swFocusClient',   ->(client_id)       { sw_hooks[:focus_client]&.call(client_id);       nil }) if sw_hooks[:focus_client]
+        c.attach('__csim_swNavigateClient', ->(client_id, url, nav_id) { sw_hooks[:navigate_client]&.call(client_id, url, nav_id); nil }) if sw_hooks[:navigate_client]
         c.attach('__csim_swClaim',        ->                  { sw_hooks[:claim]&.call; nil }) if sw_hooks[:claim]
+        c.attach('__csim_swSkipWaitingRequest', ->             { sw_hooks[:skip_waiting]&.call; nil }) if sw_hooks[:skip_waiting]
         c.attach('__csim_swFetchRespond', ->(fetch_id, resp, realm_id) { sw_hooks[:fetch_respond]&.call(fetch_id, resp, realm_id); nil }) if sw_hooks[:fetch_respond]
         c.attach('__csim_swFetchStream',  ->(fetch_id, kind, payload, realm_id) { sw_hooks[:fetch_stream]&.call(fetch_id, kind, payload, realm_id); nil }) if sw_hooks[:fetch_stream]
         # Cross-isolate MessagePort channel signals (a worker/SW port endpoint + its outbound messages).

data/lib/capybara/simulated/version.rb

@@ -2,6 +2,6 @@
 
 module Capybara
   module Simulated
-    VERSION = '0.8.0'
+    VERSION = '0.9.0'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: capybara-simulated
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Keita Urashima