capybara-lightpanda 0.2.2 → 0.4.0

data/lib/capybara/lightpanda/keyboard.rb

@@ -69,6 +69,23 @@ module Capybara
         shift: 8,
       }.freeze
 
+      # US-layout shifted variants of the printable ASCII characters that
+      # don't just upcase. Used by dispatch_modified_char so
+      # send_keys([:shift, "1"]) types "!" instead of "1". Letters fall
+      # through to String#upcase via the default branch.
+      SHIFT_MAP = {
+        "1" => "!", "2" => "@", "3" => "#", "4" => "$", "5" => "%",
+        "6" => "^", "7" => "&", "8" => "*", "9" => "(", "0" => ")",
+        "-" => "_", "=" => "+", "[" => "{", "]" => "}", "\\" => "|",
+        ";" => ":", "'" => "\"", "," => "<", "." => ">", "/" => "?",
+        "`" => "~",
+      }.freeze
+      private_constant :SHIFT_MAP
+
+      def self.shifted(char)
+        SHIFT_MAP[char] || char.upcase
+      end
+
       def initialize(browser)
         @browser = browser
       end
@@ -155,7 +172,7 @@ module Capybara
       end
 
       def dispatch_modified_char(char, modifier_value, modifiers)
-        text = modifiers.include?(:shift) ? char.upcase : char
+        text = modifiers.include?(:shift) ? self.class.shifted(char) : char
         send_key_event("keyDown", { key: text, text: text, unmodifiedText: char }, modifiers: modifier_value)
         send_key_event("keyUp", { key: text }, modifiers: modifier_value)
       end

data/lib/capybara/lightpanda/network.rb

@@ -8,6 +8,7 @@ module Capybara
       def initialize(browser)
         @browser = browser
         @traffic = []
+        @traffic_mutex = Mutex.new
         @enabled = false
         @request_handler = nil
         @response_handler = nil
@@ -35,11 +36,11 @@ module Capybara
       end
 
       def traffic
-        @traffic.dup
+        @traffic_mutex.synchronize { @traffic.dup }
       end
 
       def clear
-        @traffic.clear
+        @traffic_mutex.synchronize { @traffic.clear }
       end
 
       # Wipe local state without sending Network.disable. Called by
@@ -50,61 +51,89 @@ module Capybara
       # cleared the Subscriber first.
       def reset
         unsubscribe
-        @traffic.clear
+        @traffic_mutex.synchronize { @traffic.clear }
         @enabled = false
       end
 
+      # 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.
       def headers=(headers)
+        enable
         @extra_headers = headers
         browser.page_command("Network.setExtraHTTPHeaders", headers: headers)
       end
 
       def add_headers(headers)
+        enable
         @extra_headers = (@extra_headers || {}).merge(headers)
         browser.page_command("Network.setExtraHTTPHeaders", headers: @extra_headers)
       end
 
       def clear_headers
+        enable
         @extra_headers = {}
         browser.page_command("Network.setExtraHTTPHeaders", headers: {})
       end
 
-      def wait_for_idle(timeout: 5, connections: 0) # rubocop:disable Naming/PredicateMethod
-        started_at = Time.now
-
-        while Time.now - started_at < timeout
-          pending = @traffic.count { |t| t[:response].nil? }
-          return true if pending <= connections
+      # Count of in-flight requests (those with no response yet recorded).
+      # Cheap predicate-friendly accessor (ferrum parity).
+      def pending_connections
+        @traffic_mutex.synchronize { @traffic.count { |t| t[:response].nil? } }
+      end
 
-          sleep 0.1
-        end
+      # True when no more than `connections` requests are in-flight.
+      def idle?(connections = 0)
+        pending_connections <= connections
+      end
 
+      def wait_for_idle(timeout: 5, connections: 0)
+        wait_for_idle!(timeout: timeout, connections: connections)
+      rescue TimeoutError
         false
       end
 
+      # Raising variant of #wait_for_idle (ferrum parity). Returns true on
+      # success, raises TimeoutError on timeout so callers that treat the
+      # idle wait as a precondition don't have to remember to check a bool.
+      def wait_for_idle!(timeout: 5, connections: 0) # rubocop:disable Naming/PredicateMethod
+        Utils::Wait.until(
+          timeout: timeout,
+          interval: 0.1,
+          message: "Network did not become idle within #{timeout}s " \
+                   "(pending=#{pending_connections}, allowed=#{connections})"
+        ) { idle?(connections) }
+        true
+      end
+
       private
 
       def subscribe
+        # CDP events arrive on the message thread while wait_for_idle /
+        # pending_connections read from the main thread; serialize all
+        # @traffic mutations and reads through @traffic_mutex.
         @request_handler = lambda do |params|
-          @traffic << {
+          entry = {
             request_id: params["requestId"],
             url: params.dig("request", "url"),
             method: params.dig("request", "method"),
             timestamp: params["timestamp"],
             response: nil,
           }
+          @traffic_mutex.synchronize { @traffic << entry }
         end
 
         @response_handler = lambda do |params|
-          request = @traffic.find { |t| t[:request_id] == params["requestId"] }
-
-          next unless request
-
-          request[:response] = {
-            status: params.dig("response", "status"),
-            headers: params.dig("response", "headers"),
-            mime_type: params.dig("response", "mimeType"),
-          }
+          @traffic_mutex.synchronize do
+            request = @traffic.find { |t| t[:request_id] == params["requestId"] }
+            next unless request
+
+            request[:response] = {
+              status: params.dig("response", "status"),
+              headers: params.dig("response", "headers"),
+              mime_type: params.dig("response", "mimeType"),
+            }
+          end
         end
 
         browser.on("Network.requestWillBeSent", &@request_handler)

data/lib/capybara/lightpanda/node.rb

@@ -14,12 +14,10 @@ module Capybara
       end
 
       def text
-        ensure_connected
         call("function() { return this.textContent }")
       end
 
       def all_text
-        ensure_connected
         filter_text(call("function() { return this.textContent }"))
       end
 
@@ -28,7 +26,6 @@ module Capybara
       # that fail VISIBLE_JS, and emit newlines around block-display elements
       # (the part of innerText behavior we still need).
       def visible_text
-        ensure_connected
         call(VISIBLE_TEXT_JS).to_s
                              .gsub(/\A[[:space:]&&[^\u00A0]]+/, "")
                              .gsub(/[[:space:]&&[^\u00A0]]+\z/, "")
@@ -116,6 +113,17 @@ module Capybara
         call("function() { this.dispatchEvent(new MouseEvent('mouseover', {bubbles: true, cancelable: true})) }")
       end
 
+      # Lightpanda has no rendering engine — `window.scrollTo` / `scrollIntoView`
+      # are no-ops at the browser level, and `getBoundingClientRect` reflects
+      # logical-DOM geometry rather than scroll-aware viewport coords. So
+      # there's nothing to scroll. Silently succeed so callers like
+      # `session.scroll_to(find('#thing'))` (Selenium-flavoured specs leaning
+      # on real layout) don't crash with NotImplementedError; assertions that
+      # depend on post-scroll visibility are already gated by the cuprite
+      # fallback in dual-driver setups.
+      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
@@ -199,6 +207,13 @@ module Capybara
         call(GET_PATH_JS)
       end
 
+      # Ancestor chain from `parentNode` up to (but not including) `document`,
+      # returned as Lightpanda::Node wrappers. Mirrors Cuprite's `Node#parents`.
+      def parents
+        oids = driver.browser.parents_of(@remote_object_id)
+        oids.map { |oid| self.class.new(driver, oid) }
+      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) }
@@ -243,19 +258,6 @@ module Capybara
 
       private
 
-      # Capybara's `automatic_reload` re-runs the original query when an element
-      # access raises one of the driver's `invalid_element_errors`. After a DOM
-      # mutation like `replaceWith`, our cached objectId still resolves to the
-      # detached node, so reads succeed (with stale data) and the auto-reload
-      # never fires. Detect detachment via `isConnected` and raise so the
-      # synchronize-loop notices and triggers a re-find.
-      def ensure_connected
-        connected = call("function() { return this.isConnected }")
-        return if connected
-
-        raise ObsoleteNode.new(self, "Node is no longer attached to the document")
-      end
-
       def implicit_submit
         call(IMPLICIT_SUBMIT_JS)
         driver.browser.wait_for_idle
@@ -277,6 +279,10 @@ module Capybara
           call(SET_VALUE_JS, format_time_value(value))
         when "datetime-local"
           call(SET_VALUE_JS, format_datetime_value(value))
+        when "month"
+          call(SET_VALUE_JS, format_month_value(value))
+        when "week"
+          call(SET_VALUE_JS, format_week_value(value))
         else
           fill_text_input(type, value.to_s)
         end
@@ -316,6 +322,22 @@ module Capybara
         value.to_time.strftime("%Y-%m-%dT%H:%M")
       end
 
+      def format_month_value(value)
+        return value.to_s if value.is_a?(String) || !value.respond_to?(:to_date)
+
+        value.to_date.strftime("%Y-%m")
+      end
+
+      # 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.
+      def format_week_value(value)
+        return value.to_s if value.is_a?(String) || !value.respond_to?(:to_date)
+
+        value.to_date.strftime("%G-W%V")
+      end
+
       # `maxlength` only constrains user typing, not direct value assignment, but
       # Selenium-style drivers truncate to match what a user would have ended up
       # with. Honor it explicitly so Capybara-shared specs behave the same.
@@ -345,24 +367,41 @@ module Capybara
       # JS bodies may reference `_lightpanda.*` helpers — they're registered via
       # Page.addScriptToEvaluateOnNewDocument in every document (top frame and
       # iframes alike), so the namespace is available wherever `this` lives.
+      #
+      # The supplied declaration is wrapped with an `isConnected` guard so a
+      # detached node raises ObsoleteNode (in Driver#invalid_element_errors)
+      # instead of returning stale data from V8's still-live reference. After
+      # a DOM mutation like `replaceWith`, the cached objectId still resolves
+      # to the detached node, so reads succeed quietly and Capybara's
+      # automatic_reload never re-runs the original query.
       def call(function_declaration, *args)
+        guarded = wrap_with_attached_guard(function_declaration)
         driver.browser.with_default_context_wait do
-          driver.browser.call_function_on(@remote_object_id, function_declaration, *args)
+          driver.browser.call_function_on(@remote_object_id, guarded, *args)
         end
       rescue JavaScriptError => e
+        if e.message.include?(OBSOLETE_NODE_MARKER)
+          raise ObsoleteNode.new(self, "Node is no longer attached to the document")
+        end
+
         case e.class_name
         when "InvalidSelector"
           raise InvalidSelector.new(e.message, nil, args.first)
         else
           raise
         end
-      rescue BrowserError => e
-        case e.message
-        when /MouseEventFailed/i
-          raise MouseEventFailed.new(self, e.response&.dig("message"))
-        else
-          raise
-        end
+      end
+
+      OBSOLETE_NODE_MARKER = "LIGHTPANDA_OBSOLETE_NODE"
+      private_constant :OBSOLETE_NODE_MARKER
+
+      def wrap_with_attached_guard(function_declaration)
+        <<~JS
+          function() {
+            if (!this.isConnected) throw new Error(#{OBSOLETE_NODE_MARKER.inspect});
+            return (#{function_declaration}).apply(this, arguments);
+          }
+        JS
       end
 
       # We dispatch a `MouseEvent` (not a generic `Event`) because Turbo's link
@@ -372,15 +411,14 @@ module Capybara
       # the manual default action below, which does a full-page navigation
       # instead of a frame swap.
       #
-      # For submit buttons (`<button type=submit>`, `<input type=submit>`,
-      # `<input type=image>`): route through `form.requestSubmit(this)` so the
-      # browser dispatches a real `SubmitEvent` with submitter set, honors the
-      # submitter's `formaction` / `formmethod` / `formenctype`, and includes
-      # the submitter's name/value in the form data. A manual
-      # `dispatchEvent(new Event('submit'))` + `form.submit()` would lose all of
-      # that and break Turbo Drive / Hotwire form handling. We can't rely on
-      # the synthetic click's default action because synthetic events don't
-      # trigger the implicit form-submission default action per DOM spec.
+      # Submit buttons (`<input type=submit>`, `<input type=image>`,
+      # `<button type=submit>`): native click on the dispatched MouseEvent
+      # already runs the form-submission default action via Frame.submitForm
+      # in Lightpanda (extension of PR #2312 for image to all submit
+      # variants). A manual `form.requestSubmit(this)` here would fire a
+      # second SubmitEvent and double-submit the form — observed on nightly
+      # 6167 as duplicate `turbo:submit-start` events; the first request
+      # gets aborted by the second and Turbo never renders the response.
       CLICK_JS = <<~JS
         function() {
           var EventCtor = (typeof MouseEvent !== 'undefined') ? MouseEvent : Event;
@@ -388,24 +426,7 @@ module Capybara
           var notCancelled = this.dispatchEvent(clickEvt);
           if (!notCancelled || clickEvt.defaultPrevented) return;
           var tag = this.tagName;
-          var type = (this.type || '').toLowerCase();
-          var isSubmitButton =
-            (tag === 'BUTTON' && (type === 'submit' || type === '')) ||
-            (tag === 'INPUT' && (type === 'submit' || type === 'image'));
-          if (isSubmitButton && this.form) {
-            // Lightpanda raises a JsException from requestSubmit when a
-            // bubble-phase listener (e.g. Turbo's submitBubbled) calls
-            // preventDefault + stopImmediatePropagation on the SubmitEvent.
-            // Per HTML spec a cancelled submission should be a silent no-op.
-            // Log unexpected errors via console.warn so they remain
-            // diagnosable (LIGHTPANDA_DEBUG surfaces console output) instead
-            // of silently swallowing future regressions.
-            try {
-              this.form.requestSubmit(this);
-            } catch (e) {
-              try { console.warn('[capybara-lightpanda] requestSubmit threw:', e && e.message ? e.message : e); } catch (_) {}
-            }
-          } else if (tag === 'A' && this.href && this.target !== '_blank') {
+          if (tag === 'A' && this.href && this.target !== '_blank') {
             // Same-document fragment-only navigation: just update hash (or do
             // nothing if identical). Mirrors Chrome — assigning location.href
             // to a same-document URL on Lightpanda triggers a real navigation

data/lib/capybara/lightpanda/process.rb

@@ -8,10 +8,10 @@ module Capybara
       READY_PATTERN = /server running.*address\s*=\s*(\d+\.\d+\.\d+\.\d+:\d+)/m
       ADDRESS_IN_USE_PATTERN = /err=AddressInUse/
 
-      # Floor for the cookie/navigation/redirect/modal/keyboard/css/forms/dispatch
-      # fixes the gem now relies on: PR #2255 (Network.clearBrowserCookies
-      # empty params + Network.getAllCookies), PR #2257
-      # (window.location.pathname/.search assignment triggers navigation),
+      # Floor for the cookie/navigation/redirect/modal/keyboard/css/forms/dispatch/
+      # xpath/history/iframe-context/dialog fixes the gem now relies on:
+      # PR #2255 (Network.clearBrowserCookies empty params + Network.getAllCookies),
+      # PR #2257 (window.location.pathname/.search assignment triggers navigation),
       # PR #2265 (URL fragment inherited across fragment-less redirect),
       # PR #2261 (LP.handleJavaScriptDialog pre-arm), PR #2283 (Referer on
       # cross-page nav), PR #2292 (KeyboardEvent.keyCode/charCode), PR #2294
@@ -25,10 +25,37 @@ module Capybara
       # PR #2342 (<summary> click toggles parent <details>.open),
       # PR #2352 (HTMLInputElement.pattern + patternMismatch via V8 RegExp),
       # PR #2368 (events: report listener exceptions instead of halting
-      # dispatch — lets us drop the polyfills.js patchDispatch IIFE).
-      # Build 6065 = main HEAD 61364437 (2026-05-06, PR #2368 merge);
-      # ships in nightly published 2026-05-06 ~03:30 UTC for all four platforms.
-      MINIMUM_NIGHTLY_BUILD = Gem::Version.new("6065")
+      # dispatch — load-bearing for the gem's JS bundle dispatch assumptions),
+      # PR #2289 (Page.getNavigationHistory + Page.navigateToHistoryEntry —
+      # lets us drop the history.back()/history.forward() JS workaround in
+      # Browser#back / #forward), PR #2305 (XPath 1.0: Document.evaluate,
+      # XPathResult, XPathEvaluator, XPathExpression — lets us drop the
+      # ~700 LOC XPath polyfill in javascripts/index.js),
+      # PR #2431 (cdp: remove duplicate Page.frameNavigated emission + reuse
+      # child frame's V8 context — fixes issue #2400 iframe contextId churn,
+      # lets us drop Browser#find_in_frame's refresh_frame_stack! rescue),
+      # PR #2445 (cdp: reset browser context arena on Target.disposeBrowserContext
+      # — restores per-spec state hygiene during Driver#reset!, cures the
+      # batch-mode pollution that PR #2431 alone exposed),
+      # PR #2435 (dom: implement HTMLDialogElement.{show, showModal, close}
+      # natively — load-bearing for the gem's HTMLDialogElement assumptions
+      # after polyfills.js was deleted),
+      # PR #2450 (forms: add enctype + 5 submitter form-* IDL accessors +
+      # text/plain submission — lets us delete polyfills.js entirely; reads
+      # of form.enctype / submitter.form{Action,Enctype,Method,NoValidate,
+      # Target} now return spec-typed values natively),
+      # PR #2478 (css: evaluate @media and matchMedia against viewport —
+      # inline <style> @media blocks now apply declarations against the
+      # hardcoded 1920×1080 viewport, and window.matchMedia(q).matches
+      # returns spec-correct booleans. Lets _lightpanda.isVisible detect
+      # inline-@media-gated hides via el.checkVisibility() without any
+      # gem-side workaround. External <link rel="stylesheet"> fetch stays
+      # out of scope by design — see .claude/rules/lightpanda-io.md
+      # limitation #6).
+      # Build 6269 = first nightly carrying PR #2478 (merge commit
+      # ab63cfbf, 2026-05-16); the 2026-05-16 nightly cut at 03:36 UTC
+      # was hours before the merge at 13:42 UTC.
+      MINIMUM_NIGHTLY_BUILD = Gem::Version.new("6269")
 
       attr_reader :pid, :ws_url, :version, :nightly_build
 
@@ -42,10 +69,11 @@ module Capybara
         @stdout_w = nil
         @stderr_r = nil
         @stderr_w = nil
+        @finalizer_registered = false
       end
 
       def start
-        binary_path = @options.browser_path || Binary.find_or_download
+        binary_path = @options.browser_path || Binary.update
 
         raise BinaryNotFoundError, "Lightpanda binary not found" unless binary_path
 
@@ -165,7 +193,7 @@ module Capybara
       end
 
       def build_args
-        [
+        base = [
           "serve",
           "--host",
           @options.host.to_s,
@@ -174,6 +202,8 @@ module Capybara
           "--log_level",
           "info",
         ]
+        extra = ENV.fetch("LIGHTPANDA_EXTRA_ARGS", "").split
+        base + extra
       end
 
       def wait_for_ready
@@ -252,17 +282,29 @@ module Capybara
       end
 
       # Returns an array of PIDs holding the TCP port, [] if none, or nil if
-      # `lsof` itself isn't available on this system.
+      # `lsof` itself isn't available / usable on this system.
+      #
+      # `lsof -ti` exits 1 with empty stdout/stderr when nothing matches the
+      # filter — that's the common "port not held" case, so we treat
+      # (exit != 0, empty stdout, empty stderr) as []. A non-zero exit with
+      # stderr content is a real lsof failure (broken install, permission
+      # error, etc.); surface that as `nil` so the caller raises a clear
+      # BinaryError instead of silently retrying the start.
       def pids_listening_on(port)
-        stdout, _, status = Open3.capture3("lsof", "-ti", "tcp:#{port}")
-        return [] unless status.success?
+        stdout, stderr, status = Open3.capture3("lsof", "-ti", "tcp:#{port}")
+        return parse_lsof_pids(stdout) if status.success?
+        return [] if stdout.strip.empty? && stderr.strip.empty?
 
+        nil
+      rescue Errno::ENOENT
+        nil
+      end
+
+      def parse_lsof_pids(stdout)
         stdout.split("\n").filter_map do |line|
           pid = line.strip.to_i
           pid.positive? ? pid : nil
         end
-      rescue Errno::ENOENT
-        nil
       end
 
       # Class method so the finalizer proc doesn't capture `self` (which
@@ -280,8 +322,19 @@ module Capybara
         end
       end
 
+      # `start` may be called more than once on the same Process instance
+      # (Browser#restart_process_if_dead runs `stop` then `start` after a
+      # crash). Each `attempt_start` calls `register_finalizer`, and
+      # ObjectSpace allows multiple finalizers per object — so without
+      # this guard the second start would queue a redundant TERM-on-GC
+      # whose first invocation no-ops on ESRCH but is still pure noise.
+      # We register exactly once; the captured `pid` is overwritten by
+      # `undefine_finalizer + define_finalizer` so the finalizer always
+      # references the most recently started process.
       def register_finalizer(pid)
+        ObjectSpace.undefine_finalizer(self) if @finalizer_registered
         ObjectSpace.define_finalizer(self, self.class.send(:weak_kill, pid))
+        @finalizer_registered = true
       end
 
       def cleanup_pipes

data/lib/capybara/lightpanda/tasks/binary.rake

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "capybara-lightpanda"
+
+namespace :lightpanda do
+  namespace :binary do
+    desc "Print the version of the cached Lightpanda binary"
+    task :version do
+      version = Capybara::Lightpanda::Binary.current_version
+      if version
+        puts version
+      else
+        warn "No cached Lightpanda binary at #{Capybara::Lightpanda::Binary.install_path}"
+        exit 1
+      end
+    end
+
+    desc "Download the Lightpanda binary (optionally pinned: rake lightpanda:binary:update[0.3.0])"
+    task :update, [:version] do |_, args|
+      Capybara::Lightpanda::Binary.required_version = args[:version] if args[:version]
+      path = Capybara::Lightpanda::Binary.update
+      puts "Lightpanda binary ready at #{path}"
+    end
+
+    desc "Remove the cached Lightpanda binary"
+    task :remove do
+      removed = Capybara::Lightpanda::Binary.remove
+      if removed
+        puts "Removed #{removed}"
+      else
+        puts "Nothing to remove at #{Capybara::Lightpanda::Binary.install_path}"
+      end
+    end
+  end
+end

data/lib/capybara/lightpanda/utils/wait.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Lightpanda
+    module Utils
+      # Block-based polling helper. Borrowed from selenium-webdriver's
+      # Wait class (rb/lib/selenium/webdriver/common/wait.rb). Sibling
+      # of Utils::Attempt — Attempt retries on a specific error class,
+      # Wait loops until the block returns truthy.
+      module Wait
+        DEFAULT_INTERVAL = 0.1
+
+        # Polls the block until it returns a truthy value or `timeout`
+        # seconds elapse. Exceptions whose class is listed in `ignore`
+        # are swallowed between polls; the most recent one is appended
+        # to the timeout message so the failure stays diagnosable.
+        #
+        # @raise [Capybara::Lightpanda::TimeoutError] if the block never
+        #   returns truthy within `timeout` seconds.
+        # @return the truthy value returned by the block.
+        def self.until(timeout:, interval: DEFAULT_INTERVAL, ignore: [], message: nil)
+          deadline = monotonic_time + timeout
+          last_error = nil
+          loop do
+            begin
+              result = yield
+              return result if result
+            rescue *Array(ignore) => e
+              last_error = e
+            end
+
+            break if monotonic_time > deadline
+
+            sleep interval
+          end
+
+          msg = message || "timed out after #{timeout}s"
+          msg = "#{msg} (#{last_error.message})" if last_error
+          raise Capybara::Lightpanda::TimeoutError, msg
+        end
+
+        def self.monotonic_time
+          ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+        end
+      end
+    end
+  end
+end

data/lib/capybara/lightpanda/version.rb

@@ -2,6 +2,6 @@
 
 module Capybara
   module Lightpanda
-    VERSION = "0.2.2"
+    VERSION = "0.4.0"
   end
 end

data/lib/capybara-lightpanda.rb

@@ -10,14 +10,16 @@ require_relative "capybara/lightpanda/binary"
 require_relative "capybara/lightpanda/process"
 require_relative "capybara/lightpanda/utils/event"
 require_relative "capybara/lightpanda/utils/attempt"
+require_relative "capybara/lightpanda/utils/wait"
 require_relative "capybara/lightpanda/client"
+require_relative "capybara/lightpanda/headers"
 require_relative "capybara/lightpanda/network"
 require_relative "capybara/lightpanda/cookies"
 require_relative "capybara/lightpanda/keyboard"
-require_relative "capybara/lightpanda/frame"
 require_relative "capybara/lightpanda/browser"
-require_relative "capybara/lightpanda/xpath_polyfill"
+require_relative "capybara/lightpanda/auto_scripts"
 require_relative "capybara/lightpanda/node"
+require_relative "capybara/lightpanda/element_extension"
 require_relative "capybara/lightpanda/driver"
 
 module Capybara