capybara-lightpanda 0.14.1 → 0.15.0

data/lib/capybara/lightpanda/node.rb

@@ -11,14 +11,22 @@ module Capybara
       # `frame_scoped`: the node lives in an iframe's document — it was found
       # while a frame was switched to, or from another frame-scoped node. See
       # #wrap_with_attached_guard for what that changes.
-      def initialize(driver, remote_object_id, frame_scoped: false)
-        super(driver, remote_object_id)
+      def initialize(driver, remote_object_id, initial_cache = {}, frame_scoped: false)
+        super(driver, remote_object_id, initial_cache)
         @remote_object_id = remote_object_id
         @frame_scoped = frame_scoped
+        @tag_name = initial_cache[:tag_name]
+      end
+
+      # Capybara's finder hints → the spec `_lightpanda.findHints` answers.
+      # Only tag_name is cached (when the bounded helper runs); Capybara reads
+      # initial_cache[:tag_name] before asking the node.
+      def self.hint_spec(texts: nil, **)
+        texts&.any? ? { texts: texts.map(&:to_s) } : {}
       end
 
       # Capybara::Driver::Node#native returns the constructor's second argument,
-      # which here is the raw CDP objectId — a String. So the Selenium/Cuprite
+      # which here is the raw CDP objectId — a String. So the Selenium
       # idiom `element.native.send_keys(...)` (solidus's
       # return_authorizations_spec.rb does exactly that) died with
       # "undefined method 'send_keys' for an instance of String". This driver
@@ -112,7 +120,7 @@ module Capybara
         self.class.new(driver, result["objectId"])
       end
 
-      # Smart property/attribute getter (Cuprite pattern).
+      # Smart property/attribute getter.
       # Returns resolved URLs for src/href, raw attributes otherwise.
       def [](name)
         call(PROPERTY_OR_ATTRIBUTE_JS, name.to_s)
@@ -165,10 +173,10 @@ module Capybara
       def scroll_to(*); end
       def scroll_by(*); 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')`).
+      # Dispatch an arbitrary DOM event by name. 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
@@ -194,10 +202,10 @@ module Capybara
       # on this element, so HTML5 dropzones see the payload via
       # `event.dataTransfer`.
       #
-      # Files reach the page the way Cuprite's #316 does it: a hidden
-      # `<input type=file>` is attached to this element's document,
-      # `DOM.setFileInputFiles` points it at the paths (the browser reads the
-      # bytes off disk itself), and the drop JS moves `input.files` into the
+      # Files reach the page through a hidden `<input type=file>`: it is
+      # attached to this element's document, `DOM.setFileInputFiles` points it
+      # at the paths (the browser reads the bytes off disk itself), and the
+      # drop JS moves `input.files` into the
       # DataTransfer and removes the input. Previously the bytes were base64'd
       # into the `Runtime.callFunctionOn` message, which capped a drop at
       # ~70 MB under `--cdp-max-message-size` and pinned every byte in Ruby;
@@ -216,15 +224,15 @@ module Capybara
       end
 
       # Maps Capybara's documented drop_modifiers aliases onto the DragEvent
-      # init keys (`ctrlKey`, `metaKey`, ...). Same table as Cuprite's #315.
+      # init keys (`ctrlKey`, `metaKey`, ...).
       DRAG_MODIFIER_ALIASES = { control: :ctrl, command: :meta, cmd: :meta }.freeze
 
       # Capybara's `Element#drag_to` — HTML5 half only. HTML5_DRAG_JS replays
-      # Capybara's own Selenium HTML5_DRAG_DROP_SCRIPT (the same source
-      # Cuprite's drag.js ports): dragstart on the draggable ancestor, then
-      # dragenter -> 2x dragover -> dragleave/drop -> dragend, setTimeout-paced,
-      # sharing one DataTransfer so `setData` in the page's dragstart handler is
-      # readable at drop. Runs through `evaluate_async` (the script signals
+      # Capybara's own Selenium HTML5_DRAG_DROP_SCRIPT: dragstart on the
+      # draggable ancestor, then dragenter -> 2x dragover -> drop (accepted)
+      # or dragleave (refused) -> dragend, setTimeout-paced, sharing one
+      # DataTransfer so `setData` in the page's dragstart handler is readable
+      # at drop. Runs through `evaluate_async` (the script signals
       # completion via the appended callback), so the drag has fully played out
       # before this method returns.
       #
@@ -235,8 +243,8 @@ module Capybara
       # Selenium presses a real button, then apply the same
       # prevented-or-no-draggable-ancestor test.
       #
-      # `steps:`/`scroll:` (Cuprite's legacy-path knobs) are accepted and
-      # ignored so suites migrating from cuprite don't ArgumentError.
+      # `steps:`/`scroll:` (legacy mouse-path knobs of other CDP drivers) are
+      # accepted and ignored so suites migrating from them don't ArgumentError.
       def drag_to(other, html5: nil, delay: 0.05, drop_modifiers: [], **)
         keys = Array(drop_modifiers).map { |m| DRAG_MODIFIER_ALIASES.fetch(m.to_sym, m.to_sym).to_s }
         html5 = !call(LEGACY_DRAG_CHECK_JS) if html5.nil?
@@ -318,20 +326,18 @@ module Capybara
       end
 
       # Ancestor chain from `parentNode` up to (but not including) `document`,
-      # returned as Lightpanda::Node wrappers. Mirrors Cuprite's `Node#parents`.
+      # returned as Lightpanda::Node wrappers.
       def parents
         oids = driver.browser.parents_of(@remote_object_id)
         oids.map { |oid| self.class.new(driver, oid, frame_scoped: @frame_scoped) }
       end
 
-      def find_xpath(selector)
-        object_ids = driver.browser.find_within(@remote_object_id, "xpath", selector)
-        object_ids.map { |oid| self.class.new(driver, oid, frame_scoped: @frame_scoped) }
+      def find_xpath(selector, **hints)
+        find_hinted("xpath", selector, hints)
       end
 
-      def find_css(selector)
-        object_ids = driver.browser.find_within(@remote_object_id, "css", selector)
-        object_ids.map { |oid| self.class.new(driver, oid, frame_scoped: @frame_scoped) }
+      def find_css(selector, **hints)
+        find_hinted("css", selector, hints)
       end
 
       # Equality compares the underlying DOM node via backendNodeId, the only
@@ -368,6 +374,11 @@ module Capybara
 
       private
 
+      def find_hinted(method, selector, hints)
+        driver.browser.find_within_hinted(@remote_object_id, method, selector, self.class.hint_spec(**hints))
+              .map { |oid, cache| self.class.new(driver, oid, cache, frame_scoped: @frame_scoped) }
+      end
+
       def implicit_submit
         call(IMPLICIT_SUBMIT_JS)
         driver.browser.wait_for_idle
@@ -446,8 +457,8 @@ module Capybara
 
       # ISO 8601 week-of-year, "%G" giving the ISO week-numbering year so that
       # the last days of December that belong to week 1 of the next year are
-      # rendered with the correct year. Matches Cuprite's `Node#set` for week
-      # inputs and what the user would type into a `<input type=week>` field.
+      # rendered with the correct year. Matches what the user would type into
+      # a `<input type=week>` field.
       def format_week_value(value)
         return value.to_s if value.is_a?(String) || !value.respond_to?(:to_date)
 
@@ -492,7 +503,7 @@ module Capybara
         self.class.new(driver, oid)
       end
 
-      # Whitespace-normalized text (Cuprite pattern). Capybara's text matchers compare
+      # Whitespace-normalized text. Capybara's text matchers compare
       # against this, and Lightpanda's textContent preserves source-template whitespace
       # differently than Chrome — without normalization, multi-line fixtures fail
       # `text: "Line\nLine"` matchers.
@@ -638,8 +649,15 @@ module Capybara
           }
           hit.dispatchEvent(new EventCtor('mouseup', { bubbles: true, cancelable: true }));
           var clickEvt = new EventCtor('click', { bubbles: true, cancelable: true });
+          // A link to a scheme the browser can't fetch (mailto:, tel:, sms:…)
+          // goes to an external app in Chrome and the page stays. The link's
+          // own activation is a no-op for it since upstream #3940 (10536, in
+          // the floor); don't navigate to it ourselves either.
+          var link = hit.closest ? hit.closest('a[href]') : null;
+          var scheme = link && /^\\s*([a-z][a-z0-9+.-]*):/i.exec(link.getAttribute('href'));
+          var external = !!scheme && !/^(https?|about|blob|data|file|javascript)$/i.test(scheme[1]);
           var notCancelled = hit.dispatchEvent(clickEvt);
-          if (!notCancelled || clickEvt.defaultPrevented) return;
+          if (external || !notCancelled || clickEvt.defaultPrevented) return;
           var tag = hit.tagName;
           // A `javascript:` link never navigates: the click's own activation
           // behavior has already run its code. Assigning it to location.href
@@ -676,9 +694,9 @@ module Capybara
         }
       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
+      # 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
@@ -696,6 +714,9 @@ module Capybara
             event = new FocusEvent(name, init);
           } else if (name === 'submit' && typeof SubmitEvent !== 'undefined') {
             event = new SubmitEvent(name, init);
+          } else if (name === 'input' && typeof InputEvent !== 'undefined') {
+            // inputType is what typing sends; a plain Event leaves it undefined.
+            event = new InputEvent(name, { bubbles: true, cancelable: false, inputType: 'insertText' });
           } else {
             event = new Event(name, init);
           }
@@ -757,19 +778,45 @@ module Capybara
         }
       JS
 
-      # Ported near-verbatim from Capybara's Selenium driver
+      # Ported from Capybara's Selenium driver
       # (capybara/selenium/extensions/html5_drag.rb, HTML5_DRAG_DROP_SCRIPT) —
-      # the same source Cuprite's #315 drag.js ports — kept close to ease
-      # future syncs. Upstream quirks preserved deliberately: `rectPt.top` in
-      # pointOnRect (DOMPoint has no .top, that branch just falls through), the
-      # undeclared `key` loop variable, and `callback.call(true)`. The
+      # kept close to ease future syncs. Unlike the original, a drag ends the
+      # way it does in a browser: `drop` if the target accepted it (cancelled
+      # the last dragover), otherwise `dragleave`, never both. Selenium's
+      # script fired `dragleave` before `drop`, and Pragmatic drag and drop
+      # reads a relatedTarget-less `dragleave` as the drag leaving the window,
+      # so the drop landed on nothing. Two port bugs are fixed too:
+      # pointOnRect read `rectPt.top` (a DOMPoint has none, so a target
+      # entered from above or below got the source's center as its entry
+      # point), and `key` leaked as a global. Cuprite made the same changes
+      # (rubycdp/cuprite#343). The
       # `source.draggable` reads are native — the HTMLElement.draggable IDL
       # shipped upstream in #3257 (build 8793, guaranteed by the floor; the
       # `_lightpanda.isDraggable` polyfill was retired with that bump).
       # Coordinates come from getBoundingClientRect, which Lightpanda
       # synthesizes without layout — dropzones reading clientX/Y get
       # plausible-but-synthetic (integer since #3259) numbers.
+      #
+      # One deliberate deviation: the target is centered by
+      # `scrollCenterIntoView`, not `scrollIntoView({block: 'center'})`.
+      # Lightpanda's scrollIntoView ignores its options and aligns the
+      # element's top with the viewport's, and since upstream #3658 (nightly
+      # 10661) rects follow the scroll, so a source just above the target
+      # left the viewport and the first dragover carried a negative clientY.
+      # The helper does what Chrome does (element center at viewport center,
+      # clamped to the scrollable range), measuring against the root's rect
+      # so it holds whether or not the build's rects follow the scroll.
+      # Pinned by `drag_test.rb`.
       HTML5_DRAG_JS = <<~JS
+        function scrollCenterIntoView(el) {
+          var doc = el.ownerDocument, win = doc.defaultView;
+          var rect = el.getBoundingClientRect();
+          var root = doc.documentElement.getBoundingClientRect();
+          var x = rect.left - root.left + rect.width / 2 - win.innerWidth / 2;
+          var y = rect.top - root.top + rect.height / 2 - win.innerHeight / 2;
+          win.scrollTo(Math.max(0, x), Math.max(0, y));
+        }
+
         function rectCenter(rect){
           return new DOMPoint(
             (rect.left + rect.right)/2,
@@ -794,7 +841,7 @@ module Capybara
           }
 
           if (pt.y <= rectPt.y) { // top side
-            var minYx = (rectPt.top - pt.y) / slope + pt.x;
+            var minYx = (rect.top - pt.y) / slope + pt.x;
             if (rect.left <= minYx && minYx <= rect.right)
               return new DOMPoint(minYx, rect.top);
           }
@@ -809,12 +856,12 @@ module Capybara
         }
 
         function dragEnterTarget() {
-          target.scrollIntoView({behavior: 'instant', block: 'center', inline: 'center'});
+          scrollCenterIntoView(target);
           var targetRect = target.getBoundingClientRect();
           var sourceCenter = rectCenter(source.getBoundingClientRect());
 
           for (var i = 0; i < drop_modifier_keys.length; i++) {
-            key = drop_modifier_keys[i];
+            var key = drop_modifier_keys[i];
             if (key == "control"){
               key = "ctrl"
             }
@@ -837,18 +884,14 @@ module Capybara
           var dragOverOpts = Object.assign({clientX: targetCenter.x, clientY: targetCenter.y}, opts);
           var dragOverEvent = new DragEvent('dragover', dragOverOpts);
           target.dispatchEvent(dragOverEvent);
-          window.setTimeout(dragLeave, step_delay, dragOverEvent.defaultPrevented, dragOverOpts);
+          window.setTimeout(dragEnd, step_delay, dragOverEvent.defaultPrevented, dragOverOpts);
         }
 
-        function dragLeave(drop, dragOverOpts) {
-          var dragLeaveOptions = Object.assign({}, opts, dragOverOpts);
-          var dragLeaveEvent = new DragEvent('dragleave', dragLeaveOptions);
-          target.dispatchEvent(dragLeaveEvent);
-          if (drop) {
-            var dropEvent = new DragEvent('drop', dragLeaveOptions);
-            target.dispatchEvent(dropEvent);
-          }
-          var dragEndEvent = new DragEvent('dragend', dragLeaveOptions);
+        function dragEnd(drop, dragOverOpts) {
+          var dragEndOptions = Object.assign({}, opts, dragOverOpts);
+          var dropOrLeaveEvent = new DragEvent(drop ? 'drop' : 'dragleave', dragEndOptions);
+          target.dispatchEvent(dropOrLeaveEvent);
+          var dragEndEvent = new DragEvent('dragend', dragEndOptions);
           source.dispatchEvent(dragEndEvent);
           callback.call(true);
         }
@@ -1066,7 +1109,7 @@ module Capybara
       # same node (`node #path returns xpath which points to itself`), so this
       # emits `/HTML/BODY/DIV[2]/P[1]` rather than the CSS-ish
       # `html > body > div:nth-of-type(2) > p` it used to. Chrome exposes no
-      # native equivalent either; Cuprite hand-rolls the same walk.
+      # native equivalent either.
       #
       # Every step is indexed, including single children: `P[1]` and `P` select
       # the same node, but the explicit index keeps the output stable if a

data/lib/capybara/lightpanda/options.rb

@@ -20,10 +20,11 @@ module Capybara
       # `Capybara::Lightpanda.configure { |c| c.port = 9222 }` when external
       # tooling needs a known address.
       DEFAULT_PORT = 0
-      # Mirrors Lightpanda's own `Viewport.default` (1920x1080) rather than
-      # Cuprite's 1024x768. window_size is applied for real now (see below), so
-      # a 1024x768 default would silently shrink the viewport of every existing
-      # suite and flip `@media` branches under them. Matching the browser's
+      # Mirrors Lightpanda's own `Viewport.default` (1920x1080), not the
+      # 1024x768 some drivers default to. window_size is applied for real now
+      # (see below), so a 1024x768 default would silently shrink the viewport
+      # of every existing suite and flip `@media` branches under them.
+      # Matching the browser's
       # native default keeps `window_size` truthful AND leaves default
       # behavior byte-identical to before it was wired up.
       DEFAULT_WINDOW_SIZE = [1920, 1080].freeze
@@ -36,16 +37,17 @@ module Capybara
       # no rendering engine, so getBoundingClientRect stays synthetic and
       # nothing reflows. Sizing down will not make an off-viewport element
       # report as obscured.
-      # headless is accepted for Cuprite drop-in compatibility but inert —
+      # headless is accepted so suites migrating from other drivers keep
+      # working, but is inert —
       # headless is the only mode Lightpanda runs in.
-      # save_path: directory for downloaded files (Cuprite parity). nil falls
+      # save_path: directory for downloaded files. nil falls
       # back to Capybara.save_path at create_page time; downloads stay off when
       # both are nil (Browser#create_page only opts in when a path exists).
       # raise_on_unhandled_modal: a JS dialog that opens with no
       # accept_modal/dismiss_modal pre-arm in flight is resolved by Lightpanda's
       # silent default (confirm → cancel, prompt → null, alert → dismissed), so
       # a runaway confirm cancels the action and the spec can still pass. false
-      # (default, Cuprite parity) warns on stderr; true raises
+      # (default) warns on stderr; true raises
       # UnhandledModalError from the action that opened it.
       # load_images: adds `image` to the `--load-resources` value so `<img>`
       # elements are fetched over the network (upstream #3230, build >= 8834,

data/lib/capybara/lightpanda/process.rb

@@ -264,7 +264,48 @@ module Capybara
       # end in Network.loadingFailed, which Network consumes); #3529 (9877)
       # SameSite=None without Secure refused (Cookies#set reports it);
       # #3702 (9968) click no longer focuses (CLICK_JS focuses itself).
-      MINIMUM_NIGHTLY_BUILD = Gem::Version.new("9994")
+      #
+      # 2026-10-16 bump 9994 -> 10641 (= release 1.0.1, the new lockstep cap).
+      # Retired or ungated by it:
+      #   #3958 (10613, ours) Window and Document carry the GlobalEventHandlers
+      #     `on*` attributes, so javascripts/event_handlers.js is gone — jQuery
+      #     1.x sees `'onchange' in window` natively.
+      #   #3940 (10536) a link to a non-fetchable scheme (mailto:, tel:) is a
+      #     no-op that keeps the document, so CLICK_JS no longer cancels the
+      #     click's default from a window listener.
+      #   #3755 / #3849 (10049 / 10310, ours / upstream) exceptions from timers,
+      #     rAF, inline handlers and microtasks reach `window.onerror`, so
+      #     Browser#page_errors sees them; #3757 (10052) hides a closed
+      #     [popover]; #3759 (10057) routes send_keys into an iframe; #3874
+      #     (10366) Ctrl+A selects a field — upstream_fixes_test.rb runs them
+      #     un-gated.
+      #   #3763 (10239, ours) history traverses pushState entries in place;
+      #     #3831 (10255) `window` serializes as CyclicObject, not a node;
+      #     #3843 (10261) a failed navigation commits an error document — their
+      #     tests drop the nightly_build branches.
+      #   #3952 (10575) typed text fires `change` when committed by blur/Enter.
+      # A `nightly_build` gate is nil on a release binary, so every such test
+      # skipped on 1.0.1 although it carried the fix: ungate, don't re-gate.
+      #
+      # 2026-10-23 bump 10641 -> 10965 (= release 1.0.2, the new lockstep cap;
+      # CSS nesting #3962 at 10976 and blank-page timers #4148 at 11012 stay
+      # above it). Rides along:
+      #   #4096 (10904) Runtime.exceptionThrown for unhandled rejections, and
+      #     `unhandledrejection` no longer fires for a rejection handled in
+      #     the same tick — errors.js stops reporting those false positives;
+      #     page_errors_test.rb drops its nightly_build gate. With #4115
+      #     (10910, an iframe's exception carries its context id) this
+      #     unblocks the B19 swap off errors.js.
+      #   #3997 (10685) the scheduler rework: a MessageChannel task loop no
+      #     longer delays a pending fetch tenfold (#4042), which held
+      #     wait_for_idle.
+      #   #3658 (10657) client rects follow the scroll and
+      #     DOM.scrollIntoViewIfNeeded is real — HTML5_DRAG_JS centers the
+      #     drop target itself because scrollIntoView ignores `block`.
+      MINIMUM_NIGHTLY_BUILD = Gem::Version.new("10965")
+
+      # Lines of browser output #output keeps (ferrum keeps the same 100).
+      OUTPUT_LINES = 100
 
       # Second, equivalent floor for the *release* channel.
       #
@@ -273,16 +314,16 @@ module Capybara
       # bare "0.3.6" carrying no commit counter at all, and MINIMUM_NIGHTLY_BUILD
       # has nothing to compare against. Releases are cut from the same trunk, so
       # a release is acceptable exactly when its own commit count clears the
-      # nightly floor. 1.0.0 (2026-10-02) is build 9994 — exactly the nightly
+      # nightly floor. 1.0.2 (2026-10-23) is build 10965 — exactly the nightly
       # floor, which is no accident: the floor was raised *to* the release so
-      # both channels gate the same commit. (0.4.1 = 9463 and 0.4.0 = 9058
-      # predate fixes the floor exists for.)
+      # both channels gate the same commit. (1.0.1 = 10641 predates fixes the
+      # floor exists for.)
       #
       # INVARIANT: every MINIMUM_NIGHTLY_BUILD bump must also move this to the
       # first release containing that build (`git rev-list --count <tag>` in the
       # browser repo tells you). Leaving it behind would let the release channel
       # silently accept a binary the nightly channel rejects.
-      MINIMUM_RELEASE = Gem::Version.new("1.0.0")
+      MINIMUM_RELEASE = Gem::Version.new("1.0.2")
 
       class << self
         # `lightpanda version` prints one of two shapes, and the gem supports
@@ -348,6 +389,17 @@ module Capybara
         @stderr_r = nil
         @stderr_w = nil
         @finalizer_registered = false
+        @output = []
+        @output_partial = {}
+        @output_mutex = Mutex.new
+      end
+
+      # The last OUTPUT_LINES lines Lightpanda wrote to stdout/stderr, oldest
+      # first, across restarts of this Process. Kept for diagnostics: a crash
+      # or panic only ever shows up there, and from build 10783 so do page
+      # errors (`page_error` scope, WARN). Mirrors ferrum's Process::Output.
+      def output
+        @output_mutex.synchronize { @output.dup }
       end
 
       def start
@@ -416,7 +468,7 @@ module Capybara
             next unless ready
 
             ready[0].each do |io|
-              io.read_nonblock(4096)
+              record_output(io, io.read_nonblock(4096))
             rescue IO::WaitReadable
               # No data
             rescue EOFError
@@ -430,6 +482,18 @@ module Capybara
         end
       end
 
+      # Split per pipe so a line cut across two reads is kept whole, and a
+      # stdout fragment never glues onto a stderr one.
+      def record_output(io, chunk)
+        text = chunk.dup.force_encoding(Encoding::UTF_8).scrub
+        @output_mutex.synchronize do
+          *lines, rest = "#{@output_partial[io]}#{text}".split("\n", -1)
+          @output_partial[io] = rest
+          @output.concat(lines)
+          @output.shift(@output.size - OUTPUT_LINES) if @output.size > OUTPUT_LINES
+        end
+      end
+
       def spawn_process(binary_path)
         args = build_args
 
@@ -499,6 +563,7 @@ module Capybara
             ready[0].each do |io|
               chunk = io.read_nonblock(1024)
               output << chunk
+              record_output(io, chunk)
 
               if (match = output.match(READY_PATTERN))
                 @ws_url = "ws://#{match[1]}/"

data/lib/capybara/lightpanda/version.rb

@@ -2,6 +2,6 @@
 
 module Capybara
   module Lightpanda
-    VERSION = "0.14.1"
+    VERSION = "0.15.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: capybara-lightpanda
 version: !ruby/object:Gem::Version
-  version: 0.14.1
+  version: 0.15.0
 platform: ruby
 authors:
 - Navid Emad
@@ -91,7 +91,6 @@ files:
 - lib/capybara/lightpanda/headers.rb
 - lib/capybara/lightpanda/javascripts/attach.js
 - lib/capybara/lightpanda/javascripts/banner.js
-- lib/capybara/lightpanda/javascripts/errors.js
 - lib/capybara/lightpanda/javascripts/predicates.js
 - lib/capybara/lightpanda/javascripts/turbo.js
 - lib/capybara/lightpanda/keyboard.rb

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

@@ -1,74 +0,0 @@
-// --- Uncaught page errors ---
-// Lightpanda implements no `Runtime.exceptionThrown` (upstream gap, wishlist
-// B19), so an uncaught exception in page JS reaches no CDP client at all. It is
-// invisible to console_logs, which only ever sees explicit console.* calls, so
-// a handler that dies on a TypeError leaves no trace and the failure surfaces
-// far away as ElementNotFound on whatever it was supposed to produce. That is
-// the exact shape of the solidus taxon-tree failure in real-apps causes.yml.
-//
-// These listeners are passive — no preventDefault, so nothing the page would
-// otherwise see is swallowed, and nothing that would have propagated stops
-// propagating. They re-emit through the same console.debug sentinel channel
-// turbo.js uses, and console.rb routes them into Browser#page_errors rather
-// than #console_logs. Keeping the two apart is deliberate: console_logs stays
-// "the console.* calls the page made", which is what Chrome models (an
-// exception is exceptionThrown, not consoleAPICalled) and what Playwright and
-// Puppeteer expose (pageerror, separate from console). Folding exceptions into
-// console_logs would also break every suite already asserting that buffer is
-// free of errors.
-//
-// Delete this file once upstream emits Runtime.exceptionThrown and the floor
-// covers it: subscribe Browser::Console to that event and feed the same buffer.
-function _reportPageError(fields) {
-  try {
-    console.debug('__lightpanda_page_error_' + JSON.stringify(fields));
-  } catch (e) {
-    // A field that won't serialize (a getter that throws, a cyclic `reason`)
-    // must not turn one page error into two, so report the kind and move on.
-    try {
-      console.debug('__lightpanda_page_error_' + JSON.stringify({
-        kind: fields && fields.kind ? fields.kind : 'error',
-        message: '(page error could not be serialized)'
-      }));
-    } catch (e2) {}
-  }
-}
-
-window.addEventListener('error', function (e) {
-  // A failed <img>/<script>/<link> fetch fires `error` too, but on the element
-  // and without bubbling, so it shouldn't reach this listener. Guard anyway
-  // (Lightpanda's dispatch need not match Chrome's exactly) and identify those
-  // by their missing string `message` — a resource failure is a network fact
-  // and Network#traffic already carries it.
-  if (!e || typeof e.message !== 'string') return;
-
-  _reportPageError({
-    kind: 'error',
-    message: e.message,
-    url: typeof e.filename === 'string' ? e.filename : '',
-    line: typeof e.lineno === 'number' ? e.lineno : null,
-    column: typeof e.colno === 'number' ? e.colno : null,
-    // Cap the stack: it rides a console argument over the CDP WebSocket, and a
-    // deep recursion stack can be megabytes.
-    stack: e.error && typeof e.error.stack === 'string' ? e.error.stack.slice(0, 4000) : null
-  });
-});
-
-window.addEventListener('unhandledrejection', function (e) {
-  var reason = e ? e.reason : null;
-  var message;
-  try {
-    message = reason && reason.message ? String(reason.message) : String(reason);
-  } catch (err) {
-    message = '(rejection reason could not be stringified)';
-  }
-
-  _reportPageError({
-    kind: 'unhandledrejection',
-    message: message,
-    url: '',
-    line: null,
-    column: null,
-    stack: reason && typeof reason.stack === 'string' ? reason.stack.slice(0, 4000) : null
-  });
-});