capybara-lightpanda 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ffb56a5986bbbe2ecfd36662d9e8bfed778046344f013ec028121100f9f87a5
-  data.tar.gz: c9a86b39d5ab675b6e00dfeb22b26a8aaef10b3a4d88e7455ce517452ec1c317
+  metadata.gz: 42246ea44b80c592e6779cf2aa95890c7635fb057b0061064b63bf15004dcde6
+  data.tar.gz: 63131038538438b32d39d8e46a36005df0306e8daadaa38ff88540874c6c46aa
 SHA512:
-  metadata.gz: 883cc590c12520bf5be6c617c106ddf9b5e859384115b768ea2c1b434b4e62ee848354cf171facac43092577aec7ed8aef7dbd43871dc5b5c1415363d26e80e8
-  data.tar.gz: fbd160fa34522967f09275f5f9fd5da225f9f2ec365e233576a495be7e29873a221c1d42edf1cef8d585b7972c0813e6b15cb876f6eb1b6879836248144907ab
+  metadata.gz: 1728491bdd3d3dac24559cc663ee250af16f90d7944d2c27be0b879ddbfc23a2a00181f39970d7622fd1b640449d97c7d373c4f6a414aae9073dc0f3cf92d1f8
+  data.tar.gz: 47e0408c55b5150347656d8136b6dc993b39d38a051a39efec480e2d913cf799f45c18242fd031bbb6962f79b7a39d63cc2eec8d2c14e2f42f34ed3b029af867

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.2.1] - 2026-05-05
+
+### Fixed
+
+- Turbo Frame links now correctly swap the frame instead of falling through to a full-page navigation. Affects any test that clicks a link or submits a form inside a `<turbo-frame>`.
+- Internal driver errors (`NoMethodError`, `NameError`, `Errno::*`) inside `extract_node_object_ids` and `page_ready?` are no longer swallowed and silently downgraded to `[]` / `false` — they surface as real exceptions so bugs are visible.
+
+### Internal
+
+- Local test suite migrated from RSpec to Minitest::Spec. The Capybara shared-spec battery (`spec/features/session_spec.rb`) still runs on RSpec.
+
 ## [0.2.0] - 2026-05-04
 
 Reliability and feature polish as Lightpanda matured. **Update Lightpanda before upgrading**: this release requires a current nightly (the gem will tell you if yours is too old).

data/lib/capybara/lightpanda/binary.rb

@@ -73,7 +73,7 @@ module Capybara
         end
 
         def find
-          env_path = ENV.fetch("LIGHTPANDA_PATH", nil)
+          env_path = ENV.fetch("LIGHTPANDA_BIN", nil)
           return env_path if env_path && File.executable?(env_path)
 
           path_binary = find_in_path

data/lib/capybara/lightpanda/browser.rb

@@ -8,7 +8,7 @@ module Capybara
     class Browser
       extend Forwardable
 
-      attr_reader :options, :process, :client, :target_id, :session_id, :frame_stack
+      attr_reader :options, :process, :client, :target_id, :session_id, :browser_context_id, :frame_stack
 
       delegate %i[on off] => :client
 
@@ -29,6 +29,7 @@ module Capybara
         @client = nil
         @target_id = nil
         @session_id = nil
+        @browser_context_id = nil
         @started = false
         @page_events_enabled = false
         @modal_messages = []
@@ -52,13 +53,25 @@ module Capybara
           @client = Client.new(@process.ws_url, @options)
         end
 
+        create_browser_context
         create_page
 
         @started = true
       end
 
+      # Per-session BrowserContext (Chrome's incognito-profile primitive).
+      # Cookies, storage, and targets created within the context are wiped
+      # when it's disposed — so `reset` is one CDP call instead of an
+      # explicit cookies.clear / storage.clear / close-target dance.
+      # Mirrors ferrum's Contexts model.
+      def create_browser_context
+        result = @client.command("Target.createBrowserContext")
+        @browser_context_id = result["browserContextId"]
+      end
+
       def create_page
-        result = @client.command("Target.createTarget", { url: "about:blank" })
+        result = @client.command("Target.createTarget",
+                                 { url: "about:blank", browserContextId: @browser_context_id }.compact)
         @target_id = result["targetId"]
 
         attach_result = @client.command("Target.attachToTarget", { targetId: @target_id, flatten: true })
@@ -78,6 +91,33 @@ module Capybara
         start
       end
 
+      # Wipe per-session state — cookies, storage, all targets — and start
+      # over with a fresh BrowserContext. Mirrors ferrum's Browser#reset:
+      # one CDP call (`Target.disposeBrowserContext`) does the work that
+      # would otherwise require explicit cookies.clear / storage.clear /
+      # close-target dance, and the browser auto-isolates state for the
+      # new context. Driver#reset! delegates here.
+      #
+      # Side benefit: avoids `Page.navigate("about:blank")` against a
+      # non-blank tab, which doesn't actually replace the document on
+      # current Lightpanda nightly (lightpanda-io/browser#2363). The
+      # context-disposal path sidesteps that bug entirely.
+      def reset
+        dispose_browser_context
+        @client.clear_subscriptions
+        @page_events_enabled = false
+        @modal_handler_installed = false
+        @modal_messages.clear
+        @frame_stack.clear
+        # Network#reset, not #clear: disposing the BrowserContext also
+        # destroyed the Network domain and its subscriptions, so we must
+        # flip @enabled back to false — otherwise the next #enable
+        # short-circuits and traffic tracking is silently dead.
+        @network&.reset
+        create_browser_context
+        create_page
+      end
+
       # Recover after a WebSocket disconnect or process crash during navigation.
       # Restarts the process if it died, then creates a fresh client and page.
       def reconnect
@@ -88,6 +128,9 @@ module Capybara
         raise DeadBrowserError, "Cannot reconnect: no WebSocket URL" unless ws_url
 
         @client = Client.new(ws_url, @options)
+        # Process may have died; the old browserContextId is gone with it.
+        @browser_context_id = nil
+        create_browser_context
         create_page
         @page_events_enabled = false
       end
@@ -106,6 +149,9 @@ module Capybara
         @client = nil
         @process = nil
         @started = false
+        @browser_context_id = nil
+        @target_id = nil
+        @session_id = nil
         @modal_handler_installed = false
         @frame_stack.clear
       end
@@ -204,7 +250,10 @@ module Capybara
       def evaluate(expression, *args)
         if args.empty?
           response = page_command("Runtime.evaluate", expression: expression, returnByValue: false, awaitPromise: true)
-          raise JavaScriptError, response if response["exceptionDetails"]
+          if response["exceptionDetails"]
+            debug_js_failure("evaluate", expression, response)
+            raise JavaScriptError, response
+          end
 
           return unwrap_call_result(response["result"])
         end
@@ -225,6 +274,15 @@ module Capybara
         nil
       end
 
+      # When LIGHTPANDA_DEBUG=1 is set, log the JS expression and full CDP
+      # response for every JsException to STDERR. Invaluable for isolating
+      # which exact JS triggers an upstream Lightpanda bug.
+      def debug_js_failure(site, expression, response)
+        return unless ENV["LIGHTPANDA_DEBUG"]
+
+        warn "[lightpanda:#{site}] expression:\n#{expression}\n[lightpanda:#{site}] response:\n#{response.inspect}\n"
+      end
+
       # 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.
@@ -249,7 +307,10 @@ module Capybara
       # Evaluate JS and return a RemoteObject reference (for DOM nodes, arrays).
       def evaluate_with_ref(expression)
         response = page_command("Runtime.evaluate", expression: expression, returnByValue: false, awaitPromise: true)
-        raise JavaScriptError, response if response["exceptionDetails"]
+        if response["exceptionDetails"]
+          debug_js_failure("evaluate_with_ref", expression, response)
+          raise JavaScriptError, response
+        end
 
         result = response["result"]
         return nil if result["type"] == "undefined"
@@ -269,7 +330,10 @@ module Capybara
         params[:arguments] = args.map { |a| serialize_argument(a) } unless args.empty?
 
         response = page_command("Runtime.callFunctionOn", **params)
-        raise JavaScriptError, response if response["exceptionDetails"]
+        if response["exceptionDetails"]
+          debug_js_failure("call_function_on", function_declaration, response)
+          raise JavaScriptError, response
+        end
 
         result = response["result"]
         return nil if result["type"] == "undefined"
@@ -304,6 +368,8 @@ module Capybara
       def find_within(remote_object_id, method, selector)
         result = call_function_on(remote_object_id, FIND_WITHIN_JS, method, selector, return_by_value: false)
         extract_node_object_ids(result)
+      rescue JavaScriptError => e
+        raise_invalid_selector(e, method, selector)
       end
 
       # objectId of document.activeElement, or nil if none/document detached.
@@ -528,20 +594,32 @@ module Capybara
         raise Capybara::ModalNotFound, "Unable to find modal dialog#{" with #{text}" if text}"
       end
 
+      # Sentinel string thrown from FIND_*_JS when querySelectorAll rejects a
+      # malformed selector, so the Ruby side can convert JavaScriptError into
+      # Capybara::Lightpanda::InvalidSelector. Cuprite uses a JS subclass for
+      # the same purpose; a plain prefixed string keeps our inline JS simple.
+      INVALID_SELECTOR_MARKER = "LIGHTPANDA_INVALID_SELECTOR:"
+
       # JS function for finding elements within a node.
-      # Works in any execution context (top frame or iframe).
-      FIND_WITHIN_JS = <<~JS
+      # Works in any execution context (top frame or iframe). Any throw from
+      # querySelectorAll means the selector is malformed (the spec only allows
+      # SYNTAX_ERR DOMException; Lightpanda's V8 currently throws a generic
+      # Error with messages like "InvalidClassSelector"). Re-throw with the
+      # marker prefix so Ruby converts to InvalidSelector regardless.
+      FIND_WITHIN_JS = <<~JS.freeze
         function(method, selector) {
           if (method === 'xpath') {
             if (typeof _lightpanda !== 'undefined') return _lightpanda.xpathFind(selector, this);
             return [];
           }
-          try { return Array.from(this.querySelectorAll(selector)); } catch(e) { return []; }
+          try { return Array.from(this.querySelectorAll(selector)); }
+          catch(e) { throw new Error('#{INVALID_SELECTOR_MARKER}' + selector); }
         }
       JS
+      private_constant :FIND_WITHIN_JS
 
       # JS function for finding elements in an iframe's contentDocument.
-      FIND_IN_FRAME_JS = <<~JS
+      FIND_IN_FRAME_JS = <<~JS.freeze
         function(method, selector) {
           var doc;
           try { doc = this.contentDocument || (this.contentWindow && this.contentWindow.document); } catch(e) {}
@@ -550,9 +628,11 @@ module Capybara
             if (typeof _lightpanda !== 'undefined') return _lightpanda.xpathFind(selector, doc);
             return [];
           }
-          try { return Array.from(doc.querySelectorAll(selector)); } catch(e) { return []; }
+          try { return Array.from(doc.querySelectorAll(selector)); }
+          catch(e) { throw new Error('#{INVALID_SELECTOR_MARKER}' + selector); }
         }
       JS
+      private_constant :FIND_IN_FRAME_JS
 
       def find_in_document(method, selector)
         with_default_context_wait do
@@ -563,12 +643,18 @@ module Capybara
           js = if method == "xpath"
                  "(typeof _lightpanda !== 'undefined') ? _lightpanda.xpathFind(#{selector_literal}, document) : []"
                else
-                 "(function() { try { return Array.from(document.querySelectorAll(#{selector_literal})); } " \
-                   "catch(e) { return []; } })()"
+                 <<~CSS_FIND
+                   (function() {
+                     try { return Array.from(document.querySelectorAll(#{selector_literal})); }
+                     catch(e) { throw new Error('#{INVALID_SELECTOR_MARKER}' + #{selector_literal}); }
+                   })()
+                 CSS_FIND
                end
           result = evaluate_with_ref(js)
           extract_node_object_ids(result)
         end
+      rescue JavaScriptError => e
+        raise_invalid_selector(e, method, selector)
       end
 
       def find_in_frame(method, selector)
@@ -576,6 +662,16 @@ module Capybara
         result = call_function_on(frame_node.remote_object_id, FIND_IN_FRAME_JS, method, selector,
                                   return_by_value: false)
         extract_node_object_ids(result)
+      rescue JavaScriptError => e
+        raise_invalid_selector(e, method, selector)
+      end
+
+      def raise_invalid_selector(js_error, method, selector)
+        if js_error.message.include?(INVALID_SELECTOR_MARKER)
+          raise InvalidSelector.new("Invalid #{method} selector: #{selector.inspect}", method, selector)
+        end
+
+        raise js_error
       end
 
       # Extract individual node objectIds from a remote array reference.
@@ -592,12 +688,13 @@ module Capybara
 
         release_object(result["objectId"])
         ids
-      rescue StandardError
+      rescue Error
         []
       end
 
       def register_auto_scripts
         page_command("Page.addScriptToEvaluateOnNewDocument", source: XPathPolyfill::JS)
+        page_command("Page.addScriptToEvaluateOnNewDocument", source: XPathPolyfill::POLYFILLS_JS)
       end
 
       def subscribe_to_console_logs
@@ -716,7 +813,10 @@ module Capybara
       end
 
       def handle_evaluate_response(response)
-        raise JavaScriptError, response if response["exceptionDetails"]
+        if response["exceptionDetails"]
+          debug_js_failure("handle_evaluate_response", "(unknown — already-issued call)", response)
+          raise JavaScriptError, response
+        end
 
         result = response["result"]
         return nil if result["type"] == "undefined"
@@ -738,7 +838,10 @@ module Capybara
           arguments: args.map { |a| serialize_argument(a) },
         }
         response = page_command("Runtime.callFunctionOn", **params)
-        raise JavaScriptError, response if response["exceptionDetails"]
+        if response["exceptionDetails"]
+          debug_js_failure("call_with_args", function_declaration, response)
+          raise JavaScriptError, response
+        end
 
         return_by_value ? handle_evaluate_response(response) : unwrap_call_result(response["result"])
       end
@@ -839,6 +942,21 @@ module Capybara
         nil
       end
 
+      def dispose_browser_context
+        return unless @browser_context_id
+
+        begin
+          @client.command("Target.disposeBrowserContext", { browserContextId: @browser_context_id })
+        rescue StandardError
+          # Context may already be disposed or the WS may be down; we
+          # recreate either way.
+        ensure
+          @browser_context_id = nil
+          @target_id = nil
+          @session_id = nil
+        end
+      end
+
       def restart_process_if_dead
         return unless @process && !@process.alive?
 
@@ -927,7 +1045,7 @@ module Capybara
 
         url_changed = starting_url.nil? || state["u"] != starting_url
         url_changed && %w[complete interactive].include?(state["r"])
-      rescue StandardError
+      rescue Error
         false
       end
 

data/lib/capybara/lightpanda/client/subscriber.rb

@@ -4,9 +4,18 @@ module Capybara
   module Lightpanda
     class Client
       class Subscriber
-        def initialize
+        # Default error sink: write a one-line warning so a misbehaving handler
+        # is visible without crashing the CDP message thread. Tests can inject
+        # a custom proc via `on_error:` to capture failures.
+        DEFAULT_ON_ERROR = lambda do |event, error|
+          warn("[capybara-lightpanda] subscriber callback for #{event.inspect} raised " \
+               "#{error.class}: #{error.message}")
+        end
+
+        def initialize(on_error: DEFAULT_ON_ERROR)
           @subscriptions = Hash.new { |h, k| h[k] = [] }
           @mutex = Mutex.new
+          @on_error = on_error
         end
 
         def subscribe(event, &block)
@@ -25,10 +34,28 @@ module Capybara
           end
         end
 
+        # Run every callback registered for `event`. Exceptions in one
+        # callback must not stop the others or propagate out — the message
+        # thread sets `abort_on_exception = true`, so an unhandled raise
+        # would tear down the entire CDP connection.
+        #
+        # Two layers of rescue:
+        #   1. The callback itself may raise — route to @on_error.
+        #   2. @on_error itself may raise (custom hook, broken stderr) —
+        #      swallow at the last level so the dispatch loop survives.
         def dispatch(event, params)
           callbacks = @mutex.synchronize { @subscriptions[event].dup }
 
-          callbacks.each { |callback| callback.call(params) }
+          callbacks.each do |callback|
+            callback.call(params)
+          rescue StandardError => e
+            begin
+              @on_error.call(event, e)
+            rescue StandardError
+              # The error sink failed — nothing to do but keep going. We
+              # cannot log here without re-entering the broken path.
+            end
+          end
         end
 
         def subscribed?(event)

data/lib/capybara/lightpanda/client.rb

@@ -60,6 +60,13 @@ module Capybara
         @subscriber.unsubscribe(event, block)
       end
 
+      # Drop all event subscriptions without closing the WebSocket. Used by
+      # Browser#recreate_page so a fresh target's event handlers don't pile
+      # up on top of the previous target's subscriptions.
+      def clear_subscriptions
+        @subscriber.clear
+      end
+
       def close
         @ws&.close
         @message_thread&.join(1) || @message_thread&.kill

data/lib/capybara/lightpanda/driver.rb

@@ -196,12 +196,12 @@ module Capybara
 
       # -- Lifecycle --
 
+      # Thin Cuprite-style wrapper. The interesting work — disposing the
+      # BrowserContext (cookies, storage, all targets) and starting a fresh
+      # one — happens in Browser#reset.
       def reset!
-        browser.clear_frames
-        browser.reset_modals
-        browser.cookies.clear
-        browser.network.clear
-        browser.go_to("about:blank")
+        browser.reset
+        @started = false
       rescue StandardError
         @browser&.quit
         @browser = nil

data/lib/capybara/lightpanda/errors.rb

@@ -46,11 +46,36 @@ module Capybara
       attr_reader :class_name, :stack_trace
 
       def initialize(response)
-        @class_name = response.dig("exceptionDetails", "exception", "className")
-        @stack_trace = response.dig("exceptionDetails", "stackTrace")
-        message = response.dig("exceptionDetails", "exception", "description") ||
-                  response.dig("exceptionDetails", "text")
-        super(message)
+        details = response["exceptionDetails"] || {}
+        exception = details["exception"] || {}
+        @class_name = exception["className"]
+        @stack_trace = details["stackTrace"]
+        super(build_message(details, exception))
+      end
+
+      private
+
+      def build_message(details, exception)
+        base = exception["description"] || details["text"] || "JsException"
+        parts = [base]
+        parts << "(#{@class_name})" if @class_name && !base.include?(@class_name)
+        if (val = exception["value"])
+          parts << "value=#{val.inspect}"
+        end
+        if @stack_trace && (frames = @stack_trace["callFrames"])
+          parts << format_stack(frames)
+        end
+        parts.join(" | ")
+      end
+
+      def format_stack(frames)
+        formatted = frames.first(5).map { |f| format_frame(f) }
+        "stack:\n  #{formatted.join("\n  ")}"
+      end
+
+      def format_frame(frame)
+        name = frame["functionName"].to_s.empty? ? "<anon>" : frame["functionName"]
+        "#{name} @ #{frame['url']}:#{frame['lineNumber']}:#{frame['columnNumber']}"
       end
     end
 

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

@@ -0,0 +1,81 @@
+// Polyfills compensant des limitations du binaire Lightpanda.
+// Chaque section est gardée par un test de feature : dès qu'upstream implémente
+// l'API native, le polyfill devient un no-op et peut être retiré.
+// Voir UPSTREAM_BUGS.md à la racine du gem pour les repros et liens d'issues.
+(function () {
+  "use strict";
+
+  // ── Bug #4 — HTMLDialogElement.{showModal, show, close} non implémentés ──
+  // https://html.spec.whatwg.org/multipage/interactive-elements.html#the-dialog-element
+  if (typeof HTMLDialogElement !== "undefined") {
+    var dproto = HTMLDialogElement.prototype;
+    if (typeof dproto.showModal !== "function") {
+      dproto.showModal = function () {
+        if (this.hasAttribute("open")) {
+          throw new (window.DOMException || Error)(
+            "The element already has an 'open' attribute, and therefore cannot be opened modally.",
+            "InvalidStateError"
+          );
+        }
+        this.setAttribute("open", "");
+      };
+    }
+    if (typeof dproto.show !== "function") {
+      dproto.show = function () {
+        if (!this.hasAttribute("open")) this.setAttribute("open", "");
+      };
+    }
+    if (typeof dproto.close !== "function") {
+      dproto.close = function (returnValue) {
+        if (!this.hasAttribute("open")) return;
+        this.removeAttribute("open");
+        if (returnValue !== undefined) this.returnValue = String(returnValue);
+        this.dispatchEvent(new Event("close"));
+      };
+    }
+  }
+
+  // ── Bug #3 (narrower than originally diagnosed; verified 2026-05-04 against build 6005) ──
+  // Native dispatch DOES propagate to ancestors with event.target preserved — but if
+  // ANY listener throws, Lightpanda halts the whole dispatch path (incl. the bubble
+  // phase) instead of reporting the exception and continuing per DOM §2.9 step 4.
+  // Stimulus / Turbo Drive listeners that throw silently swallow document-level
+  // delegation. Workaround: catch the propagated JsException and re-walk parents
+  // manually, spoofing event.target via Object.defineProperty for delegated handlers.
+  (function patchDispatch() {
+    if (!window.EventTarget || !EventTarget.prototype.dispatchEvent) return;
+    var orig = EventTarget.prototype.dispatchEvent;
+
+    EventTarget.prototype.dispatchEvent = function (event) {
+      try {
+        return orig.call(this, event);
+      } catch (err) {
+        if (!event || !event.bubbles || !this.parentNode) throw err;
+
+        var originalTarget = this;
+        try {
+          Object.defineProperty(event, "target", {
+            value: originalTarget,
+            configurable: true,
+          });
+        } catch (_) { /* target not redefinable — continue anyway */ }
+
+        var node = this.parentNode;
+        while (node) {
+          try {
+            Object.defineProperty(event, "currentTarget", {
+              value: node,
+              configurable: true,
+            });
+          } catch (_) {}
+          try {
+            orig.call(node, event);
+          } catch (_) { /* ignore intermediate crashes; keep propagating */ }
+          if (event.cancelBubble) break;
+          node = node.parentNode || node.host || null;
+        }
+        return !event.defaultPrevented;
+      }
+    };
+  })();
+})();

data/lib/capybara/lightpanda/network.rb

@@ -9,6 +9,8 @@ module Capybara
         @browser = browser
         @traffic = []
         @enabled = false
+        @request_handler = nil
+        @response_handler = nil
       end
 
       def enable
@@ -22,7 +24,13 @@ module Capybara
       def disable
         return unless @enabled
 
+        # Tell the browser to stop emitting BEFORE unsubscribing locally:
+        # otherwise an in-flight Network.responseReceived can race past the
+        # already-removed handler and leave a `response: nil` entry in
+        # @traffic for the matching request — which then trips
+        # wait_for_idle's pending count on a future call.
         browser.command("Network.disable")
+        unsubscribe
         @enabled = false
       end
 
@@ -34,6 +42,18 @@ module Capybara
         @traffic.clear
       end
 
+      # Wipe local state without sending Network.disable. Called by
+      # Browser#reset after Target.disposeBrowserContext, which destroys
+      # the subscriptions and the Network domain along with the context —
+      # leaving @enabled true would silently no-op the next #enable.
+      # Also unsubscribes locally so we don't rely on the caller having
+      # cleared the Subscriber first.
+      def reset
+        unsubscribe
+        @traffic.clear
+        @enabled = false
+      end
+
       def headers=(headers)
         @extra_headers = headers
         browser.page_command("Network.setExtraHTTPHeaders", headers: headers)
@@ -65,7 +85,7 @@ module Capybara
       private
 
       def subscribe
-        browser.on("Network.requestWillBeSent") do |params|
+        @request_handler = lambda do |params|
           @traffic << {
             request_id: params["requestId"],
             url: params.dig("request", "url"),
@@ -75,7 +95,7 @@ module Capybara
           }
         end
 
-        browser.on("Network.responseReceived") do |params|
+        @response_handler = lambda do |params|
           request = @traffic.find { |t| t[:request_id] == params["requestId"] }
 
           next unless request
@@ -86,6 +106,16 @@ module Capybara
             mime_type: params.dig("response", "mimeType"),
           }
         end
+
+        browser.on("Network.requestWillBeSent", &@request_handler)
+        browser.on("Network.responseReceived", &@response_handler)
+      end
+
+      def unsubscribe
+        browser.off("Network.requestWillBeSent", @request_handler) if @request_handler
+        browser.off("Network.responseReceived", @response_handler) if @response_handler
+        @request_handler = nil
+        @response_handler = nil
       end
     end
   end

data/lib/capybara/lightpanda/node.rb

@@ -116,6 +116,14 @@ module Capybara
         call("function() { this.dispatchEvent(new MouseEvent('mouseover', {bubbles: true, cancelable: true})) }")
       end
 
+      # Dispatch an arbitrary DOM event by name. Mirrors Cuprite's Node#trigger
+      # — picks the right Event constructor for known mouse/focus/form names
+      # and falls back to a generic Event for everything else (so callers can
+      # fire custom events like `node.trigger('lp:custom')`).
+      def trigger(event)
+        call(TRIGGER_JS, event.to_s)
+      end
+
       def set(value, **_options)
         case tag_name
         when "input"
@@ -355,7 +363,77 @@ module Capybara
         end
       end
 
-      CLICK_JS = "function() { this.click() }"
+      # Native `this.click()` reaches all ancestors on the happy path, but if any
+      # listener throws (Stimulus / Turbo edge cases) Lightpanda halts dispatch
+      # instead of reporting the exception per DOM §2.9 step 4 (see UPSTREAM_BUGS.md
+      # Bug #3). Dispatching via JS routes through `polyfills.js`'s patchDispatch
+      # IIFE, which catches the throw and re-walks parents manually so document-
+      # level delegated handlers still see the event.
+      #
+      # We dispatch a `MouseEvent` (not a generic `Event`) because Turbo's link
+      # and form interceptors guard with `event instanceof MouseEvent` before
+      # they consider intercepting — a synthetic `Event('click')` is silently
+      # ignored by Turbo Frame / Drive, and CLICK_JS would then fall through to
+      # the manual default action below, which does a full-page navigation
+      # instead of a frame swap.
+      #
+      # For submit buttons (`<button type=submit>`, `<input type=submit>`,
+      # `<input type=image>`): route through `form.requestSubmit(this)` so the
+      # browser dispatches a real `SubmitEvent` with submitter set, honors the
+      # submitter's `formaction` / `formmethod` / `formenctype`, and includes
+      # the submitter's name/value in the form data. A manual
+      # `dispatchEvent(new Event('submit'))` + `form.submit()` would lose all of
+      # that and break Turbo Drive / Hotwire form handling. We can't rely on
+      # the synthetic click's default action because synthetic events don't
+      # trigger the implicit form-submission default action per DOM spec.
+      CLICK_JS = <<~JS
+        function() {
+          var EventCtor = (typeof MouseEvent !== 'undefined') ? MouseEvent : Event;
+          var clickEvt = new EventCtor('click', { bubbles: true, cancelable: true });
+          var notCancelled = true;
+          try {
+            notCancelled = this.dispatchEvent(clickEvt);
+          } catch (e) { /* patchDispatch in polyfills.js rescues bubble phase */ }
+          if (!notCancelled || clickEvt.defaultPrevented) return;
+          var tag = this.tagName;
+          var type = (this.type || '').toLowerCase();
+          var isSubmitButton =
+            (tag === 'BUTTON' && (type === 'submit' || type === '')) ||
+            (tag === 'INPUT' && (type === 'submit' || type === 'image'));
+          if (isSubmitButton && this.form) {
+            this.form.requestSubmit(this);
+          } else if (tag === 'A' && this.href && this.target !== '_blank') {
+            window.location.href = this.href;
+          }
+        }
+      JS
+
+      # Mirrors Cuprite's trigger map. Picks the right Event constructor based
+      # on the event name so listeners that key on `event instanceof MouseEvent`
+      # / `instanceof SubmitEvent` see what they expect; everything else goes
+      # through a generic Event so custom names ("turbo:load", "lp:custom")
+      # still dispatch. Each constructor is feature-detected (`typeof X !==
+      # 'undefined'`) before use so a missing IDL on Lightpanda falls back
+      # to plain Event rather than throwing.
+      TRIGGER_JS = <<~JS
+        function(name) {
+          var MOUSE = ['click','dblclick','mousedown','mouseenter','mouseleave',
+                       'mousemove','mouseover','mouseout','mouseup','contextmenu'];
+          var FOCUS = ['blur','focus','focusin','focusout'];
+          var init = { bubbles: true, cancelable: true };
+          var event;
+          if (MOUSE.indexOf(name) !== -1 && typeof MouseEvent !== 'undefined') {
+            event = new MouseEvent(name, init);
+          } else if (FOCUS.indexOf(name) !== -1 && typeof FocusEvent !== 'undefined') {
+            event = new FocusEvent(name, init);
+          } else if (name === 'submit' && typeof SubmitEvent !== 'undefined') {
+            event = new SubmitEvent(name, init);
+          } else {
+            event = new Event(name, init);
+          }
+          this.dispatchEvent(event);
+        }
+      JS
 
       VISIBLE_JS = "function() { return _lightpanda.isVisible(this); }"
 
@@ -382,7 +460,14 @@ module Capybara
                             autofocus: 'autofocus', required: 'required' };
           var prop = BOOL_PROP[name.toLowerCase()];
           if (prop && this[prop] !== undefined) return this[prop];
-          return this.getAttribute(name);
+          if (this.hasAttribute(name)) return this.getAttribute(name);
+          // Property-only fallback: things like `validationMessage` have no
+          // backing HTML attribute. Return primitives only — DOM-node properties
+          // (form, options, etc.) shouldn't leak through.
+          var live = this[name];
+          if (live === null || live === undefined) return null;
+          var t = typeof live;
+          return (t === 'string' || t === 'number' || t === 'boolean') ? live : null;
         }
       JS
 
@@ -464,8 +549,6 @@ module Capybara
 
       SET_CHECKBOX_JS = <<~JS
         function(value) {
-          // Use `click()` so user-installed click/change handlers fire and
-          // observe a real toggle. No-op if already in the requested state.
           if (this.checked !== value) this.click();
         }
       JS

data/lib/capybara/lightpanda/process.rb

@@ -22,10 +22,11 @@ module Capybara
       # promptText is null), PR #2324 (<label> click runs activation behavior
       # on labeled control), PR #2286 (HTML constraint validation API:
       # el.validity, validationMessage, checkValidity, reportValidity),
-      # PR #2342 (<summary> click toggles parent <details>.open). Build
-      # 6005 = main HEAD 0420802f (2026-05-04); ships in nightly published
-      # 2026-05-04 03:44 UTC for all four platforms.
-      MINIMUM_NIGHTLY_BUILD = Gem::Version.new("6005")
+      # PR #2342 (<summary> click toggles parent <details>.open),
+      # PR #2352 (HTMLInputElement.pattern + patternMismatch via V8 RegExp).
+      # Build 6051 = main HEAD d360fcc0 (2026-05-04); ships in nightly
+      # published 2026-05-05 ~03:30 UTC for all four platforms.
+      MINIMUM_NIGHTLY_BUILD = Gem::Version.new("6051")
 
       attr_reader :pid, :ws_url, :version, :nightly_build
 

data/lib/capybara/lightpanda/version.rb

@@ -2,6 +2,6 @@
 
 module Capybara
   module Lightpanda
-    VERSION = "0.2.0"
+    VERSION = "0.2.1"
   end
 end

data/lib/capybara/lightpanda/xpath_polyfill.rb

@@ -5,6 +5,11 @@ module Capybara
     module XPathPolyfill
       JS_PATH = File.expand_path("javascripts/index.js", __dir__).freeze
       JS = File.read(JS_PATH).freeze
+
+      # Polyfills pour les APIs DOM manquantes du binaire Lightpanda.
+      # Voir UPSTREAM_BUGS.md à la racine du gem.
+      POLYFILLS_PATH = File.expand_path("javascripts/polyfills.js", __dir__).freeze
+      POLYFILLS_JS = File.read(POLYFILLS_PATH).freeze
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: capybara-lightpanda
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Navid Emad
@@ -81,6 +81,7 @@ files:
 - lib/capybara/lightpanda/errors.rb
 - lib/capybara/lightpanda/frame.rb
 - lib/capybara/lightpanda/javascripts/index.js
+- lib/capybara/lightpanda/javascripts/polyfills.js
 - lib/capybara/lightpanda/keyboard.rb
 - lib/capybara/lightpanda/logger.rb
 - lib/capybara/lightpanda/network.rb