selenium-webdriver 4.47.0 → 4.49.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/protocol/browsing_context.rb

@@ -209,7 +209,8 @@ module Selenium
             context: {wire_key: 'context', primitive: 'string'},
             origin: {wire_key: 'origin', required: false, enum: 'BrowsingContext::CAPTURE_SCREENSHOT_PARAMETERS_ORIGIN'},
             format: {wire_key: 'format', required: false, ref: 'BrowsingContext::ImageFormat'},
-            clip: {wire_key: 'clip', required: false, ref: 'BrowsingContext::ClipRectangle'}
+            clip: {wire_key: 'clip', required: false, ref: 'BrowsingContext::ClipRectangle'},
+            image_size: {wire_key: 'imageSize', required: false, ref: 'BrowsingContext::ImageSize'}
           )
 
           # @api private
@@ -220,6 +221,14 @@ module Selenium
             quality: {wire_key: 'quality', required: false, primitive: 'number'}
           )
 
+          # @api private
+          # @see https://www.selenium.dev/documentation/warnings/bidi-implementation/
+          # @see https://w3c.github.io/webdriver-bidi/#cddl-type-browsingcontextimagesize
+          ImageSize = Serialization::Record.define(
+            max_width: {wire_key: 'maxWidth', required: false, primitive: 'integer'},
+            max_height: {wire_key: 'maxHeight', required: false, primitive: 'integer'}
+          )
+
           # @api private
           # @see https://www.selenium.dev/documentation/warnings/bidi-implementation/
           # @see https://w3c.github.io/webdriver-bidi/#cddl-type-browsingcontextcliprectangle
@@ -585,6 +594,7 @@ module Selenium
           def inner_text_locator(**) = InnerTextLocator.new(**)
           def x_path_locator(**) = XPathLocator.new(**)
           def image_format(**) = ImageFormat.new(**)
+          def image_size(**) = ImageSize.new(**)
           def clip_rectangle = ClipRectangle
           def element_clip_rectangle(**) = ElementClipRectangle.new(**)
           def box_clip_rectangle(**) = BoxClipRectangle.new(**)
@@ -610,10 +620,17 @@ module Selenium
             context:,
             origin: Serialization::UNSET,
             format: Serialization::UNSET,
-            clip: Serialization::UNSET
+            clip: Serialization::UNSET,
+            image_size: Serialization::UNSET
           )
             Serialization.validate!('origin', origin, BrowsingContext::CAPTURE_SCREENSHOT_PARAMETERS_ORIGIN)
-            params = CaptureScreenshotParameters.new(context: context, origin: origin, format: format, clip: clip)
+            params = CaptureScreenshotParameters.new(
+              context: context,
+              origin: origin,
+              format: format,
+              clip: clip,
+              image_size: image_size
+            )
             execute(
               cmd: 'browsingContext.captureScreenshot',
               params: params,

data/lib/selenium/webdriver/bidi/protocol/emulation.rb

@@ -48,6 +48,140 @@ module Selenium
             landscape_secondary: 'landscape-secondary'
           }.freeze
 
+          MEDIA_FEATURES_ANY_HOVER = {
+            none: 'none',
+            hover: 'hover'
+          }.freeze
+
+          MEDIA_FEATURES_ANY_POINTER = {
+            none: 'none',
+            coarse: 'coarse',
+            fine: 'fine'
+          }.freeze
+
+          MEDIA_FEATURES_COLOR_GAMUT = {
+            srgb: 'srgb',
+            p3: 'p3',
+            rec2020: 'rec2020'
+          }.freeze
+
+          MEDIA_FEATURES_DISPLAY_MODE = {
+            fullscreen: 'fullscreen',
+            standalone: 'standalone',
+            minimal_ui: 'minimal-ui',
+            browser: 'browser',
+            picture_in_picture: 'picture-in-picture'
+          }.freeze
+
+          MEDIA_FEATURES_DYNAMIC_RANGE = {
+            standard: 'standard',
+            high: 'high'
+          }.freeze
+
+          MEDIA_FEATURES_ENVIRONMENT_BLENDING = {
+            opaque: 'opaque',
+            additive: 'additive',
+            subtractive: 'subtractive'
+          }.freeze
+
+          MEDIA_FEATURES_FORCED_COLORS = {
+            none: 'none',
+            active: 'active'
+          }.freeze
+
+          MEDIA_FEATURES_GRID = {
+            _0: 0,
+            _1: 1
+          }.freeze
+
+          MEDIA_FEATURES_HOVER = {
+            none: 'none',
+            hover: 'hover'
+          }.freeze
+
+          MEDIA_FEATURES_INVERTED_COLORS = {
+            none: 'none',
+            inverted: 'inverted'
+          }.freeze
+
+          MEDIA_FEATURES_NAV_CONTROLS = {
+            none: 'none',
+            back: 'back'
+          }.freeze
+
+          MEDIA_FEATURES_OVERFLOW_BLOCK = {
+            none: 'none',
+            scroll: 'scroll',
+            optional_paged: 'optional-paged',
+            paged: 'paged'
+          }.freeze
+
+          MEDIA_FEATURES_OVERFLOW_INLINE = {
+            none: 'none',
+            scroll: 'scroll'
+          }.freeze
+
+          MEDIA_FEATURES_POINTER = {
+            none: 'none',
+            coarse: 'coarse',
+            fine: 'fine'
+          }.freeze
+
+          MEDIA_FEATURES_PREFERS_COLOR_SCHEME = {
+            light: 'light',
+            dark: 'dark'
+          }.freeze
+
+          MEDIA_FEATURES_PREFERS_CONTRAST = {
+            no_preference: 'no-preference',
+            more: 'more',
+            less: 'less',
+            custom: 'custom'
+          }.freeze
+
+          MEDIA_FEATURES_PREFERS_REDUCED_DATA = {
+            no_preference: 'no-preference',
+            reduce: 'reduce'
+          }.freeze
+
+          MEDIA_FEATURES_PREFERS_REDUCED_MOTION = {
+            no_preference: 'no-preference',
+            reduce: 'reduce'
+          }.freeze
+
+          MEDIA_FEATURES_PREFERS_REDUCED_TRANSPARENCY = {
+            no_preference: 'no-preference',
+            reduce: 'reduce'
+          }.freeze
+
+          MEDIA_FEATURES_SCAN = {
+            interlace: 'interlace',
+            progressive: 'progressive'
+          }.freeze
+
+          MEDIA_FEATURES_SCRIPTING = {
+            none: 'none',
+            initial_only: 'initial-only',
+            enabled: 'enabled'
+          }.freeze
+
+          MEDIA_FEATURES_UPDATE = {
+            none: 'none',
+            slow: 'slow',
+            fast: 'fast'
+          }.freeze
+
+          MEDIA_FEATURES_VIDEO_COLOR_GAMUT = {
+            srgb: 'srgb',
+            p3: 'p3',
+            rec2020: 'rec2020'
+          }.freeze
+
+          MEDIA_FEATURES_VIDEO_DYNAMIC_RANGE = {
+            standard: 'standard',
+            high: 'high'
+          }.freeze
+
           SET_SCROLLBAR_TYPE_OVERRIDE_PARAMETERS_SCROLLBAR_TYPE = {
             classic: 'classic',
             overlay: 'overlay'
@@ -120,17 +254,149 @@ module Selenium
           # @see https://www.selenium.dev/documentation/warnings/bidi-implementation/
           # @see https://w3c.github.io/webdriver-bidi/#cddl-type-emulationsetmediafeaturesoverrideparameters
           SetMediaFeaturesOverrideParameters = Serialization::Record.define(
-            features: {wire_key: 'features', nullable: true, ref: 'Emulation::MediaFeature', list: true},
+            features: {wire_key: 'features', nullable: true, ref: 'Emulation::MediaFeatures'},
             contexts: {wire_key: 'contexts', required: false, list: true},
             user_contexts: {wire_key: 'userContexts', required: false, list: true}
           )
 
           # @api private
           # @see https://www.selenium.dev/documentation/warnings/bidi-implementation/
-          # @see https://w3c.github.io/webdriver-bidi/#cddl-type-emulationmediafeature
-          MediaFeature = Serialization::Record.define(
-            name: {wire_key: 'name', primitive: 'string'},
-            value: {wire_key: 'value', primitive: 'string'}
+          # @see https://w3c.github.io/webdriver-bidi/#cddl-type-emulationmediafeatures
+          MediaFeatures = Serialization::Record.define(
+            any_hover: {
+              wire_key: 'any-hover',
+              required: false,
+              nullable: true,
+              enum: 'Emulation::MEDIA_FEATURES_ANY_HOVER'
+            },
+            any_pointer: {
+              wire_key: 'any-pointer',
+              required: false,
+              nullable: true,
+              enum: 'Emulation::MEDIA_FEATURES_ANY_POINTER'
+            },
+            color: {wire_key: 'color', required: false, nullable: true, primitive: 'integer'},
+            color_gamut: {
+              wire_key: 'color-gamut',
+              required: false,
+              nullable: true,
+              enum: 'Emulation::MEDIA_FEATURES_COLOR_GAMUT'
+            },
+            color_index: {wire_key: 'color-index', required: false, nullable: true, primitive: 'integer'},
+            display_mode: {
+              wire_key: 'display-mode',
+              required: false,
+              nullable: true,
+              enum: 'Emulation::MEDIA_FEATURES_DISPLAY_MODE'
+            },
+            dynamic_range: {
+              wire_key: 'dynamic-range',
+              required: false,
+              nullable: true,
+              enum: 'Emulation::MEDIA_FEATURES_DYNAMIC_RANGE'
+            },
+            environment_blending: {
+              wire_key: 'environment-blending',
+              required: false,
+              nullable: true,
+              enum: 'Emulation::MEDIA_FEATURES_ENVIRONMENT_BLENDING'
+            },
+            forced_colors: {
+              wire_key: 'forced-colors',
+              required: false,
+              nullable: true,
+              enum: 'Emulation::MEDIA_FEATURES_FORCED_COLORS'
+            },
+            grid: {wire_key: 'grid', required: false, nullable: true, enum: 'Emulation::MEDIA_FEATURES_GRID'},
+            horizontal_viewport_segments: {
+              wire_key: 'horizontal-viewport-segments',
+              required: false,
+              nullable: true,
+              primitive: 'integer'
+            },
+            hover: {wire_key: 'hover', required: false, nullable: true, enum: 'Emulation::MEDIA_FEATURES_HOVER'},
+            inverted_colors: {
+              wire_key: 'inverted-colors',
+              required: false,
+              nullable: true,
+              enum: 'Emulation::MEDIA_FEATURES_INVERTED_COLORS'
+            },
+            monochrome: {wire_key: 'monochrome', required: false, nullable: true, primitive: 'integer'},
+            nav_controls: {
+              wire_key: 'nav-controls',
+              required: false,
+              nullable: true,
+              enum: 'Emulation::MEDIA_FEATURES_NAV_CONTROLS'
+            },
+            overflow_block: {
+              wire_key: 'overflow-block',
+              required: false,
+              nullable: true,
+              enum: 'Emulation::MEDIA_FEATURES_OVERFLOW_BLOCK'
+            },
+            overflow_inline: {
+              wire_key: 'overflow-inline',
+              required: false,
+              nullable: true,
+              enum: 'Emulation::MEDIA_FEATURES_OVERFLOW_INLINE'
+            },
+            pointer: {wire_key: 'pointer', required: false, nullable: true, enum: 'Emulation::MEDIA_FEATURES_POINTER'},
+            prefers_color_scheme: {
+              wire_key: 'prefers-color-scheme',
+              required: false,
+              nullable: true,
+              enum: 'Emulation::MEDIA_FEATURES_PREFERS_COLOR_SCHEME'
+            },
+            prefers_contrast: {
+              wire_key: 'prefers-contrast',
+              required: false,
+              nullable: true,
+              enum: 'Emulation::MEDIA_FEATURES_PREFERS_CONTRAST'
+            },
+            prefers_reduced_data: {
+              wire_key: 'prefers-reduced-data',
+              required: false,
+              nullable: true,
+              enum: 'Emulation::MEDIA_FEATURES_PREFERS_REDUCED_DATA'
+            },
+            prefers_reduced_motion: {
+              wire_key: 'prefers-reduced-motion',
+              required: false,
+              nullable: true,
+              enum: 'Emulation::MEDIA_FEATURES_PREFERS_REDUCED_MOTION'
+            },
+            prefers_reduced_transparency: {
+              wire_key: 'prefers-reduced-transparency',
+              required: false,
+              nullable: true,
+              enum: 'Emulation::MEDIA_FEATURES_PREFERS_REDUCED_TRANSPARENCY'
+            },
+            scan: {wire_key: 'scan', required: false, nullable: true, enum: 'Emulation::MEDIA_FEATURES_SCAN'},
+            scripting: {
+              wire_key: 'scripting',
+              required: false,
+              nullable: true,
+              enum: 'Emulation::MEDIA_FEATURES_SCRIPTING'
+            },
+            update: {wire_key: 'update', required: false, nullable: true, enum: 'Emulation::MEDIA_FEATURES_UPDATE'},
+            vertical_viewport_segments: {
+              wire_key: 'vertical-viewport-segments',
+              required: false,
+              nullable: true,
+              primitive: 'integer'
+            },
+            video_color_gamut: {
+              wire_key: 'video-color-gamut',
+              required: false,
+              nullable: true,
+              enum: 'Emulation::MEDIA_FEATURES_VIDEO_COLOR_GAMUT'
+            },
+            video_dynamic_range: {
+              wire_key: 'video-dynamic-range',
+              required: false,
+              nullable: true,
+              enum: 'Emulation::MEDIA_FEATURES_VIDEO_DYNAMIC_RANGE'
+            }
           )
 
           # @api private
@@ -245,7 +511,7 @@ module Selenium
 
           def geolocation_coordinates(**) = GeolocationCoordinates.new(**)
           def geolocation_position_error(**) = GeolocationPositionError.new(**)
-          def media_feature(**) = MediaFeature.new(**)
+          def media_features(**) = MediaFeatures.new(**)
           def network_conditions_offline(**) = NetworkConditionsOffline.new(**)
           def screen_area(**) = ScreenArea.new(**)
           def screen_orientation(**) = ScreenOrientation.new(**)

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/bidi/support/bidi_generate.rb

@@ -137,14 +137,16 @@ module BiDiGenerate
   # snake_case hash key for an enum value (only a label for the wire value it maps to).
   # Preserves camelCase word boundaries (beforeRequestSent → before_request_sent), maps a
   # leading minus to "neg" (-0 → neg0, -Infinity → neg_infinity; no underscore before a
-  # digit, so the key stays normalcase), and collapses other punctuation
-  # (dedicated-worker → dedicated_worker).
+  # digit, so the key stays normalcase), collapses other punctuation
+  # (dedicated-worker → dedicated_worker), and prefixes a numeric value so the key
+  # is still a valid symbol (0 → _0).
   def self.enum_key(value)
-    camel_to_snake(value.to_s)
-      .sub(/\A-(?=\d)/, 'neg')
-      .sub(/\A-/, 'neg_')
-      .gsub(/[^a-z0-9]+/, '_')
-      .gsub(/\A_+|_+\z/, '')
+    token = camel_to_snake(value.to_s)
+            .sub(/\A-(?=\d)/, 'neg')
+            .sub(/\A-/, 'neg_')
+            .gsub(/[^a-z0-9]+/, '_')
+            .gsub(/\A_+|_+\z/, '')
+    token.empty? || token.match?(/\A\d/) ? "_#{token}" : token
   end
 
   # ruby_name is the snake_case keyword argument; wire_name is the exact key the
@@ -308,9 +310,16 @@ module BiDiGenerate
     def type_entry = "'#{wire_name}' => #{payload_ref || 'nil'}"
   end
 
-  # constant_name is the SCREAMING_SNAKE hash name; pairs are [symbol_key, wire_value] tuples.
-  # spec_href links to the type's definition in the live spec (nil when the schema has none).
-  Enum = Struct.new(:constant_name, :pairs, :spec_href, keyword_init: true)
+  # The RBS type a schema value primitive maps to; an unrecognized one is untyped.
+  RBS_VALUE_TYPES = {'string' => 'String', 'integer' => 'Integer', 'number' => 'Float',
+                     'boolean' => 'bool'}.freeze
+
+  # constant_name is the SCREAMING_SNAKE hash name; pairs are [symbol_key, wire_value] tuples;
+  # primitive is the schema's declared value type. spec_href links to the type's definition in
+  # the live spec (nil when the schema has none).
+  Enum = Struct.new(:constant_name, :pairs, :primitive, :spec_href, keyword_init: true) do
+    def rbs_value_type = RBS_VALUE_TYPES.fetch(primitive, 'untyped')
+  end
 
   # The generated Protocol::ErrorCode module (filename 'error_code'): `codes` is the [wire, class_name]
   # pairs in schema order (the full map); `new_classes` is the subset of class names the classic
@@ -694,9 +703,9 @@ module BiDiGenerate
         next unless type['kind'] == 'enum'
         next unless name.start_with?("#{domain}.")
 
-        pairs = type['values'].map { |v| [BiDiGenerate.enum_key(v), v.to_s] }
+        pairs = type['values'].map { |v| [BiDiGenerate.enum_key(v), v] }
         Enum.new(constant_name: BiDiGenerate.screaming_snake(name.sub("#{domain}.", '')), pairs: pairs,
-                 spec_href: type['specHref'])
+                 primitive: type['primitive'], spec_href: type['specHref'])
       end
     end