selenium-webdriver 4.47.0 → 4.48.0

data/lib/selenium/webdriver/bidi/error.rb

@@ -23,6 +23,10 @@ require 'selenium/webdriver/bidi/protocol/error_code'
 module Selenium
   module WebDriver
     module Error
+      # Raised locally when a BiDi wire payload does not match this Selenium's generated
+      # schema. It is not a protocol error code; the (de)serialization layer raises it directly.
+      class SerializationError < WebDriverError; end
+
       # Register each BiDi-only code as a WebDriverError subclass; shared codes keep their classic class.
       BiDi::Protocol::ErrorCode::CLASS_NAMES.each_value do |name|
         const_set(name, Class.new(WebDriverError)) unless const_defined?(name, false)

data/lib/selenium/webdriver/bidi/serialization/record.rb

@@ -79,13 +79,13 @@ module Selenium
               construct(**attributes)
             end
 
-            # Inbound: builds from the wire. A missing required field is omitted and warned (or
-            # raised in strict mode, in +wire_value+); enum tokens are mapped back to symbols and an
-            # unrecognized one raises (in +read+); an undeclared property is captured silently
-            # (extensible) or warned and dropped (closed) — strict on shape, lenient on extras.
+            # Inbound: builds from the wire. A missing required field raises (in +wire_value+); enum
+            # tokens are mapped back to symbols and an unrecognized one raises (in +read+); an
+            # undeclared property is captured silently (extensible) or warned and dropped (closed)
+            # — strict on shape, lenient on extras.
             def from_json(json_payload)
               unless json_payload.is_a?(::Hash)
-                raise Error::WebDriverError, "#{name} expected an object on the wire, got #{json_payload.inspect}"
+                raise Error::SerializationError, "#{name} expected an object on the wire, got #{json_payload.inspect}"
               end
 
               attributes = fields.to_h do |f|
@@ -173,8 +173,8 @@ module Selenium
 
             # Outbound mirror of scalar_value: a bare map key must match one of the arm's primitives.
             def check_outbound_scalar(field, value)
-              expected = Array(field.scalar).flat_map { |primitive| PRIMITIVE_TYPES[primitive] || [] }
-              return if expected.empty? || expected.any? { |type| value.is_a?(type) }
+              checks = Array(field.scalar).filter_map { |primitive| PRIMITIVE_CHECKS[primitive] }
+              return if checks.empty? || checks.any? { |check| check.call(value) }
 
               raise ::ArgumentError,
                     "#{name}##{field.name} expected #{Array(field.scalar).join(' or ')}, got #{value.inspect}"
@@ -204,8 +204,8 @@ module Selenium
             # ArgumentError here rather than a rejection the browser reports a round-trip later. A field
             # with no primitive descriptor (enum, ref, opaque) passes; lists are skipped, as inbound does.
             def check_outbound_primitive(field, value)
-              expected = PRIMITIVE_TYPES[field.primitive]
-              return if expected.nil? || expected.any? { |type| value.is_a?(type) }
+              check = PRIMITIVE_CHECKS[field.primitive]
+              return if check.nil? || check.call(value)
 
               raise ::ArgumentError, "#{name}##{field.name} expected #{field.primitive}, got #{value.inspect}"
             end
@@ -214,38 +214,32 @@ module Selenium
               !UNSET.equal?(field.fixed)
             end
 
+            # A required field absent from the response cannot yield a valid typed object, so it raises
+            # rather than substitute a placeholder or represent the field as omitted; a remote end that
+            # lags the schema is handled by a project schema override, not by runtime tolerance.
             def wire_value(field, json_payload)
               return field.fixed if fixed?(field)
               return read(field, json_payload[field.wire_key]) if json_payload.key?(field.wire_key)
               return UNSET unless field.required
 
-              missing_required(field)
-            end
-
-            # A required field absent from the response is tolerated as omitted (UNSET) and warned, so a
-            # schema ahead of the browser does not block the caller; strict mode (SE_BIDI_STRICT) escalates
-            # to an error for callers who want it. Omitted (UNSET) stays distinct from an explicit null (nil),
-            # which matters for the required-and-nullable fields the schema flags.
-            def missing_required(field)
-              message = "#{name}##{field.name} is required but was missing from the response"
-              raise Error::WebDriverError, message if Serialization.strict?
-
-              WebDriver.logger.warn(message, id: :bidi_missing_required)
-              UNSET
+              raise Error::SerializationError, "#{name}##{field.name} is required but was missing from the response"
             end
 
             def read(field, raw)
               if raw.nil?
                 return raw if field.nullable
 
-                raise Error::WebDriverError, "#{name}##{field.name} received null but is not nullable"
+                raise Error::SerializationError, "#{name}##{field.name} received null but is not nullable"
               end
               check_shape(field, raw)
               return Serialization.to_symbol("#{name}##{field.name}", raw, enum_hash(field)) if field.enum
 
               if field.ref.nil?
-                check_primitive(field, raw) unless field.list
-                return raw
+                return raw if field.list
+
+                check_primitive(field, raw)
+                # A whole number is exact in both types, so the declared type is held with nothing lost.
+                return field.primitive == 'integer' && raw.is_a?(::Float) ? raw.to_i : raw
               end
 
               read_ref(field, raw)
@@ -268,24 +262,27 @@ module Selenium
               return if field.list == raw.is_a?(::Array)
               return unless field.list || field.enum || field.ref
 
-              raise Error::WebDriverError,
+              raise Error::SerializationError,
                     "#{name}##{field.name} expected #{field.list ? 'a list' : 'a single value'}, got #{raw.inspect}"
             end
 
-            # Ruby classes a checkable primitive admits. `number` is any Numeric (JSON has one
-            # number type); `integer` requires an Integer — a browser emits `5`, not `5.0`, for an
-            # integer (JS has no int/float split), so this rarely false-positives yet still rejects
-            # a genuine non-integer like 1.5. A field with no primitive descriptor is left unchecked.
-            PRIMITIVE_TYPES = {
-              'string' => [::String], 'boolean' => [::TrueClass, ::FalseClass],
-              'number' => [::Numeric], 'integer' => [::Integer]
+            # The check a schema primitive admits, by JSON kind rather than Ruby class: `number` is
+            # any Numeric (JSON has one number type), and `integer` is any whole one — a browser is
+            # free to send `5` or `5.0` (JS has no int/float split), while a fractional value like
+            # 1.5 is a real mismatch. A field with no primitive descriptor is left unchecked.
+            WHOLE_FLOAT = ->(value) { value.is_a?(::Float) && value.finite? && (value % 1).zero? }
+            PRIMITIVE_CHECKS = {
+              'string' => ->(value) { value.is_a?(::String) },
+              'boolean' => ->(value) { value.is_a?(::TrueClass) || value.is_a?(::FalseClass) },
+              'number' => ->(value) { value.is_a?(::Numeric) },
+              'integer' => ->(value) { value.is_a?(::Integer) || WHOLE_FLOAT.call(value) }
             }.freeze
 
             def check_primitive(field, raw)
-              expected = PRIMITIVE_TYPES[field.primitive]
-              return if expected.nil? || expected.any? { |type| raw.is_a?(type) }
+              check = PRIMITIVE_CHECKS[field.primitive]
+              return if check.nil? || check.call(raw)
 
-              raise Error::WebDriverError, "#{name}##{field.name} expected #{field.primitive}, got #{raw.inspect}"
+              raise Error::SerializationError, "#{name}##{field.name} expected #{field.primitive}, got #{raw.inspect}"
             end
 
             def enum_hash(field)
@@ -314,7 +311,7 @@ module Selenium
             # malformed entry and is rejected outright.
             def read_map_entry(field, element, klass)
               unless element.is_a?(::Array) && element.size == 2
-                raise Error::WebDriverError,
+                raise Error::SerializationError,
                       "#{name}##{field.name} expected a [key, value] pair, got #{element.inspect}"
               end
 
@@ -326,13 +323,13 @@ module Selenium
             # A bare scalar at a scalar-tolerant union position must match one of the union's
             # scalar-arm primitives (+scalar+ is a primitive name or an array of them); a
             # wrong-typed scalar (a number where a string is expected) is a wire error, not
-            # something to pass through. An unrecognized primitive (none in PRIMITIVE_TYPES) is
+            # something to pass through. An unrecognized primitive (none in PRIMITIVE_CHECKS) is
             # left unchecked, matching the lenient default elsewhere.
             def scalar_value(field, value)
-              expected = Array(field.scalar).flat_map { |primitive| PRIMITIVE_TYPES[primitive] || [] }
-              return value if expected.empty? || expected.any? { |type| value.is_a?(type) }
+              checks = Array(field.scalar).filter_map { |primitive| PRIMITIVE_CHECKS[primitive] }
+              return value if checks.empty? || checks.any? { |check| check.call(value) }
 
-              raise Error::WebDriverError,
+              raise Error::SerializationError,
                     "#{name}##{field.name} expected #{Array(field.scalar).join(' or ')}, got #{value.inspect}"
             end
 

data/lib/selenium/webdriver/bidi/serialization/union.rb

@@ -53,19 +53,23 @@ module Selenium
             # An outbound scalar outside that set matches no arm, so it is a caller error.
             def scalar_values(*values) = @scalar_values = values
 
-            # A non-Hash payload is a bare scalar arm (e.g. input.Origin's "viewport") with no
-            # object to dispatch on, so it is returned unchanged — unless every arm is an object
-            # (object_only), where a non-Hash cannot match any variant and is a wire error.
+            # A non-Hash payload is a bare scalar arm (e.g. input.Origin's "viewport"), valid only
+            # as a literal the schema pins; under object_only it cannot match any variant at all.
             def from_json(json_payload)
               unless json_payload.is_a?(::Hash)
-                return json_payload unless @object_only
-
-                raise Error::WebDriverError, "#{name} expected an object on the wire, got #{json_payload.inspect}"
+                if @object_only
+                  raise Error::SerializationError,
+                        "#{name} expected an object on the wire, got #{json_payload.inspect}"
+                end
+                return json_payload if scalar_arm?(json_payload)
+
+                raise Error::SerializationError,
+                      "#{name} received a scalar not in this Selenium's BiDi schema: #{json_payload.inspect}"
               end
 
               variant = select(json_payload)
               unless variant
-                raise Error::WebDriverError,
+                raise Error::SerializationError,
                       "#{name} received a variant not in this Selenium's BiDi schema: #{json_payload.inspect}"
               end
               Protocol.const_get(variant).from_json(json_payload)

data/lib/selenium/webdriver/bidi/serialization.rb

@@ -21,8 +21,7 @@ module Selenium
   module WebDriver
     class BiDi
       # Wire round-trip runtime for the generated protocol layer: the value-type bases
-      # (Record, Union), the omit sentinel (UNSET), outbound enum validation, and the
-      # strict-inbound toggle.
+      # (Record, Union), the omit sentinel (UNSET), and outbound enum validation.
       #
       # @api private
       module Serialization
@@ -34,17 +33,6 @@ module Selenium
         def UNSET.inspect = 'UNSET'
         UNSET.freeze
 
-        # Strict inbound mode. Off by default: a required field missing from a response is
-        # tolerated as omitted and warned, so a schema ahead of the browser does not block the
-        # caller. When SE_BIDI_STRICT is set to anything but 0/false, that same case escalates
-        # to an error for callers who want it.
-        #
-        # @api private
-        def self.strict?
-          value = ENV.fetch('SE_BIDI_STRICT', '').strip.downcase
-          !value.empty? && value != '0' && value != 'false'
-        end
-
         # Validates an outbound enum argument: +value+ is a symbol (or list of symbols) that
         # must be a key of the enum hash (+{symbol => wire_token}+), so a bad value fails
         # locally with a clear error instead of a round-trip. Outbound only; inbound wire
@@ -79,7 +67,7 @@ module Selenium
           return value if value.nil?
           return value.map { |element| to_symbol(name, element, enum) } if value.is_a?(::Array)
 
-          enum.key(value) || raise(Error::WebDriverError, "#{name} received an unknown value: #{value.inspect}")
+          enum.key(value) || raise(Error::SerializationError, "#{name} received an unknown value: #{value.inspect}")
         end
       end
     end # BiDi

data/lib/selenium/webdriver/common/websocket_connection.rb

@@ -21,6 +21,7 @@ require 'websocket'
 
 module Selenium
   module WebDriver
+    # @api private
     class WebSocketConnection
       CONNECTION_ERRORS = [
         Errno::ECONNRESET, # connection is aborted (browser process was killed)
@@ -35,6 +36,15 @@ module Selenium
 
       MAX_LOG_MESSAGE_SIZE = 9999
 
+      # websocket-ruby defaults to a 20MB limit and silently drops larger
+      # frames, which can stall the listener. CDP payloads (e.g. large data:
+      # URLs) can exceed that, so raise the ceiling for our connections.
+      # The gem only exposes the limit as process-global state, so it is
+      # raised (never lowered) and not restored on close - concurrent
+      # connections share the value. Other bindings rely on their own
+      # websocket clients' limits; this constant only affects websocket-ruby.
+      MAX_FRAME_SIZE = 100 * 1024 * 1024 # 100MB
+
       def initialize(url:)
         @callback_threads = ThreadGroup.new
 
@@ -46,26 +56,19 @@ module Selenium
         @session_id = nil
         @url = url
 
+        apply_frame_size_limit
         process_handshake
         @socket_thread = attach_socket_listener
       end
 
+      # Idempotent: the listener may already have initiated shutdown (see
+      # #frame_dropped?), so always close the socket and join threads rather
+      # than short-circuiting on @closing.
       def close
-        @closing_mtx.synchronize do
-          return if @closing
-
-          @closing = true
-        end
-
-        begin
-          socket.close
-        rescue *CONNECTION_ERRORS => e
-          WebDriver.logger.debug "WebSocket listener closed: #{e.class}: #{e.message}", id: :ws
-          # already closed
-        end
+        close_socket
 
         # Let threads unwind instead of calling exit
-        @socket_thread&.join(0.5)
+        @socket_thread&.join(0.5) unless @socket_thread == Thread.current
         @callback_threads.list.each do |thread|
           thread.join(0.5)
         rescue StandardError => e
@@ -97,6 +100,9 @@ module Selenium
       end
 
       def send_cmd(**payload)
+        # IOError to match what writing to an already-closed socket raises
+        raise IOError, 'WebSocket connection is closed' if @closing
+
         id = next_id
         data = payload.merge(id: id)
         WebDriver.logger.debug "WebSocket -> #{data}"[...MAX_LOG_MESSAGE_SIZE], id: :ws
@@ -109,7 +115,11 @@ module Selenium
           raise e, "WebSocket is closed (#{e.class}: #{e.message})"
         end
 
-        wait.until { @messages_mtx.synchronize { messages.delete(id) } }
+        wait.until do
+          raise IOError, 'WebSocket connection closed while waiting for a response' if @closing
+
+          @messages_mtx.synchronize { messages.delete(id) }
+        end
       end
 
       private
@@ -132,22 +142,51 @@ module Selenium
 
             incoming_frame << socket.readpartial(1024)
 
-            while (frame = incoming_frame.next)
-              break if @closing
-
-              message = process_frame(frame)
-              next unless message['method']
-
-              @messages_mtx.synchronize { callbacks[message['method']].dup }.each do |callback|
-                @callback_threads.add(callback_thread(message['params'], &callback))
-              end
-            end
+            process_incoming_frames
+            break if frame_dropped?
           end
         rescue *CONNECTION_ERRORS, WebSocket::Error => e
           WebDriver.logger.debug "WebSocket listener closed: #{e.class}: #{e.message}", id: :ws
         end
       end
 
+      def close_socket
+        @closing_mtx.synchronize { @closing = true }
+        socket.close
+      rescue *CONNECTION_ERRORS => e
+        WebDriver.logger.debug "WebSocket socket closed: #{e.class}: #{e.message}", id: :ws
+      end
+
+      def process_incoming_frames
+        while (frame = incoming_frame.next)
+          break if @closing
+
+          message = process_frame(frame)
+          next unless message['method']
+
+          @messages_mtx.synchronize { callbacks[message['method']].dup }.each do |callback|
+            @callback_threads.add(callback_thread(message['params'], &callback))
+          end
+        end
+      end
+
+      # True when the buffered frame could not be decoded (e.g. exceeds MAX_FRAME_SIZE).
+      # websocket-ruby swallows the error and keeps returning nil, so surface it and close
+      # the connection here instead of leaving a dead listener on an open socket.
+      def frame_dropped?
+        return false unless incoming_frame.error?
+
+        WebDriver.logger.error("WebSocket frame dropped (#{incoming_frame.error}); if payloads can legitimately " \
+                               "exceed #{WebSocket.max_frame_size} bytes, set WebSocket.max_frame_size " \
+                               'to a higher value', id: :ws)
+        close_socket
+        true
+      end
+
+      def apply_frame_size_limit
+        WebSocket.max_frame_size = MAX_FRAME_SIZE if WebSocket.max_frame_size < MAX_FRAME_SIZE
+      end
+
       def incoming_frame
         @incoming_frame ||= WebSocket::Frame::Incoming::Client.new(version: ws.version)
       end
@@ -204,8 +243,7 @@ module Selenium
       end
 
       def next_id
-        @id ||= 0
-        @id += 1
+        @id = (@id || 0) + 1
       end
     end # BiDi
   end # WebDriver

data/lib/selenium/webdriver/version.rb

@@ -19,6 +19,6 @@
 
 module Selenium
   module WebDriver
-    VERSION = '4.47.0'
+    VERSION = '4.48.0'
   end # WebDriver
 end # Selenium

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: selenium-webdriver
 version: !ruby/object:Gem::Version
-  version: 4.47.0
+  version: 4.48.0
 platform: ruby
 authors:
 - Alex Rodionov
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-10 00:00:00.000000000 Z
+date: 2026-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64