capybara-lightpanda 0.12.0 → 0.14.0

data/lib/capybara/lightpanda/cookies.rb

@@ -79,7 +79,15 @@ module Capybara
       # Ferrum/Cuprite spelling: `browser.cookies["session_id"]`.
       alias [] get
 
-      def set(name:, value:, domain: nil, path: "/", secure: false, http_only: false, # rubocop:disable Metrics/ParameterLists
+      # Returns whether the browser accepted the cookie (ferrum parity).
+      # 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. 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 = {
           name: name,
@@ -96,7 +104,8 @@ module Capybara
         params[:sameSite] = same_site if %w[Strict Lax None].include?(same_site)
         params[:expires] = expires.to_i if expires
 
-        browser.command("Network.setCookie", **params)
+        result = browser.command("Network.setCookie", **params)
+        !(result.is_a?(Hash) && result["success"] == false)
       end
 
       def remove(name:, domain: nil, path: "/")
@@ -119,10 +128,15 @@ module Capybara
       # Load cookies from a YAML file produced by `store` and re-set them.
       # 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).
+      # success (intentionally not a predicate — mirrors ferrum's API). A
+      # 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)
-        cookies.each { |c| restore_cookie(c) }
+        rejected = cookies.reject { |c| restore_cookie(c) }.map { |c| c.transform_keys(&:to_s)["name"] }
+        warn "Capybara::Lightpanda: the browser refused cookies from #{path}: #{rejected.join(', ')}" if rejected.any?
         true
       end
 
@@ -140,10 +154,36 @@ module Capybara
           http_only: attrs["httpOnly"] || false,
         }
         params[:domain] = attrs["domain"] if attrs["domain"]
-        params[:same_site] = attrs["sameSite"] if attrs["sameSite"]
+        same_site = restored_same_site(attrs)
+        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,
+      # upstream #3529). Leaving SameSite unset restores what the cookie
+      # actually was: unspecified, i.e. Lax-by-default.
+      def restored_same_site(attrs)
+        same_site = attrs["sameSite"]
+        return nil if same_site == "None" && !attrs["secure"]
+
+        same_site
       end
     end
   end

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/attach.js

@@ -12,5 +12,6 @@ window._lightpanda = {
   isObscured: isObscured,
   isDisabled: isDisabled,
   isContentEditable: isContentEditable,
+  pointerFocusTarget: pointerFocusTarget,
   visibleText: visibleText
 };

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

@@ -17,7 +17,7 @@
 // separately because checkVisibility's defaults (per spec) ignore it.
 //
 // External `<link rel=stylesheet>` ARE fetched and applied — the gem
-// always passes --enable-external-stylesheets (Lightpanda PR #2487,
+// always passes `--load-resources stylesheet` (Lightpanda PR #2487,
 // guaranteed by the build floor) — so stylesheet-driven `display:none`
 // participates in this check. The remaining gap is viewport emulation:
 // `@media` rules and `matchMedia()` evaluate against the hardcoded
@@ -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;
     }
   }
@@ -92,6 +94,43 @@ function isContentEditable(el) {
   return false;
 }
 
+// The element a real pointer press on `el` would focus: the nearest focusable
+// inclusive ancestor, or null when the press lands on nothing focusable (Chrome
+// then moves focus to the body). Lightpanda's handleClick stopped focusing
+// controls in upstream #3702 (build 9968), and an untrusted `mousedown` — the
+// only kind CLICK_JS can dispatch — never runs the focus default, so the
+// driver has to apply it itself or `click` then `page.send_keys` types nowhere.
+function pointerFocusTarget(el) {
+  function isEditingHost(n) {
+    if (!n.hasAttribute || !n.hasAttribute('contenteditable')) return false;
+    return (n.getAttribute('contenteditable') || '').toLowerCase() !== 'false';
+  }
+  function isFocusable(n) {
+    if (isDisabled(n)) return false;
+    switch ((n.tagName || '').toUpperCase()) {
+      case 'INPUT': return (n.getAttribute('type') || '').toLowerCase() !== 'hidden';
+      case 'SELECT': case 'TEXTAREA': case 'BUTTON': case 'IFRAME': case 'SUMMARY': return true;
+      case 'A': case 'AREA': return n.hasAttribute('href');
+    }
+    return n.hasAttribute('tabindex');
+  }
+
+  for (var n = el; n && n.nodeType === 1; n = n.parentElement) {
+    // A press on a <label> lands on its control (the label's activation
+    // behavior); the label itself is never focusable.
+    if ((n.tagName || '').toUpperCase() === 'LABEL' && n.control) {
+      return isFocusable(n.control) ? n.control : null;
+    }
+    if (isEditingHost(n)) {
+      // Focus goes to the outermost element of a contiguous editable region.
+      while (n.parentElement && isEditingHost(n.parentElement)) n = n.parentElement;
+      return n;
+    }
+    if (isFocusable(n)) return n;
+  }
+  return null;
+}
+
 // Capybara's "visible text" = WebDriver getText semantics, which native
 // innerText alone doesn't provide at two edges: a non-rendered element must
 // yield "" (innerText returns textContent per the HTML getter's step 1), and a

data/lib/capybara/lightpanda/keyboard.rb

@@ -171,19 +171,37 @@ module Capybara
         release_modifiers(active_mods)
       end
 
+      # A chord with Ctrl or Meta is a command, not text: Chrome inserts
+      # nothing for Ctrl+A, it selects. Since upstream #3542 (build 9580)
+      # Lightpanda inserts whatever the keyDown's `text` carries, so sending
+      # `text` with Ctrl held typed a stray "a" into the field. The keyDown
+      # still names the key, so shortcut handlers (`e.ctrlKey && e.key ===
+      # "a"`) fire exactly as before.
+      COMMAND_MODIFIERS = %i[ctrl control meta command].freeze
+      private_constant :COMMAND_MODIFIERS
+
       def dispatch_modified_char(char, modifier_value, modifiers)
-        text = modifiers.include?(:shift) ? self.class.shifted(char) : char
-        send_key_event("keyDown", { key: text, text: text, unmodifiedText: char }, modifiers: modifier_value)
-        send_key_event("keyUp", { key: text }, modifiers: modifier_value)
+        key = modifiers.include?(:shift) ? self.class.shifted(char) : char
+        definition = { key: key, unmodifiedText: char }
+        definition[:text] = key unless modifiers.intersect?(COMMAND_MODIFIERS)
+        send_key_event("keyDown", definition, modifiers: modifier_value)
+        send_key_event("keyUp", { key: key }, modifiers: modifier_value)
       end
 
       def key_definition(key)
         KEYS.fetch(key) { raise ArgumentError, "Unknown key: #{key.inspect}" }
       end
 
+      # Always `keyDown`, never `rawKeyDown`. Chrome's convention (Ferrum,
+      # Puppeteer) is rawKeyDown for keys that carry no `text`, but Lightpanda's
+      # Input.dispatchKeyEvent drops rawKeyDown on the floor as a
+      # Chrome-internal type (input.zig: `if (params.type == .rawKeyDown)
+      # return;`). Under that convention every text-less key — Backspace,
+      # Delete, Tab, Escape, the arrows — silently never reached the page,
+      # while Enter and Space (which have `text`) did. Lightpanda synthesizes
+      # its own keypress from a keyDown, so there is nothing to double-fire.
       def raw_dispatch(definition, modifiers: 0)
-        type = definition[:text] ? "keyDown" : "rawKeyDown"
-        send_key_event(type, definition, modifiers: modifiers)
+        send_key_event("keyDown", definition, modifiers: modifiers)
         send_key_event("keyUp", definition, modifiers: modifiers)
       end
 

data/lib/capybara/lightpanda/network.rb

@@ -20,7 +20,7 @@ module Capybara
         @traffic = []
         @traffic_mutex = Mutex.new
         @enabled = false
-        @request_handler = @response_handler = nil
+        @request_handler = @response_handler = @failure_handler = nil
         @last_navigation_response = nil
         @document_request_id = nil
       end
@@ -111,10 +111,10 @@ module Capybara
         browser.page_command("Network.setExtraHTTPHeaders", headers: {})
       end
 
-      # Count of in-flight requests (those with no response yet recorded).
+      # Count of in-flight requests (no response and no failure recorded yet).
       # Cheap predicate-friendly accessor (ferrum parity).
       def pending_connections
-        @traffic_mutex.synchronize { @traffic.count { |t| t[:response].nil? } }
+        @traffic_mutex.synchronize { @traffic.count { |t| open?(t) } }
       end
 
       # True when no more than `connections` requests are in-flight.
@@ -158,8 +158,10 @@ module Capybara
       def subscribe
         @request_handler = build_request_handler
         @response_handler = build_response_handler
+        @failure_handler = build_failure_handler
         browser.on("Network.requestWillBeSent", &@request_handler)
         browser.on("Network.responseReceived", &@response_handler)
+        browser.on("Network.loadingFailed", &@failure_handler)
       end
 
       # Redirects follow Chrome's shape (Lightpanda since #3175, build ≥8602):
@@ -184,6 +186,7 @@ module Capybara
             method: params.dig("request", "method"),
             timestamp: params["timestamp"],
             response: nil,
+            error: nil,
           }
           @traffic_mutex.synchronize do
             if (redirect = params["redirectResponse"]) && (previous = last_open_entry(params["requestId"]))
@@ -214,9 +217,31 @@ module Capybara
         end
       end
 
+      # A request that never gets a response — refused connection, CORS
+      # block, abort — ends with Network.loadingFailed instead. Without this
+      # handler its entry stayed open forever, so pending_connections never
+      # reached zero and every wait_for_idle burned its full timeout. Routine
+      # since Lightpanda enforces CORS by default (upstream #3654, build 9883:
+      # a blocked fetch reports errorText "CorsBlocked"). Ferrum closes its
+      # exchange on the same event.
+      def build_failure_handler
+        lambda do |params|
+          @traffic_mutex.synchronize do
+            request = last_open_entry(params["requestId"])
+            next unless request
+
+            request[:error] = params["errorText"].to_s
+          end
+        end
+      end
+
       # Caller holds @traffic_mutex.
       def last_open_entry(request_id)
-        @traffic.reverse_each.find { |t| t[:request_id] == request_id && t[:response].nil? }
+        @traffic.reverse_each.find { |t| t[:request_id] == request_id && open?(t) }
+      end
+
+      def open?(entry)
+        entry[:response].nil? && entry[:error].nil?
       end
 
       def response_summary(response)
@@ -231,8 +256,10 @@ module Capybara
       def unsubscribe
         browser.off("Network.requestWillBeSent", @request_handler) if @request_handler
         browser.off("Network.responseReceived", @response_handler) if @response_handler
+        browser.off("Network.loadingFailed", @failure_handler) if @failure_handler
         @request_handler = nil
         @response_handler = nil
+        @failure_handler = nil
       end
     end
   end

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,14 +269,11 @@ 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("function() { this.focus() }")
+        call(SEND_KEYS_FOCUS_JS)
         driver.browser.keyboard.type(*)
         driver.browser.wait_for_idle
       end
@@ -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
@@ -609,28 +621,56 @@ module Capybara
           // Cancelling mousedown suppresses focus/text-selection in a real
           // browser but never the click, so the click below is dispatched
           // unconditionally.
-          hit.dispatchEvent(new EventCtor('mousedown', { bubbles: true, cancelable: true }));
+          var pressed = hit.dispatchEvent(new EventCtor('mousedown', { bubbles: true, cancelable: true }));
+          // mousedown's default action moves focus. Ours is untrusted, so the
+          // browser won't do it (and since upstream #3702 its click handling
+          // doesn't either): focus what the press landed on, or blur the
+          // current field when it landed on nothing focusable — Chrome's
+          // behavior, and what `click` then `page.send_keys` relies on.
+          if (pressed && window._lightpanda) {
+            var doc = hit.ownerDocument;
+            var focusTarget = _lightpanda.pointerFocusTarget(hit);
+            if (focusTarget) {
+              if (doc.activeElement !== focusTarget) focusTarget.focus();
+            } else if (doc.activeElement && doc.activeElement !== doc.body && doc.activeElement.blur) {
+              doc.activeElement.blur();
+            }
+          }
           hit.dispatchEvent(new EventCtor('mouseup', { bubbles: true, cancelable: true }));
           var clickEvt = new EventCtor('click', { bubbles: true, cancelable: true });
           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;
             }
           }
         }
@@ -918,8 +958,46 @@ module Capybara
         }
       JS
 
+      # Focuses the element keys are about to be typed into, WebDriver's
+      # "Element Send Keys" way (what chromedriver's focus script does): an
+      # element that did NOT already have focus gets its caret after its
+      # content. Since upstream #3424 (build 9234) `Input.insertText` inserts
+      # at the caret, and a value seeded by the `value=` attribute leaves the
+      # caret at 0 — without this, `send_keys("x")` on a pre-filled field
+      # typed "xfoo" where Chrome types "foox". An element that already has
+      # focus keeps its caret, so `page.send_keys` mid-edit continues in place.
+      # A non-focusable target (focus() is a no-op on those since upstream
+      # #3592, build 9646) must not leave the previous field focused, or its
+      # keys land there: blur it so they go to the body, as in Chrome.
+      SEND_KEYS_FOCUS_JS = <<~JS
+        function() {
+          var doc = this.ownerDocument;
+          if (doc.activeElement === this) return;
+          this.focus();
+          if (doc.activeElement !== this) {
+            if (doc.activeElement && doc.activeElement !== doc.body && doc.activeElement.blur) doc.activeElement.blur();
+            return;
+          }
+          if (typeof this.setSelectionRange === 'function') {
+            // Throws on types without a selection (email, number, …) — those
+            // have no caret to place.
+            try {
+              var end = String(this.value || '').length;
+              this.setSelectionRange(end, end);
+            } catch (e) {}
+          }
+        }
+      JS
+
+      # A disabled option (or one in a disabled <optgroup>/<select>) is not
+      # selectable by a user, and Capybara's shared spec expects selecting one
+      # to be a no-op (rack_test: `return if disabled?`). Both IDL routes —
+      # `sel.value =` and `option.selected = true` — select it per spec;
+      # Lightpanda's `value` getter used to skip disabled options and hide that,
+      # until upstream #3502 (build 9424).
       SELECT_OPTION_JS = <<~JS
         function() {
+          if (_lightpanda.isDisabled(this)) return;
           var sel = this.parentElement;
           while (sel && (sel.tagName || '').toUpperCase() !== 'SELECT') sel = sel.parentElement;
           if (!sel) {
@@ -929,14 +1007,10 @@ module Capybara
             // that path itself; just no-op here.
             return;
           }
-          if (sel.multiple) {
-            this.selected = true;
-          } else {
-            // Lightpanda doesn't auto-deselect siblings when we set
-            // `option.selected`, so mirror what a real browser does and
-            // route the change through the parent's `value`.
-            sel.value = this.value;
-          }
+          // Selects exactly this option — not the first one sharing its
+          // value — and, in a single <select>, deselects the rest (upstream
+          // #3375, guaranteed by the floor).
+          this.selected = true;
           sel.dispatchEvent(new Event('input', {bubbles: true}));
           sel.dispatchEvent(new Event('change', {bubbles: true}));
         }

data/lib/capybara/lightpanda/options.rb

@@ -47,13 +47,12 @@ module Capybara
       # a runaway confirm cancels the action and the spec can still pass. false
       # (default, Cuprite parity) warns on stderr; true raises
       # UnhandledModalError from the action that opened it.
-      # load_images: passes `--load-resources image` so `<img>` elements are
-      # fetched over the network (upstream #3230, build >= 8834). Off by
-      # default, matching Lightpanda's default of skipping image fetches
-      # entirely. When on, image requests ride the Network domain like any
-      # other — they show in `network.traffic` and count toward
-      # `wait_for_network_idle`. On builds < 8834 the flag is a fatal
-      # UnknownOption at boot, so only enable against binaries that have it.
+      # load_images: adds `image` to the `--load-resources` value so `<img>`
+      # elements are fetched over the network (upstream #3230, build >= 8834,
+      # in the floor). Off by default, matching Lightpanda's default of
+      # skipping image fetches entirely. When on, image requests ride the
+      # Network domain like any other — they show in `network.traffic` and
+      # count toward `wait_for_network_idle`.
       attr_accessor :host, :port, :timeout, :handshake_timeout, :process_timeout,
                     :window_size, :browser_path, :headless, :logger, :save_path,
                     :raise_on_unhandled_modal, :load_images