capybara-lightpanda 0.7.0 → 0.9.0

data/lib/capybara/lightpanda/network.rb

@@ -3,25 +3,54 @@
 module Capybara
   module Lightpanda
     class Network
+      # Tracking is always on (create_page enables it), so the buffer needs
+      # the same unbounded-growth cap as Browser's console ring buffer —
+      # one very long session would otherwise grow @traffic indefinitely.
+      TRAFFIC_LIMIT = 1_000
+
       attr_reader :browser
 
+      # Status/headers of the last top-level document navigation; nil before
+      # the first navigation completes. Backs Browser#status_code /
+      # #response_headers. Captured by #subscribe's handlers.
+      attr_reader :last_navigation_response
+
       def initialize(browser)
         @browser = browser
         @traffic = []
         @traffic_mutex = Mutex.new
         @enabled = false
-        @request_handler = nil
-        @response_handler = nil
+        @request_handler = @response_handler = nil
+        @last_navigation_response = nil
+        @document_request_id = nil
       end
 
+      # The domain toggle is connection-scoped (browser.command), while
+      # setExtraHTTPHeaders is session-scoped (browser.page_command) — see
+      # #headers=. Browser#create_page calls this, so tracking (traffic AND
+      # the navigation-response capture) is on for every page.
       def enable
         return if @enabled
 
-        browser.command("Network.enable")
+        # Subscribe BEFORE flipping the wire toggle (mirror image of
+        # #disable's ordering): events can't be emitted while the domain is
+        # off, so this order can never miss one. If the command fails
+        # (Lightpanda can block commands mid-navigation), roll the handlers
+        # back — orphaned duplicates would double-count every request and
+        # wedge pending_connections above zero for the session.
         subscribe
+        begin
+          browser.command("Network.enable")
+        rescue StandardError
+          unsubscribe
+          raise
+        end
         @enabled = true
       end
 
+      # Caveat: disabling the domain also stops the navigation-response
+      # capture, so Browser#status_code / #response_headers freeze at their
+      # last values until the next #enable.
       def disable
         return unless @enabled
 
@@ -51,10 +80,16 @@ module Capybara
       # cleared the Subscriber first.
       def reset
         unsubscribe
-        @traffic_mutex.synchronize { @traffic.clear }
+        clear
         @enabled = false
+        @extra_headers = nil # the fresh context never received setExtraHTTPHeaders
+        @last_navigation_response = nil
+        @document_request_id = nil
       end
 
+      # Headers applied via headers= / add_headers. Backs Driver#headers.
+      def extra_headers = @extra_headers || {}
+
       # Setting extra headers also lazily enables the Network domain. Without
       # this, headers were silently ignored until the caller separately ran
       # `network.enable` (or `wait_for_network_idle`). Cuprite/Ferrum parity.
@@ -108,11 +143,30 @@ module Capybara
 
       private
 
+      # CDP events arrive on the message thread while wait_for_idle /
+      # pending_connections read from the main thread; serialize all
+      # @traffic mutations and reads through @traffic_mutex.
+      #
+      # The handlers also capture the last top-level navigation response
+      # (mirrors capybara-playwright-driver's navigation_request? hook). CDP
+      # normally marks the main-document response via
+      # `Network.responseReceived.type`, but Lightpanda omits that field on
+      # responses (only emits `type` on requestWillBeSent) — so match the
+      # long way: remember the document requestId, store the response whose
+      # requestId equals it.
       def subscribe
-        # CDP events arrive on the message thread while wait_for_idle /
-        # pending_connections read from the main thread; serialize all
-        # @traffic mutations and reads through @traffic_mutex.
-        @request_handler = lambda do |params|
+        @request_handler = build_request_handler
+        @response_handler = build_response_handler
+        browser.on("Network.requestWillBeSent", &@request_handler)
+        browser.on("Network.responseReceived", &@response_handler)
+      end
+
+      def build_request_handler
+        lambda do |params|
+          if params["type"] == "Document"
+            @document_request_id = params["requestId"]
+            @last_navigation_response = nil
+          end
           entry = {
             request_id: params["requestId"],
             url: params.dig("request", "url"),
@@ -120,10 +174,21 @@ module Capybara
             timestamp: params["timestamp"],
             response: nil,
           }
-          @traffic_mutex.synchronize { @traffic << entry }
+          @traffic_mutex.synchronize do
+            @traffic << entry
+            @traffic.shift(@traffic.size - TRAFFIC_LIMIT) if @traffic.size > TRAFFIC_LIMIT
+          end
         end
+      end
 
-        @response_handler = lambda do |params|
+      def build_response_handler
+        lambda do |params|
+          if params["requestId"] == @document_request_id
+            @last_navigation_response = {
+              status: params.dig("response", "status"),
+              headers: params.dig("response", "headers") || {},
+            }
+          end
           @traffic_mutex.synchronize do
             request = @traffic.find { |t| t[:request_id] == params["requestId"] }
             next unless request
@@ -135,9 +200,6 @@ module Capybara
             }
           end
         end
-
-        browser.on("Network.requestWillBeSent", &@request_handler)
-        browser.on("Network.responseReceived", &@response_handler)
       end
 
       def unsubscribe

data/lib/capybara/lightpanda/node.rb

@@ -69,14 +69,12 @@ module Capybara
         previous
       end
 
+      # Routed through #call (not a bare call_function_on) so a detached
+      # host raises ObsoleteNode like every other node operation — Capybara's
+      # automatic_reload then re-finds the host instead of silently reading
+      # a stale shadowRoot.
       def shadow_root
-        result = driver.browser.with_default_context_wait do
-          driver.browser.call_function_on(
-            @remote_object_id,
-            "function() { return this.shadowRoot }",
-            return_by_value: false
-          )
-        end
+        result = call(SHADOW_ROOT_JS, return_by_value: false)
         return nil unless result.is_a?(Hash) && result["objectId"]
 
         self.class.new(driver, result["objectId"])
@@ -171,15 +169,9 @@ module Capybara
       end
 
       def unselect_option
-        unless call("function() {
-          var s = this.parentElement;
-          while (s && (s.tagName || '').toUpperCase() !== 'SELECT') s = s.parentElement;
-          return !!(s && s.multiple);
-        }")
-          raise Capybara::UnselectNotAllowed, "Cannot unselect option from single select box."
-        end
+        return unless call(UNSELECT_OPTION_JS) == "not_multiple"
 
-        call(UNSELECT_OPTION_JS)
+        raise Capybara::UnselectNotAllowed, "Cannot unselect option from single select box."
       end
 
       def send_keys(*)
@@ -437,22 +429,18 @@ module Capybara
       # 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.
-      def call(function_declaration, *args)
+      def call(function_declaration, *args, return_by_value: true)
         guarded = wrap_with_attached_guard(function_declaration)
         driver.browser.with_default_context_wait do
-          driver.browser.call_function_on(@remote_object_id, guarded, *args)
+          driver.browser.call_function_on(@remote_object_id, guarded, *args,
+                                          return_by_value: return_by_value)
         end
       rescue JavaScriptError => e
         if e.message.include?(OBSOLETE_NODE_MARKER)
           raise ObsoleteNode.new(self, "Node is no longer attached to the document")
         end
 
-        case e.class_name
-        when "InvalidSelector"
-          raise InvalidSelector.new(e.message, nil, args.first)
-        else
-          raise
-        end
+        raise
       end
 
       OBSOLETE_NODE_MARKER = "LIGHTPANDA_OBSOLETE_NODE"
@@ -485,6 +473,13 @@ module Capybara
       CLICK_JS = <<~JS
         function() {
           var EventCtor = (typeof MouseEvent !== 'undefined') ? MouseEvent : Event;
+          // Real pointer clicks are a mousedown -> mouseup -> click sequence,
+          // and widgets like select2 open on `mousedown`, not `click`.
+          // Cancelling mousedown suppresses focus/text-selection in a real
+          // browser but never the click, so the click below is dispatched
+          // unconditionally.
+          this.dispatchEvent(new EventCtor('mousedown', { bubbles: true, cancelable: true }));
+          this.dispatchEvent(new EventCtor('mouseup', { bubbles: true, cancelable: true }));
           var clickEvt = new EventCtor('click', { bubbles: true, cancelable: true });
           var notCancelled = this.dispatchEvent(clickEvt);
           if (!notCancelled || clickEvt.defaultPrevented) return;
@@ -658,11 +653,14 @@ module Capybara
         }
       JS
 
+      # Returns 'not_multiple' (without mutating) when the owning <select>
+      # isn't multiple — Ruby raises Capybara::UnselectNotAllowed. One CDP
+      # round-trip instead of a separate ancestor-walk precheck.
       UNSELECT_OPTION_JS = <<~JS
         function() {
           var sel = this.parentElement;
           while (sel && (sel.tagName || '').toUpperCase() !== 'SELECT') sel = sel.parentElement;
-          if (!sel || !sel.multiple) return;
+          if (!sel || !sel.multiple) return 'not_multiple';
           this.selected = false;
           sel.dispatchEvent(new Event('input', {bubbles: true}));
           sel.dispatchEvent(new Event('change', {bubbles: true}));
@@ -675,13 +673,7 @@ module Capybara
         }
       JS
 
-      APPEND_KEYS_JS = <<~JS
-        function(key) {
-          this.focus();
-          this.value += key;
-          this.dispatchEvent(new Event('input', {bubbles: true}));
-        }
-      JS
+      SHADOW_ROOT_JS = "function() { return this.shadowRoot }"
 
       EDITABLE_HOST_JS = "function() { return _lightpanda.isContentEditable(this); }"
 
@@ -731,6 +723,14 @@ module Capybara
           return path.join(' > ');
         }
       JS
+
+      # Internal wire format, not API — aligned with browser.rb's convention
+      # of private_constant for its JS snippets.
+      private_constant :CLICK_JS, :TRIGGER_JS, :DROP_JS, :SHADOW_ROOT_JS, :VISIBLE_JS, :VISIBLE_TEXT_JS,
+                       :PROPERTY_OR_ATTRIBUTE_JS, :GET_VALUE_JS, :SET_VALUE_JS,
+                       :IMPLICIT_SUBMIT_JS, :SELECT_OPTION_JS, :UNSELECT_OPTION_JS,
+                       :SET_CHECKBOX_JS, :EDITABLE_HOST_JS, :DISABLED_JS, :GET_STYLE_JS,
+                       :GET_RECT_JS, :OBSCURED_JS, :GET_PATH_JS
     end
   end
 end

data/lib/capybara/lightpanda/options.rb

@@ -22,6 +22,10 @@ module Capybara
       DEFAULT_PORT = 0
       DEFAULT_WINDOW_SIZE = [1024, 768].freeze
 
+      # window_size and headless are accepted for Cuprite drop-in
+      # compatibility (standard options at driver registration) but are
+      # inert: Lightpanda has no rendering engine, so there is nothing to
+      # resize, and headless is the only mode it runs in.
       attr_accessor :host, :port, :timeout, :handshake_timeout, :process_timeout,
                     :window_size, :browser_path, :headless, :logger
       attr_writer :ws_url

data/lib/capybara/lightpanda/process.rb

@@ -90,10 +90,16 @@ module Capybara
       # DragEvent, merged 2026-06-10) provides the APIs Node#drop's DROP_JS
       # assembles its payload from; on builds without it the drop JS raises
       # "DataTransfer is not defined".
-      # Build 6699 = the #2671 merge (d1f4c409, 2026-06-10) — now the binding
-      # floor. (The prior 6672 file-upload floor — and 6353 before it — are
-      # subsumed.)
-      MINIMUM_NIGHTLY_BUILD = Gem::Version.new("6699")
+      # Build 6699 = the #2671 merge (d1f4c409, 2026-06-10) — the Node#drop
+      # DataTransfer floor. (The prior 6672 file-upload floor — and 6353
+      # before it — are subsumed.)
+      # PR #2708 (document fires readystatechange on readiness changes,
+      # merged 2026-06-12) made the index.js readystatechange re-dispatch
+      # shim redundant, so it was removed — on builds without #2708 Turbo's
+      # PageObserver never reaches pageLoaded() and turbo:load never fires.
+      # Build 6736 = first published nightly carrying the #2708 merge — now
+      # the binding floor.
+      MINIMUM_NIGHTLY_BUILD = Gem::Version.new("6736")
 
       attr_reader :pid, :ws_url, :version, :nightly_build
 
@@ -117,9 +123,7 @@ module Capybara
 
         check_minimum_version(binary_path)
         attempt_start(binary_path)
-      rescue ProcessTimeoutError => e
-        raise unless e.message.include?("already in use")
-
+      rescue PortInUseError
         kill_process_on_port(@options.port)
         attempt_start(binary_path)
       end
@@ -251,8 +255,8 @@ module Capybara
               end
 
               if output.match?(ADDRESS_IN_USE_PATTERN)
-                cleanup_failed_process
-                raise ProcessTimeoutError,
+                stop
+                raise PortInUseError,
                       "Lightpanda failed to start: port #{@options.port} is already in use"
               end
             rescue IO::WaitReadable
@@ -269,19 +273,6 @@ module Capybara
         end
       end
 
-      def cleanup_failed_process
-        return unless @pid
-
-        begin
-          ::Process.wait(@pid, ::Process::WNOHANG)
-        rescue Errno::ECHILD
-          nil
-        end
-
-        cleanup_pipes
-        @pid = nil
-      end
-
       # Auto-recover when a previous Lightpanda is still bound to our port.
       # Best-effort: relies on `lsof` to map port → pid (macOS / most Linux
       # distros). Where `lsof` isn't on PATH, we surface a clear error rather

data/lib/capybara/lightpanda/railtie.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Lightpanda
+    # Exposes the gem's rake tasks (lightpanda:binary:*) inside Rails apps.
+    # Without this, the BinaryError remediation hint ("bundle exec rake
+    # lightpanda:binary:remove lightpanda:binary:update") pointed at tasks
+    # that didn't exist in the app's rake namespace.
+    class Railtie < Rails::Railtie
+      rake_tasks do
+        load File.expand_path("tasks/binary.rake", __dir__)
+      end
+    end
+  end
+end

data/lib/capybara/lightpanda/version.rb

@@ -2,6 +2,6 @@
 
 module Capybara
   module Lightpanda
-    VERSION = "0.7.0"
+    VERSION = "0.9.0"
   end
 end

data/lib/capybara-lightpanda.rb

@@ -21,6 +21,7 @@ require_relative "capybara/lightpanda/auto_scripts"
 require_relative "capybara/lightpanda/node"
 require_relative "capybara/lightpanda/element_extension"
 require_relative "capybara/lightpanda/driver"
+require_relative "capybara/lightpanda/railtie" if defined?(Rails::Railtie)
 
 module Capybara
   module Lightpanda

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: capybara-lightpanda
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Navid Emad
@@ -74,6 +74,11 @@ files:
 - lib/capybara/lightpanda/auto_scripts.rb
 - lib/capybara/lightpanda/binary.rb
 - lib/capybara/lightpanda/browser.rb
+- lib/capybara/lightpanda/browser/console.rb
+- lib/capybara/lightpanda/browser/finder.rb
+- lib/capybara/lightpanda/browser/modals.rb
+- lib/capybara/lightpanda/browser/navigation.rb
+- lib/capybara/lightpanda/browser/runtime.rb
 - lib/capybara/lightpanda/client.rb
 - lib/capybara/lightpanda/client/subscriber.rb
 - lib/capybara/lightpanda/client/web_socket.rb
@@ -82,13 +87,17 @@ files:
 - lib/capybara/lightpanda/element_extension.rb
 - lib/capybara/lightpanda/errors.rb
 - lib/capybara/lightpanda/headers.rb
-- lib/capybara/lightpanda/javascripts/index.js
+- lib/capybara/lightpanda/javascripts/attach.js
+- lib/capybara/lightpanda/javascripts/banner.js
+- lib/capybara/lightpanda/javascripts/predicates.js
+- lib/capybara/lightpanda/javascripts/turbo.js
 - lib/capybara/lightpanda/keyboard.rb
 - lib/capybara/lightpanda/logger.rb
 - lib/capybara/lightpanda/network.rb
 - lib/capybara/lightpanda/node.rb
 - lib/capybara/lightpanda/options.rb
 - lib/capybara/lightpanda/process.rb
+- lib/capybara/lightpanda/railtie.rb
 - lib/capybara/lightpanda/tasks/binary.rake
 - lib/capybara/lightpanda/utils/attempt.rb
 - lib/capybara/lightpanda/utils/event.rb

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

@@ -1,239 +0,0 @@
-(function() {
-  if (window._lightpanda) return;
-
-  // --- readystatechange re-dispatch (upstream gap, wishlist A36) ---
-  // Lightpanda transitions document.readyState correctly but never fires the
-  // readystatechange event. Turbo's PageObserver listens ONLY for that event
-  // to reach pageLoaded() — without it, turbo:load never fires. Re-dispatch
-  // from the two lifecycle events Lightpanda does fire: DOMContentLoaded
-  // (readyState=interactive) and window load (readyState=complete).
-  // Drop this block once the upstream fix is covered by MINIMUM_NIGHTLY_BUILD.
-  function _fireReadyStateChange() {
-    document.dispatchEvent(new Event('readystatechange'));
-  }
-  document.addEventListener('DOMContentLoaded', _fireReadyStateChange);
-  window.addEventListener('load', _fireReadyStateChange);
-
-  // --- Turbo activity tracking ---
-  // Tracks pending Turbo operations so the driver can wait for Turbo to settle.
-  // Inspired by the CapybaraLockstep approach for stabilizing Turbo integration tests.
-  // Events are not perfectly symmetrical in Turbo, so we track multiple pairs
-  // and use a counter to handle overlapping operations.
-  //
-  // Transitions across 0 emit `__lightpanda_turbo_busy` / `__lightpanda_turbo_idle`
-  // sentinels via console.debug. Browser#wait_for_turbo subscribes to those
-  // sentinels (Runtime.consoleAPICalled) and toggles a Concurrent::Event so the
-  // Ruby side can wait event-driven instead of polling.
-  //
-  // Pages without Turbo never trigger _turboStart, so no sentinels fire and the
-  // Ruby Event stays set (idle by default) — wait_for_turbo returns immediately.
-  var _pendingTurboOps = 0;
-  function _signalTurbo(state) {
-    try { console.debug('__lightpanda_turbo_' + state); } catch (e) {}
-  }
-  function _turboStart() {
-    _pendingTurboOps++;
-    if (_pendingTurboOps === 1) _signalTurbo('busy');
-  }
-  function _turboEnd() {
-    if (_pendingTurboOps > 0) {
-      _pendingTurboOps--;
-      if (_pendingTurboOps === 0) _signalTurbo('idle');
-    }
-  }
-
-  // Fetch requests (covers Drive, Frames, and Form submission fetches)
-  document.addEventListener('turbo:before-fetch-request', _turboStart);
-  document.addEventListener('turbo:before-fetch-response', _turboEnd);
-  document.addEventListener('turbo:fetch-request-error', _turboEnd);
-
-  // Form submissions (can outlast their underlying fetch)
-  document.addEventListener('turbo:submit-start', _turboStart);
-  document.addEventListener('turbo:submit-end', _turboEnd);
-
-  // Frame rendering (can outlast the fetch that triggered it)
-  document.addEventListener('turbo:before-frame-render', _turboStart);
-  document.addEventListener('turbo:frame-render', _turboEnd);
-
-  // Stream rendering (no symmetric end event — wrap the render function)
-  document.addEventListener('turbo:before-stream-render', function(event) {
-    _turboStart();
-    if (event.detail && event.detail.render) {
-      var originalRender = event.detail.render;
-      event.detail.render = function(streamElement) {
-        var result = originalRender(streamElement);
-        if (result && typeof result.then === 'function') {
-          return result.finally(_turboEnd);
-        }
-        _turboEnd();
-        return result;
-      };
-    } else {
-      _turboEnd();
-    }
-  });
-
-  // Drive page visits: turbo:load fires after the page is fully rendered.
-  // Also serves as a safety reset — clears any counter leaks from aborted fetches.
-  // Always re-signal idle so the Ruby Event re-arms even if some `_turboEnd`
-  // call dropped on the floor mid-navigation.
-  document.addEventListener('turbo:load', function() {
-    _pendingTurboOps = 0;
-    _signalTurbo('idle');
-  });
-
-  // --- Main API ---
-
-  window._lightpanda = {
-    turbo: {
-      pending: function() { return _pendingTurboOps; },
-      idle: function() { return _pendingTurboOps <= 0; }
-    },
-
-    // --- DOM visibility / state predicates ---
-    // Centralized so node.rb's predicate methods (visible?, obscured?, disabled?)
-    // and the visible_text walker share one implementation of the ancestor
-    // cascade. Available in iframes too because index.js is registered via
-    // Page.addScriptToEvaluateOnNewDocument.
-
-    // Returns true if `el` is visible per Capybara's semantics. Lightpanda's
-    // `checkVisibility()` walks ancestors and rejects `display:none` from
-    // inline styles, stylesheets, and the UA sheet (PR #2294 — covers
-    // HEAD/SCRIPT/STYLE/NOSCRIPT/TEMPLATE/TITLE, `[hidden]`, `[type=hidden]`,
-    // closed-<details> children). `visibility:hidden|collapse` is handled
-    // separately because checkVisibility's defaults (per spec) ignore it.
-    //
-    // Intentional upstream out-of-scope (upstream-wishlist.md C10):
-    // Lightpanda is a headless agentic browser and deliberately doesn't
-    // load external `<link rel=stylesheet>` or apply `@media` rules to
-    // the cascade, and `matchMedia()` returns false for every query.
-    // Responsive patterns that hide one of two mobile/desktop CTA
-    // duplicates via `@media (min-width: …) { display: none }` leak
-    // both variants past this check — Capybara then raises
-    // `Ambiguous: found 2 elements`. There is no in-gem fix: rebuilding
-    // the CSS cascade in JS would need a CSS parser, sync access to
-    // remote stylesheets, and a real media-query evaluator. Run
-    // cuprite for responsive-UI assertions.
-    isVisible: function(el) {
-      if (!el || el.nodeType !== 1) return false;
-      var win = el.ownerDocument.defaultView || window;
-      var style = win.getComputedStyle(el);
-      if (style.visibility === 'hidden' || style.visibility === 'collapse') return false;
-      return el.checkVisibility();
-    },
-
-    // Returns true if the element is obscured at its center point — i.e.
-    // hit-testing elementFromPoint at the center returns something that is
-    // not the element or its descendant. `visibility:hidden|collapse` is
-    // short-circuited explicitly because those elements still produce a
-    // layout box (so the rect-zero check below can't catch them); every
-    // other "not rendered" case (display:none, [hidden], descendants of
-    // either) falls out naturally because getBoundingClientRect returns
-    // DOMRect{0,0,0,0} for elements with no layout box.
-    isObscured: function(el) {
-      var doc = el.ownerDocument;
-      var win = doc.defaultView || window;
-      var style = win.getComputedStyle(el);
-      if (style.visibility === 'hidden' || style.visibility === 'collapse') return true;
-      var r = el.getBoundingClientRect();
-      if (r.width === 0 || r.height === 0) return true;
-      var cx = r.left + (r.width / 2);
-      var cy = r.top + (r.height / 2);
-      var w = win.innerWidth || doc.documentElement.clientWidth;
-      var h = win.innerHeight || doc.documentElement.clientHeight;
-      if (cx < 0 || cy < 0 || cx > w || cy > h) return true;
-      var hit = doc.elementFromPoint(cx, cy);
-      if (!hit) return true;
-      if (hit === el) return false;
-      return !el.contains(hit);
-    },
-
-    // Capybara's `Node#disabled?` is more permissive than CSS `:disabled`:
-    // an `<option>` inside a disabled `<select>` or a disabled `<fieldset>`
-    // is reported as disabled, even though those don't match CSS `:disabled`
-    // per the HTML spec. Mirrors Cuprite's behavior so the shared specs pass.
-    isDisabled: function(el) {
-      if (el.matches && el.matches(':disabled')) return true;
-      if ((el.tagName || '').toUpperCase() === 'OPTION') {
-        var p = el.parentElement;
-        while (p) {
-          if (p.disabled) return true;
-          p = p.parentElement;
-        }
-      }
-      return false;
-    },
-
-    // True if the element is the host of a contenteditable region: it (or any
-    // ancestor) has a non-"false" `contenteditable` attribute. Lightpanda's
-    // native `HTMLElement.isContentEditable` (PR #2310) is hardwired to return
-    // `false` for every element — it has no caret/keyboard editing pipeline —
-    // so the IDL property is useless here and we walk ancestors ourselves.
-    isContentEditable: function(el) {
-      var n = el;
-      while (n && n.nodeType === 1) {
-        if (n.hasAttribute && n.hasAttribute('contenteditable')) {
-          var v = (n.getAttribute('contenteditable') || '').toLowerCase();
-          return v !== 'false';
-        }
-        n = n.parentElement;
-      }
-      return false;
-    },
-
-    // Walk descendants and accumulate text from visible nodes only. Inserts
-    // newlines around block-display containers so paragraphs/lists render with
-    // natural breaks (Capybara expects this from Chrome's innerText).
-    // Lightpanda's innerText returns textContent verbatim (no rendering, so no
-    // hidden-descendant filtering), so we DIY the visibility filtering here.
-    visibleText: function(el) {
-      var BLOCK_DISP = { BLOCK:1, FLEX:1, GRID:1, 'LIST-ITEM':1, TABLE:1, 'TABLE-ROW':1,
-                         'TABLE-CAPTION':1, 'TABLE-CELL':1 };
-      var BLOCK_TAG = { ADDRESS:1, ARTICLE:1, ASIDE:1, BLOCKQUOTE:1, DETAILS:1, DIALOG:1,
-                        DIV:1, DL:1, DT:1, DD:1, FIELDSET:1, FIGCAPTION:1, FIGURE:1,
-                        FOOTER:1, FORM:1, H1:1, H2:1, H3:1, H4:1, H5:1, H6:1, HEADER:1,
-                        HGROUP:1, HR:1, LI:1, MAIN:1, NAV:1, OL:1, P:1, PRE:1, SECTION:1,
-                        TABLE:1, TR:1, UL:1 };
-      var self = this;
-
-      // Collapse runs of ASCII whitespace (preserving NBSP) to a single space —
-      // matches Chrome's innerText whitespace handling for text nodes.
-      function normText(s) {
-        return s.replace(/[\t\n\r\f\v ]+/g, ' ');
-      }
-
-      function walk(node) {
-        if (node.nodeType === 3) return normText(node.nodeValue);
-        // DocumentFragment / ShadowRoot — no element of its own to test
-        // for visibility, just walk children.
-        if (node.nodeType === 11) {
-          var fout = '';
-          for (var k = 0; k < node.childNodes.length; k++) fout += walk(node.childNodes[k]);
-          return fout;
-        }
-        if (node.nodeType !== 1) return '';
-        if (!self.isVisible(node)) return '';
-        var tag = (node.tagName || '').toUpperCase();
-        if (tag === 'TEXTAREA') return node.value || '';
-        if (tag === 'BR') return '\n';
-        var win = node.ownerDocument.defaultView || window;
-        var style = win.getComputedStyle(node);
-        var disp = (style.display || '').toUpperCase();
-        var isBlock = BLOCK_DISP[disp] || BLOCK_TAG[tag];
-        var out = '';
-        for (var i = 0; i < node.childNodes.length; i++) {
-          out += walk(node.childNodes[i]);
-        }
-        // Block-level elements get wrapped in \n…\n only when they actually
-        // contribute visible text. An empty <div> between two inline siblings
-        // would otherwise introduce a phantom line break that Chrome's
-        // innerText algorithm collapses out (required line breaks around
-        // empty blocks coalesce in the line-collapse pass).
-        if (isBlock && /\S/.test(out)) out = '\n' + out + '\n';
-        return out;
-      }
-
-      return walk(el);
-    }
-  };
-})();