capybara-lightpanda 0.14.2 → 0.15.0

data/lib/capybara/lightpanda/cookies.rb

@@ -76,7 +76,7 @@ module Capybara
       def get(name)
         find { |cookie| cookie.name == name }
       end
-      # Ferrum/Cuprite spelling: `browser.cookies["session_id"]`.
+      # Ferrum spelling: `browser.cookies["session_id"]`.
       alias [] get
 
       # Returns whether the browser accepted the cookie (ferrum parity).

data/lib/capybara/lightpanda/driver.rb

@@ -72,20 +72,20 @@ module Capybara
         oid && build_node(oid)
       end
 
-      # Capybara's Session#send_keys routes to Driver#send_keys; Cuprite's pattern
-      # is to fan that out to whatever element currently has focus.
+      # Capybara's Session#send_keys routes to Driver#send_keys; fan that out
+      # to whatever element currently has focus.
       def send_keys(*keys)
         active_element&.send_keys(*keys)
       end
 
-      def find_xpath(selector)
-        object_ids = browser.find("xpath", selector)
-        object_ids.map { |oid| build_node(oid) }
+      # Accepting `**hints` is what makes Capybara send them (it checks the
+      # arity); Node.hint_spec turns them into the answers the find returns.
+      def find_xpath(selector, **hints)
+        browser.find_hinted("xpath", selector, Node.hint_spec(**hints)).map { |oid, cache| build_node(oid, cache) }
       end
 
-      def find_css(selector)
-        object_ids = browser.find("css", selector)
-        object_ids.map { |oid| build_node(oid) }
+      def find_css(selector, **hints)
+        browser.find_hinted("css", selector, Node.hint_spec(**hints)).map { |oid, cache| build_node(oid, cache) }
       end
 
       # Inside `within_frame` these run in the frame's document, as in Chrome.
@@ -107,7 +107,7 @@ module Capybara
       # -- Network Inspection --
 
       # Network tracker (lazily auto-enabled). Exposes `traffic`, `clear`,
-      # `wait_for_idle`, header overrides, etc. Cuprite parity.
+      # `wait_for_idle`, header overrides, etc.
       def network
         browser.network
       end
@@ -124,7 +124,7 @@ module Capybara
       # Files downloaded since the session started (absolute paths). Capture is
       # on whenever a destination exists (the :save_path driver option, else
       # Capybara.save_path) and the server sends `Content-Disposition:
-      # attachment`. Ferrum/Cuprite expose downloads on the driver too.
+      # attachment`. Ferrum exposes downloads on its browser too.
 
       def downloads
         browser.downloads.files
@@ -286,18 +286,18 @@ module Capybara
       end
 
       # capybara-screenshot's fallback for unregistered drivers calls
-      # `driver.render(path)` (the Cuprite/Ferrum spelling). Without the alias
-      # every failed test in a capybara-screenshot suite logged
-      # "Screenshot could not be saved: undefined method 'render'".
+      # `driver.render(path)`. Without the alias every failed test in a
+      # capybara-screenshot suite logged "Screenshot could not be saved:
+      # undefined method 'render'".
       alias render save_screenshot
 
-      # -- Headers (Cuprite-compatible driver surface) --
+      # -- Headers (driver surface) --
       # Delegates to Network, which lazily enables the Network domain. The
       # overrides do NOT survive reset!: disposing the BrowserContext takes
       # setExtraHTTPHeaders with it, so Network#reset drops its cached copy
       # rather than report headers the browser stopped sending (pinned by
-      # network_test.rb "clears extra_headers"). Cuprite exposes these on the
-      # driver, and real suites call them there (page.driver.headers = ...).
+      # network_test.rb "clears extra_headers"). Real suites call these on the
+      # driver (page.driver.headers = ...).
 
       def headers
         browser.network.extra_headers
@@ -313,9 +313,9 @@ module Capybara
 
       # -- Lifecycle --
 
-      # Thin Cuprite-style wrapper. The interesting work — disposing the
-      # BrowserContext (cookies, storage, all targets) and starting a fresh
-      # one — happens in Browser#reset.
+      # Thin wrapper. The interesting work — disposing the BrowserContext
+      # (cookies, storage, all targets) and starting a fresh one — happens in
+      # Browser#reset.
       #
       # Rescue is the gem hierarchy plus raw IO escapees only — NOT
       # StandardError: reset! runs between every test, so a blanket rescue
@@ -345,11 +345,10 @@ module Capybara
         true
       end
 
-      # Expanded error list for Capybara retry logic (Cuprite pattern).
-      # MouseEventFailed is in Cuprite's list, but Lightpanda has no
-      # rendering engine and the gem dispatches clicks through JS — the
-      # underlying CDP Input.dispatchMouseEvent path doesn't run, so
-      # MouseEventFailed is never raised.
+      # Expanded error list for Capybara retry logic. MouseEventFailed is left
+      # out: Lightpanda has no rendering engine and the gem dispatches clicks
+      # through JS — the underlying CDP Input.dispatchMouseEvent path doesn't
+      # run, so MouseEventFailed is never raised.
       def invalid_element_errors
         [
           NodeNotFoundError,
@@ -374,8 +373,8 @@ module Capybara
 
       # A node found while a frame is switched to lives in that frame's
       # document, which Node#call checks for a frame navigation.
-      def build_node(oid)
-        Node.new(self, oid, frame_scoped: browser.frame_stack.any?)
+      def build_node(oid, initial_cache = {})
+        Node.new(self, oid, initial_cache, frame_scoped: browser.frame_stack.any?)
       end
 
       # Every window method takes a handle because Capybara's Window objects
@@ -391,7 +390,7 @@ module Capybara
 
       # Unwrap arguments before sending to the browser. Capybara::Node::Element wraps
       # our Lightpanda::Node — pull `.base` out so `serialize_argument` can build
-      # `{objectId: …}` for the CDP payload. Cuprite's `native_args` pattern.
+      # `{objectId: …}` for the CDP payload.
       def native_args(args)
         args.map { |a| a.is_a?(Capybara::Node::Element) ? a.base : a }
       end
@@ -399,7 +398,7 @@ module Capybara
       # Lightpanda's `Network.setCookie` requires either `domain` or `url`
       # (storage.zig → Cookie.parseDomain). When the caller doesn't supply one,
       # use the host of the current page if any, else `Capybara.app_host`,
-      # else loopback. Cuprite parity — lets pre-visit cookie setup just work.
+      # else loopback. Lets pre-visit cookie setup just work.
       def default_domain
         candidate = (@started && safe_uri_host(browser.current_url)) ||
                     safe_uri_host(Capybara.app_host)

data/lib/capybara/lightpanda/errors.rb

@@ -106,11 +106,11 @@ module Capybara
       end
     end
 
-    # --- Cuprite/Ferrum drop-in compatibility surface ---
+    # --- Drop-in compatibility surface ---
     # This gem never raises the three classes below (no coordinate-based
     # mouse path, no multi-page API, no page-status tracking). They mirror
-    # the peer taxonomy (Cuprite's MouseEventFailed, Ferrum's
-    # NoSuchPageError/StatusError) so suites migrating from those drivers
+    # the error taxonomy of other Capybara CDP drivers (MouseEventFailed, plus
+    # Ferrum's NoSuchPageError/StatusError) so suites migrating from them
     # don't NameError on rescue lists that reference them.
     class MouseEventFailed < BrowserError
       attr_reader :node, :selector, :position

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

@@ -13,5 +13,6 @@ window._lightpanda = {
   isDisabled: isDisabled,
   isContentEditable: isContentEditable,
   pointerFocusTarget: pointerFocusTarget,
-  visibleText: visibleText
+  visibleText: visibleText,
+  findHints: findHints
 };

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

@@ -19,12 +19,11 @@
 // External `<link rel=stylesheet>` ARE fetched and applied — the gem
 // always passes `--load-resources stylesheet` (Lightpanda PR #2487,
 // guaranteed by the build floor) — so stylesheet-driven `display:none`
-// participates in this check. The remaining gap is viewport emulation:
-// `@media` rules and `matchMedia()` evaluate against the hardcoded
-// 1920×1080 viewport (no resize), so visibility gated on a non-desktop
-// viewport — e.g. a mobile-only CTA under `@media (max-width: …)` —
-// resolves like desktop Chrome at 1920×1080. Keep those specs on a
-// full-layout driver (README's dual-driver setup).
+// participates in this check. `@media` rules evaluate against the
+// emulated viewport (`window_size`, 1920×1080 by default), so a
+// mobile-only CTA under `@media (max-width: …)` needs a narrow
+// `window_size` — or `resize_to` then `visit`, since a loaded document's
+// cascade doesn't re-resolve on resize.
 function isVisible(el) {
   if (!el || el.nodeType !== 1) return false;
   var win = el.ownerDocument.defaultView || window;
@@ -56,13 +55,22 @@ function isObscured(el) {
   var hit = doc.elementFromPoint(cx, cy);
   if (!hit) return true;
   if (hit === el) return false;
-  return !el.contains(hit);
+  if (el.contains(hit)) return false;
+  // A hit inside a shadow tree is retargeted to its host, and there is no
+  // ShadowRoot.elementFromPoint to look further, so landing on one of el's own
+  // hosts is the best "not obscured" answer available.
+  var root = el.getRootNode ? el.getRootNode() : doc;
+  while (root && root !== doc && root.host) {
+    if (hit === root.host) return false;
+    root = root.host.getRootNode();
+  }
+  return true;
 }
 
 // Capybara's `Node#disabled?` is more permissive than CSS `:disabled`:
 // an `<option>` inside a disabled `<select>` or a disabled `<fieldset>`
 // is reported as disabled, even though those don't match CSS `:disabled`
-// per the HTML spec. Mirrors Cuprite's behavior so the shared specs pass.
+// per the HTML spec — the Capybara shared specs expect them disabled.
 function isDisabled(el) {
   if (el.matches && el.matches(':disabled')) return true;
   if ((el.tagName || '').toUpperCase() === 'OPTION') {
@@ -153,3 +161,60 @@ function visibleText(el) {
   }
   return out;
 }
+
+// Capture intrinsics before page scripts can replace them. Array operations use
+// indexed loops: an overridden map must never detach cache rows from node IDs.
+var hintStringify = JSON.stringify;
+var hintLowerCase = Function.prototype.call.bind(String.prototype.toLowerCase);
+
+// Capybara keeps Result candidates for lazy enumeration, possibly after the DOM
+// changes. Only immutable tag names belong in initial_cache; mutable visibility,
+// geometry and styles must be read live. Text hints are a conservative prefilter.
+function findHints(nodes, spec) {
+  // Bound eager subtree text walks: nested candidates otherwise make first()
+  // quadratic even though Capybara would inspect only the first candidate.
+  if (nodes.length > 512) return nodes;
+  try {
+    var texts = spec.texts || [];
+    var needles = [];
+    for (var i = 0; i < texts.length; i++) {
+      // Ruby splits ASCII whitespace, not every Unicode separator. Unicode
+      // casing can also depend on context (Greek final sigma). Fail open.
+      if (/[^\x00-\x7F]/.test(texts[i])) return nodes;
+      needles[i] = hintLowerCase(texts[i]);
+    }
+    var kept = [];
+    var hints = [];
+    for (var j = 0; j < nodes.length; j++) {
+      var el = nodes[j];
+      var matches = true;
+      if (needles.length) {
+        var all = el.textContent || '';
+        var visible = visibleText(el) || '';
+        // The driver's all_text and visible_text normalize Unicode differently.
+        // Retain such candidates for Capybara's authoritative text comparison.
+        if (!/[^\x00-\x7F]/.test(all + visible)) {
+          all = hintLowerCase(all);
+          visible = hintLowerCase(visible);
+          for (var k = 0; k < needles.length; k++) {
+            if (all.indexOf(needles[k]) === -1 && visible.indexOf(needles[k]) === -1) {
+              matches = false;
+              break;
+            }
+          }
+        }
+      }
+      if (matches) {
+        hints[kept.length] = { tag_name: el.nodeType === 11 ? 'ShadowRoot' :
+          (el.tagName ? hintLowerCase(el.tagName) : '') };
+        kept[kept.length] = el;
+      }
+    }
+    // Publish only after every read succeeds. Any exception returns the exact
+    // original array, without partial filtering or partially constructed hints.
+    kept.__lightpandaHints = hintStringify(hints);
+    return kept;
+  } catch (e) {
+    return nodes;
+  }
+}

data/lib/capybara/lightpanda/keyboard.rb

@@ -97,6 +97,11 @@ module Capybara
       # so JS keydown handlers see the modifier event; CDP's `rawKeyDown` is
       # documented as "no JS keyDown event is generated" and would hide the
       # modifier from listeners that count keydown events.
+      #
+      # Anything that is not a Symbol or an Array is typed as its `to_s`, as
+      # Selenium's `Keys.encode` does: `send_keys [1, :tab]` types "1", and
+      # `nil` types nothing. Without it an Integer was dropped silently and
+      # only the Tab went out.
       def type(*keys)
         active_mods = []
         keys.each do |key|
@@ -107,10 +112,10 @@ module Capybara
             else
               dispatch_key_with_mods(key, active_mods)
             end
-          when String
-            key.each_char { |char| dispatch_char_with_mods(char, active_mods) }
           when Array
             type_with_modifiers(key)
+          else
+            type_text(key, active_mods)
           end
         end
         release_modifiers(active_mods)
@@ -163,14 +168,19 @@ module Capybara
         active_mods = []
         modifiers.each { |m| press_modifier(m, active_mods) }
         rest.each do |key|
-          case key
-          when Symbol then dispatch_key_with_mods(key, active_mods)
-          when String then key.each_char { |char| dispatch_char_with_mods(char, active_mods) }
+          if key.is_a?(Symbol)
+            dispatch_key_with_mods(key, active_mods)
+          else
+            type_text(key, active_mods)
           end
         end
         release_modifiers(active_mods)
       end
 
+      def type_text(key, active_mods)
+        key.to_s.each_char { |char| dispatch_char_with_mods(char, active_mods) }
+      end
+
       # A chord with Ctrl or Meta is a command, not text: Chrome inserts
       # nothing for Ctrl+A, it selects. Since upstream #3542 (build 9580)
       # Lightpanda inserts whatever the keyDown's `text` carries, so sending

data/lib/capybara/lightpanda/network.rb

@@ -92,7 +92,7 @@ module Capybara
 
       # Setting extra headers also lazily enables the Network domain. Without
       # this, headers were silently ignored until the caller separately ran
-      # `network.enable` (or `wait_for_network_idle`). Cuprite/Ferrum parity.
+      # `network.enable` (or `wait_for_network_idle`).
       def headers=(headers)
         enable
         @extra_headers = headers

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.
@@ -639,25 +650,13 @@ 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. Below
-          // upstream #3940 (build 10536) the link's own activation instead
-          // turns `mailto:a@b.com` into `http://mailto:a@b.com/` and loads
-          // b.com (1.0.0), or loses the execution context on a failed `tel:`
-          // navigation (10261–10535). Cancel that default from a window
-          // listener added for this one dispatch: it runs after the page's
-          // own listeners, which still see an uncancelled click.
+          // 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 view = hit.ownerDocument.defaultView;
-          var keepPage = function (e) { if (e === clickEvt) e.preventDefault(); };
-          if (external && view) view.addEventListener('click', keepPage);
-          var notCancelled;
-          try {
-            notCancelled = hit.dispatchEvent(clickEvt);
-          } finally {
-            if (external && view) view.removeEventListener('click', keepPage);
-          }
+          var notCancelled = hit.dispatchEvent(clickEvt);
           if (external || !notCancelled || clickEvt.defaultPrevented) return;
           var tag = hit.tagName;
           // A `javascript:` link never navigates: the click's own activation
@@ -695,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
@@ -715,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);
           }
@@ -776,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,
@@ -813,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);
           }
@@ -828,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"
             }
@@ -856,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);
         }
@@ -1085,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