capybara-lightpanda 0.13.0 → 0.14.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c435f7a8f49c34c68012f2c34cb4f9766531acbdd61e9e3f70e4ac9395d54e3
-  data.tar.gz: 11cca4dc77a1b415eff5e0e45796e9f806ee36169c8ad0c672c0947d2281f834
+  metadata.gz: d38fc6a0a5cbba01bba3a0a1363d8e0577dc99c2cb8a77b81f407b273a91863b
+  data.tar.gz: 21cdea0aeba27736c52f800c22e850d80ea15d3c7bb1c6c9b173421bb227be7d
 SHA512:
-  metadata.gz: '07464388df9304ea1f4bf3bbde2c6dfd1c654d787690d47d3d3d62f6f89c22860a24185f14c839979e0d6fb1aebfb030aee97c450894d8da418357341994a4dd'
-  data.tar.gz: 03d0b12cf3cb0728639faed14706fffce40f1287f65b714f4126d4a4da8063071ac9423e6a1b040e68dfc6473e451d29658944a8bfa4d5db3c462520c0b260c6
+  metadata.gz: ec4a2743650df3602c43fc393a82af00c19c5b44d59fab31156aed0b3252e8fb7f3c5f06df1b6e2fe994c9b974a1b21b29707c22c6bff571d4c2b6aca195add4
+  data.tar.gz: ba19fbd3c2754eae2b6d3af02584d739eba498b93e0e0ff392f9dc7a9feefdc1af1ff68081cd5b6963ca41c768cf8cebcf3b48b9debd9923e5142b15ac1c9223

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [0.14.1] - 2026-10-12
+
+### Fixed
+
+- **A click that loads a new page waits for that page's scripts.** `click` used to return as soon as the new document existed, before its deferred and module scripts had run. Apps load Stimulus, Turbo and Bootstrap that way, so the next action could land on a page whose handlers were not wired yet: a Bootstrap collapse that did not open, a `confirm()` that never showed (`accept_confirm` raised `ModalNotFound`) while the form was submitted anyway, a form posted before its JavaScript was ready. The click now also waits for `DOMContentLoaded`, as Cuprite waits for the load event. `send_keys`, `go_back` and `go_forward` wait the same way when they load a new page. Clicks that don't navigate are as fast as before.
+- **A click on a link that Turbo hands back to the browser waits for the new page.** With Turbo on the page, such a click returned immediately on the page being left, because Turbo reported activity and went idle again before the navigation started.
+
+## [0.14.0] - 2026-10-11
+
+### Fixed
+
+- **`evaluate_script` returns `Capybara::Lightpanda::CyclicObject` for a result that references itself, as Cuprite returns `Ferrum::CyclicObject`.** A self-referencing object used to raise `BrowserError: Object reference chain is too long`. So did `evaluate_script("window")` on recent Lightpanda nightlies, and on older builds it came back as a broken element.
+- **`Cookies#load` keeps restoring a file when one cookie is malformed.** Recent Lightpanda nightlies reject a cookie with a `;` or control character in its name or value, as Chrome does, where older builds stored it. A file saved from an older build could hold such a cookie, and `load` stopped at it with a `BrowserError`. It now skips that cookie and names it in its warning, like any other cookie the browser refuses. `Cookies#set` still raises for it.
+- **Clicking a `javascript:` link no longer breaks the page on recent Lightpanda nightlies.** On nightly 10261 and later, clicking `<a href="javascript:void(0)">` (select2, Bootstrap toggles, older jQuery code) left the page unusable: every later `find` or `evaluate_script` raised `NoExecutionContextError` until the next `visit`. The link's code still runs, once, and the page stays.
+- **A click waits for the page it navigates to, even when the server is slow.** `click` used to return after about 50 ms, before a link, `window.location` assignment or form submission had loaded the next page whenever the server took longer than that (a slow action, a redirect). The very next `current_url` or `assert_current_path(..., wait: 0)` then read the page being left. The click now waits for the new page, as in Cuprite. Clicks that don't navigate are as fast as before, and so are `pushState` and anchor clicks. A navigation that fails, such as a refused connection, doesn't make the click wait for the timeout. `send_keys` waits the same way when Enter submits a form.
+- **`go_back` and `go_forward` keep the page when the history entry comes from `pushState`.** They used to reload the document from the server, so the page's JavaScript state was lost and no `popstate` event fired: a "browser back button" test on a step-by-step page could not pass. They now behave like the browser's buttons: the page stays, `popstate` fires and `current_url` is up to date when the call returns. Going back or forward to another page still loads it, and the call waits for it. Lightpanda limit: on Lightpanda 1.0.0 this only applies when the two entries differ by their `#fragment`. When `pushState` changed the path (Turbo Drive, client-side routers), 1.0.0 still reloads the page ([lightpanda-io/browser#3726](https://github.com/lightpanda-io/browser/issues/3726)); nightly builds from 10239 keep it.
+- **Clicking a link inside an iframe navigates the iframe, not the whole page.** Inside `within_frame`, `click_link` used to replace the whole page with the link's target, and a `#fragment` link in a frame did the same. Links with `target="_top"` or `target="_parent"` still leave the frame, as in Chrome.
+- **Scripts run inside the frame within `within_frame`.** `execute_script`, `evaluate_script` and `evaluate_async_script` used to run against the page around the frame, so `document` and `window` were the top page's. They now see the frame's document, as in Chrome.
+- **An element found in an iframe goes stale when that iframe navigates.** It used to keep answering from the old document: empty text, not visible, clicks that did nothing. Capybara never found it again. It is now treated as obsolete, as in Chrome, and Capybara's automatic reload finds the element in the new page.
+- **`select` works in a form that has a field named `disabled`.** On recent Lightpanda nightlies, an `<input name="disabled">` made every option in its form read as disabled, so `select` silently did nothing.
+
 ## [0.13.0] - 2026-10-03
 
 > **Update Lightpanda before upgrading.** This release requires Lightpanda **1.0.0** or a nightly build ≥ 9994. The driver refuses anything older and names the version it found. Tagged releases work again: pin `1.0.0` for a reproducible browser.

data/lib/capybara/lightpanda/browser/navigation.rb

@@ -33,12 +33,20 @@ module Capybara
         end
         alias goto go_to
 
+        # Back/forward go through the page's own History API, like the
+        # browser's buttons: an entry created by `pushState` is restored in
+        # the same document (JS state kept, `popstate` fired synchronously),
+        # while an entry from another document starts a real navigation that
+        # `wait_for_idle` sniffs and waits out. CDP's
+        # `Page.navigateToHistoryEntry` is not an option — Lightpanda reloads
+        # the document even for a `pushState` entry. Both are no-ops at either
+        # end of the session history.
         def back
-          wait_for_navigation { navigate_history(-1) }
+          traverse_history("history.back()")
         end
 
         def forward
-          wait_for_navigation { navigate_history(+1) }
+          traverse_history("history.forward()")
         end
 
         def refresh
@@ -98,23 +106,13 @@ module Capybara
           await_navigation(&)
         end
 
-        # Step the session history by `offset` (-1 = back, +1 = forward) using
-        # native CDP. `Page.getNavigationHistory` returns the entry list and
-        # `currentIndex`; `Page.navigateToHistoryEntry` jumps to the chosen
-        # entry's `id`. No-op when the offset would step past either end so
-        # the behavior matches `history.back()` / `history.forward()` on a
-        # bounded session history.
-        def navigate_history(offset)
-          history = page_command("Page.getNavigationHistory")
-          target_index = history["currentIndex"] + offset
-          entries = history["entries"]
-          return if target_index.negative? || target_index >= entries.length
-
-          page_command("Page.navigateToHistoryEntry", entryId: entries[target_index]["id"])
+        def traverse_history(expression)
+          page_command("Runtime.evaluate", expression: expression)
+          wait_for_idle
         end
 
         # Common navigation lifecycle shared by `wait_for_page_load` (fresh
-        # `Page.navigate`) and `wait_for_navigation` (back / forward / reload).
+        # `Page.navigate`) and `wait_for_navigation` (reload).
         # Subscribes to Page.loadEventFired, runs the trigger, waits briefly for
         # the event, falls back to readyState polling for the remaining budget.
         # The handler is unsubscribed via `ensure` so a raising trigger doesn't

data/lib/capybara/lightpanda/browser/runtime.rb

@@ -1,7 +1,20 @@
 # frozen_string_literal: true
 
+require "singleton"
+
 module Capybara
   module Lightpanda
+    # Stands in for a script result that has no Ruby representation because it
+    # references itself — `window`, or `a.self = a` — so `returnByValue` can't
+    # serialize it. Ferrum returns its own `Ferrum::CyclicObject` the same way.
+    class CyclicObject
+      include Singleton
+
+      def inspect
+        %(#<#{self.class} JavaScript object that cannot be represented in Ruby>)
+      end
+    end
+
     class Browser
       # JS evaluation and RemoteObject plumbing: Runtime.evaluate /
       # callFunctionOn dispatch, result serialization (Ferrum's
@@ -23,7 +36,15 @@ module Capybara
         # later calls, like the DevTools console) but allows redeclaration.
         # Completion-value semantics cover a bare expression (`'foo'`), a
         # `throw` statement, and multi-statement scripts alike.
-        def evaluate(expression, *args)
+        #
+        # `frame` (an `<iframe>` Node, `frame_stack.last` inside `within_frame`)
+        # runs the script against that frame's globals — see call_with_args.
+        # There the script goes through the frame's indirect `eval` rather than
+        # REPL mode: same completion-value semantics, `var` still lands on the
+        # frame's window, but a top-level `const`/`let` lives only for its call.
+        def evaluate(expression, *args, frame: nil)
+          return call_with_args(FRAME_EVAL_JS, [expression], frame: frame) if frame && args.empty?
+
           if args.empty?
             response = page_command("Runtime.evaluate", expression: expression, returnByValue: false,
                                                         awaitPromise: true, replMode: true)
@@ -33,7 +54,7 @@ module Capybara
           end
 
           wrapped = "function() { return #{expression} }"
-          call_with_args(wrapped, args)
+          call_with_args(wrapped, args, frame: frame)
         end
 
         # Execute JS without returning a value.
@@ -43,7 +64,12 @@ module Capybara
         # on JS exceptions so silent failures don't mask test bugs (the
         # previous fast path swallowed them because `awaitPromise: false` was
         # checked but `exceptionDetails` was not).
-        def execute(expression, *args)
+        def execute(expression, *args, frame: nil)
+          if frame && args.empty?
+            call_with_args(FRAME_EXECUTE_JS, [expression], return_by_value: true, frame: frame)
+            return nil
+          end
+
           if args.empty?
             response = page_command("Runtime.evaluate", expression: expression, returnByValue: false,
                                                         awaitPromise: false, replMode: true)
@@ -52,7 +78,7 @@ module Capybara
           end
 
           wrapped = "function() { #{expression} }"
-          call_with_args(wrapped, args, return_by_value: false)
+          call_with_args(wrapped, args, return_by_value: false, frame: frame)
           nil
         end
 
@@ -77,7 +103,7 @@ module Capybara
         # Evaluate async JS with a callback. The user's script receives
         # the callback as its last argument (`arguments[arguments.length - 1]`),
         # matching Capybara's evaluate_async_script contract.
-        def evaluate_async(expression, *args, wait: @options.timeout)
+        def evaluate_async(expression, *args, wait: @options.timeout, frame: nil)
           timeout_ms = (wait * 1000).to_i
           wrapped = <<~JS
             function() {
@@ -92,7 +118,7 @@ module Capybara
               });
             }
           JS
-          call_with_args(wrapped, args)
+          call_with_args(wrapped, args, frame: frame)
         end
 
         # Evaluate JS and return a RemoteObject reference (for DOM nodes, arrays).
@@ -142,6 +168,19 @@ module Capybara
           # itself timed out / failed in transport.
         end
 
+        # Compiles the declaration (first argument) with the frame's `eval` and
+        # applies it to the rest. `this` is the `<iframe>` element.
+        FRAME_APPLY_JS = <<~JS
+          function(declaration) {
+            var fn = this.contentWindow.eval('(' + declaration + ')');
+            return fn.apply(null, Array.prototype.slice.call(arguments, 1));
+          }
+        JS
+        # Indirect eval: global code in the frame, like a classic script.
+        FRAME_EVAL_JS = "function(source) { return (0, eval)(source); }"
+        # No return, so a script ending in a pending Promise isn't awaited.
+        FRAME_EXECUTE_JS = "function(source) { (0, eval)(source); }"
+
         private
 
         def serialize_argument(arg)
@@ -167,17 +206,32 @@ module Capybara
         # When `return_by_value: false` (the default) the return value is unwrapped via
         # `unwrap_call_result` so that DOM nodes come back as `{ "__lightpanda_node__" => ... }`
         # hashes the Driver can wrap as Capybara nodes.
-        def call_with_args(function_declaration, args, return_by_value: false)
-          # document_object_id returns a fresh RemoteObject handle every call.
-          # Release it on the way out so long-running shared-spec sessions don't
-          # accumulate orphaned V8 handles between resets.
-          doc_oid = document_object_id
+        #
+        # With `frame`, the function is compiled by the frame's own `eval`, so
+        # its free names (`window`, `document`, `location`) are the frame's, and
+        # called from the `<iframe>` element. Running it in the frame's own
+        # execution context instead would not do: Lightpanda runs every
+        # callFunctionOn in the top context, so node handles found inside a
+        # frame belong to that context and can't be passed into another
+        # ("Argument should belong to the same JavaScript world").
+        def call_with_args(function_declaration, args, return_by_value: false, frame: nil)
+          arguments = args.map { |a| serialize_argument(a) }
+          if frame
+            target = frame.remote_object_id
+            arguments.unshift({ value: function_declaration })
+            function_declaration = FRAME_APPLY_JS
+          else
+            # document_object_id returns a fresh RemoteObject handle every call.
+            # Release it on the way out so long-running shared-spec sessions
+            # don't accumulate orphaned V8 handles between resets.
+            target = doc_oid = document_object_id
+          end
           params = {
-            objectId: doc_oid,
+            objectId: target,
             functionDeclaration: function_declaration,
             returnByValue: return_by_value,
             awaitPromise: true,
-            arguments: args.map { |a| serialize_argument(a) },
+            arguments: arguments,
           }
           response = page_command("Runtime.callFunctionOn", **params)
           raise_on_js_error!("call_with_args", function_declaration, response)
@@ -216,6 +270,11 @@ module Capybara
         # Re-fetch a remote object as JSON-serializable value for plain objects/arrays.
         # Cheaper than walking properties and good enough for shared specs. Releases
         # the original handle so long-lived sessions don't accumulate leaked objectIds.
+        #
+        # V8 refuses to return a cyclic object by value. Through 1.0.0 every
+        # Zig-backed object, `window` included, came back as a node; since
+        # upstream #3831 (build 10255) `window` lands here and raised. Both it
+        # and a plain self-referencing object now return CyclicObject.
         def serialize_remote_object(object_id)
           json = page_command(
             "Runtime.callFunctionOn",
@@ -224,10 +283,17 @@ module Capybara
             returnByValue: true
           )
           handle_evaluate_response(json, "function() { return this }")
+        rescue BrowserError => e
+          raise unless CYCLIC_VALUE_ERRORS.any? { |message| e.message.to_s.include?(message) }
+
+          CyclicObject.instance
         ensure
           release_object(object_id)
         end
 
+        CYCLIC_VALUE_ERRORS = ["Object reference chain is too long", "Object couldn't be returned by value"].freeze
+        private_constant :CYCLIC_VALUE_ERRORS
+
         # Walk an array's own indexed properties via `Runtime.getProperties`,
         # unwrapping each element through the regular result pipeline so that
         # DOM-node entries surface as `{ "__lightpanda_node__" => ... }` instead

data/lib/capybara/lightpanda/browser/selenium_compat.rb

@@ -85,9 +85,10 @@ module Capybara
         # Selenium's `execute_async_script`: the script receives a completion
         # callback as its last argument. Same contract as
         # Driver#evaluate_async_script, minus the DOM-node unwrapping — callers
-        # on this path (axe-core et al.) hand back plain JSON.
+        # on this path (axe-core et al.) hand back plain JSON. Runs in the
+        # current frame, as Selenium's does.
         def execute_async_script(script, *)
-          evaluate_async(script.to_s.strip, *)
+          evaluate_async(script.to_s.strip, *, frame: frame_stack.last)
         end
 
         # Selenium's raw-CDP escape hatch, as used by

data/lib/capybara/lightpanda/browser.rb

@@ -166,6 +166,8 @@ module Capybara
         subscribe_to_console_logs
         subscribe_to_console_capture
         subscribe_to_execution_context
+        subscribe_to_navigation
+        subscribe_to_document_ready
         subscribe_to_turbo_signals
         # Network owns the Network.* domain: enabling installs traffic
         # tracking AND the navigation-response capture behind status_code.
@@ -423,24 +425,39 @@ module Capybara
       # (title, current_url, …) without racing the navigation lifecycle.
       #
       # Sniff window: the action returns synchronously, but the CDP events
-      # signalling its async fallout (Runtime.executionContextsCleared for
-      # full nav; the turbo sentinel for Turbo) arrive later on the dispatch
-      # thread. We poll briefly for either signal — if neither fires within
-      # the window, assume the action was inert and exit fast.
+      # signalling its async fallout arrive later on the dispatch thread. We
+      # poll briefly for either of them — a main-frame navigation start (see
+      # subscribe_to_navigation) or Runtime.executionContextsCleared — and if
+      # none fires within the window, assume the action was inert and exit
+      # fast. Lightpanda announces a navigation ~5 ms after the click but only
+      # swaps the execution context once the response lands, so watching the
+      # context alone returned on the old document whenever the server took
+      # longer than the window. The turbo sentinel does not end the sniff
+      # (it is awaited after): Turbo goes busy then idle within a few ms on a
+      # link it hands back to the browser, before the navigation start lands.
       SNIFF_WINDOW = 0.05
       private_constant :SNIFF_WINDOW
 
       def wait_for_idle
         prior_context_iteration = @default_context_event.iteration
+        prior_navigation_iteration = @navigation_event.iteration
         sniff_deadline = monotonic_time + SNIFF_WINDOW
+        navigating = false
         loop do
+          navigating = @navigation_event.iteration > prior_navigation_iteration
+          break if navigating
           break if @default_context_event.iteration > prior_context_iteration
-          break unless @turbo_event.set?
           break if monotonic_time > sniff_deadline
 
           sleep 0.001
         end
 
+        # Only a navigation this action started is awaited: one left pending
+        # by an earlier load must not make every later click pay the timeout.
+        if navigating
+          @navigation_event.wait(@options.timeout)
+          wait_for_document_ready
+        end
         @default_context_event.wait(@options.timeout)
         @turbo_event.wait(@options.timeout)
         check_unhandled_modal!
@@ -607,6 +624,111 @@ module Capybara
         page_command("Runtime.enable")
       end
 
+      # Track cross-document navigations of the main frame, from the moment
+      # they start until the frame stops loading. Same-document ones
+      # (pushState, fragment) emit Page.navigatedWithinDocument instead and
+      # never reset the event, so they don't make wait_for_idle block; nor do
+      # iframe navigations (other frameId). The main frame shares the
+      # target's id.
+      #
+      # It ends at whichever comes first: the main frame's new default
+      # execution context (the new document committed — enough even when
+      # the load event never comes, lightpanda-io/browser#1801) or
+      # Page.frameStoppedLoading. A navigation whose request fails
+      # (connection refused, DNS) emits neither — only Network.loadingFailed for the
+      # document request — so that ends it too, keyed by the requestId the
+      # main-frame Document request was sent with. Needs Page.enable, which
+      # the first go_to turns on; a page that was never visited has no
+      # navigation to click into.
+      def subscribe_to_navigation
+        @navigation_event = Utils::Event.new
+        @navigation_event.set
+        @navigation_request_id = nil
+
+        on("Page.frameStartedNavigating") do |params|
+          @navigation_event.reset if main_frame_navigation_start?(params)
+        end
+        on("Network.requestWillBeSent") do |params|
+          @navigation_request_id = params["requestId"] if main_frame_document_request?(params)
+        end
+        on("Page.frameStoppedLoading") do |params|
+          @navigation_event.set if params["frameId"] == @target_id
+        end
+        on("Runtime.executionContextCreated") do |params|
+          aux = params.dig("context", "auxData") || {}
+          @navigation_event.set if aux["isDefault"] && aux["frameId"] == @target_id
+        end
+        on("Network.loadingFailed") do |params|
+          @navigation_event.set if params["requestId"] == @navigation_request_id
+        end
+      end
+
+      # The new document's context exists before its deferred and module
+      # scripts have run: this event marks the end of that phase, at
+      # Page.domContentEventFired or anything later that proves it is over
+      # (load, the frame stopping, the document request failing).
+      def subscribe_to_document_ready
+        @document_ready_event = Utils::Event.new
+        @document_ready_event.set
+
+        on("Page.frameStartedNavigating") do |params|
+          @document_ready_event.reset if main_frame_navigation_start?(params)
+        end
+        on("Page.domContentEventFired") { @document_ready_event.set }
+        on("Page.loadEventFired") { @document_ready_event.set }
+        on("Page.frameStoppedLoading") do |params|
+          @document_ready_event.set if params["frameId"] == @target_id
+        end
+        on("Network.loadingFailed") do |params|
+          @document_ready_event.set if params["requestId"] == @navigation_request_id
+        end
+      end
+
+      # After a click that navigated, the next action must not run before the
+      # new page's JS has wired its handlers: Stimulus, Bootstrap's data-api
+      # and Turbo load as module scripts, which run after the document commits
+      # and before DOMContentLoaded. Cuprite waits for the load event. The
+      # event is awaited briefly, then document.readyState is polled for the
+      # rest of the budget, as #go_to does (lightpanda-io/browser#1801: page
+      # events may never come). Never raises: a page that never settles costs
+      # the timeout once, then the action returns as it did before.
+      DOCUMENT_READY_EVENT_WAIT = 2
+      private_constant :DOCUMENT_READY_EVENT_WAIT
+
+      def wait_for_document_ready
+        deadline = monotonic_time + @options.timeout
+        return if @document_ready_event.wait([DOCUMENT_READY_EVENT_WAIT, @options.timeout].min)
+
+        remaining = deadline - monotonic_time
+        return unless remaining.positive?
+
+        Utils::Wait.until(timeout: remaining, interval: 0.1) do
+          @document_ready_event.set? || @client.closed? || document_complete?
+        end
+      rescue TimeoutError
+        nil
+      end
+
+      def document_complete?
+        response = @client.command(
+          "Runtime.evaluate",
+          { expression: "document.readyState", returnByValue: true },
+          session_id: @session_id,
+          timeout: 2
+        )
+        response.dig("result", "value") == "complete"
+      rescue Error
+        false
+      end
+
+      def main_frame_navigation_start?(params)
+        params["frameId"] == @target_id && !params["navigationType"].to_s.match?(/same/i)
+      end
+
+      def main_frame_document_request?(params)
+        params["type"] == "Document" && params["frameId"] == @target_id
+      end
+
       def close_client_silently
         @client&.close
       rescue StandardError

data/lib/capybara/lightpanda/cookies.rb

@@ -83,7 +83,10 @@ module Capybara
       # Lightpanda answers `{success: false}` and drops the cookie for an
       # invalid combination — notably `same_site: "None"` without `secure`
       # since upstream #3529 (build 9877), Chrome's rule — so callers that
-      # need it to stick should check the result.
+      # need it to stick should check the result. A malformed field (a `;` or
+      # control character in the name or value, surrounding whitespace) raises
+      # BrowserError instead: since upstream #3791 (build 10212) the browser
+      # answers `-32602 Sanitizing cookie failed`, as Chrome does.
       def set(name:, value:, domain: nil, path: "/", secure: false, http_only: false, # rubocop:disable Metrics/ParameterLists, Naming/PredicateMethod
               same_site: nil, expires: nil)
         params = {
@@ -126,8 +129,10 @@ module Capybara
       # CDP requires either domain or url for each cookie; entries from `store`
       # already include domain, so they round-trip cleanly. Returns true on
       # success (intentionally not a predicate — mirrors ferrum's API). A
-      # cookie the browser refuses is reported on stderr rather than raised,
-      # so one bad entry doesn't abort restoring the rest.
+      # cookie the browser refuses — `{success: false}`, or a malformed field
+      # it rejects outright — is reported on stderr rather than raised, so one
+      # bad entry doesn't abort restoring the rest. Builds before 10212 stored
+      # malformed cookies, so files saved from them can hold such entries.
       def load(path = "cookies.yml") # rubocop:disable Naming/PredicateMethod
         cookies = YAML.load_file(path)
         rejected = cookies.reject { |c| restore_cookie(c) }.map { |c| c.transform_keys(&:to_s)["name"] }
@@ -153,9 +158,22 @@ module Capybara
         params[:same_site] = same_site if same_site
         exp = attrs["expires"]
         params[:expires] = Time.at(exp) if exp.is_a?(Numeric) && exp.positive?
+        set_or_refuse(**params)
+      end
+
+      def set_or_refuse(**params)
         set(**params)
+      rescue BrowserError => e
+        raise unless e.code == INVALID_PARAMS
+
+        false
       end
 
+      # Chrome's (and, since upstream #3791, Lightpanda's) answer to a cookie
+      # whose fields fail sanitizing.
+      INVALID_PARAMS = -32_602
+      private_constant :INVALID_PARAMS
+
       # Lightpanda below build 9877 reported every cookie without a SameSite
       # attribute as "None", so a file stored then is full of insecure
       # SameSite=None cookies — which the browser now rejects (Chrome's rule,

data/lib/capybara/lightpanda/driver.rb

@@ -69,7 +69,7 @@ module Capybara
 
       def active_element
         oid = browser.active_element
-        oid && Node.new(self, oid)
+        oid && build_node(oid)
       end
 
       # Capybara's Session#send_keys routes to Driver#send_keys; Cuprite's pattern
@@ -80,25 +80,28 @@ module Capybara
 
       def find_xpath(selector)
         object_ids = browser.find("xpath", selector)
-        object_ids.map { |oid| Node.new(self, oid) }
+        object_ids.map { |oid| build_node(oid) }
       end
 
       def find_css(selector)
         object_ids = browser.find("css", selector)
-        object_ids.map { |oid| Node.new(self, oid) }
+        object_ids.map { |oid| build_node(oid) }
       end
 
+      # Inside `within_frame` these run in the frame's document, as in Chrome.
       def evaluate_script(script, *args)
-        unwrap_script_result(browser.evaluate(script.strip, *native_args(args)))
+        unwrap_script_result(browser.evaluate(script.strip, *native_args(args),
+                                              frame: browser.frame_stack.last))
       end
 
       def execute_script(script, *args)
-        browser.execute(script.strip, *native_args(args))
+        browser.execute(script.strip, *native_args(args), frame: browser.frame_stack.last)
         nil
       end
 
       def evaluate_async_script(script, *args)
-        unwrap_script_result(browser.evaluate_async(script.strip, *native_args(args)))
+        unwrap_script_result(browser.evaluate_async(script.strip, *native_args(args),
+                                                    frame: browser.frame_stack.last))
       end
 
       # -- Network Inspection --
@@ -369,6 +372,12 @@ module Capybara
 
       private
 
+      # A node found while a frame is switched to lives in that frame's
+      # document, which Node#call checks for a frame navigation.
+      def build_node(oid)
+        Node.new(self, oid, frame_scoped: browser.frame_stack.any?)
+      end
+
       # Every window method takes a handle because Capybara's Window objects
       # carry one; with a single window the only valid value is the current
       # target id. Reject anything else rather than silently operating on the
@@ -414,7 +423,7 @@ module Capybara
         when Array then value.map { |v| unwrap_script_result(v) }
         when Hash
           if value.size == 1 && value.key?(Browser::NODE_MARKER)
-            Node.new(self, value[Browser::NODE_MARKER])
+            build_node(value[Browser::NODE_MARKER])
           else
             value.transform_values { |v| unwrap_script_result(v) }
           end

data/lib/capybara/lightpanda/javascripts/predicates.js

@@ -68,7 +68,9 @@ function isDisabled(el) {
   if ((el.tagName || '').toUpperCase() === 'OPTION') {
     var p = el.parentElement;
     while (p) {
-      if (p.disabled) return true;
+      // `=== true`: a <form>'s `disabled` is named field access, so
+      // `<input name="disabled">` makes `form.disabled` that input.
+      if (p.disabled === true) return true;
       p = p.parentElement;
     }
   }

data/lib/capybara/lightpanda/node.rb

@@ -8,9 +8,13 @@ module Capybara
 
       attr_reader :remote_object_id
 
-      def initialize(driver, remote_object_id)
-        super
+      # `frame_scoped`: the node lives in an iframe's document — it was found
+      # while a frame was switched to, or from another frame-scoped node. See
+      # #wrap_with_attached_guard for what that changes.
+      def initialize(driver, remote_object_id, frame_scoped: false)
+        super(driver, remote_object_id)
         @remote_object_id = remote_object_id
+        @frame_scoped = frame_scoped
       end
 
       # Capybara::Driver::Node#native returns the constructor's second argument,
@@ -265,12 +269,9 @@ module Capybara
       # absence then showed up as `current_url` being read against the
       # outgoing document (test/features/keyboard_activation_test.rb).
       #
-      # Caveat, shared with #click: `wait_for_idle` only sniffs for ~50 ms
-      # (Browser::SNIFF_WINDOW) and watches Runtime.executionContextsCleared,
-      # which Lightpanda emits when the *response* lands, not when the request
-      # starts. A navigation whose server round-trip exceeds that window is
-      # therefore still not awaited here — use Capybara's waiting matchers
-      # (`have_current_path`) for those, as you would after a click.
+      # `wait_for_idle` sniffs for ~50 ms (Browser::SNIFF_WINDOW) for the
+      # main frame to *start* navigating, then waits for the new document —
+      # so a slow server round-trip is awaited, as after a click.
       def send_keys(*)
         call(SEND_KEYS_FOCUS_JS)
         driver.browser.keyboard.type(*)
@@ -320,17 +321,17 @@ module Capybara
       # returned as Lightpanda::Node wrappers. Mirrors Cuprite's `Node#parents`.
       def parents
         oids = driver.browser.parents_of(@remote_object_id)
-        oids.map { |oid| self.class.new(driver, oid) }
+        oids.map { |oid| self.class.new(driver, oid, frame_scoped: @frame_scoped) }
       end
 
       def find_xpath(selector)
         object_ids = driver.browser.find_within(@remote_object_id, "xpath", selector)
-        object_ids.map { |oid| self.class.new(driver, oid) }
+        object_ids.map { |oid| self.class.new(driver, oid, frame_scoped: @frame_scoped) }
       end
 
       def find_css(selector)
         object_ids = driver.browser.find_within(@remote_object_id, "css", selector)
-        object_ids.map { |oid| self.class.new(driver, oid) }
+        object_ids.map { |oid| self.class.new(driver, oid, frame_scoped: @frame_scoped) }
       end
 
       # Equality compares the underlying DOM node via backendNodeId, the only
@@ -515,7 +516,9 @@ module Capybara
       # instead of returning stale data from V8's still-live reference. After
       # a DOM mutation like `replaceWith`, the cached objectId still resolves
       # to the detached node, so reads succeed quietly and Capybara's
-      # automatic_reload never re-runs the original query.
+      # automatic_reload never re-runs the original query. A frame-scoped node
+      # whose document has lost its window is obsolete too (see
+      # DISCARDED_DOCUMENT_CHECK).
       def call(function_declaration, *args, return_by_value: true)
         guarded = wrap_with_attached_guard(function_declaration)
         driver.browser.with_default_context_wait do
@@ -531,12 +534,21 @@ module Capybara
       end
 
       OBSOLETE_NODE_MARKER = "LIGHTPANDA_OBSOLETE_NODE"
-      private_constant :OBSOLETE_NODE_MARKER
+
+      # When an iframe navigates, Chrome destroys the old document's context,
+      # so calls on its nodes fail and Capybara re-finds them. Lightpanda keeps
+      # the context alive: the node stays `isConnected` and answers from the
+      # discarded document, whose `defaultView` is null. Only for frame-scoped
+      # nodes: a script-built document (DOMParser, createHTMLDocument) has no
+      # window either, and its nodes stay usable. `|| this` covers a Document
+      # node, whose ownerDocument is null.
+      DISCARDED_DOCUMENT_CHECK = " || (this.ownerDocument || this).defaultView === null"
+      private_constant :OBSOLETE_NODE_MARKER, :DISCARDED_DOCUMENT_CHECK
 
       def wrap_with_attached_guard(function_declaration)
         <<~JS
           function() {
-            if (!this.isConnected) throw new Error(#{OBSOLETE_NODE_MARKER.inspect});
+            if (!this.isConnected#{DISCARDED_DOCUMENT_CHECK if @frame_scoped}) throw new Error(#{OBSOLETE_NODE_MARKER.inspect});
             return (#{function_declaration}).apply(this, arguments);
           }
         JS
@@ -629,22 +641,36 @@ module Capybara
           var notCancelled = hit.dispatchEvent(clickEvt);
           if (!notCancelled || clickEvt.defaultPrevented) return;
           var tag = hit.tagName;
+          // A `javascript:` link never navigates: the click's own activation
+          // behavior has already run its code. Assigning it to location.href
+          // makes Lightpanda request `http://javascript:…`, and since upstream
+          // #3843 (build 10261) that failed navigation leaves the page with no
+          // execution context — `href="javascript:void(0)"` toggles (select2,
+          // Bootstrap) killed the page (lightpanda-io/browser#3898).
+          if (tag === 'A' && /^\\s*javascript:/i.test(hit.getAttribute('href') || '')) return;
           if (tag === 'A' && hit.href && hit.target !== '_blank') {
+            // Navigate the link's own window, never the bare `window`:
+            // Lightpanda runs callFunctionOn in the top document's context
+            // even for a node inside an iframe, so `window` would be the top
+            // window and a link clicked in a frame replaced the whole page.
+            var own = hit.ownerDocument.defaultView || window;
+            var target = (hit.target || '').toLowerCase();
+            var win = (target === '_top' && own.top) || (target === '_parent' && own.parent) || own;
             // Same-document fragment-only navigation: just update hash (or do
             // nothing if identical). Mirrors Chrome — assigning location.href
             // to a same-document URL on Lightpanda triggers a real navigation
             // tick that cancels pending setTimeout callbacks and clears form
             // values, which breaks any test driving DOM updates from a click
             // handler on `<a href="#...">`.
-            var dest = new URL(hit.href, document.baseURI);
-            var here = new URL(window.location.href);
+            var dest = new URL(hit.href, hit.ownerDocument.baseURI);
+            var here = new URL(win.location.href);
             if (dest.origin === here.origin && dest.pathname === here.pathname &&
                 dest.search === here.search) {
               if (dest.hash !== here.hash) {
-                window.location.hash = dest.hash;
+                win.location.hash = dest.hash;
               }
             } else {
-              window.location.href = hit.href;
+              win.location.href = hit.href;
             }
           }
         }

data/lib/capybara/lightpanda/version.rb

@@ -2,6 +2,6 @@
 
 module Capybara
   module Lightpanda
-    VERSION = "0.13.0"
+    VERSION = "0.14.1"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: capybara-lightpanda
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.14.1
 platform: ruby
 authors:
 - Navid Emad