capybara-simulated 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02f56bfd3215e67c4a8faa799352e0ae3c399557f928926cafcdc9dde7dd2b9c
-  data.tar.gz: 12e88e441d93de921d0727bfae9e3728cc56d100f8e32e525e37e21a28f0e273
+  metadata.gz: 3b2b947ec8b6945ec441d61c70a2bf0155283696c7d8188a135c990850149f68
+  data.tar.gz: c7530db87c7b019f25db0370213c6965a4c3f44172284ef469f84e8617319291
 SHA512:
-  metadata.gz: a1f22b4a5d7ffec1b33080982aa169b5b3356c014d49a399de4cf5b5a430021eec7fb1ba4d624b00769640ffdcd314e55df765afdd44ac90575c88cb137519c9
-  data.tar.gz: 04d95fd0e7215800124d4d81de11247b814e352c0b511d550bb9bb1557a0af069c1261b52a570e82f6100cab90e07d627b18b7a02267f193dd92c4c98c92e2cd
+  metadata.gz: 1c3e5d6358892be026316a31531ed4ced5e66f52ac0dafcda51236977f8f94f40b5465e9653cce4ce2ad84cee0ef4d29b8fbe2d850cd94efb3f1a3ab47db3eb6
+  data.tar.gz: '099d9b40e65a21667a543721f26b1df60176a2651da945f175016d5d85bbd81b0296099a17bf23b2a415101387489573d6b487aecdf8255ee0a923935d0f9b10'

data/README.md

@@ -2,9 +2,8 @@
 
 A lightweight Capybara driver that runs JavaScript against an
 in-process JS-resident DOM, with no Chrome. Forms submit through
-`Rack::MockRequest`, inline `<script>` and event handlers run,
-MutationObserver / custom elements / `<template>` / Shadow DOM /
-Trix / Stimulus / Turbo all work, and the Capybara DSL is unchanged.
+`Rack::MockRequest`, inline `<script>` and event handlers run, and the
+Capybara DSL is unchanged.
 
 The DOM lives entirely inside the JS engine — V8 via
 [rusty_racer](https://github.com/ursm/rusty_racer) or QuickJS via
@@ -37,35 +36,15 @@ visual layout:
 
 **Reach for a real browser** (Selenium / Cuprite) **when** your tests need
 what this driver doesn't simulate **by design** — there's no rendering
-engine or real network stack, the same ground Selenium covers via a real
-browser:
-
-- **Pixel layout** — `getBoundingClientRect()` returns zeros and
-  `elementFromPoint()` isn't implemented, so visual hit-testing,
-  coordinate drag-and-drop, and sticky-scroll math don't work.
-- **Real networking** — `fetch` / XHR are synchronous through Rack: no
-  streaming, no HTTP concurrency. (`EventSource` and `WebSocket` *do*
-  work — they ride real reader threads / the in-process `rack.hijack`
-  socket; see below.)
-- **Screenshots**.
-
-**`within_frame` / `switch_to_frame`** work on the V8 (rusty_racer) engine:
-each `<iframe>` runs its own scripts in its own per-frame realm, and the DSL
-routes finds, reads, interactions, `evaluate_script`, and self-targeted
-navigation (a link or form submit inside the frame) into the active frame —
-nested frames included. (QuickJS keeps a same-realm fallback, so
-`within_frame` is V8-only.)
-
-**Multiple windows / tabs** work on both engines: each window is its own
-Browser + JS VM (own DOM, sessionStorage, history; cookies + localStorage
-shared). `open_new_window` / `within_window` / `switch_to_window` /
-`window_opened_by` drive them, and JS `window.open` opens a real window,
-`window.opener` points back to the opener, and `postMessage` is delivered
-across windows. (`target="_blank"` defaults to no-opener, matching modern
-browsers; cross-window `postMessage` data is JSON-shaped, not a full
-structured clone.)
-
-See [Known limits](#known-limits) for the full picture.
+engine: **pixel layout** (`getBoundingClientRect()` returns zeros,
+`elementFromPoint()` isn't implemented, so visual hit-testing, coordinate
+drag-and-drop, and sticky-scroll math don't work) and **screenshots**.
+
+Most of the rest runs in-process — including the things that usually mean
+"you need a real browser": **`within_frame`**, **multiple windows / tabs**,
+**WebSocket + Action Cable**, **EventSource**, and **Web Workers** all work.
+Each has constraints (JS engine, settle-timing, no layout); see
+[Capabilities & limits](#capabilities--limits).
 
 ## Status
 
@@ -78,10 +57,9 @@ Mastodon / Discourse) runs its full system suite against the driver in
 [capybara-simulated-vs-world](https://github.com/ursm/capybara-simulated-vs-world)
 as an integration check.
 
-The remaining gaps need a real layout engine (`elementFromPoint`,
-truthy `getBoundingClientRect`, viewport-clip visibility, `display:
-contents` table edge cases) — the same set Selenium escapes via
-screenshots and this driver deliberately doesn't simulate.
+The remaining gaps are the layout / pixel-geometry features the driver
+deliberately doesn't simulate — the same set Selenium escapes via
+screenshots (see [Capabilities & limits](#capabilities--limits)).
 
 ## Install
 
@@ -290,21 +268,6 @@ isolate whose context is reset to a clean realm per navigation
 snapshot-loaded VM out of a small pre-warmed pool. Either way, every
 navigation lands on a clean, warm JS context near-instantly.
 
-**Wall time is sensitive to whether the app uses Turbo Drive**,
-because navigation simulates real-browser semantics:
-
-| navigation source | what happens |
-|---|---|
-| `visit(...)`, `refresh`, programmatic `location.assign` | full reload — fresh JS Context, scripts re-evaluated |
-| link click *with Turbo Drive loaded* | Turbo intercepts, body-swap via JS, **JS context preserved** |
-| link click *without Turbo Drive* | full reload (anchor default action) |
-| form submit *with Turbo Drive loaded* | Turbo intercepts (turbo-frame or page-level), body-swap |
-| form submit *without Turbo Drive* | full reload |
-
-So Turbo Drive apps stay fast even with click-heavy tests; non-Turbo
-apps pay full-reload cost per click — exactly mirroring what the
-production site does.
-
 ### Library snapshot policy
 
 Per visit, `<script src>`-referenced libraries (jQuery, Stimulus,
@@ -335,67 +298,64 @@ referenced page-specific DOM.
   for 2 s; the callback fires once polling has advanced the clock past
   it.
 
-## Known limits
-
-- **No layout engine.** `visible?` and `Node#style` consult the CSS
-  cascade and the inline `style` attribute, but
-  `getBoundingClientRect()` returns zeros and `elementFromPoint()`
-  isn't implemented. Click offsets work for fixture-style absolute /
-  relative positioning (ancestor-summed `top`/`left`); position-via-
-  layout (Dragula drops, sticky-header scroll math) needs a real
-  browser.
-- **`:hover` / `:focus-within`-gated content** is reachable two ways:
-  call `element.hover` explicitly (we track the most-recently-hovered
-  element and propagate `:hover` up its chain), or rely on the
-  candidate-chain fallback (when stateless cascade reports
-  `display: none`, we re-evaluate with the candidate itself in the
-  `:hover` set). Symmetric peers — N rows each with `tr:hover .icon`
-  revealing `.icon`, queried as bare `find('.icon')` — reveal all and
-  Capybara raises `Capybara::Ambiguous`. Scope the test (`find('tr',
-  text: 'foo').hover` then `find('.icon')`) — also more robust
-  against real-browser flake.
-- **`fetch` is synchronous-via-Rack** — HTML / JSON round-trips work
-  but there's no real network, no streaming, no `Request#body`
-  ReadableStream, and no concurrent requests. XHR is implemented
-  with the same Rack pass-through.
-- **WebSocket** works in-process: `new WebSocket(url)` rides the
-  `rack.hijack` socket the Rack app hijacks, with a hand-rolled RFC6455
-  client (handshake + subprotocol negotiation, masked client frames,
-  ping/pong, close handshake). Frames deliver as `message` events when
-  the page next settles, like SSE. **Action Cable** works end-to-end on
-  this: the real `@rails/actioncable` consumer connects, subscribes, and
-  receives server broadcasts (so `turbo_stream_from` live updates are
-  reachable) — Action Cable hijacks the connection just as csim drives
-  it. Caveats: server pushes land at settle (not instant); the app must
-  use the **async / in-process** Cable adapter (a real Redis adapter
-  would need real Redis); binary frames are V8-only (QuickJS corrupts
-  raw bytes across the host boundary — text, hence Action Cable, is fine
-  on both). `EventSource` and Web Workers are likewise implemented.
-- **Screenshots and drag pixel coordinates** are out of scope by
-  design — use Selenium / Cuprite.
-- **`within_frame` / `switch_to_frame`** work on the V8 engine: each
-  `<iframe>` runs in its own per-frame realm and the DSL routes finds,
-  reads, interactions, `evaluate_script`, and self-targeted navigation
-  (link / form submit) into the active frame (nested frames included) — the
-  frame's realm is rebuilt from the fetched document, leaving the top page
-  untouched. `_top` navigates the main page; a `_parent` target from a
-  frame nested ≥2 levels falls back to navigating the main page, and
-  cross-origin frame locality resolves against the main origin. QuickJS has
-  no nested browsing context, so `within_frame` raises there.
-- **Multiple windows / tabs** work on both engines: each window is its own
+## Capabilities & limits
+
+Most features run in-process; the notes below are mostly "works, but…",
+followed by the short list of things that need a real browser **by design**.
+
+### Works, with constraints
+
+- **`within_frame` / `switch_to_frame`** (V8 engine) — each `<iframe>` runs
+  its own scripts in its own per-frame realm; the DSL routes finds, reads,
+  interactions, `evaluate_script`, and navigation into the active frame,
+  nested frames included — the target frame's realm is rebuilt from the
+  fetched document, the top page untouched. QuickJS has no nested browsing
+  context, so `within_frame` raises there.
+- **Multiple windows / tabs** (both engines) — each window is its own
   Browser + JS VM (own DOM, sessionStorage, history; cookies + localStorage
-  shared across windows). `open_new_window` / `within_window` /
-  `switch_to_window` / `window_opened_by` drive them; JS `window.open` opens
-  a real window, `window.opener` links back, and `postMessage` is routed
-  across windows (delivered as a `message` event when the target window next
-  settles). Caveats: `target="_blank"` opens with no opener (modern-browser
-  no-opener default); cross-window `postMessage` data is JSON-shaped, not a
-  full structured clone (no `DataCloneError`, `undefined`→`null`) — but a
-  buffer in the `transfer` list moves **zero-copy** (its backing store crosses
-  isolates by token and the source is detached); and only the active window's
-  event loop runs, so a message is delivered when you switch to its window.
-  Window viewport APIs (`maximize` / `fullscreen` /
-  pixel-exact `resize_to`) are no-ops — no layout engine.
+  shared). `open_new_window` / `within_window` / `switch_to_window` /
+  `window_opened_by` drive them; JS `window.open` opens a real window,
+  `window.opener` links back, and `postMessage` crosses windows. Only the
+  active window's event loop runs, so a message is delivered when you switch
+  to its window. `target="_blank"` opens with no opener (modern-browser
+  default). `postMessage` carries real structured data (not a lossy JSON
+  hop) — `Map` / `Set` / `Date` / `BigInt` / typed arrays / cyclic graphs all
+  round-trip on V8 — and a `transfer`-list buffer moves **zero-copy** (backing
+  store by token, source detached); only bare `undefined` collapses to `null`
+  (Ruby has no distinct `undefined`). Window viewport APIs (`maximize` /
+  `fullscreen` / pixel-exact `resize_to`) are no-ops (no layout engine).
+- **WebSocket + Action Cable** — `new WebSocket(url)` works in-process over
+  the `rack.hijack` socket the Rack app hijacks (hand-rolled RFC6455, including
+  subprotocol negotiation). The real `@rails/actioncable` consumer connects,
+  subscribes, and receives broadcasts, so `turbo_stream_from` live updates
+  work. Constraints: server
+  pushes land at settle (not instant); the Cable app must use the **async /
+  in-process** adapter (a real Redis adapter needs real Redis); binary frames
+  are V8-only (QuickJS corrupts raw bytes across the host boundary — text,
+  hence Action Cable, works on both engines). `EventSource` and Web Workers
+  are likewise real (background reader threads draining at settle).
+- **`fetch` / XHR** — synchronous through Rack: HTML / JSON round-trips work,
+  but there's no streaming, no `Request#body` ReadableStream, and no
+  concurrent requests.
+- **`:hover` / `:focus-within`-gated content** — reachable two ways: call
+  `element.hover` explicitly (we track the most-recently-hovered element and
+  propagate `:hover` up its chain), or rely on the candidate-chain fallback
+  (when the stateless cascade reports `display: none`, we re-evaluate with the
+  candidate itself in the `:hover` set). Symmetric peers — N rows each with
+  `tr:hover .icon` revealing `.icon`, queried as a bare `find('.icon')` —
+  reveal all and Capybara raises `Capybara::Ambiguous`; scope the test
+  (`find('tr', text: 'foo').hover` then `find('.icon')`), which is also more
+  robust against real-browser flake.
+
+### Out of scope (by design — use Selenium / Cuprite)
+
+- **Layout / pixel geometry.** `visible?` and `Node#style` consult the CSS
+  cascade and the inline `style` attribute, but `getBoundingClientRect()`
+  returns zeros and `elementFromPoint()` isn't implemented. Click offsets work
+  for fixture-style absolute / relative positioning (ancestor-summed
+  `top`/`left`); position-via-layout (Dragula drops, sticky-header scroll math,
+  viewport-clip visibility) needs a real browser.
+- **Screenshots.**
 
 ## Architecture
 
@@ -429,39 +389,6 @@ referenced page-specific DOM.
   `(handle_id, context_gen)` pair so a handle from a pre-rebuild
   Context can't ghost into the next one.
 
-## ES modules + importmap
-
-`<script type="module">` and `<script type="importmap">` work the
-same way they do in a real browser: bare specifiers resolve through
-the importmap, relative paths resolve against the importer's URL,
-and every load (including dynamic `import(...)`) routes back through
-the in-process Rack app. No bundling step, no Node toolchain.
-
-The standard importmap-rails layout works as-is:
-
-```erb
-<%= javascript_importmap_tags %>
-<!-- emits:
-  <script type="importmap">{ "imports": { "application": "/assets/application-...js", ... } }</script>
-  <script type="module">import "application"</script>
--->
-```
-
-## Hotwire (Stimulus + Turbo)
-
-Stimulus and Turbo work both via UMD (classic `<script src>`) and via
-the standard ESM bundles imported through importmap. For
-importmap-rails apps, no changes are needed:
-
-```ruby
-# config/importmap.rb
-pin '@hotwired/stimulus'
-pin '@hotwired/turbo'
-```
-
-`window.fetch` routes through Rack, so Turbo's frame fetch and
-link-action POSTs round-trip the test app.
-
 ## License
 
 [MIT](LICENSE).

data/lib/capybara/simulated/browser.rb

@@ -531,13 +531,14 @@ module Capybara
       # the find cache (its keys aren't realm-qualified, and a switch is rare).
       #
       # Scope: finds, reads, interactions (click/fill_in/…), evaluate_script,
-      # and a self-targeted navigation (a link / form submit whose default
-      # action loads a new document) all route into the frame — the frame's
-      # realm is rebuilt from the fetched document, leaving the top page
-      # untouched (see `navigate_frame`). Out of scope: `_top` navigates the
-      # main page (correct), but a `_parent` target from a frame nested ≥2
-      # levels navigates the main page rather than the intermediate frame, and
-      # cross-origin frame locality is resolved against the main page's origin.
+      # and navigation (a link / form submit whose default action loads a new
+      # document) all route into the frame — the target frame's realm is rebuilt
+      # from the fetched document, leaving the top page untouched (see
+      # `navigate_frame` / `frame_nav_target_entry`). A `_parent`-targeted link
+      # or form from a frame nested ≥2 levels rebuilds the intermediate parent
+      # frame; `_top` (and a one-level `_parent`, whose parent is the top
+      # context) navigate the main page. Cross-origin frame locality is resolved
+      # against the main page's origin.
       def switch_to_frame(target)
         invalidate_find_cache
         case target
@@ -601,16 +602,27 @@ module Capybara
       end
 
       # Does a link/form `target` load into the CURRENT frame? Empty or `_self`
-      # do; `_top` / `_blank` / `_parent` / a named context do not. `_top`
-      # correctly navigates the main page (it falls through to `navigate`).
-      # `_parent` from a frame nested ≥2 levels would ideally navigate the
-      # intermediate parent frame, not the top page — that ancestor-targeted
-      # case isn't modelled yet (rare); it currently navigates the main page.
+      # do; `_top` / `_blank` / `_parent` / a named context do not.
       def frame_self_target?(target)
         t = target.to_s.downcase
         t.empty? || t == '_self'
       end
 
+      # Resolve a link/form `target` to the frame stack entry its navigation
+      # should rebuild, or nil when it targets the top page / a new context
+      # (the caller then falls through to a full-page `navigate` or aux window).
+      # Only meaningful inside a frame (`@current_realm_id` set):
+      #   - `''` / `_self` → the current frame.
+      #   - `_parent` → the intermediate parent frame, but only when nested ≥2
+      #     levels deep; at one level the parent IS the top browsing context, so
+      #     it returns nil and the full-page path handles it (same as `_top`).
+      def frame_nav_target_entry(target)
+        return nil unless @current_realm_id
+        return @frame_stack.last if frame_self_target?(target)
+        return @frame_stack[-2] if target.to_s.downcase == '_parent' && @frame_stack.size >= 2
+        nil
+      end
+
       def find_css(css, context_handle = nil)
         s = css.to_s
         return find_xpath(s, context_handle) if xpath_shaped?(s)
@@ -875,13 +887,14 @@ module Capybara
         when 'navigate'
           url = action['url'].to_s
           target = action['target'].to_s
-          # Inside a frame, a self-targeted link navigates the FRAME, not the
-          # top page: fetch + rebuild this frame's realm. A pure-fragment link
-          # is already handled in-realm by the frame's own location JS.
-          if @current_realm_id && frame_self_target?(target)
-            unless pure_fragment_navigation?(url)
+          # Inside a frame, a frame-targeted link (self, or `_parent` of a
+          # ≥2-deep frame) navigates that FRAME, not the top page: fetch +
+          # rebuild its realm. A self-targeted pure-fragment link is already
+          # handled in-realm by the frame's own location JS, so skip it.
+          if (frame_entry = frame_nav_target_entry(target))
+            unless frame_entry.equal?(@frame_stack.last) && pure_fragment_navigation?(url)
               tick_real_time
-              navigate_frame(resolve_against_current(url, use_base: true))
+              navigate_frame(resolve_against_current(url, use_base: true), entry: frame_entry)
             end
           # `target="_blank"` (or any non-_self/_top/_parent name) opens
           # in a new browsing context (its own Browser/VM); the primary
@@ -2105,15 +2118,15 @@ module Capybara
             URI.encode_www_form(fields)
           end
         action_url = action.empty? ? (current_browsing_context_url || @default_host) : resolve_against_current(action)
-        # A form submitted inside a frame whose target is the frame itself
-        # navigates the FRAME, not the top page.
-        in_frame = !!@current_realm_id && frame_self_target?(spec['target'])
+        # A form submitted inside a frame whose target is that frame (self, or a
+        # `_parent` of a ≥2-deep frame) navigates the FRAME, not the top page.
+        frame_entry = frame_nav_target_entry(spec['target'])
         if method == 'GET'
           uri = URI.parse(action_url)
           uri.query = body unless body.empty?
-          in_frame ? navigate_frame(uri.to_s) : navigate(uri.to_s)
-        elsif in_frame
-          navigate_frame_post(action_url, body, content_type || enctype)
+          frame_entry ? navigate_frame(uri.to_s, entry: frame_entry) : navigate(uri.to_s)
+        elsif frame_entry
+          navigate_frame_post(action_url, body, content_type || enctype, entry: frame_entry)
         else
           navigate_post(action_url, body, content_type || enctype)
         end
@@ -2126,7 +2139,7 @@ module Capybara
           append_multipart_part(body, boundary, name, value.to_s)
         end
         file_inputs.each do |fi|
-          picks = @file_picks && @file_picks[fi['handle'].to_i] || []
+          picks = file_pick_paths(fi)
           if picks.empty?
             append_multipart_part(body, boundary, fi['name'].to_s, '', filename: '')
           else
@@ -2141,6 +2154,34 @@ module Capybara
         {content_type: "multipart/form-data; boundary=#{boundary}", body: body}
       end
 
+      # The on-disk paths backing a file input's current selection. Each
+      # selected File reports its host-backed source (`handle`/`index` → the
+      # `@file_picks` slot recorded at `attach_file` time); this resolves bytes
+      # even when JS moved a File onto a different input (`input.files =
+      # dataTransfer.files`), whose own handle was never attached to. Falls back
+      # to the input's own handle for older serializer payloads.
+      #
+      # Only host-backed Files (from `attach_file`) resolve here; a purely
+      # in-memory `new File(['bytes'], …)` assigned via JS has no `@file_picks`
+      # slot, so a CLASSIC (non-Turbo) submit drops its bytes — the fetch/XHR
+      # path serializes those in JS (`serializeMultipart` → `blobBytes`) and is
+      # unaffected. This matches the pre-existing behaviour and covers every
+      # realistic upload (host-backed file submitted through Turbo or a plain
+      # form).
+      def file_pick_paths(fi)
+        refs = fi['files']
+        if refs.is_a?(Array) && !refs.empty?
+          refs.filter_map {|ref|
+            handle = ref['handle']
+            next if handle.nil?
+            picks = @file_picks && @file_picks[handle.to_i]
+            picks && picks[ref['index'].to_i]
+          }
+        else
+          (@file_picks && @file_picks[fi['handle'].to_i]) || []
+        end
+      end
+
       def append_multipart_part(body, boundary, name, content, filename: nil, content_type: nil)
         body << "--#{boundary}\r\n"
         disposition = %[form-data; name="#{name}"]
@@ -2615,10 +2656,16 @@ module Capybara
 
       # `binary` is set by the JS side (it knows whether `send` was given a
       # string or an ArrayBuffer/view) → opcode 0x2 vs the text 0x1. Action
-      # Cable is text-only (JSON). The payload's bytes are written as-is.
-      def ws_send(id, data, binary = false)
+      # Cable is text-only (JSON). `b64` is set when the bytes arrived base64-
+      # encoded (the QuickJS binary path — raw bytes ≥0x80 don't survive its
+      # host boundary); decode before framing.
+      def ws_send(id, data, binary = false, b64 = false)
         sock = @websocket_sockets[id.to_i] or return
-        ws_write_frame(sock, binary ? 0x2 : 0x1, data.to_s.b)
+        if binary
+          ws_write_frame(sock, 0x2, b64 ? Base64.decode64(data.to_s) : data.to_s.b)
+        else
+          ws_write_frame(sock, 0x1, data.to_s.b)
+        end
         nil
       rescue StandardError
         nil
@@ -3566,6 +3613,12 @@ module Capybara
         # the page, discarding all JS state.
         if pure_fragment_navigation?(url)
           update_current_hash(url)
+        elsif @current_realm_id
+          # A JS-driven `location.*` from inside a `within_frame` block
+          # navigates the FRAME, not the top page (same as a self-targeted
+          # link/form there). Gated on the realm, so the main-page path is
+          # untouched.
+          navigate_frame(url)
         else
           navigate(url)
         end
@@ -3724,11 +3777,11 @@ module Capybara
       # Mirrors `navigate` / `navigate_post`'s fetch + redirect-follow but
       # terminates in `reload_current_frame_realm` instead of a main-page boot.
 
-      def navigate_frame(url, depth: 0)
+      def navigate_frame(url, depth: 0, entry: @frame_stack.last)
         raise 'too many redirects' if depth > 10
         invalidate_find_cache
         if url.to_s.match?(%r{\Aabout:blank(?:[?#]|\z)}i)
-          reload_current_frame_realm('about:blank', '', 'text/html')
+          reload_current_frame_realm('about:blank', '', 'text/html', entry: entry)
           return
         end
         env = Rack::MockRequest.env_for(url, method: 'GET')
@@ -3738,16 +3791,16 @@ module Capybara
         if (loc = redirect_location(status, headers))
           next_url = carry_fragment(url, resolve_against_current(loc))
           body.close if body.respond_to?(:close)
-          return navigate_frame(next_url, depth: depth + 1)
+          return navigate_frame(next_url, depth: depth + 1, entry: entry)
         end
         if download_response?(headers)
           save_downloaded_response(url, headers, body)
           return
         end
-        reload_current_frame_realm(url.to_s, read_rack_body(body), response_content_type(headers))
+        reload_current_frame_realm(url.to_s, read_rack_body(body), response_content_type(headers), entry: entry)
       end
 
-      def navigate_frame_post(url, body, content_type, depth: 0)
+      def navigate_frame_post(url, body, content_type, depth: 0, entry: @frame_stack.last)
         raise 'too many redirects' if depth > 10
         invalidate_find_cache
         env = Rack::MockRequest.env_for(url, method: 'POST', input: body)
@@ -3761,31 +3814,53 @@ module Capybara
           resp_body.close if resp_body.respond_to?(:close)
           # 301/302/303 → GET; 307/308 preserve method + body (same as navigate_post).
           if [307, 308].include?(status)
-            return navigate_frame_post(next_url, body, content_type, depth: depth + 1)
+            return navigate_frame_post(next_url, body, content_type, depth: depth + 1, entry: entry)
           else
-            return navigate_frame(next_url, depth: depth + 1)
+            return navigate_frame(next_url, depth: depth + 1, entry: entry)
           end
         end
         if download_response?(headers)
           save_downloaded_response(url, headers, resp_body)
           return
         end
-        reload_current_frame_realm(url.to_s, read_rack_body(resp_body), response_content_type(headers))
-      end
-
-      # Tear down the active frame's realm and rebuild it from `html`, then
-      # re-point the iframe element at the new realm. The iframe lives in the
-      # PARENT realm, so the rebind host fn runs there.
-      def reload_current_frame_realm(url, html, content_type)
-        entry = @frame_stack.last
+        reload_current_frame_realm(url.to_s, read_rack_body(resp_body), response_content_type(headers), entry: entry)
+      end
+
+      # Tear down a frame's realm and rebuild it from `html`, then re-point the
+      # iframe element at the new realm. The iframe lives in the PARENT realm, so
+      # the rebind host fn runs there. `entry` defaults to the active frame; a
+      # `_parent`-targeted navigation passes an ancestor entry instead — every
+      # frame below it in the stack is destroyed along with the ancestor's old
+      # document, so we dispose those realms and leave `@current_realm_id` on the
+      # (now-gone) current frame, surfacing StaleElement for the rest of the open
+      # `within_frame` block. Its `ensure` pops back to `entry`, whose `realm_id`
+      # we've updated to the rebuilt realm.
+      #
+      # Teardown reaches the realms on the entered `@frame_stack` (the ones a
+      # find could route into). Like the self-nav path, descendant realms of the
+      # rebuilt frame that were entered-then-popped earlier (so they no longer
+      # sit on the stack) aren't disposed here — they linger, unreferenced and
+      # un-stepped, until the next full-page rebuild's `dispose_frame_realms`. A
+      # bounded per-test leak, only reachable by re-entering a sibling subframe
+      # before an ancestor `_parent` nav; not worth a JS descendant walk on this
+      # path's perf budget.
+      def reload_current_frame_realm(url, html, content_type, entry: @frame_stack.last)
         return unless entry
         old_id = entry[:realm_id]
         parent = entry[:parent_realm_id]
         new_id = @runtime.reload_frame_realm(old_id, parent.to_i, url, RuntimeShared.utf8_text(html), content_type).to_i
         return if new_id.zero?
         rebind_frame_realm(parent, entry[:iframe_handle], old_id, new_id)
-        entry[:realm_id]  = new_id
-        @current_realm_id = new_id
+        if entry.equal?(@frame_stack.last)
+          entry[:realm_id]  = new_id
+          @current_realm_id = new_id
+        else
+          # Match by object identity (the branch was chosen by `equal?`); index
+          # by `==` could collide if two entries were ever structurally equal.
+          idx = @frame_stack.index {|e| e.equal?(entry) }
+          @frame_stack[(idx + 1)..].each {|descendant| @runtime.dispose_frame_realm(descendant[:realm_id]) }
+          entry[:realm_id] = new_id
+        end
         invalidate_find_cache
         settle
       end

data/lib/capybara/simulated/js/bridge.bundle.js

@@ -1798,7 +1798,7 @@
   globalThis.__isVisibleNode = isVisibleNode;
   globalThis.__isLaidOutNode = isLaidOutNode;
   function selfHidden(el, ignoreVisibility = false) {
-    if (el._attrs.hidden != null) return true;
+    const hidden = el._attrs.hidden != null;
     if (el._tag === "dialog" && el._attrs.open == null) return true;
     const inline = inlineHideDecl(el);
     if (inline && !state.hasImportantHideRule) {
@@ -1808,7 +1808,7 @@
       const visibilitySettled = ignoreVisibility || inline.visibility != null;
       if (displaySettled && visibilitySettled) return false;
     }
-    return matchesAnyHideRule(el, ignoreVisibility, inline);
+    return matchesAnyHideRule(el, ignoreVisibility, inline, hidden);
   }
   __name(selfHidden, "selfHidden");
   function inlineHideDecl(el) {
@@ -2297,13 +2297,22 @@
   }
   __name(forEachCandidateRule, "forEachCandidateRule");
   var LAYOUT_PROPS = [...CAPTURED_PROPS, "text-transform", "white-space"];
+  var IMPORTANT_RE = /\s*!\s*important\s*$/i;
+  function splitImportant(value) {
+    if (typeof value !== "string" || value.indexOf("!") < 0) return { value, important: false };
+    return IMPORTANT_RE.test(value) ? { value: value.replace(IMPORTANT_RE, "").trim(), important: true } : { value, important: false };
+  }
+  __name(splitImportant, "splitImportant");
   function parseInlineLayout(el) {
     const out = {};
     const s = el._attrs && el._attrs.style;
     if (!s) return out;
     for (const part of String(s).split(";")) {
       const m = /^\s*(top|left|width|height)\s*:\s*([^;]+?)\s*$/.exec(part);
-      if (m) out[m[1]] = { value: m[2], important: /\s+!important\s*$/.test(m[2]) };
+      if (m) {
+        const d = splitImportant(m[2]);
+        out[m[1]] = { value: d.value, important: d.important };
+      }
     }
     return out;
   }
@@ -2343,8 +2352,8 @@
     return candSource >= current.source;
   }
   __name(winsProp, "winsProp");
-  function matchesAnyHideRule(el, ignoreVisibility = false, inline = null) {
-    if (state.hideRules.length === 0 && !inline) return false;
+  function matchesAnyHideRule(el, ignoreVisibility = false, inline = null, hidden = false) {
+    if (state.hideRules.length === 0 && !inline) return hidden;
     let bestD = null, bestV = null;
     if (inline) {
       if (inline.display != null) {
@@ -2367,6 +2376,7 @@
       });
     }
     if (bestD && bestD.value === "none") return true;
+    if (hidden && bestD == null) return true;
     if (bestV && (bestV.value === "hidden" || bestV.value === "collapse")) return true;
     return false;
   }
@@ -2523,11 +2533,11 @@
   }
   __name(cascadedProperty, "cascadedProperty");
   function parseInlinePropertyValue(style, prop) {
-    const re = new RegExp("(?:^|;)\\s*" + prop + "\\s*:\\s*([^;!]+?)\\s*(?:!important)?\\s*(?:;|$)", "i");
+    const re = new RegExp("(?:^|;)\\s*" + prop + "\\s*:\\s*([^;!]+?)\\s*(!\\s*important)?\\s*(?:;|$)", "i");
     const m = re.exec(String(style));
     if (!m) return null;
     const lower = prop === "display" || prop === "visibility" || prop === "text-transform" || prop === "white-space";
-    return { value: lower ? m[1].toLowerCase() : m[1], important: /!important/i.test(style) };
+    return { value: lower ? m[1].toLowerCase() : m[1], important: m[2] != null };
   }
   __name(parseInlinePropertyValue, "parseInlinePropertyValue");
   function rulesIndexHas(prop) {
@@ -4817,6 +4827,10 @@
       this.lastModified = i.lastModified || Date.now();
     }
   };
+  function utf8Latin1(s) {
+    return bytesToLatin1(new globalThis.TextEncoder().encode(String(s)));
+  }
+  __name(utf8Latin1, "utf8Latin1");
   function serializeMultipart(formData) {
     const boundary = "----csimFormBoundary" + Math.random().toString(36).slice(2);
     let body = "";
@@ -4825,13 +4839,13 @@
       if (value instanceof Blob) {
         const filename = value.name != null ? String(value.name) : "blob";
         const contentType = value.type || "application/octet-stream";
-        body += 'Content-Disposition: form-data; name="' + key + '"; filename="' + filename + '"\r\n';
+        body += 'Content-Disposition: form-data; name="' + utf8Latin1(key) + '"; filename="' + utf8Latin1(filename) + '"\r\n';
         body += "Content-Type: " + contentType + "\r\n\r\n";
         body += blobBytes(value);
         body += "\r\n";
       } else {
-        body += 'Content-Disposition: form-data; name="' + key + '"\r\n\r\n';
-        body += String(value) + "\r\n";
+        body += 'Content-Disposition: form-data; name="' + utf8Latin1(key) + '"\r\n\r\n';
+        body += utf8Latin1(value) + "\r\n";
       }
     });
     body += "--" + boundary + "--\r\n";
@@ -5487,7 +5501,8 @@
       get(_t, prop) {
         if (prop === "cssText") return el._attrs.style || "";
         if (prop === "getPropertyValue") return (name) => readCssProp(el, String(name));
-        if (prop === "setProperty") return (n, v) => writeCssProp(el, String(n), String(v));
+        if (prop === "getPropertyPriority") return (name) => readCssPriority(el, String(name));
+        if (prop === "setProperty") return (n, v, priority) => writeCssProp(el, String(n), String(v), priority);
         if (prop === "removeProperty") return (name) => removeCssProp(el, String(name));
         if (prop === "length") return Object.keys(parsedDecls(el)).length;
         if (typeof prop !== "string") return void 0;
@@ -5504,7 +5519,7 @@
         return true;
       },
       has(_t, prop) {
-        if (prop === "cssText" || prop === "getPropertyValue" || prop === "setProperty" || prop === "removeProperty" || prop === "length") return true;
+        if (prop === "cssText" || prop === "getPropertyValue" || prop === "getPropertyPriority" || prop === "setProperty" || prop === "removeProperty" || prop === "length") return true;
         return readCssProp(el, camelToKebab(String(prop))) !== "";
       }
     };
@@ -5524,17 +5539,34 @@
     return el._declCache;
   }
   __name(parsedDecls, "parsedDecls");
+  var IMPORTANT_SUFFIX_RE = /\s*!\s*important\s*$/i;
+  function stripImportant(v) {
+    if (typeof v !== "string" || v.indexOf("!") < 0) return v;
+    return v.replace(IMPORTANT_SUFFIX_RE, "").trim();
+  }
+  __name(stripImportant, "stripImportant");
   function readCssProp(el, name) {
     const decls = parsedDecls(el);
-    return decls[name] != null ? decls[name] : "";
+    return decls[name] != null ? stripImportant(decls[name]) : "";
   }
   __name(readCssProp, "readCssProp");
-  function writeCssProp(el, name, value) {
+  function readCssPriority(el, name) {
+    const v = parsedDecls(el)[name];
+    return v != null && splitImportant(v).important ? "important" : "";
+  }
+  __name(readCssPriority, "readCssPriority");
+  function writeCssProp(el, name, value, priority) {
     const decls = parseStyleDecls(el._attrs.style || "");
     if (value === "" || value == null) {
       delete decls[name];
     } else {
-      decls[name] = String(value);
+      let v = String(value);
+      if (/^\s*important\s*$/i.test(String(priority == null ? "" : priority))) {
+        v = stripImportant(v) + " !important";
+      } else if (priority != null && priority !== "") {
+        return;
+      }
+      decls[name] = v;
     }
     el.setAttribute("style", serializeStyleDecls(decls));
   }
@@ -5657,10 +5689,9 @@
     const inlineStyle = el._attrs.style;
     if (inlineStyle) {
       const m = /(^|;|\s)display\s*:\s*([^;]+)/i.exec(inlineStyle);
-      if (m) return m[2].trim();
+      if (m) return stripImportant(m[2].trim());
     }
-    if (el._attrs.hidden != null) return "none";
-    if (matchesAnyHideRule(el)) return "none";
+    if (matchesAnyHideRule(el, true, null, el._attrs.hidden != null)) return "none";
     return DEFAULT_DISPLAY[el._tag] || "block";
   }
   __name(computedDisplayFor, "computedDisplayFor");
@@ -5668,7 +5699,7 @@
     const inlineStyle = el._attrs.style;
     if (inlineStyle) {
       const m = /(^|;|\s)visibility\s*:\s*([^;]+)/i.exec(inlineStyle);
-      if (m) return m[2].trim();
+      if (m) return stripImportant(m[2].trim());
     }
     return "";
   }
@@ -10067,6 +10098,15 @@
       };
       return list;
     }
+    // HTML lets you assign a `FileList` to a file input programmatically — the
+    // canonical pattern is `input.files = dataTransfer.files` (drag-drop libraries,
+    // and the kamalog `attach-images` Stimulus controller, do exactly this). Accept
+    // any array-like of File objects; null/undefined clears the selection.
+    set files(value) {
+      if (this._tag !== "input") return;
+      if ((this._attrs.type || "").toLowerCase() !== "file") return;
+      this._files = value == null ? [] : Array.from(value);
+    }
     get innerHTML() {
       return serializeChildren(this);
     }
@@ -14201,14 +14241,18 @@
       if (this.readyState === 0) throw new DOMException("Failed to execute 'send' on 'WebSocket': Still in CONNECTING state.", "InvalidStateError");
       if (this.readyState !== 1) return;
       if (typeof data === "string") {
-        globalThis.__csim_wsSend(this._id, data, false);
+        globalThis.__csim_wsSend(this._id, data, false, false);
         return;
       }
       let bytes;
       if (data instanceof ArrayBuffer) bytes = new Uint8Array(data);
       else if (ArrayBuffer.isView(data)) bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
       else bytes = new Uint8Array(0);
-      globalThis.__csim_wsSend(this._id, bytes, true);
+      if (globalThis.RustyRacer) {
+        globalThis.__csim_wsSend(this._id, bytes, true, false);
+      } else {
+        globalThis.__csim_wsSend(this._id, globalThis.btoa(bytesToLatin1(bytes)), true, true);
+      }
     }
     close(code, reason) {
       if (this.readyState === 2 || this.readyState === 3) return;
@@ -14658,6 +14702,18 @@
         if (spec && Array.isArray(spec.fields)) {
           for (const pair of spec.fields) this._entries.push([String(pair[0]), String(pair[1])]);
         }
+        if (spec && Array.isArray(spec.fileInputs)) {
+          const File2 = globalThis.File;
+          for (const fi of spec.fileInputs) {
+            const el = lookup(fi.handle);
+            const files = el && el.files;
+            if (files && files.length) {
+              for (const f of files) this._entries.push([String(fi.name), f]);
+            } else if (File2) {
+              this._entries.push([String(fi.name), new File2([], "", { type: "application/octet-stream" })]);
+            }
+          }
+        }
         if (submitter && submitter._attrs && submitter._attrs.name) {
           this._entries.push([String(submitter._attrs.name), String(submitter._attrs.value || "")]);
         }
@@ -15686,7 +15742,12 @@
           continue;
         }
         if (type === "file") {
-          fileInputs.push({ name, handle: f._id });
+          const files = (f._files || []).map((file) => ({
+            name: String(file.name || ""),
+            handle: file && file._csimHost ? file._handle : null,
+            index: file && file._csimHost ? file._index : null
+          }));
+          fileInputs.push({ name, handle: f._id, files });
           continue;
         }
         fields.push([name, f._attrs.value != null ? f._attrs.value : ""]);
@@ -17919,7 +17980,16 @@
       this.dropEffect = "none";
       this.effectAllowed = "all";
       this.types = [];
-      this.files = [];
+    }
+    // `files` is the FileList view of the file-kind items — derived so it stays in
+    // sync however items were added (`items.add(file)`, drag-drop construction, …).
+    get files() {
+      const out = [];
+      for (const it of this.items) if (it.kind === "file" && it._file) out.push(it._file);
+      out.item = function(i) {
+        return this[i] || null;
+      };
+      return out;
     }
     getData(type) {
       for (const it of this.items) if (it.kind === "string" && it.type === type) return it._value;
@@ -19921,7 +19991,6 @@
         if (it.kind === "file") {
           const file = { name: it.name, type: "", size: 0 };
           dt.items.push(new globalThis.DataTransferItem("file", "application/octet-stream", null, file));
-          dt.files.push(file);
           if (!dt.types.includes("Files")) dt.types.push("Files");
         } else {
           dt.items.push(new globalThis.DataTransferItem("string", it.type, it.value, null));
@@ -19988,7 +20057,6 @@
     function __isTabbable(el) {
       if (!el || el.nodeType !== NODE_ELEMENT) return false;
       if (el._attrs.disabled != null) return false;
-      if (el._attrs.hidden != null) return false;
       if (selfHidden(el)) return false;
       const ti = el._attrs.tabindex;
       if (ti != null) {

data/lib/capybara/simulated/runtime_shared.rb

@@ -67,7 +67,7 @@ module Capybara
         '__csim_eventSourceOpen'     => ->(b, *a) { b.event_source_open(a[0]) },
         '__csim_eventSourceClose'    => ->(b, *a) { b.event_source_close(a[0]); nil },
         '__csim_wsOpen'              => ->(b, *a) { b.ws_open(a[0], a[1]) },
-        '__csim_wsSend'              => ->(b, *a) { b.ws_send(a[0], a[1], a[2]); nil },
+        '__csim_wsSend'              => ->(b, *a) { b.ws_send(a[0], a[1], a[2], a[3]); nil },
         '__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 },

data/lib/capybara/simulated/v8_runtime.rb

@@ -411,13 +411,20 @@ module Capybara
       # keeps the new realm's `parent`/`top` wired to the owning realm. The
       # Browser then re-points the iframe element at the new id (`__csimRebindFrameRealm`).
       def reload_frame_realm(old_id, parent_id, url, body, content_type)
-        if (fr = frame_realms.delete(old_id))
-          @realm_module_handles&.delete(old_id)
-          fr.dispose rescue nil
-        end
+        dispose_frame_realm(old_id)
         create_frame_realm(ctx, url, body, content_type, parent_id)
       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)
+        return if id.nil? || id.zero?
+        @realm_module_handles&.delete(id)
+        fr = frame_realms.delete(id)
+        fr.dispose rescue nil if fr
+        nil
+      end
+
       # One native microtask checkpoint — a checkpoint runs the queue until
       # empty, and rusty already performs one at the end of every top-level
       # eval/call (V8's default kAuto policy), so a single explicit checkpoint

data/lib/capybara/simulated/version.rb

@@ -2,6 +2,6 @@
 
 module Capybara
   module Simulated
-    VERSION = '0.3.0'
+    VERSION = '0.4.0'
   end
 end

metadata

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