capybara-lightpanda 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1cb36e68fb7bcc35abcbae5a3417091eb54444f7b57e161cb44cb6436d243684
-  data.tar.gz: 9eff2c5cd278d16ed8ad55d106dca14dab3597a87c3315c46371b98672a35163
+  metadata.gz: 9bb84252bec4e22492ad1e2165a63842c3fad60ab9d80ee0df60db55c2425c9a
+  data.tar.gz: '090fbdca94bf7e482dda301a2aad4b51065211972bff4a06a9aa3e848a2a9ef4'
 SHA512:
-  metadata.gz: 156126b7f57785869aca23b79fe02bc3fe7370cf5b2826999715d5e69794a6b62f8c69bb64601e5e67f935d946e2348274c8ec76d79b674930b239d6b2383677
-  data.tar.gz: c73dab9284d0d8e0091794e2f88674951bafc64af2fa2e87200926a60d7d86767f31cd5114d5348af51013fe3b4846f1066d0bdca886a5a1051432673b76ef52
+  metadata.gz: 3bf39418c02c38ead4fc8ead897064730711d97bcd2e787d049ae1860e89bcf07e155f4ebb3743263e4c531250935d73e02ae768196aa5d27e205f8c3f903d1e
+  data.tar.gz: 145951b47b0ef2ce55e4c02932c006efdaa48fd6ac556daf5a18fef5949d63ebf861eabf262a93bb1a2a51dcc46b89d9d510fcbcc5c38fc7153dc1a0cd24402b

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.3.0] - 2026-05-12
+
+> **Update Lightpanda before upgrading.** Requires a nightly build ≥ 6109 (published 2026-05-12). The driver refuses to start against older binaries.
+
+### Fixed
+
+- Iframe tests no longer crash with `NoExecutionContextError` when the page inside the iframe navigates. `switch_to_frame` and `within_frame` now re-resolve the iframe element on a stale-handle error and retry once, so multi-step flows inside an `<iframe>` (logins, embedded checkouts, OAuth dialogs) stay stable across child-frame navigations.
+- Clicking a submit button no longer fires `submit` twice. On Turbo Drive pages this previously produced duplicate `turbo:submit-start` events and could abort the real fetch mid-flight.
+
+### Removed
+
+- The gem no longer ships its own XPath engine — Lightpanda evaluates XPath natively now, including the full XPath 1.0 selector surface. `find(:xpath, …)`, Capybara's automatic XPath fallback, and any custom XPath finders all keep working unchanged; the same behavior, with ~750 fewer lines injected per test process.
+- The gem's JavaScript shim for `back` / `forward` is gone. Navigation history now routes through Lightpanda directly, which is more reliable across navigation crashes.
+
 ## [0.2.2] - 2026-05-06
 
 > **Update Lightpanda before upgrading.** Requires a nightly build ≥ 6065 (published 2026-05-06). The driver refuses to start against older binaries.

data/lib/capybara/lightpanda/browser.rb

@@ -35,6 +35,7 @@ module Capybara
         @modal_messages = []
         @modal_handler_installed = false
         @frame_stack = []
+        @frame_locators = []
         @frames = Concurrent::Hash.new
         @turbo_event = Utils::Event.new
         @turbo_event.set
@@ -108,7 +109,7 @@ module Capybara
         @page_events_enabled = false
         @modal_handler_installed = false
         @modal_messages.clear
-        @frame_stack.clear
+        clear_frames
         # 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
@@ -153,7 +154,7 @@ module Capybara
         @target_id = nil
         @session_id = nil
         @modal_handler_installed = false
-        @frame_stack.clear
+        clear_frames
       end
 
       def command(method, **params)
@@ -217,11 +218,11 @@ module Capybara
       end
 
       def back
-        wait_for_navigation { execute("history.back()") }
+        wait_for_navigation { navigate_history(-1) }
       end
 
       def forward
-        wait_for_navigation { execute("history.forward()") }
+        wait_for_navigation { navigate_history(+1) }
       end
 
       def refresh
@@ -528,13 +529,16 @@ module Capybara
 
       def push_frame(node)
         @frame_stack.push(node)
+        @frame_locators.push(capture_frame_locator(node))
       end
 
       def pop_frame
+        @frame_locators.pop
         @frame_stack.pop
       end
 
       def clear_frames
+        @frame_locators.clear
         @frame_stack.clear
       end
 
@@ -632,16 +636,26 @@ module Capybara
       INVALID_SELECTOR_MARKER = "LIGHTPANDA_INVALID_SELECTOR:"
 
       # JS function for finding elements within a node.
-      # 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.
+      # Works in any execution context (top frame or iframe). For CSS, any
+      # throw from querySelectorAll means the selector is malformed
+      # (re-throw with the marker prefix so Ruby converts to InvalidSelector).
+      # XPath routes through native `Document.evaluate` + `XPathResult`
+      # (Lightpanda PR #2305, in nightly >=6109); on parse error we return
+      # [] silently to match Capybara's internal XPath generator, which
+      # sometimes produces selectors with empty trailing predicates like
+      # `(...)[]` that native rejects but `has_element?` expects to behave
+      # as "not found" rather than raise InvalidSelector.
+      # `XPathResult.ORDERED_NODE_SNAPSHOT_TYPE` is `7` in the spec — inlined
+      # so the JS doesn't depend on the enum being defined as a constant.
       FIND_WITHIN_JS = <<~JS.freeze
         function(method, selector) {
           if (method === 'xpath') {
-            if (typeof _lightpanda !== 'undefined') return _lightpanda.xpathFind(selector, this);
-            return [];
+            try {
+              var r = this.ownerDocument.evaluate(selector, this, null, 7, null);
+              var nodes = [];
+              for (var i = 0; i < r.snapshotLength; i++) nodes.push(r.snapshotItem(i));
+              return nodes;
+            } catch(e) { return []; }
           }
           try { return Array.from(this.querySelectorAll(selector)); }
           catch(e) { throw new Error('#{INVALID_SELECTOR_MARKER}' + selector); }
@@ -656,8 +670,12 @@ module Capybara
           try { doc = this.contentDocument || (this.contentWindow && this.contentWindow.document); } catch(e) {}
           if (!doc) return [];
           if (method === 'xpath') {
-            if (typeof _lightpanda !== 'undefined') return _lightpanda.xpathFind(selector, doc);
-            return [];
+            try {
+              var r = doc.evaluate(selector, doc, null, 7, null);
+              var nodes = [];
+              for (var i = 0; i < r.snapshotLength; i++) nodes.push(r.snapshotItem(i));
+              return nodes;
+            } catch(e) { return []; }
           }
           try { return Array.from(doc.querySelectorAll(selector)); }
           catch(e) { throw new Error('#{INVALID_SELECTOR_MARKER}' + selector); }
@@ -665,14 +683,97 @@ module Capybara
       JS
       private_constant :FIND_IN_FRAME_JS
 
+      # Captures identifying attributes of an iframe element at push_frame
+      # time so we can re-resolve it later if its contextId is churned by
+      # lightpanda-io/browser#2400. id/name/src are tried in order; `index`
+      # (position among iframes in the owning document) is the last-resort
+      # fallback when none of the attributes is present.
+      CAPTURE_FRAME_LOCATOR_JS = <<~JS
+        function() {
+          var siblings = this.ownerDocument.querySelectorAll('iframe');
+          var index = -1;
+          for (var i = 0; i < siblings.length; i++) {
+            if (siblings[i] === this) { index = i; break; }
+          }
+          return {
+            id: this.getAttribute('id'),
+            name: this.getAttribute('name'),
+            src: this.getAttribute('src'),
+            index: index,
+          };
+        }
+      JS
+      private_constant :CAPTURE_FRAME_LOCATOR_JS
+
+      # Picks the iframe inside `this.contentDocument` matching a locator
+      # produced by CAPTURE_FRAME_LOCATOR_JS. Used to re-resolve a nested
+      # iframe element when its parent iframe has just been refreshed.
+      RESOLVE_NESTED_IFRAME_JS = <<~JS
+        function(locator) {
+          var doc;
+          try { doc = this.contentDocument || (this.contentWindow && this.contentWindow.document); } catch(e) {}
+          if (!doc) return null;
+          var iframes = doc.querySelectorAll('iframe');
+          for (var i = 0; i < iframes.length; i++) {
+            var f = iframes[i];
+            if (locator.id && f.getAttribute('id') === locator.id) return f;
+            if (locator.name && f.getAttribute('name') === locator.name) return f;
+            if (locator.src && f.getAttribute('src') === locator.src) return f;
+          }
+          if (typeof locator.index === 'number' && locator.index >= 0 && locator.index < iframes.length) {
+            return iframes[locator.index];
+          }
+          return null;
+        }
+      JS
+      private_constant :RESOLVE_NESTED_IFRAME_JS
+
+      # Same shape as RESOLVE_NESTED_IFRAME_JS but reads `document` directly
+      # for the top-level case where `this` is unbound (Runtime.evaluate).
+      RESOLVE_ROOT_IFRAME_JS = <<~JS
+        (function(locator) {
+          var iframes = document.querySelectorAll('iframe');
+          for (var i = 0; i < iframes.length; i++) {
+            var f = iframes[i];
+            if (locator.id && f.getAttribute('id') === locator.id) return f;
+            if (locator.name && f.getAttribute('name') === locator.name) return f;
+            if (locator.src && f.getAttribute('src') === locator.src) return f;
+          }
+          if (typeof locator.index === 'number' && locator.index >= 0 && locator.index < iframes.length) {
+            return iframes[locator.index];
+          }
+          return null;
+        })
+      JS
+      private_constant :RESOLVE_ROOT_IFRAME_JS
+
+      # Lightweight stand-in for a Node when refresh_frame_stack! re-resolves
+      # an iframe. The only field anyone reads off frame_stack entries is
+      # remote_object_id (browser.rb find_in_frame, driver.rb frame_url /
+      # frame_title), so a Struct with that one field is sufficient and
+      # avoids constructing real Node instances (which need a Driver ref).
+      FrameRef = Struct.new(:remote_object_id)
+      private_constant :FrameRef
+
       def find_in_document(method, selector)
         with_default_context_wait do
           # Coerce Symbol selectors (e.g. Capybara warning path lets `have_css(:p)`
           # through) to a string before quoting. Symbol#inspect returns `:p`,
           # which would inject a bare token into the JS source.
           selector_literal = selector.to_s.inspect
+          # XPath parse errors return [] silently to match Capybara's expected
+          # "not found" behavior (see FIND_WITHIN_JS comment above for why).
           js = if method == "xpath"
-                 "(typeof _lightpanda !== 'undefined') ? _lightpanda.xpathFind(#{selector_literal}, document) : []"
+                 <<~XPATH_FIND
+                   (function() {
+                     try {
+                       var r = document.evaluate(#{selector_literal}, document, null, 7, null);
+                       var nodes = [];
+                       for (var i = 0; i < r.snapshotLength; i++) nodes.push(r.snapshotItem(i));
+                       return nodes;
+                     } catch(e) { return []; }
+                   })()
+                 XPATH_FIND
                else
                  <<~CSS_FIND
                    (function() {
@@ -689,10 +790,27 @@ module Capybara
       end
 
       def find_in_frame(method, selector)
-        frame_node = @frame_stack.last
-        result = call_function_on(frame_node.remote_object_id, FIND_IN_FRAME_JS, method, selector,
-                                  return_by_value: false)
-        extract_node_object_ids(result)
+        refreshed = false
+        begin
+          with_default_context_wait do
+            frame_node = @frame_stack.last
+            result = call_function_on(frame_node.remote_object_id, FIND_IN_FRAME_JS, method, selector,
+                                      return_by_value: false)
+            extract_node_object_ids(result)
+          end
+        rescue NoExecutionContextError
+          # Issue #2400: a child iframe navigation re-emits executionContextCreated
+          # for the main-frame V8 context under the child's frameId, churning the
+          # iframe's executionContextId. Our stored remote_object_id is bound to
+          # the old contextId, so callFunctionOn raises "Cannot find context with
+          # specified id". with_default_context_wait can't help — the default
+          # context is fine; only the iframe handle is stale. Re-resolve the
+          # stack from locators captured at push_frame time and retry once.
+          raise if refreshed || !refresh_frame_stack!
+
+          refreshed = true
+          retry
+        end
       rescue JavaScriptError => e
         raise_invalid_selector(e, method, selector)
       end
@@ -705,6 +823,63 @@ module Capybara
         raise js_error
       end
 
+      # Snapshot iframe identifying attributes at push_frame time so we can
+      # re-find the element after lightpanda-io/browser#2400 churns its
+      # contextId. Returns a Hash on success or nil if the call fails — the
+      # latter blocks refresh attempts for this stack entry but leaves the
+      # original behaviour intact (caller falls through to the upstream
+      # error). Best-effort: never raises.
+      def capture_frame_locator(node)
+        call_function_on(node.remote_object_id, CAPTURE_FRAME_LOCATOR_JS)
+      rescue BrowserError
+        nil
+      end
+
+      # Re-resolve every level of @frame_stack from locators captured at
+      # push_frame time. Replaces stack entries in-place with FrameRef
+      # holders whose objectIds are bound to the current contextId.
+      # Returns true on success, false if any level can't be resolved
+      # (missing locator, iframe removed from DOM, fresh CDP error).
+      # Called from find_in_frame on NoExecutionContextError; failure is
+      # not fatal — the caller re-raises the original error.
+      def refresh_frame_stack!
+        return false if @frame_stack.empty?
+        return false if @frame_locators.any?(&:nil?)
+
+        fresh = []
+        @frame_locators.each_with_index do |locator, level|
+          node = level.zero? ? resolve_root_iframe(locator) : resolve_nested_iframe(fresh.last, locator)
+          return false unless node
+
+          fresh << node
+        end
+
+        @frame_stack.replace(fresh)
+        true
+      rescue BrowserError
+        false
+      end
+
+      def resolve_root_iframe(locator)
+        # Runtime.evaluate doesn't accept call arguments, so inline the
+        # locator as a JSON literal into the invocation expression. The
+        # locator was captured from the browser's own getAttribute reads
+        # at push_frame time, so JSON.generate is safe.
+        expression = "(#{RESOLVE_ROOT_IFRAME_JS})(#{locator.to_json})"
+        result = evaluate_with_ref(expression)
+        return nil unless result && result["objectId"]
+
+        FrameRef.new(result["objectId"])
+      end
+
+      def resolve_nested_iframe(parent, locator)
+        result = call_function_on(parent.remote_object_id, RESOLVE_NESTED_IFRAME_JS, locator,
+                                  return_by_value: false)
+        return nil unless result && result["objectId"]
+
+        FrameRef.new(result["objectId"])
+      end
+
       # Extract individual node objectIds from a remote array reference.
       def extract_node_object_ids(result)
         return [] unless result && result["objectId"]
@@ -1012,6 +1187,21 @@ 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"])
+      end
+
       # Common navigation lifecycle shared by `wait_for_page_load` (fresh
       # `Page.navigate`) and `wait_for_navigation` (back / forward / reload).
       # Subscribes to Page.loadEventFired, runs the trigger, waits briefly for

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

@@ -69,748 +69,9 @@
     _signalTurbo('idle');
   });
 
-  // ====== XPath 1.0 Evaluator ======
-
-  var XPathEval = (function() {
-
-    // --- Tokenizer ---
-
-    var NODE_TYPES = {text:1, node:1, comment:1, 'processing-instruction':1};
-
-    function tokenize(expr) {
-      var toks = [], i = 0, len = expr.length;
-      while (i < len) {
-        // Skip whitespace
-        while (i < len && ' \t\n\r'.indexOf(expr[i]) >= 0) i++;
-        if (i >= len) break;
-        var c = expr[i];
-
-        // String literals
-        if (c === '"' || c === "'") {
-          var q = c, s = ++i;
-          while (i < len && expr[i] !== q) i++;
-          toks.push({t: 'S', v: expr.substring(s, i)});
-          i++;
-          continue;
-        }
-
-        // Numbers: digits or . followed by digit
-        if (c >= '0' && c <= '9' || (c === '.' && i + 1 < len && expr[i + 1] >= '0' && expr[i + 1] <= '9')) {
-          var s = i;
-          while (i < len && expr[i] >= '0' && expr[i] <= '9') i++;
-          if (i < len && expr[i] === '.') { i++; while (i < len && expr[i] >= '0' && expr[i] <= '9') i++; }
-          toks.push({t: 'D', v: parseFloat(expr.substring(s, i))});
-          continue;
-        }
-
-        // Double-char operators
-        if (i + 1 < len) {
-          var c2 = expr[i + 1];
-          if (c === '/' && c2 === '/') { toks.push({t: '//'}); i += 2; continue; }
-          if (c === ':' && c2 === ':') { toks.push({t: '::'}); i += 2; continue; }
-          if (c === '!' && c2 === '=') { toks.push({t: '!='}); i += 2; continue; }
-          if (c === '<' && c2 === '=') { toks.push({t: '<='}); i += 2; continue; }
-          if (c === '>' && c2 === '=') { toks.push({t: '>='}); i += 2; continue; }
-          if (c === '.' && c2 === '.') { toks.push({t: '..'}); i += 2; continue; }
-        }
-
-        // Single-char operators
-        if ('()[],|=<>+-*$/@.'.indexOf(c) >= 0) { toks.push({t: c}); i++; continue; }
-
-        // Names (NCName, possibly with namespace prefix)
-        if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c === '_') {
-          var s = i;
-          while (i < len && /[a-zA-Z0-9_\-.]/.test(expr[i])) i++;
-          var name = expr.substring(s, i);
-          // Check for namespace prefix (name:localname but not name::)
-          if (i < len && expr[i] === ':' && (i + 1 >= len || expr[i + 1] !== ':')) {
-            i++; // skip :
-            if (i < len && expr[i] === '*') { name += ':*'; i++; }
-            else { var ls = i; while (i < len && /[a-zA-Z0-9_\-.]/.test(expr[i])) i++; name += ':' + expr.substring(ls, i); }
-          }
-          toks.push({t: 'N', v: name});
-          continue;
-        }
-
-        i++; // skip unknown characters
-      }
-      toks.push({t: 'E'}); // EOF
-      return toks;
-    }
-
-    // --- Parser ---
-    // Recursive descent parser producing an AST from XPath 1.0 tokens.
-
-    function Parser(tokens) { this.tk = tokens; this.p = 0; }
-
-    Parser.prototype.peek = function() { return this.tk[this.p]; };
-    Parser.prototype.next = function() { return this.tk[this.p++]; };
-    Parser.prototype.expect = function(t) {
-      var tok = this.next();
-      if (tok.t !== t) throw new Error('XPath parse error: expected ' + t + ', got ' + tok.t);
-      return tok;
-    };
-    Parser.prototype.at = function(t) { return this.peek().t === t; };
-    Parser.prototype.match = function(t) { if (this.at(t)) { this.p++; return true; } return false; };
-    Parser.prototype.lookahead = function(offset) { return this.tk[this.p + offset] || {t: 'E'}; };
-
-    Parser.prototype.parseExpr = function() { return this.parseOrExpr(); };
-
-    Parser.prototype.parseOrExpr = function() {
-      var left = this.parseAndExpr();
-      while (this.peek().t === 'N' && this.peek().v === 'or') { this.next(); left = {op: 'or', l: left, r: this.parseAndExpr()}; }
-      return left;
-    };
-
-    Parser.prototype.parseAndExpr = function() {
-      var left = this.parseEqualityExpr();
-      while (this.peek().t === 'N' && this.peek().v === 'and') { this.next(); left = {op: 'and', l: left, r: this.parseEqualityExpr()}; }
-      return left;
-    };
-
-    Parser.prototype.parseEqualityExpr = function() {
-      var left = this.parseRelationalExpr();
-      while (this.at('=') || this.at('!=')) {
-        var op = this.next().t === '=' ? 'eq' : 'neq';
-        left = {op: op, l: left, r: this.parseRelationalExpr()};
-      }
-      return left;
-    };
-
-    Parser.prototype.parseRelationalExpr = function() {
-      var left = this.parseAdditiveExpr();
-      while (true) {
-        var t = this.peek().t, op;
-        if (t === '<') op = 'lt'; else if (t === '>') op = 'gt'; else if (t === '<=') op = 'lte'; else if (t === '>=') op = 'gte'; else break;
-        this.next();
-        left = {op: op, l: left, r: this.parseAdditiveExpr()};
-      }
-      return left;
-    };
-
-    Parser.prototype.parseAdditiveExpr = function() {
-      var left = this.parseMultExpr();
-      while (this.at('+') || this.at('-')) {
-        var op = this.next().t === '+' ? 'add' : 'sub';
-        left = {op: op, l: left, r: this.parseMultExpr()};
-      }
-      return left;
-    };
-
-    // After a complete unary expression, * is multiply; div/mod are operators
-    Parser.prototype.parseMultExpr = function() {
-      var left = this.parseUnaryExpr();
-      while (true) {
-        var t = this.peek(), op;
-        if (t.t === '*') op = 'mul';
-        else if (t.t === 'N' && t.v === 'div') op = 'div';
-        else if (t.t === 'N' && t.v === 'mod') op = 'mod';
-        else break;
-        this.next();
-        left = {op: op, l: left, r: this.parseUnaryExpr()};
-      }
-      return left;
-    };
-
-    Parser.prototype.parseUnaryExpr = function() {
-      if (this.at('-')) { this.next(); return {op: 'neg', a: this.parseUnaryExpr()}; }
-      return this.parseUnionExpr();
-    };
-
-    Parser.prototype.parseUnionExpr = function() {
-      var left = this.parsePathExpr();
-      while (this.match('|')) { left = {op: 'union', l: left, r: this.parsePathExpr()}; }
-      return left;
-    };
-
-    // Distinguishes filter expressions (starting with primary) from location paths
-    Parser.prototype.parsePathExpr = function() {
-      var t = this.peek();
-
-      // Absolute path: / or //
-      if (t.t === '/' || t.t === '//') return this.parseAbsPath();
-
-      // Check if this starts a filter expression (primary expr)
-      var isFilter = false;
-      if (t.t === '(' || t.t === 'S' || t.t === 'D' || t.t === '$') isFilter = true;
-      else if (t.t === 'N' && this.lookahead(1).t === '(' && !NODE_TYPES[t.v]) isFilter = true;
-
-      if (isFilter) {
-        var primary = this.parsePrimaryExpr();
-        // Parse predicates on the filter expression
-        while (this.at('[')) { this.next(); var pred = this.parseExpr(); this.expect(']'); primary = {op: 'filt', e: primary, pred: pred}; }
-        // Optional / or // after filter
-        if (this.at('/') || this.at('//')) {
-          var dsl = this.next().t === '//';
-          var steps = this.parseRelSteps();
-          if (dsl) steps.unshift({ax: 'descendant-or-self', test: {ty: 'type', nt: 'node'}, preds: []});
-          return {op: 'fpath', f: primary, steps: steps};
-        }
-        return primary;
-      }
-
-      // Relative location path
-      return this.parseRelPath();
-    };
-
-    Parser.prototype.parseAbsPath = function() {
-      var steps = [];
-      if (this.match('//')) {
-        steps.push({ax: 'descendant-or-self', test: {ty: 'type', nt: 'node'}, preds: []});
-        steps = steps.concat(this.parseRelSteps());
-      } else {
-        this.expect('/');
-        if (this.canStartStep()) steps = this.parseRelSteps();
-      }
-      return {op: 'path', abs: true, steps: steps};
-    };
-
-    Parser.prototype.parseRelPath = function() {
-      return {op: 'path', abs: false, steps: this.parseRelSteps()};
-    };
-
-    Parser.prototype.parseRelSteps = function() {
-      var steps = [this.parseStep()];
-      while (this.at('/') || this.at('//')) {
-        if (this.next().t === '//') steps.push({ax: 'descendant-or-self', test: {ty: 'type', nt: 'node'}, preds: []});
-        steps.push(this.parseStep());
-      }
-      return steps;
-    };
-
-    Parser.prototype.canStartStep = function() {
-      var t = this.peek().t;
-      return t === 'N' || t === '*' || t === '.' || t === '..' || t === '@';
-    };
-
-    Parser.prototype.parseStep = function() {
-      // Abbreviated steps
-      if (this.match('.')) return {ax: 'self', test: {ty: 'type', nt: 'node'}, preds: []};
-      if (this.match('..')) return {ax: 'parent', test: {ty: 'type', nt: 'node'}, preds: []};
-
-      // Determine axis
-      var axis = 'child';
-      if (this.match('@')) {
-        axis = 'attribute';
-      } else if (this.peek().t === 'N' && this.lookahead(1).t === '::') {
-        axis = this.next().v; this.next(); // consume name and ::
-      }
-
-      // Node test
-      var test;
-      if (this.match('*')) {
-        test = {ty: 'name', n: '*'};
-      } else if (this.peek().t === 'N') {
-        var name = this.peek().v;
-        if (NODE_TYPES[name] && this.lookahead(1).t === '(') {
-          this.next(); this.next(); // consume name and (
-          if (name === 'processing-instruction' && this.at('S')) this.next(); // optional literal
-          this.expect(')');
-          test = {ty: 'type', nt: name};
-        } else {
-          this.next();
-          test = {ty: 'name', n: name};
-        }
-      } else {
-        throw new Error('XPath parse error: expected node test, got ' + this.peek().t);
-      }
-
-      // Predicates
-      var preds = [];
-      while (this.at('[')) { this.next(); preds.push(this.parseExpr()); this.expect(']'); }
-
-      return {ax: axis, test: test, preds: preds};
-    };
-
-    Parser.prototype.parsePrimaryExpr = function() {
-      if (this.at('S')) { var v = this.next().v; return {op: 'lit', v: v}; }
-      if (this.at('D')) { var v = this.next().v; return {op: 'num', v: v}; }
-      if (this.match('$')) { return {op: 'var', v: this.expect('N').v}; }
-      if (this.match('(')) { var e = this.parseExpr(); this.expect(')'); return e; }
-      if (this.at('N')) {
-        var name = this.next().v;
-        this.expect('(');
-        var args = [];
-        if (!this.at(')')) {
-          args.push(this.parseExpr());
-          while (this.match(',')) args.push(this.parseExpr());
-        }
-        this.expect(')');
-        return {op: 'fn', name: name, args: args};
-      }
-      throw new Error('XPath parse error: expected primary expression, got ' + this.peek().t);
-    };
-
-    // --- Evaluator Utilities ---
-
-    function stringVal(node) {
-      if (!node) return '';
-      if (node.nodeType === 1 || node.nodeType === 9) return node.textContent || '';
-      if (node.nodeType === 2) return node.value || '';
-      return node.nodeValue || node.textContent || '';
-    }
-
-    function toStr(val) {
-      if (Array.isArray(val)) return val.length > 0 ? stringVal(val[0]) : '';
-      if (typeof val === 'boolean') return val ? 'true' : 'false';
-      if (typeof val === 'number') return isNaN(val) ? 'NaN' : String(val);
-      return String(val);
-    }
-
-    function toNum(val) {
-      if (typeof val === 'number') return val;
-      if (typeof val === 'boolean') return val ? 1 : 0;
-      if (Array.isArray(val)) val = toStr(val);
-      var s = String(val).trim();
-      return s === '' ? NaN : Number(s);
-    }
-
-    function toBool(val) {
-      if (Array.isArray(val)) return val.length > 0;
-      if (typeof val === 'string') return val.length > 0;
-      if (typeof val === 'number') return val !== 0 && !isNaN(val);
-      return Boolean(val);
-    }
-
-    // --- Comparison ---
-
-    function cmpOp(a, b, op) {
-      switch (op) {
-        case 'eq': return a === b;
-        case 'neq': return a !== b;
-        case 'lt': return a < b;
-        case 'gt': return a > b;
-        case 'lte': return a <= b;
-        case 'gte': return a >= b;
-      }
-      return false;
-    }
-
-    // XPath comparison with type coercion rules per spec section 3.4
-    function xCmp(left, right, op) {
-      var isEq = (op === 'eq' || op === 'neq');
-      var lArr = Array.isArray(left), rArr = Array.isArray(right);
-
-      // Both node-sets
-      if (lArr && rArr) {
-        for (var i = 0; i < left.length; i++) {
-          var lv = stringVal(left[i]);
-          for (var j = 0; j < right.length; j++) {
-            if (isEq ? cmpOp(lv, stringVal(right[j]), op) : cmpOp(toNum(lv), toNum(stringVal(right[j])), op)) return true;
-          }
-        }
-        return false;
-      }
-
-      // One node-set, one scalar
-      if (lArr || rArr) {
-        var ns = lArr ? left : right, other = lArr ? right : left, nsLeft = lArr;
-
-        // Boolean comparison: convert node-set to boolean
-        if (typeof other === 'boolean') {
-          var b = ns.length > 0;
-          return cmpOp(nsLeft ? b : other, nsLeft ? other : b, op);
-        }
-
-        for (var i = 0; i < ns.length; i++) {
-          var sv = stringVal(ns[i]);
-          var a, b;
-          if (typeof other === 'number') {
-            a = nsLeft ? toNum(sv) : other;
-            b = nsLeft ? other : toNum(sv);
-          } else if (isEq) {
-            a = nsLeft ? sv : String(other);
-            b = nsLeft ? String(other) : sv;
-          } else {
-            a = nsLeft ? toNum(sv) : toNum(String(other));
-            b = nsLeft ? toNum(String(other)) : toNum(sv);
-          }
-          if (cmpOp(a, b, op)) return true;
-        }
-        return false;
-      }
-
-      // Neither is a node-set
-      if (isEq) {
-        if (typeof left === 'boolean' || typeof right === 'boolean') return cmpOp(toBool(left), toBool(right), op);
-        if (typeof left === 'number' || typeof right === 'number') return cmpOp(toNum(left), toNum(right), op);
-        return cmpOp(toStr(left), toStr(right), op);
-      }
-      return cmpOp(toNum(left), toNum(right), op);
-    }
-
-    // --- Axis Traversal ---
-
-    function addDesc(node, out) {
-      var c = node.firstChild;
-      while (c) { out.push(c); addDesc(c, out); c = c.nextSibling; }
-    }
-
-    function addFollowing(node, out) {
-      var n = node;
-      while (n) {
-        var s = n.nextSibling;
-        while (s) { out.push(s); addDesc(s, out); s = s.nextSibling; }
-        n = n.parentNode;
-      }
-    }
-
-    function addPrecedingSubtree(node, out) {
-      var c = node.lastChild;
-      while (c) { addPrecedingSubtree(c, out); c = c.previousSibling; }
-      out.push(node);
-    }
-
-    function addPreceding(node, out) {
-      var n = node;
-      while (n.parentNode) {
-        var s = n.previousSibling;
-        while (s) { addPrecedingSubtree(s, out); s = s.previousSibling; }
-        n = n.parentNode;
-      }
-    }
-
-    function getAxisNodes(node, axis) {
-      var out = [], c, p;
-      switch (axis) {
-        case 'child':
-          c = node.firstChild; while (c) { out.push(c); c = c.nextSibling; } break;
-        case 'descendant':
-          addDesc(node, out); break;
-        case 'descendant-or-self':
-          out.push(node); addDesc(node, out); break;
-        case 'self':
-          out.push(node); break;
-        case 'parent':
-          if (node.parentNode) out.push(node.parentNode); break;
-        case 'ancestor':
-          // Reverse axis — emit in PROXIMITY order (nearest first) so positional
-          // predicates evaluate correctly: ancestor::*[1] picks the parent, not
-          // the root. The final node-set is sorted into document order at the
-          // XPathEval.find entry point per the XPath spec.
-          p = node.parentNode; while (p) { out.push(p); p = p.parentNode; } break;
-        case 'ancestor-or-self':
-          out.push(node); p = node.parentNode; while (p) { out.push(p); p = p.parentNode; } break;
-        case 'following-sibling':
-          c = node.nextSibling; while (c) { out.push(c); c = c.nextSibling; } break;
-        case 'preceding-sibling':
-          // Reverse axis — emit in proximity order (closest first).
-          c = node.previousSibling; while (c) { out.push(c); c = c.previousSibling; } break;
-        case 'following':
-          addFollowing(node, out); break;
-        case 'preceding':
-          addPreceding(node, out); break;
-        case 'attribute':
-          if (node.attributes) { for (var i = 0; i < node.attributes.length; i++) out.push(node.attributes[i]); } break;
-        case 'namespace':
-          break; // stub
-      }
-      return out;
-    }
-
-    // --- Node Test Matching ---
-
-    function matchTest(node, test, axis) {
-      if (test.ty === 'type') {
-        switch (test.nt) {
-          case 'node': return true;
-          case 'text': return node.nodeType === 3;
-          case 'comment': return node.nodeType === 8;
-          case 'processing-instruction': return node.nodeType === 7;
-        }
-        return false;
-      }
-      // Name test
-      if (axis === 'attribute') {
-        return test.n === '*' || (node.name || node.nodeName || '').toLowerCase() === test.n.toLowerCase();
-      }
-      if (node.nodeType !== 1) return false;
-      if (test.n === '*') return true;
-      return node.nodeName.toLowerCase() === test.n.toLowerCase();
-    }
-
-    // --- Step Evaluation ---
-
-    function evalStep(ctxNodes, step) {
-      var result = [];
-      for (var i = 0; i < ctxNodes.length; i++) {
-        var axNodes = getAxisNodes(ctxNodes[i], step.ax);
-        // Filter by node test
-        var filtered = [];
-        for (var j = 0; j < axNodes.length; j++) {
-          if (matchTest(axNodes[j], step.test, step.ax)) filtered.push(axNodes[j]);
-        }
-        // Apply predicates
-        var cur = filtered;
-        for (var p = 0; p < step.preds.length; p++) {
-          var newCur = [], sz = cur.length;
-          for (var k = 0; k < cur.length; k++) {
-            var val = evaluate(step.preds[p], cur[k], k + 1, sz);
-            if (typeof val === 'number') { if (val === k + 1) newCur.push(cur[k]); }
-            else { if (toBool(val)) newCur.push(cur[k]); }
-          }
-          cur = newCur;
-        }
-        // Add to result, dedup
-        for (var k = 0; k < cur.length; k++) {
-          if (result.indexOf(cur[k]) < 0) result.push(cur[k]);
-        }
-      }
-      return result;
-    }
-
-    // --- Document Order Sort ---
-
-    function sortDocOrder(nodes) {
-      if (nodes.length <= 1) return nodes;
-      if (nodes[0] && typeof nodes[0].compareDocumentPosition === 'function') {
-        return nodes.sort(function(a, b) {
-          if (a === b) return 0;
-          var pos = a.compareDocumentPosition(b);
-          return (pos & 4) ? -1 : (pos & 2) ? 1 : 0;
-        });
-      }
-      return nodes;
-    }
-
-    // --- AST Evaluation ---
-
-    function evaluate(ast, ctx, pos, size) {
-      if (!ast || !ast.op) {
-        // Step node (from path parsing)
-        if (ast && ast.ax) return evalStep([ctx], ast);
-        throw new Error('XPath eval error: invalid AST node');
-      }
-
-      switch (ast.op) {
-        case 'path': {
-          var nodes;
-          if (ast.abs) {
-            nodes = [ctx.nodeType === 9 ? ctx : (ctx.ownerDocument || ctx)];
-          } else {
-            nodes = [ctx];
-          }
-          for (var i = 0; i < ast.steps.length; i++) nodes = evalStep(nodes, ast.steps[i]);
-          return nodes;
-        }
-
-        case 'fpath': {
-          var base = evaluate(ast.f, ctx, pos, size);
-          if (!Array.isArray(base)) return base;
-          for (var i = 0; i < ast.steps.length; i++) base = evalStep(base, ast.steps[i]);
-          return base;
-        }
-
-        case 'filt': {
-          var base = evaluate(ast.e, ctx, pos, size);
-          if (!Array.isArray(base)) return base;
-          var out = [], sz = base.length;
-          for (var i = 0; i < base.length; i++) {
-            var val = evaluate(ast.pred, base[i], i + 1, sz);
-            if (typeof val === 'number') { if (val === i + 1) out.push(base[i]); }
-            else { if (toBool(val)) out.push(base[i]); }
-          }
-          return out;
-        }
-
-        case 'or': return toBool(evaluate(ast.l, ctx, pos, size)) || toBool(evaluate(ast.r, ctx, pos, size));
-        case 'and': return toBool(evaluate(ast.l, ctx, pos, size)) && toBool(evaluate(ast.r, ctx, pos, size));
-
-        case 'eq': case 'neq': case 'lt': case 'gt': case 'lte': case 'gte':
-          return xCmp(evaluate(ast.l, ctx, pos, size), evaluate(ast.r, ctx, pos, size), ast.op);
-
-        case 'add': return toNum(evaluate(ast.l, ctx, pos, size)) + toNum(evaluate(ast.r, ctx, pos, size));
-        case 'sub': return toNum(evaluate(ast.l, ctx, pos, size)) - toNum(evaluate(ast.r, ctx, pos, size));
-        case 'mul': return toNum(evaluate(ast.l, ctx, pos, size)) * toNum(evaluate(ast.r, ctx, pos, size));
-        case 'div': return toNum(evaluate(ast.l, ctx, pos, size)) / toNum(evaluate(ast.r, ctx, pos, size));
-        case 'mod': return toNum(evaluate(ast.l, ctx, pos, size)) % toNum(evaluate(ast.r, ctx, pos, size));
-        case 'neg': return -toNum(evaluate(ast.a, ctx, pos, size));
-
-        case 'union': {
-          var l = evaluate(ast.l, ctx, pos, size), r = evaluate(ast.r, ctx, pos, size);
-          if (!Array.isArray(l) || !Array.isArray(r)) throw new Error('Union requires node-sets');
-          var merged = l.slice();
-          for (var i = 0; i < r.length; i++) { if (merged.indexOf(r[i]) < 0) merged.push(r[i]); }
-          return sortDocOrder(merged);
-        }
-
-        case 'lit': return ast.v;
-        case 'num': return ast.v;
-        case 'var': return '';
-        case 'fn': return evalFunc(ast.name, ast.args, ctx, pos, size);
-      }
-
-      throw new Error('XPath eval error: unknown op ' + ast.op);
-    }
-
-    // --- XPath Functions ---
-
-    function evalFunc(name, args, ctx, pos, size) {
-      switch (name) {
-        // -- Node-set functions --
-        case 'position': return pos;
-        case 'last': return size;
-        case 'count': {
-          var ns = evaluate(args[0], ctx, pos, size);
-          return Array.isArray(ns) ? ns.length : 0;
-        }
-        case 'id': {
-          var val = evaluate(args[0], ctx, pos, size);
-          var idStr;
-          if (Array.isArray(val)) { idStr = []; for (var i = 0; i < val.length; i++) idStr.push(stringVal(val[i])); idStr = idStr.join(' '); }
-          else idStr = toStr(val);
-          var ids = idStr.split(/\s+/), doc = ctx.ownerDocument || ctx, nodes = [];
-          for (var i = 0; i < ids.length; i++) {
-            if (ids[i]) { var el = doc.getElementById(ids[i]); if (el && nodes.indexOf(el) < 0) nodes.push(el); }
-          }
-          return nodes;
-        }
-        case 'local-name': {
-          var ns = args.length === 0 ? [ctx] : evaluate(args[0], ctx, pos, size);
-          if (!Array.isArray(ns) || ns.length === 0) return '';
-          return (ns[0].localName || ns[0].nodeName || '').toLowerCase();
-        }
-        case 'name': case 'namespace-uri': {
-          if (name === 'namespace-uri') return '';
-          var ns = args.length === 0 ? [ctx] : evaluate(args[0], ctx, pos, size);
-          if (!Array.isArray(ns) || ns.length === 0) return '';
-          return (ns[0].nodeName || '').toLowerCase();
-        }
-
-        // -- String functions --
-        case 'string':
-          return args.length === 0 ? stringVal(ctx) : toStr(evaluate(args[0], ctx, pos, size));
-        case 'concat': {
-          var r = '';
-          for (var i = 0; i < args.length; i++) r += toStr(evaluate(args[i], ctx, pos, size));
-          return r;
-        }
-        case 'contains': {
-          var s1 = toStr(evaluate(args[0], ctx, pos, size));
-          var s2 = toStr(evaluate(args[1], ctx, pos, size));
-          return s1.indexOf(s2) >= 0;
-        }
-        case 'starts-with': {
-          var s1 = toStr(evaluate(args[0], ctx, pos, size));
-          var s2 = toStr(evaluate(args[1], ctx, pos, size));
-          return s1.indexOf(s2) === 0;
-        }
-        case 'substring': {
-          var s = toStr(evaluate(args[0], ctx, pos, size));
-          var start = Math.round(toNum(evaluate(args[1], ctx, pos, size)));
-          if (isNaN(start)) return '';
-          if (args.length >= 3) {
-            var len = Math.round(toNum(evaluate(args[2], ctx, pos, size)));
-            if (isNaN(len)) return '';
-            var si = Math.max(start - 1, 0), ei = Math.min(start - 1 + len, s.length);
-            return si >= ei ? '' : s.substring(si, ei);
-          }
-          return s.substring(Math.max(start - 1, 0));
-        }
-        case 'substring-before': {
-          var s1 = toStr(evaluate(args[0], ctx, pos, size));
-          var s2 = toStr(evaluate(args[1], ctx, pos, size));
-          var idx = s1.indexOf(s2);
-          return idx >= 0 ? s1.substring(0, idx) : '';
-        }
-        case 'substring-after': {
-          var s1 = toStr(evaluate(args[0], ctx, pos, size));
-          var s2 = toStr(evaluate(args[1], ctx, pos, size));
-          var idx = s1.indexOf(s2);
-          return idx >= 0 ? s1.substring(idx + s2.length) : '';
-        }
-        case 'string-length': {
-          var s = args.length === 0 ? stringVal(ctx) : toStr(evaluate(args[0], ctx, pos, size));
-          return s.length;
-        }
-        case 'normalize-space': {
-          var s = args.length === 0 ? stringVal(ctx) : toStr(evaluate(args[0], ctx, pos, size));
-          return s.replace(/^\s+|\s+$/g, '').replace(/\s+/g, ' ');
-        }
-        case 'translate': {
-          var s = toStr(evaluate(args[0], ctx, pos, size));
-          var from = toStr(evaluate(args[1], ctx, pos, size));
-          var to = toStr(evaluate(args[2], ctx, pos, size));
-          var r = '';
-          for (var i = 0; i < s.length; i++) {
-            var idx = from.indexOf(s[i]);
-            if (idx < 0) r += s[i];
-            else if (idx < to.length) r += to[idx];
-            // else: character removed
-          }
-          return r;
-        }
-
-        // -- Boolean functions --
-        case 'boolean': return toBool(evaluate(args[0], ctx, pos, size));
-        case 'not': return !toBool(evaluate(args[0], ctx, pos, size));
-        case 'true': return true;
-        case 'false': return false;
-        case 'lang': return false; // stub
-
-        // -- Number functions --
-        case 'number':
-          return args.length === 0 ? toNum(stringVal(ctx)) : toNum(evaluate(args[0], ctx, pos, size));
-        case 'sum': {
-          var ns = evaluate(args[0], ctx, pos, size);
-          if (!Array.isArray(ns)) return NaN;
-          var total = 0;
-          for (var i = 0; i < ns.length; i++) total += toNum(stringVal(ns[i]));
-          return total;
-        }
-        case 'floor': return Math.floor(toNum(evaluate(args[0], ctx, pos, size)));
-        case 'ceiling': return Math.ceil(toNum(evaluate(args[0], ctx, pos, size)));
-        case 'round': {
-          var n = toNum(evaluate(args[0], ctx, pos, size));
-          if (isNaN(n) || !isFinite(n)) return n;
-          return Math.round(n);
-        }
-      }
-      throw new Error('XPath error: unknown function ' + name + '()');
-    }
-
-    // --- Public API ---
-    return {
-      find: function(expression, contextNode) {
-        var tokens = tokenize(expression);
-        var parser = new Parser(tokens);
-        var ast = parser.parseExpr();
-        var result = evaluate(ast, contextNode, 1, 1);
-        // XPath spec: deliver the final node-set in document order. Internal
-        // step results are kept in axis order for predicate semantics; we sort
-        // here, at the public entry, so consumers see ordered results.
-        return Array.isArray(result) ? sortDocOrder(result) : [];
-      }
-    };
-  })();
-
   // --- Main API ---
 
   window._lightpanda = {
-    xpathFind: function(expression, contextNode) {
-      // Use native XPath if available (non-polyfilled)
-      if (typeof contextNode.evaluate === 'function' && typeof XPathResult !== 'undefined' &&
-          !XPathResult._polyfilled) {
-        try {
-          var result = contextNode.evaluate(expression, contextNode, null,
-            XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
-          var nodes = [];
-          for (var i = 0; i < result.snapshotLength; i++) {
-            nodes.push(result.snapshotItem(i));
-          }
-          return nodes;
-        } catch(e) {
-          // Fall through to polyfill
-        }
-      }
-
-      try {
-        return XPathEval.find(expression, contextNode);
-      } catch(e) {
-        return [];
-      }
-    },
-
     turbo: {
       pending: function() { return _pendingTurboOps; },
       idle: function() { return _pendingTurboOps <= 0; }
@@ -975,24 +236,4 @@
       return walk(el);
     }
   };
-
-  // --- XPathResult polyfill ---
-
-  if (typeof XPathResult === 'undefined') {
-    window.XPathResult = {
-      ORDERED_NODE_SNAPSHOT_TYPE: 7,
-      FIRST_ORDERED_NODE_TYPE: 9,
-      _polyfilled: true
-    };
-  }
-  if (!document.evaluate) {
-    document.evaluate = function(expression, contextNode) {
-      var nodes = window._lightpanda.xpathFind(expression, contextNode);
-      return {
-        snapshotLength: nodes.length,
-        snapshotItem: function(i) { return nodes[i] || null; },
-        singleNodeValue: nodes[0] || null
-      };
-    };
-  }
 })();

data/lib/capybara/lightpanda/node.rb

@@ -372,15 +372,14 @@ module Capybara
       # 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.
+      # Submit buttons (`<input type=submit>`, `<input type=image>`,
+      # `<button type=submit>`): native click on the dispatched MouseEvent
+      # already runs the form-submission default action via Frame.submitForm
+      # in Lightpanda (extension of PR #2312 for image to all submit
+      # variants). A manual `form.requestSubmit(this)` here would fire a
+      # second SubmitEvent and double-submit the form — observed on nightly
+      # 6167 as duplicate `turbo:submit-start` events; the first request
+      # gets aborted by the second and Turbo never renders the response.
       CLICK_JS = <<~JS
         function() {
           var EventCtor = (typeof MouseEvent !== 'undefined') ? MouseEvent : Event;
@@ -388,24 +387,7 @@ module Capybara
           var notCancelled = this.dispatchEvent(clickEvt);
           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) {
-            // Lightpanda raises a JsException from requestSubmit when a
-            // bubble-phase listener (e.g. Turbo's submitBubbled) calls
-            // preventDefault + stopImmediatePropagation on the SubmitEvent.
-            // Per HTML spec a cancelled submission should be a silent no-op.
-            // Log unexpected errors via console.warn so they remain
-            // diagnosable (LIGHTPANDA_DEBUG surfaces console output) instead
-            // of silently swallowing future regressions.
-            try {
-              this.form.requestSubmit(this);
-            } catch (e) {
-              try { console.warn('[capybara-lightpanda] requestSubmit threw:', e && e.message ? e.message : e); } catch (_) {}
-            }
-          } else if (tag === 'A' && this.href && this.target !== '_blank') {
+          if (tag === 'A' && this.href && this.target !== '_blank') {
             // 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

data/lib/capybara/lightpanda/process.rb

@@ -8,8 +8,8 @@ module Capybara
       READY_PATTERN = /server running.*address\s*=\s*(\d+\.\d+\.\d+\.\d+:\d+)/m
       ADDRESS_IN_USE_PATTERN = /err=AddressInUse/
 
-      # Floor for the cookie/navigation/redirect/modal/keyboard/css/forms/dispatch
-      # fixes the gem now relies on: PR #2255 (Network.clearBrowserCookies
+      # Floor for the cookie/navigation/redirect/modal/keyboard/css/forms/dispatch/
+      # xpath/history fixes the gem now relies on: PR #2255 (Network.clearBrowserCookies
       # empty params + Network.getAllCookies), PR #2257
       # (window.location.pathname/.search assignment triggers navigation),
       # PR #2265 (URL fragment inherited across fragment-less redirect),
@@ -25,10 +25,15 @@ module Capybara
       # PR #2342 (<summary> click toggles parent <details>.open),
       # PR #2352 (HTMLInputElement.pattern + patternMismatch via V8 RegExp),
       # PR #2368 (events: report listener exceptions instead of halting
-      # dispatch — lets us drop the polyfills.js patchDispatch IIFE).
-      # Build 6065 = main HEAD 61364437 (2026-05-06, PR #2368 merge);
-      # ships in nightly published 2026-05-06 ~03:30 UTC for all four platforms.
-      MINIMUM_NIGHTLY_BUILD = Gem::Version.new("6065")
+      # dispatch — lets us drop the polyfills.js patchDispatch IIFE),
+      # PR #2289 (Page.getNavigationHistory + Page.navigateToHistoryEntry —
+      # lets us drop the history.back()/history.forward() JS workaround in
+      # Browser#back / #forward), PR #2305 (XPath 1.0: Document.evaluate,
+      # XPathResult, XPathEvaluator, XPathExpression — lets us drop the
+      # ~700 LOC XPath polyfill in javascripts/index.js).
+      # Build 6109 = main HEAD cfcfe4ee (2026-05-11, after PR #2289 and
+      # PR #2305 merges); will ship in nightly published 2026-05-12 ~03:30 UTC.
+      MINIMUM_NIGHTLY_BUILD = Gem::Version.new("6109")
 
       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.2"
+    VERSION = "0.3.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: capybara-lightpanda
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Navid Emad
@@ -115,7 +115,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Capybara driver for the Lightpanda headless browser
 test_files: []