capybara-lightpanda 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 42246ea44b80c592e6779cf2aa95890c7635fb057b0061064b63bf15004dcde6
-  data.tar.gz: 63131038538438b32d39d8e46a36005df0306e8daadaa38ff88540874c6c46aa
+  metadata.gz: 1cb36e68fb7bcc35abcbae5a3417091eb54444f7b57e161cb44cb6436d243684
+  data.tar.gz: 9eff2c5cd278d16ed8ad55d106dca14dab3597a87c3315c46371b98672a35163
 SHA512:
-  metadata.gz: 1728491bdd3d3dac24559cc663ee250af16f90d7944d2c27be0b879ddbfc23a2a00181f39970d7622fd1b640449d97c7d373c4f6a414aae9073dc0f3cf92d1f8
-  data.tar.gz: 47e0408c55b5150347656d8136b6dc993b39d38a051a39efec480e2d913cf799f45c18242fd031bbb6962f79b7a39d63cc2eec8d2c14e2f42f34ed3b029af867
+  metadata.gz: 156126b7f57785869aca23b79fe02bc3fe7370cf5b2826999715d5e69794a6b62f8c69bb64601e5e67f935d946e2348274c8ec76d79b674930b239d6b2383677
+  data.tar.gz: c73dab9284d0d8e0091794e2f88674951bafc64af2fa2e87200926a60d7d86767f31cd5114d5348af51013fe3b4846f1066d0bdca886a5a1051432673b76ef52

data/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## [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.
+
+### Fixed
+
+- Turbo Drive `<form>` submissions now intercept correctly. Forms inside a
+  Hotwire / Turbo Drive page no longer crash on submit, and Turbo's `submit`
+  interceptors fire as they should — `click_button`, `find('form').submit`,
+  and Enter-key implicit submission all complete end-to-end.
+- `evaluate_script` and `execute_script` calls with top-level `const` / `let`
+  no longer collide across calls. Consecutive scripts that each declare the
+  same identifier used to fail with `Identifier 'foo' has already been
+  declared`; they're now isolated. `execute_script` also now raises on
+  JavaScript errors instead of silently swallowing them.
+- Same-document fragment-only `<a href="#…">` clicks update the URL hash
+  instead of triggering a real navigation. Tests that drive DOM updates from
+  an anchor click no longer lose pending `setTimeout` callbacks or have form
+  values cleared from under them.
+- `body` returns an empty string rather than crashing during the brief window
+  after `reset_session!` when the new session has a target but no document yet.
+- Stale element references during cross-document navigation now resolve to
+  `nil` internally instead of bubbling a browser error up to your test,
+  letting Capybara's automatic-reload pick a fresh element.
+
+### Internal
+
+- One internal polyfill removed: Lightpanda now matches the spec when a DOM
+  event listener throws (a throwing listener no longer halts the rest of the
+  bubble walk), so the gem doesn't need to compensate. No code change required
+  on your end.
+
 ## [0.2.1] - 2026-05-05
 
 ### Fixed

data/lib/capybara/lightpanda/browser.rb

@@ -238,7 +238,11 @@ module Capybara
       end
 
       def body
-        evaluate("document.documentElement.outerHTML")
+        # Guard against the brief window after a fresh BrowserContext / target
+        # is created where the V8 context exists but `document.documentElement`
+        # is still null. Hit by Capybara's `#reset_session! resets page body`
+        # spec since the 0.2.0 Ferrum-style reset rewrite.
+        evaluate("(document.documentElement && document.documentElement.outerHTML) || ''")
       end
       alias html body
 
@@ -247,9 +251,25 @@ module Capybara
       # and dispatch via Runtime.callFunctionOn so `arguments[i]` is bound.
       # Both paths use `returnByValue: false` and unwrap so DOM-node returns
       # come back as `{ "__lightpanda_node__" => ... }` for the Driver to wrap.
+      #
+      # Even the no-args path wraps the expression in an IIFE to isolate
+      # top-level `const`/`let` declarations. Upstream Lightpanda retains
+      # those bindings across `Runtime.evaluate` calls (V8 starts each call
+      # with fresh lexical scope per spec), so a second `const sel = ...`
+      # raises `SyntaxError: Identifier 'sel' has already been declared`.
+      # Wrapping pushes the declarations into a function scope that gets
+      # discarded when the IIFE returns.
+      #
+      # Use direct `eval` inside the IIFE so the user's text can be a bare
+      # expression (`'foo'`), a `throw` statement, OR a multi-statement
+      # script with `const`/`let`. `eval`'s completion-value semantics
+      # return the last expression's value in all cases. A naive
+      # `return EXPR;` wrap would syntax-error on `throw …` and on
+      # multi-statement scripts.
       def evaluate(expression, *args)
         if args.empty?
-          response = page_command("Runtime.evaluate", expression: expression, returnByValue: false, awaitPromise: true)
+          wrapped = "(function(){return eval(#{expression.to_json})})()"
+          response = page_command("Runtime.evaluate", expression: wrapped, returnByValue: false, awaitPromise: true)
           if response["exceptionDetails"]
             debug_js_failure("evaluate", expression, response)
             raise JavaScriptError, response
@@ -263,9 +283,20 @@ module Capybara
       end
 
       # Execute JS without returning a value.
+      #
+      # Like `evaluate`, the no-args path wraps in an IIFE — same upstream
+      # `const`/`let` leak. Also raises on JS exceptions so silent
+      # failures don't mask test bugs (the previous fast path swallowed them
+      # because `awaitPromise: false` was checked but `exceptionDetails` was
+      # not).
       def execute(expression, *args)
         if args.empty?
-          page_command("Runtime.evaluate", expression: expression, returnByValue: false, awaitPromise: false)
+          wrapped = "(function(){#{expression}})()"
+          response = page_command("Runtime.evaluate", expression: wrapped, returnByValue: false, awaitPromise: false)
+          if response["exceptionDetails"]
+            debug_js_failure("execute", expression, response)
+            raise JavaScriptError, response
+          end
           return nil
         end
 

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

@@ -5,6 +5,78 @@
 (function () {
   "use strict";
 
+  // ── Bug #7 — HTMLFormElement / HTMLButtonElement / HTMLInputElement form-* IDL gaps ──
+  // Lightpanda doesn't expose `form.enctype`, `form.method`, `form.action`,
+  // `form.target`, nor the submitter-side `formEnctype` / `formMethod` /
+  // `formAction` / `formTarget` overrides. Per WHATWG HTML these must always
+  // return a string (with the spec's missing-value default) so consumers can
+  // call `.toLowerCase()` etc. directly. Turbo's `FormSubmission` constructor
+  // does exactly that and crashes with `Cannot read properties of undefined
+  // (reading 'toLowerCase')` when it touches enctype.
+  //
+  // Polyfill strategy: only define the IDL getter when it's missing on the
+  // prototype, so a future Lightpanda nightly that adds native support wins
+  // automatically. Each getter falls back to the underlying attribute, with
+  // the spec's default if the attribute is absent. For submitter overrides
+  // (formEnctype, formMethod, etc.) we return the empty string when the
+  // override attribute is unset — Turbo and Hotwire all use the
+  // `submitter.formX || form.X` idiom, which resolves correctly when the
+  // submitter side returns "".
+  (function patchFormIDL() {
+    var ENCTYPE_VALUES = ["application/x-www-form-urlencoded", "multipart/form-data", "text/plain"];
+    function normEnctype(v) {
+      if (!v) return "application/x-www-form-urlencoded";
+      v = String(v).toLowerCase();
+      return ENCTYPE_VALUES.indexOf(v) >= 0 ? v : "application/x-www-form-urlencoded";
+    }
+    function normMethod(v) {
+      if (!v) return "get";
+      v = String(v).toLowerCase();
+      return (v === "post" || v === "dialog") ? v : "get";
+    }
+    function defineIfMissing(proto, name, getter) {
+      if (!proto || name in proto) return;
+      try { Object.defineProperty(proto, name, { configurable: true, enumerable: true, get: getter }); } catch (_) {}
+    }
+    if (typeof HTMLFormElement !== "undefined") {
+      var fp = HTMLFormElement.prototype;
+      defineIfMissing(fp, "enctype", function () { return normEnctype(this.getAttribute("enctype")); });
+      defineIfMissing(fp, "method",  function () { return normMethod(this.getAttribute("method")); });
+      defineIfMissing(fp, "action",  function () {
+        var a = this.getAttribute("action");
+        if (a == null || a === "") return (this.ownerDocument && this.ownerDocument.URL) || "";
+        try { return new URL(a, (this.ownerDocument && this.ownerDocument.URL) || undefined).href; }
+        catch (_) { return a; }
+      });
+      defineIfMissing(fp, "target",  function () { return this.getAttribute("target") || ""; });
+    }
+    function patchSubmitter(Ctor) {
+      if (typeof Ctor === "undefined") return;
+      var p = Ctor.prototype;
+      // Empty string is the spec's missing-value default for the submitter-side
+      // IDL attrs — keep Turbo's `submitter.formX || form.X` idiom flowing
+      // through to the form's value.
+      defineIfMissing(p, "formEnctype", function () {
+        var v = this.getAttribute("formenctype");
+        return v == null ? "" : normEnctype(v);
+      });
+      defineIfMissing(p, "formMethod", function () {
+        var v = this.getAttribute("formmethod");
+        return v == null ? "" : normMethod(v);
+      });
+      defineIfMissing(p, "formAction", function () {
+        var a = this.getAttribute("formaction");
+        if (a == null || a === "") return "";
+        try { return new URL(a, (this.ownerDocument && this.ownerDocument.URL) || undefined).href; }
+        catch (_) { return a; }
+      });
+      defineIfMissing(p, "formTarget", function () { return this.getAttribute("formtarget") || ""; });
+      defineIfMissing(p, "formNoValidate", function () { return this.hasAttribute("formnovalidate"); });
+    }
+    patchSubmitter(typeof HTMLButtonElement !== "undefined" ? HTMLButtonElement : null);
+    patchSubmitter(typeof HTMLInputElement  !== "undefined" ? HTMLInputElement  : null);
+  })();
+
   // ── 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") {
@@ -35,47 +107,106 @@
     }
   }
 
-  // ── 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;
+  // ── Bug #8 (added 2026-05-05) — sync remove + re-add lost across dispatch phases ──
+  // WHATWG DOM specifies that each phase of a dispatch snapshots `currentTarget`'s
+  // listener list AT THAT PHASE. Listeners removed and re-added during the capture
+  // phase correctly appear in the bubble-phase snapshot in Chrome/Cuprite. Lightpanda
+  // takes the snapshot once at dispatch start, so a remove+add during capture loses
+  // the listener for the in-flight bubble. This breaks Turbo's `FormSubmitObserver`
+  // pattern, where `submitCaptured` does `remove+add` on its own `submitBubbled` to
+  // ensure that handler runs LAST in bubble — under Lightpanda, `submitBubbled` is
+  // dropped entirely and Turbo never intercepts form submissions.
+  //
+  // Native form submission via `requestSubmit()` doesn't route through JS-exposed
+  // `dispatchEvent`, so we can't detect "in-flight dispatch" by patching that. The
+  // workaround instead targets the remove+add idiom directly: defer every
+  // `removeEventListener` to a microtask. When `addEventListener` runs in the same
+  // synchronous turn with the SAME (target, type, fn, capture), we cancel the
+  // pending remove — the listener was never actually unregistered, so the in-flight
+  // bubble snapshot still contains it. Genuine removes (no matching add follows)
+  // happen at end-of-tick, indistinguishable from the unpatched behavior modulo
+  // tick boundary.
+  //
+  // Scope: only capture-phase `submit` listeners, the exact tuple Turbo Drive
+  // uses. This avoids changing observable DOM semantics for arbitrary
+  // remove/dispatch sequences elsewhere on the page — synchronous remove +
+  // dispatch outside this narrow tuple still fires the native `removeEventListener`
+  // path immediately.
+  //
+  // Trade-offs (within the narrowed scope):
+  //   • Code that removes a capture-phase submit listener and then reads
+  //     listener state synchronously before the microtask flush will see it
+  //     as still-attached. No known framework does this on `submit`.
+  //   • If something removes capture-phase submit listener X then adds Y of
+  //     the same type/capture before the flush, the add happens immediately
+  //     but the deferred remove fires after, removing X *after* Y is
+  //     registered. Y persists, X is gone. Same end state as without the
+  //     polyfill, just reordered in time.
+  (function patchListenerLifecycle() {
+    if (!window.EventTarget || !EventTarget.prototype.addEventListener) return;
+    if (typeof Promise === "undefined") return; // need microtasks
+    var origAdd    = EventTarget.prototype.addEventListener;
+    var origRemove = EventTarget.prototype.removeEventListener;
+
+    function captureFlag(opts) {
+      return opts === true || (opts && typeof opts === "object" && opts.capture === true);
+    }
 
-    EventTarget.prototype.dispatchEvent = function (event) {
-      try {
-        return orig.call(this, event);
-      } catch (err) {
-        if (!event || !event.bubbles || !this.parentNode) throw err;
+    function inScope(type, capture) {
+      return type === "submit" && capture === true;
+    }
 
-        var originalTarget = this;
-        try {
-          Object.defineProperty(event, "target", {
-            value: originalTarget,
-            configurable: true,
-          });
-        } catch (_) { /* target not redefinable — continue anyway */ }
+    var pending = [];      // [{ target, type, fn, capture, cancelled }]
+    var flushScheduled = false;
 
-        var node = this.parentNode;
-        while (node) {
+    function scheduleFlush() {
+      if (flushScheduled) return;
+      flushScheduled = true;
+      Promise.resolve().then(function () {
+        flushScheduled = false;
+        var queue = pending;
+        pending = [];
+        for (var i = 0; i < queue.length; i++) {
+          var r = queue[i];
+          if (r.cancelled) continue;
           try {
-            Object.defineProperty(event, "currentTarget", {
-              value: node,
-              configurable: true,
-            });
+            origRemove.call(r.target, r.type, r.fn, r.capture);
           } 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;
+      });
+    }
+
+    EventTarget.prototype.removeEventListener = function (type, fn, opts) {
+      var capture = captureFlag(opts);
+      if (!fn || !inScope(type, capture)) return origRemove.call(this, type, fn, opts);
+      pending.push({
+        target:    this,
+        type:      type,
+        fn:        fn,
+        capture:   capture,
+        cancelled: false,
+      });
+      scheduleFlush();
+    };
+
+    EventTarget.prototype.addEventListener = function (type, fn, opts) {
+      if (!fn) return origAdd.call(this, type, fn, opts);
+      var capture = captureFlag(opts);
+      if (inScope(type, capture)) {
+        // Cancel a pending remove for the same tuple (LIFO so the most recent
+        // pending remove wins for the remove-then-add idiom). Always call
+        // native add too: addEventListener is idempotent per DOM spec, and
+        // skipping risks losing the listener on a later unmatched remove.
+        for (var i = pending.length - 1; i >= 0; i--) {
+          var r = pending[i];
+          if (r.cancelled) continue;
+          if (r.target === this && r.type === type && r.fn === fn && r.capture === capture) {
+            r.cancelled = true;
+            break;
+          }
+        }
       }
+      return origAdd.call(this, type, fn, opts);
     };
   })();
 })();

data/lib/capybara/lightpanda/node.rb

@@ -237,6 +237,8 @@ module Capybara
 
       def backend_node_id
         @backend_node_id ||= driver.browser.backend_node_id(@remote_object_id)
+      rescue BrowserError
+        nil
       end
 
       private
@@ -363,13 +365,6 @@ module Capybara
         end
       end
 
-      # 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
@@ -390,10 +385,7 @@ module Capybara
         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 */ }
+          var notCancelled = this.dispatchEvent(clickEvt);
           if (!notCancelled || clickEvt.defaultPrevented) return;
           var tag = this.tagName;
           var type = (this.type || '').toLowerCase();
@@ -401,9 +393,35 @@ module Capybara
             (tag === 'BUTTON' && (type === 'submit' || type === '')) ||
             (tag === 'INPUT' && (type === 'submit' || type === 'image'));
           if (isSubmitButton && this.form) {
-            this.form.requestSubmit(this);
+            // 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') {
-            window.location.href = this.href;
+            // Same-document fragment-only navigation: just update hash (or do
+            // nothing if identical). Mirrors Chrome — assigning location.href
+            // to a same-document URL on Lightpanda triggers a real navigation
+            // tick that cancels pending setTimeout callbacks and clears form
+            // values, which breaks any test driving DOM updates from a click
+            // handler on `<a href="#...">`.
+            var dest = new URL(this.href, document.baseURI);
+            var here = new URL(window.location.href);
+            if (dest.origin === here.origin && dest.pathname === here.pathname &&
+                dest.search === here.search) {
+              if (dest.hash !== here.hash) {
+                window.location.hash = dest.hash;
+              }
+            } else {
+              window.location.href = this.href;
+            }
           }
         }
       JS

data/lib/capybara/lightpanda/process.rb

@@ -8,7 +8,7 @@ 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
+      # Floor for the cookie/navigation/redirect/modal/keyboard/css/forms/dispatch
       # fixes the gem now relies on: PR #2255 (Network.clearBrowserCookies
       # empty params + Network.getAllCookies), PR #2257
       # (window.location.pathname/.search assignment triggers navigation),
@@ -23,10 +23,12 @@ module Capybara
       # on labeled control), PR #2286 (HTML constraint validation API:
       # el.validity, validationMessage, checkValidity, reportValidity),
       # 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")
+      # 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")
 
       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.1"
+    VERSION = "0.2.2"
   end
 end

metadata

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