capybara-lightpanda 0.1.0 → 0.2.1

data/lib/capybara/lightpanda/cookies.rb

@@ -5,6 +5,8 @@ require "yaml"
 module Capybara
   module Lightpanda
     class Cookies
+      include Enumerable
+
       # Typed wrapper around a CDP cookie hash so callers don't have to remember
       # the camelCase keys (`httpOnly`, `sameSite`, …) the CDP returns. Mirrors
       # ferrum's Cookies::Cookie. `attributes` exposes the raw hash for callers
@@ -58,12 +60,21 @@ module Capybara
       end
 
       def all
-        result = browser.command("Network.getCookies")
+        result = browser.command("Network.getAllCookies")
         (result["cookies"] || []).map { |c| Cookie.new(c) }
       end
 
+      # Yields each Cookie. Powers `Enumerable` (so callers can do
+      # `cookies.find { … }`, `cookies.select { … }`, `cookies.to_a`, …
+      # without going through `all` first).
+      def each(&block)
+        return enum_for(:each) unless block
+
+        all.each(&block)
+      end
+
       def get(name)
-        all.find { |cookie| cookie.name == name }
+        find { |cookie| cookie.name == name }
       end
 
       def set(name:, value:, domain: nil, path: "/", secure: false, http_only: false, expires: nil)
@@ -88,29 +99,8 @@ module Capybara
         browser.command("Network.deleteCookies", **params)
       end
 
-      # Lightpanda gotchas observed on current nightly:
-      #   * `Network.clearBrowserCookies` raises `InvalidParams` (so it does NOT
-      #     clear anything despite the upstream PR #1821 / >= v0.2.6 note).
-      #   * `Network.getCookies` (no `urls` param) is scoped to the CURRENT
-      #     page's origin — cookies set on previously-visited domains are
-      #     invisible from a different page.
-      #   * `Network.getCookies` on `about:blank` raises `InvalidDomain`.
-      #
-      # To honor Capybara's `reset_session! removes ALL cookies` contract
-      # across multiple test domains (e.g. `localhost` AND `127.0.0.1`), we
-      # iterate every origin Browser has navigated to and per-origin call
-      # `Network.getCookies(urls: [origin])` then `Network.deleteCookies(url:)`.
-      # The bulk-clear call is still attempted first as a fast path / future-
-      # proofing for when upstream fixes it.
       def clear
-        begin
-          browser.command("Network.clearBrowserCookies")
-        rescue BrowserError, TimeoutError, StandardError
-          # InvalidParams on current nightly; pre-v0.2.6 used to crash the
-          # WebSocket. Either way, fall through to per-origin sweep.
-        end
-
-        sweep_visited_origins
+        browser.command("Network.clearBrowserCookies")
       end
 
       # Persist all current cookies to a YAML file (ferrum parity).
@@ -131,35 +121,6 @@ module Capybara
 
       private
 
-      def sweep_visited_origins
-        origins = browser.visited_origins.to_a
-        return if origins.empty?
-
-        result = browser.command("Network.getCookies", urls: origins)
-        cookies = result["cookies"] || []
-        cookies.each do |cookie|
-          # CDP needs either domain or url; build a url from the cookie's
-          # own domain+path so we don't mismatch (e.g. cookie domain `.x.test`
-          # against an origin we tracked as `https://x.test:443`).
-          url = cookie_url(cookie)
-          params = { name: cookie["name"] }
-          params[:url] = url if url
-          params[:domain] = cookie["domain"] unless url
-          browser.command("Network.deleteCookies", **params)
-        end
-      rescue StandardError
-        # Connection lost or origin no longer valid; nothing more to do.
-      end
-
-      def cookie_url(cookie)
-        domain = cookie["domain"].to_s.sub(/\A\./, "")
-        return nil if domain.empty?
-
-        scheme = cookie["secure"] ? "https" : "http"
-        path = cookie["path"] || "/"
-        "#{scheme}://#{domain}#{path}"
-      end
-
       # set() takes keyword args, but YAML round-trips give us a hash with the
       # raw CDP keys (camelCase). Normalize and forward.
       def restore_cookie(hash)

data/lib/capybara/lightpanda/driver.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "forwardable"
+require "uri"
 
 module Capybara
   module Lightpanda
@@ -16,6 +17,7 @@ module Capybara
         @app = app
         @options = options
         @browser = nil
+        @started = false
       end
 
       def browser
@@ -30,6 +32,7 @@ module Capybara
       end
 
       def visit(url)
+        @started = true
         browser.go_to(url)
       end
 
@@ -84,11 +87,26 @@ module Capybara
         unwrap_script_result(browser.evaluate_async(script.strip, *native_args(args)))
       end
 
+      # -- Network Inspection --
+
+      # Network tracker (lazily auto-enabled). Exposes `traffic`, `clear`,
+      # `wait_for_idle`, header overrides, etc. Cuprite parity.
+      def network
+        browser.network
+      end
+
+      # Block until in-flight HTTP traffic settles. Auto-enables the tracker
+      # on first call so callers don't have to remember to flip it on.
+      # Returns true on success, false on timeout.
+      def wait_for_network_idle(timeout: 5, connections: 0)
+        network.enable
+        network.wait_for_idle(timeout: timeout, connections: connections)
+      end
+
       # -- Cookie Management --
 
       def set_cookie(name, value, **options)
-        cookie_options = {}
-        cookie_options[:domain] = options[:domain] if options[:domain]
+        cookie_options = { domain: options[:domain] || default_domain }
         cookie_options[:path] = options[:path] if options[:path]
         cookie_options[:secure] = options[:secure] if options.key?(:secure)
         if options.key?(:httpOnly) || options.key?(:http_only)
@@ -178,11 +196,12 @@ module Capybara
 
       # -- Lifecycle --
 
+      # Thin Cuprite-style wrapper. The interesting work — disposing the
+      # BrowserContext (cookies, storage, all targets) and starting a fresh
+      # one — happens in Browser#reset.
       def reset!
-        browser.clear_frames
-        browser.reset_modals
-        browser.cookies.clear
-        browser.go_to("about:blank")
+        browser.reset
+        @started = false
       rescue StandardError
         @browser&.quit
         @browser = nil
@@ -232,6 +251,24 @@ module Capybara
         args.map { |a| a.is_a?(Capybara::Node::Element) ? a.base : a }
       end
 
+      # 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.
+      def default_domain
+        candidate = (@started && safe_uri_host(browser.current_url)) ||
+                    safe_uri_host(Capybara.app_host)
+        candidate || "127.0.0.1"
+      end
+
+      def safe_uri_host(url)
+        return nil if url.nil? || url.empty? || url == "about:blank"
+
+        URI(url).host
+      rescue URI::InvalidURIError
+        nil
+      end
+
       # Walk through evaluate-script results turning DOM-node markers (the
       # `{ "__lightpanda_node__" => "..." }` hashes produced by `Browser#unwrap_call_result`)
       # into Lightpanda::Node instances so Capybara can wrap them as elements.

data/lib/capybara/lightpanda/errors.rb

@@ -9,34 +9,77 @@ module Capybara
     class BinaryError < Error; end
     class UnsupportedPlatformError < Error; end
 
-    class DeadBrowserError < Error; end
     class TimeoutError < Error; end
 
+    # Base class for any error originating from a CDP response or live browser
+    # state. Lets callers `rescue BrowserError` to catch the whole CDP family
+    # in one go (mirrors ferrum's hierarchy). Accepts either a CDP error hash
+    # (`{"message" => ..., "code" => ...}`) or a plain string for callsites
+    # that raise with a literal message.
     class BrowserError < Error
       attr_reader :response
 
-      def initialize(response)
-        @response = response
-        super(response["message"])
+      def initialize(response_or_message = nil)
+        if response_or_message.is_a?(Hash)
+          @response = response_or_message
+          super(response_or_message["message"])
+        else
+          @response = nil
+          super
+        end
+      end
+
+      def code
+        @response&.dig("code")
+      end
+
+      def data
+        @response&.dig("data")
       end
     end
 
-    class JavaScriptError < Error
-      attr_reader :class_name, :message
+    class DeadBrowserError < BrowserError; end
+    class NodeNotFoundError < BrowserError; end
+    class NoExecutionContextError < BrowserError; end
+
+    class JavaScriptError < BrowserError
+      attr_reader :class_name, :stack_trace
 
       def initialize(response)
-        @class_name = response.dig("exceptionDetails", "exception", "className")
-        @message = response.dig("exceptionDetails", "exception",
-                                "description") || response.dig("exceptionDetails", "text")
+        details = response["exceptionDetails"] || {}
+        exception = details["exception"] || {}
+        @class_name = exception["className"]
+        @stack_trace = details["stackTrace"]
+        super(build_message(details, exception))
+      end
 
-        super(@message)
+      private
+
+      def build_message(details, exception)
+        base = exception["description"] || details["text"] || "JsException"
+        parts = [base]
+        parts << "(#{@class_name})" if @class_name && !base.include?(@class_name)
+        if (val = exception["value"])
+          parts << "value=#{val.inspect}"
+        end
+        if @stack_trace && (frames = @stack_trace["callFrames"])
+          parts << format_stack(frames)
+        end
+        parts.join(" | ")
       end
-    end
 
-    class NodeNotFoundError < Error; end
-    class NoExecutionContextError < Error; end
+      def format_stack(frames)
+        formatted = frames.first(5).map { |f| format_frame(f) }
+        "stack:\n  #{formatted.join("\n  ")}"
+      end
+
+      def format_frame(frame)
+        name = frame["functionName"].to_s.empty? ? "<anon>" : frame["functionName"]
+        "#{name} @ #{frame['url']}:#{frame['lineNumber']}:#{frame['columnNumber']}"
+      end
+    end
 
-    class ObsoleteNode < Error
+    class ObsoleteNode < BrowserError
       attr_reader :node
 
       def initialize(node, message = nil)
@@ -45,7 +88,7 @@ module Capybara
       end
     end
 
-    class MouseEventFailed < Error
+    class MouseEventFailed < BrowserError
       attr_reader :node, :selector, :position
 
       PATTERN = /at position \((\d+),\s*(\d+)\).*selector:\s*(.+)/i

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

@@ -822,43 +822,36 @@
     // cascade. Available in iframes too because index.js is registered via
     // Page.addScriptToEvaluateOnNewDocument.
 
-    // Returns true if `el` is visible per Capybara's semantics: not in an
-    // unrendered tag (HEAD/SCRIPT/TEMPLATE/etc), no `hidden` attribute on
-    // self/ancestor, no closed-<details> ancestor, not visibility:hidden, and
-    // (when checkVisibility() is unavailable) not display:none.
+    // Returns true if `el` is visible per Capybara's semantics. Lightpanda's
+    // UA stylesheet (PR #2294, nightly ≥5918) puts `display:none` on
+    // HEAD/SCRIPT/STYLE/NOSCRIPT/TEMPLATE/TITLE and `[type=hidden]`, and
+    // `[hidden]` / closed-<details> children also resolve to `display:none`
+    // through the cascade — so a single display:none walk catches the
+    // unrendered-element cases without an explicit tag list. `visibility`
+    // and offsetParent stay explicit because they aren't covered by display.
+    // `checkVisibility()` does the parent walk for us when available.
     //
     // `opts.checkOffsetParent` (default true): when true, also rejects
-    // elements with offsetParent === null as a fallback for ancestor display:none.
-    // The visible_text walker passes false because it already short-circuits
-    // when descending into hidden subtrees.
+    // elements with `offsetParent === null` as a fallback for ancestor
+    // `display:none`. The visible_text walker passes false because it
+    // already short-circuits when descending into hidden subtrees.
     isVisible: function(el, opts) {
       if (!el || el.nodeType !== 1) return false;
       var checkOffsetParent = !opts || opts.checkOffsetParent !== false;
       var TAG = (el.tagName || '').toUpperCase();
-      if (TAG === 'HEAD' || TAG === 'TEMPLATE' || TAG === 'NOSCRIPT' ||
-          TAG === 'SCRIPT' || TAG === 'STYLE' || TAG === 'TITLE') return false;
-      if (TAG === 'INPUT' && (el.type || '').toLowerCase() === 'hidden') return false;
-
-      var node = el;
-      while (node && node.nodeType === 1) {
-        if (node.hasAttribute && node.hasAttribute('hidden')) return false;
-        var parent = node.parentNode;
-        if (parent && parent.nodeType === 1) {
-          var ptag = (parent.tagName || '').toUpperCase();
-          if (ptag === 'HEAD' || ptag === 'TEMPLATE' || ptag === 'NOSCRIPT') return false;
-          if (ptag === 'DETAILS' && !parent.open) {
-            var ntag = (node.tagName || '').toUpperCase();
-            if (ntag !== 'SUMMARY') return false;
-          }
-        }
-        node = parent;
-      }
 
       var win = el.ownerDocument.defaultView || window;
       var style = win.getComputedStyle(el);
       if (style.visibility === 'hidden' || style.visibility === 'collapse') return false;
-      if (typeof el.checkVisibility === 'function') return el.checkVisibility();
-      if (style.display === 'none') return false;
+      if (typeof el.checkVisibility === 'function') {
+        if (!el.checkVisibility()) return false;
+      } else {
+        var node = el;
+        while (node && node.nodeType === 1) {
+          if (win.getComputedStyle(node).display === 'none') return false;
+          node = node.parentElement;
+        }
+      }
       if (checkOffsetParent && el.offsetParent === null && style.position !== 'fixed' &&
           TAG !== 'BODY' && TAG !== 'HTML') return false;
       return true;
@@ -893,36 +886,18 @@
       return !el.contains(hit);
     },
 
-    // HTML defines a disabled form control as one whose own `disabled`
-    // attribute is set OR whose ancestor select/optgroup/fieldset is disabled
-    // (with a fieldset-disabled exception for descendants of its first legend).
-    // `el.disabled` only reflects the element's own attribute, so we walk
-    // up the tree to honor the inherited cases.
+    // 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.
     isDisabled: function(el) {
-      if (el.disabled) return true;
-      var tag = (el.tagName || '').toUpperCase();
-      if (tag === 'OPTION') {
+      if (el.matches && el.matches(':disabled')) return true;
+      if ((el.tagName || '').toUpperCase() === 'OPTION') {
         var p = el.parentElement;
-        while (p && (p.tagName || '').toUpperCase() === 'OPTGROUP') {
+        while (p) {
           if (p.disabled) return true;
           p = p.parentElement;
         }
-        if (p && (p.tagName || '').toUpperCase() === 'SELECT' && p.disabled) return true;
-      }
-      var FORM = { INPUT:1, BUTTON:1, SELECT:1, TEXTAREA:1, OPTION:1 };
-      if (FORM[tag]) {
-        var node = el.parentElement;
-        while (node) {
-          if ((node.tagName || '').toUpperCase() === 'FIELDSET' && node.disabled) {
-            var firstLegend = null;
-            for (var c = node.firstElementChild; c; c = c.nextElementSibling) {
-              if ((c.tagName || '').toUpperCase() === 'LEGEND') { firstLegend = c; break; }
-            }
-            if (firstLegend && firstLegend.contains(el)) return false;
-            return true;
-          }
-          node = node.parentElement;
-        }
       }
       return false;
     },
@@ -988,7 +963,12 @@
         for (var i = 0; i < node.childNodes.length; i++) {
           out += walk(node.childNodes[i]);
         }
-        if (isBlock) out = '\n' + out + '\n';
+        // Block-level elements get wrapped in \n…\n only when they actually
+        // contribute visible text. An empty <div> between two inline siblings
+        // would otherwise introduce a phantom line break that Chrome's
+        // innerText algorithm collapses out (required line breaks around
+        // empty blocks coalesce in the line-collapse pass).
+        if (isBlock && /\S/.test(out)) out = '\n' + out + '\n';
         return out;
       }
 
@@ -1015,94 +995,4 @@
       };
     };
   }
-
-  // --- ID-shorthand rewriter for querySelector/querySelectorAll ---
-  // Lightpanda has a CSS-engine bug where `#id` selectors fail after the body is
-  // modified via innerHTML and then replaced (e.g. Turbo Drive's snapshot+swap).
-  // `[id="..."]` always works, so rewrite `#foo` -> `[id="foo"]` outside of
-  // brackets and quoted strings before delegating to the native engine.
-
-  (function() {
-    if (typeof Document === 'undefined' || typeof Element === 'undefined') return;
-
-    function rewriteIdShorthand(selector) {
-      if (typeof selector !== 'string' || selector.indexOf('#') < 0) return selector;
-      var out = '', i = 0, n = selector.length, depth = 0, quote = null;
-      while (i < n) {
-        var c = selector.charAt(i);
-        if (quote) {
-          out += c;
-          if (c === '\\' && i + 1 < n) { out += selector.charAt(i + 1); i += 2; continue; }
-          if (c === quote) quote = null;
-          i++; continue;
-        }
-        if (c === '"' || c === "'") { quote = c; out += c; i++; continue; }
-        if (c === '[') { depth++; out += c; i++; continue; }
-        if (c === ']') { if (depth > 0) depth--; out += c; i++; continue; }
-        if (c === '\\' && i + 1 < n) { out += c + selector.charAt(i + 1); i += 2; continue; }
-        if (c === '#' && depth === 0) {
-          var j = i + 1, start = j;
-          while (j < n) {
-            var cc = selector.charCodeAt(j);
-            if (cc === 92 && j + 1 < n) { j += 2; continue; }
-            // CSS identifier chars: A-Z a-z 0-9 _ - or non-ASCII (>= 128)
-            if ((cc >= 48 && cc <= 57) || (cc >= 65 && cc <= 90) ||
-                (cc >= 97 && cc <= 122) || cc === 45 || cc === 95 || cc >= 128) { j++; continue; }
-            break;
-          }
-          if (j > start) {
-            var id = selector.substring(start, j);
-            out += '[id="' + id.replace(/\\/g, '\\\\').replace(/"/g, '\\"') + '"]';
-            i = j; continue;
-          }
-        }
-        out += c; i++;
-      }
-      return out;
-    }
-
-    function patch(proto) {
-      if (!proto) return;
-      var origQS = proto.querySelector;
-      var origQSA = proto.querySelectorAll;
-      if (typeof origQS === 'function') {
-        proto.querySelector = function(s) { return origQS.call(this, rewriteIdShorthand(s)); };
-      }
-      if (typeof origQSA === 'function') {
-        proto.querySelectorAll = function(s) { return origQSA.call(this, rewriteIdShorthand(s)); };
-      }
-    }
-
-    patch(Document.prototype);
-    patch(Element.prototype);
-    if (typeof DocumentFragment !== 'undefined') patch(DocumentFragment.prototype);
-  })();
-
-  // --- requestSubmit polyfill ---
-  // Required for Turbo form interception. Turbo listens for the `submit` event,
-  // but form.submit() doesn't fire it. requestSubmit() does.
-
-  if (typeof HTMLFormElement !== 'undefined' && !HTMLFormElement.prototype.requestSubmit) {
-    HTMLFormElement.prototype.requestSubmit = function(submitter) {
-      if (submitter) {
-        var validTypes = {submit: 1, image: 1};
-        if (!validTypes[(submitter.type || '').toLowerCase()]) {
-          throw new TypeError('The specified element is not a submit button.');
-        }
-        if (submitter.form !== this) {
-          throw new DOMException('The specified element is not owned by this form element.', 'NotFoundError');
-        }
-      }
-      var event;
-      if (typeof SubmitEvent === 'function') {
-        event = new SubmitEvent('submit', {bubbles: true, cancelable: true, submitter: submitter || null});
-      } else {
-        event = new Event('submit', {bubbles: true, cancelable: true});
-        event.submitter = submitter || null;
-      }
-      if (this.dispatchEvent(event)) {
-        this.submit();
-      }
-    };
-  }
 })();

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

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

data/lib/capybara/lightpanda/keyboard.rb

@@ -73,18 +73,59 @@ module Capybara
         @browser = browser
       end
 
+      # A top-level modifier symbol (`:shift`, `:ctrl`, `:alt`, `:meta`) is
+      # held for the remainder of the call — `send_keys('ocean', :shift, 'side')`
+      # types `oceanSIDE`. Modifier presses fire `keyDown` (not `rawKeyDown`)
+      # 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.
       def type(*keys)
+        active_mods = []
         keys.each do |key|
           case key
-          when Symbol then dispatch_key(key)
-          when String then key.each_char { |char| dispatch_char(char) }
-          when Array  then type_with_modifiers(key)
+          when Symbol
+            if MODIFIERS.key?(key)
+              press_modifier(key, active_mods)
+            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)
           end
         end
+        release_modifiers(active_mods)
       end
 
       private
 
+      def press_modifier(mod, active_mods)
+        return if active_mods.include?(mod)
+
+        send_key_event("keyDown", KEYS[mod])
+        active_mods << mod
+      end
+
+      def release_modifiers(active_mods)
+        active_mods.reverse_each { |m| send_key_event("keyUp", KEYS[m]) }
+        active_mods.clear
+      end
+
+      def dispatch_key_with_mods(key, active_mods)
+        return dispatch_key(key) if active_mods.empty?
+
+        modifier_value = active_mods.sum { |m| MODIFIERS[m] }
+        dispatch_modified(key, modifier_value, active_mods)
+      end
+
+      def dispatch_char_with_mods(char, active_mods)
+        return dispatch_char(char) if active_mods.empty?
+
+        modifier_value = active_mods.sum { |m| MODIFIERS[m] }
+        dispatch_modified_char(char, modifier_value, active_mods)
+      end
+
       def dispatch_key(key)
         definition = KEYS.fetch(key) { raise ArgumentError, "Unknown key: #{key.inspect}" }
         raw_dispatch(definition)
@@ -98,7 +139,7 @@ module Capybara
         modifiers, chars = keys.partition { |k| k.is_a?(Symbol) && MODIFIERS.key?(k) }
         modifier_value = modifiers.sum { |m| MODIFIERS[m] }
 
-        modifiers.each { |m| send_key_event("rawKeyDown", KEYS[m]) }
+        modifiers.each { |m| send_key_event("keyDown", KEYS[m]) }
         chars.each { |key| dispatch_modified(key, modifier_value, modifiers) }
         modifiers.reverse_each { |m| send_key_event("keyUp", KEYS[m]) }
       end