Class: BiDiGenerate::Schema Private

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1154

def baked_discriminator?(field)
  field['type'].key?('const') && !field['type']['nullable']
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 731

def build_added_command(cmd, namespace, domain)
  command = BiDiGenerate.build_command(self, cmd.merge('name' => cmd['name'].delete_prefix("#{namespace}:")))
  spec_names = commands_for(domain).map do |c|
    BiDiGenerate.safe_method_name(BiDiGenerate.camel_to_snake(c['name']))
  end
  if spec_names.include?(command.method_name)
    raise "vendor command #{cmd['method']} would override spec command #{domain}.#{command.method_name}"
  end

  command
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 744

def build_vendor_override(cmd, type_name, fields, namespace)
  shared = @types[type_name]['fields']
  taken = shared.map { |field| field_name(field, false) }
  type = @types[type_name].merge('fields' => shared + fields.map { |f| vendor_field(f, namespace, taken) })
  record = record_class(type_name, type)
  command = Command.new(wire_name: cmd['method'],
                        method_name: BiDiGenerate.safe_method_name(BiDiGenerate.camel_to_snake(cmd['name'])),
                        params: record_params(type['fields'], false),
                        result_ref: cmd['result'] && structured_ref(cmd['result']['ref']),
                        params_class: record.ruby_name, union_params: false, spec_href: cmd['specHref'])
  [record, command]
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 981

def checkable_primitive(node)
  node['primitive'] if CHECKABLE_PRIMITIVES.include?(node['primitive'])
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 686

def command_wrapper_refs(domain)
  commands_for(domain).flat_map { |c| [c.dig('params', 'ref'), c.dig('result', 'ref')] }.compact.to_set
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 678

def commands_for(domain)
  @commands.select { |c| c['domain'] == domain }
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1388

def default_variant_enum_values(selector, by)
  default = selector['default']
  field = default && @types[default]['fields'].find { |f| f['wire'] == by }
  ref = field && field['type']['ref']
  ref && @types[ref] && @types[ref]['kind'] == 'enum' ? @types[ref]['values'] : []
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1120

def directionality(name)
  node = @types[name]
  {outbound: node['outbound'] ? true : false, inbound: node['inbound'] ? true : false}
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1248

def discriminated_variants(selector)
  variants = selector['variants'].map do |variant|
    VariantIR.new(mode: :value, value: variant['value'], ref: ruby_path(variant['ref']), requires: nil)
  end
  return variants unless selector['default']

  variants << VariantIR.new(mode: :fallback, value: nil, ref: ruby_path(selector['default']), requires: nil)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 642

def domain_href(domain)
  @domains.dig(domain, 'specHref')
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 897

def domain_path(name)
  name.include?('.') ? ruby_path(name) : nil
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 704

def domain_relative_path(name)
  prefix = "#{BiDiGenerate.snake_to_class_name(BiDiGenerate.camel_to_snake(name.split('.', 2).first))}::"
  ruby_path(name).sub(/\A#{Regexp.escape(prefix)}/, '')
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 674

def domains
  (@commands + @events).map { |entry| entry['domain'] }.uniq
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1345

def enum_const(field_type)
  ref = field_type['ref'] || field_type.dig('list', 'ref')
  return unless ref && @types[ref] && @types[ref]['kind'] == 'enum'

  BiDiGenerate.enum_const_path(ref)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 791

def enums_for(domain)
  owned_types(domain).filter_map do |name, type|
    next unless type['kind'] == 'enum'

    pairs = type['values'].map { |v| [BiDiGenerate.enum_key(v), v] }
    Enum.new(constant_name: BiDiGenerate.screaming_snake(name.split('.', 2).last), pairs: pairs,
             primitive: type['primitive'], spec_href: type['specHref'])
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 877

def envelope_synthetic?(type)
  return false unless type['synthetic']

  owner = @types[type['owner']]
  owner && owner['kind'] == 'record' && message_envelope?(owner)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 843

def error_codes
  @types.dig('ErrorCode', 'values') || []
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 770

def events_for(domain)
  @events.select { |e| e['domain'] == domain }
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1142

def extensible_record?(name)
  @types.dig(name, 'extensible') ? true : false
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1158

def field_ir(field, extensible)
  resolved = resolve(field['type'])
  ruby_name = field_name(field, extensible)
  FieldIR.new(ruby_name: ruby_name, wire_key: field['wire'],
              required: field['required'], nullable: resolved[:nullable],
              ref: resolved[:ref], list: resolved[:list], enum: enum_const(field['type']),
              primitive: resolved[:primitive], scalar: resolved[:scalar],
              const: leaf_const(field['type']), map_of: resolved[:map], bounds: resolved[:bounds] || {},
              rbs: resolved[:rbs])
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1146

def field_name(field, extensible)
  BiDiGenerate.safe_field_name(BiDiGenerate.camel_to_snake(field['name']), extensible: extensible)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 572

def fold_vendor_extensions!
  @vendor_field_refs = []
  @vendor.to_h do |namespace, section|
    params = {}
    (section['extends'] || {}).each do |type_name, entry|
      fields = vendor_extension_fields(namespace, type_name, entry)
      if params_command(type_name)
        params[type_name] = fields
      else
        optional = fields.map { |field| field.merge('required' => false) }
        @types[type_name] = @types[type_name].merge('fields' => @types[type_name]['fields'] + optional)
      end
    end
    [namespace, params]
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1411

def guard_union_dispatch_keys_simple!(selector, ref)
  keys = selector['by'] ? [selector['by']] : (selector['ordered'] || []).flat_map { |arm| arm['requires'] }
  camel = keys.reject { |k| BiDiGenerate.camel_to_snake(k) == k }
  return if camel.empty?

  raise "union command param #{ref} dispatches on non-snake wire key(s) #{camel.inspect}; " \
        'Union.build matches kwargs to dispatch keys by symbol, so give the outbound ' \
        'dispatch an explicit wire<->ruby mapping before shipping this.'
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 601

def hoist_vendor_enum(type_name, field)
  values = field['type']['enum']
  return field unless values

  domain = type_name.split('.', 2).first
  name = "#{domain}.#{BiDiGenerate.snake_to_class_name(BiDiGenerate.camel_to_snake(field['name']))}"
  enum = {'kind' => 'enum', 'values' => values, 'primitive' => field['type']['primitive']}
  raise "vendor enum #{name} conflicts with an existing type" if @types.key?(name) && @types[name] != enum

  @types[name] = enum
  field.merge('type' => field['type'].slice('nullable').merge('ref' => name))
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1173

def leaf_const(node, seen = {})
  return node['const'] if node.key?('const')
  return nil unless node.key?('ref')

  name = node['ref']
  type = @types[name]
  return nil if seen[name] || type.nil? || type['kind'] != 'alias'

  seen[name] = true
  leaf_const(type['type'], seen)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1068

def map_record(type)
  primitives = map_value_primitives(type['map'])
  return OPAQUE unless primitives

  rbs = primitives.map { |primitive| PRIMITIVE_RBS.fetch(primitive) }.join(' | ')
  {ref: nil, list: false, map: primitives.one? ? primitives.first : primitives,
   bounds: union_bounds(type['map']['union'] || [type['map']]), rbs: "Hash[String, #{rbs}]"}
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1078

def map_value_primitives(node)
  union_primitives(node['union'] || [node]) if node
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1397

def merged_params(variant_fields, extensible)
  all_fields = variant_fields.flatten
  all_fields.map { |f| f['wire'] }.uniq.map do |wire|
    field = all_fields.find { |f| f['wire'] == wire }
    required = variant_fields.all? { |fields| fields.any? { |f| f['wire'] == wire && f['required'] } }
    Param.new(ruby_name: field_name(field, extensible),
              wire_name: wire, required: required, rbs: rbs_type(field['type']))
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 872

def message_envelope?(type)
  type['fields'].any? { |f| f['wire'] == 'method' && f['type'].key?('const') }
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1085

def named_type(name)
  {ref: domain_path(name), list: false, rbs: rbs_abs(ruby_path(name))}
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1092

def named_union(name)
  {ref: domain_path(name), list: false, rbs: union_alias_path(name)}
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1186

def narrow_bounds(bounds, narrowing)
  result = bounds.dup
  {'min' => 'exclusiveMin', 'max' => 'exclusiveMax'}.each do |side, flag|
    next unless narrowing.key?(side) && tighter_bound?(side, flag, narrowing, bounds)

    result[side] = narrowing[side]
    result.delete(flag)
    result[flag] = true if narrowing[flag]
  end
  result.slice(*BOUND_KEYS)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 963

def narrowed(named, node)
  own = node.slice(*BOUND_KEYS)
  own.empty? ? named : named.merge(bounds: narrow_bounds(named[:bounds] || {}, own))
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1114

def nilable(type, flag)
  flag ? BiDiGenerate.rbs_nilable(type) : type
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1257

def ordered_variants(selector)
  (selector['ordered'] || []).map do |arm|
    VariantIR.new(mode: :presence, value: nil, ref: ruby_path(arm['ref']), requires: arm['requires'])
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 805

def owned_types(domain)
  vendor = vendor_domain?(domain)
  prefixes = type_prefixes(domain).map { |prefix| "#{prefix}." }
  added = vendor ? Set.new : vendor_types_reached(domain)
  @types.select do |name, _|
    next false unless prefixes.any? { |p| name.start_with?(p) }

    @vendor_types.key?(name) ? vendor || added.include?(name) : !vendor
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 615

def params_command(type_name)
  @commands.find { |c| c.dig('params', 'ref') == type_name && !vendor_domain?(c['domain']) }
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 778

def params_for(params_ref)
  return [] unless params_ref

  type = @types[params_ref['ref']]
  return nil unless type

  case type['kind']
  when 'record' then record_params(type['fields'], extensible_record?(params_ref['ref']))
  when 'union' then union_params(type, params_ref['ref'])
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 904

def plain_refs(node)
  case node['kind']
  when 'record'
    refs = node['fields'].flat_map { |f| refs_in_type(f['type']) }
    node['map'] ? refs + refs_in_type(node['map']) : refs
  when 'alias' then refs_in_type(node['type'])
  else []
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 695

def plainly_reached_types
  @plainly_reached_types ||= @types.each_value.with_object(Set.new) do |node, reached|
    plain_refs(node).each { |ref| reached << ref }
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 654

def promote_command_params_records!
  @commands.each do |cmd|
    ref = cmd.dig('params', 'ref')
    next unless ref

    type = @types[ref]
    promote_to_domain_type!(ref) if type && envelope_synthetic?(type)
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 666

def promote_to_domain_type!(name)
  type = @types[name]
  type&.delete('synthetic')
  type&.delete('owner')
  type&.delete('label')
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1338

def rbs_abs(path)
  "::Selenium::WebDriver::BiDi::Protocol::#{path}"
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1329

def rbs_const(value)
  case value
  when true, false then 'bool'
  when ::String then 'String'
  when ::Numeric then 'Numeric'
  else 'untyped'
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1299

def rbs_type(node)
  resolve(node)[:rbs]
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1125

def record_class(name, type)
  extensible = extensible_record?(name)
  const = type['fields'].find { |f| baked_discriminator?(f) }
  discriminator = const && {ruby_name: field_name(const, extensible),
                            wire: const['wire'], value: const['type']['const'],
                            rbs: rbs_const(const['type']['const'])}
  fields = type['fields'].reject { |f| baked_discriminator?(f) }.map { |f| field_ir(f, extensible) }
  # Every extensible type gets the extensions store: an undeclared wire key is preserved
  # and echoed back on any type the spec marks extensible, whether or not it is re-sendable.
  # Extensibility alone is the signal; send-reachability does not enter into it.
  TypeClass.new(ruby_name: BiDiGenerate.type_class_name(name), fields: fields,
                discriminator: discriminator, extensible: extensible,
                schema_name: name, synthetic: type['synthetic'] ? true : false,
                owner: type['owner'], label: type['label'], spec_href: type['specHref'],
                **directionality(name))
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1287

def record_params(fields, extensible)
  fields.map do |field|
    Param.new(
      ruby_name: field_name(field, extensible),
      wire_name: field['wire'],
      required: field['required'],
      enum: enum_const(field['type']),
      rbs: rbs_type(field['type'])
    )
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 917

def refs_in_type(node)
  return [] unless node
  return [node['ref']] if node['ref']
  return refs_in_type(node['list']) if node['list']
  return refs_in_type(node['map']) if node['map']
  return node['union'].flat_map { |arm| refs_in_type(arm) } if node['union']
  return node['record'].flat_map { |f| refs_in_type(f['type']) } if node['record']

  []
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 944

def resolve(node)
  nullable = node['nullable'] ? true : false
  if node.key?('list')
    list = resolve_list(node['list'])
    return list.merge(nullable: nullable, rbs: nilable(list[:rbs], nullable))
  end
  if node.key?('ref')
    named = narrowed(resolve_named(node['ref']), node)
    return {ref: named[:ref], list: named[:list], nullable: nullable, scalar: named[:scalar],
            map: named[:map], primitive: named[:primitive], bounds: named[:bounds],
            rbs: nilable(named[:rbs], nullable)}
  end
  return resolve_union(node, nullable) if node.key?('union')

  {ref: nil, list: false, nullable: nullable, primitive: checkable_primitive(node),
   bounds: node.slice(*BOUND_KEYS), rbs: nilable(scalar_rbs(node), nullable)}
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 970

def resolve_list(element_node)
  element = resolve(element_node)
  # Record checks every element as non-null, so a nullable one would reject valid wire data.
  raise "nullable list element #{element_node.inspect} is not supported by Record" if element[:nullable]

  primitive, bounds = element.values_at(:primitive, :bounds) unless element[:list]
  {ref: element[:ref], list: true, scalar: element[:scalar], primitive: primitive, bounds: bounds,
   rbs: "Array[#{element[:rbs]}]"}
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1047

def resolve_named(name, seen = {})
  return OPAQUE if name.nil? || seen[name]

  seen[name] = true
  type = @types[name]
  return OPAQUE unless type

  case type['kind']
  when 'record' then type['fields'].empty? ? map_record(type) : named_type(name)
  when 'union' then named_union(name)
  when 'enum' then {ref: nil, list: false, rbs: 'Symbol'}
  when 'alias' then resolve_named_alias(name, type['type'], seen)
  else OPAQUE
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1105

def resolve_named_alias(name, inner, seen)
  return named_union(name) if inner.key?('union')
  return narrowed(resolve_named(inner['ref'], seen), inner) if inner.key?('ref')
  return resolve_list(inner['list']) if inner.key?('list')

  {ref: nil, list: false, primitive: checkable_primitive(inner), bounds: inner.slice(*BOUND_KEYS),
   rbs: scalar_rbs(inner)}
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 992

def resolve_union(node, nullable)
  primitives = union_primitives(node['union'])
  return scalar_union(primitives, nullable).merge(bounds: union_bounds(node['union'])) if primitives

  refs = node['union'].select { |arm| arm.key?('ref') }
  opaque = {ref: nil, list: false, nullable: nullable, rbs: nilable('untyped', nullable)}
  return opaque unless refs.one? && union_ref?(refs.first['ref'])

  named = resolve_named(refs.first['ref'])
  {ref: named[:ref], list: named[:list], nullable: nullable, scalar: node['scalar'],
   rbs: nilable('untyped', nullable)}
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 930

def ruby_path(name)
  type = @types[name]
  return BiDiGenerate.type_ruby_path(name) unless type && type['synthetic']

  "#{ruby_path(type['owner'])}::#{type['label']}"
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 893

def ruby_path_for(name) = ruby_path(name)

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1322

def scalar_rbs(node)
  return PRIMITIVE_RBS.fetch(node['primitive']) if node.key?('primitive')
  return rbs_const(node['const']) if node.key?('const')

  'untyped'
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1025

def scalar_union(primitives, nullable)
  rbs = primitives.map { |primitive| PRIMITIVE_RBS.fetch(primitive) }.join(' | ')
  rbs = "(#{rbs})" if nullable && primitives.size > 1
  {ref: nil, list: false, nullable: nullable, primitive: primitives.one? ? primitives.first : primitives,
   rbs: nilable(rbs, nullable)}
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 886

def structured_ref(name)
  resolved = resolve_named(name)
  resolved[:list] ? nil : resolved[:ref]
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 865

def suppressed_record?(type)
  message_envelope?(type) || envelope_synthetic?(type)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1198

def tighter_bound?(side, flag, candidate, current)
  return true unless current.key?(side)
  return candidate[flag] && !current[flag] if candidate[side] == current[side]

  side == 'min' ? candidate[side] > current[side] : candidate[side] < current[side]
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 766

def type_kind(ref)
  @types[ref]&.fetch('kind', nil)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 833

def type_prefixes(domain)
  return [domain] unless vendor_domain?(domain)

  messages = commands_for(domain) + events_for(domain)
  refs = messages.flat_map { |m| [m.dig('params', 'ref'), m.dig('result', 'ref')] }
  refs.compact.select { |ref| ref.include?('.') }.map { |ref| ref.split('.', 2).first }.uniq
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 852

def types_for(domain)
  owned_types(domain).filter_map do |name, type|
    case type['kind']
    when 'record' then record_class(name, type) unless type['fields'].empty? || suppressed_record?(type)
    when 'union' then union_class(name)
    when 'alias' then union_class(name) if type['type'].key?('union')
    end
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1099

def union_alias_path(name)
  segments = ruby_path(name).split('::')
  segments[-1] = BiDiGenerate.camel_to_snake(segments[-1])
  rbs_abs(segments.join('::'))
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1017

def union_bounds(arms)
  numeric = arms.map { |arm| resolve(arm) }.select { |arm| NUMERIC_PRIMITIVES.include?(arm[:primitive]) }
  bounds = numeric.map { |arm| arm[:bounds] || {} }.uniq
  raise "numeric union arms #{arms} have different bounds: #{bounds}" if bounds.size > 1

  bounds.first
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1205

def union_class(name)
  type = @types[name]
  # A first-class union carries the schema's authoritative dispatch `selector`
  # (derived spec-faithfully, including null discriminators and the spec's choice
  # order); consume it rather than re-deriving and silently depending on emit
  # order. An alias-to-union (only input.Origin) has no selector — its const-string
  # arms aren't first-class types — so it keeps the structural re-derivation.
  klass = type['kind'] == 'union' ? union_from_selector(name, type['selector']) : union_from_alias(name)
  # A non-object_only union has a bare-scalar arm; only const-literal arms (scalar_values) are
  # modeled, so the runtime can validate an outbound scalar. A non-object_only union without them
  # is a shape the generator doesn't yet handle — fail here, at generation, not at a caller's runtime.
  if !klass.object_only && !klass.scalar_values?
    raise "non-object_only union #{name} has no scalar_values to validate its bare-scalar arm"
  end

  klass
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1268

def union_from_alias(name)
  spec = @types[name]
  consts = spec['type']['union'].filter_map { |arm| arm['ref'] }.to_h do |ref|
    const = @types[ref]['fields'].find { |f| f['type'].key?('const') }
    const || raise("alias-union #{name} arm #{ref} has no const discriminator to dispatch on")
    [ref, const]
  end
  variants = consts.map do |ref, const|
    VariantIR.new(mode: :value, value: const['type']['const'], ref: ruby_path(ref), requires: nil)
  end
  # An alias-union carries bare-scalar arms (input.Origin's "viewport"/"pointer"), so it
  # is never object_only — those arms must still pass a non-Hash payload through, but only
  # a value the schema pins in scalarValues (so a stray "banana" is still rejected outbound).
  UnionClass.new(ruby_name: BiDiGenerate.type_class_name(name),
                 discriminator_wire: consts.values.first['wire'], variants: variants, schema_name: name,
                 spec_href: spec['specHref'], object_only: spec['objectOnly'] ? true : false,
                 scalar_values: spec['type']['scalarValues'], **directionality(name))
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1230

def union_from_selector(name, selector)
  # A correlated union is resolved by request id, never the payload, so it carries
  # no dispatch — it must never be emitted (every one is a top-level result
  # grouping). Fail loudly if a future schema makes one domain-scoped rather than
  # emit a Union whose every parse would raise.
  if selector['correlated']
    raise "correlated union #{name} must not be emitted (resolved by request id, not payload)"
  end

  variants = selector['by'] ? discriminated_variants(selector) : ordered_variants(selector)
  raise "union #{name} selector yielded no dispatch variants" if variants.empty?

  UnionClass.new(ruby_name: BiDiGenerate.type_class_name(name),
                 discriminator_wire: selector['by'], variants: variants, schema_name: name,
                 spec_href: @types[name]['specHref'], object_only: @types[name]['objectOnly'] ? true : false,
                 **directionality(name))
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1357

def union_params(type, ref = nil)
  variants = type['variants'].map { |variant_ref| @types[variant_ref] }
  return nil unless variants.all? { |v| v && v['kind'] == 'record' }

  selector = type['selector']
  guard_union_dispatch_keys_simple!(selector, ref)
  params = merged_params(variants.map { |v| v['fields'] }, type['variants'].any? { |v| extensible_record?(v) })
  annotate_discriminator_enum!(params, selector)
  params
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1007

def union_primitives(arms)
  primitives = arms.map do |arm|
    resolved = resolve(arm)
    resolved[:primitive] unless arm.key?('const') || resolved[:list] || resolved[:nullable]
  end
  primitives.flatten.uniq unless primitives.include?(nil)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1034

def union_ref?(name)
  type = @types[name]
  return false unless type
  return union_ref?(type['type']['ref']) if type['kind'] == 'alias' && type['type'].key?('ref')

  type['kind'] == 'union'
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 635

def vendor_added_commands(domain, namespace)
  return [] if vendor_domain?(domain)

  (@vendor.dig(namespace, 'commands') || []).select { |c| c['domain'] == domain }
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 567

def vendor_domain?(domain) = domain.include?(':')

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 625

def vendor_events
  events = vendor_messages('events')
  stray = events.reject { |e| vendor_domain?(e['domain']) }
  raise "vendor event #{stray.first['method']} in spec domain #{stray.first['domain']} is unsupported" if stray.any?

  events
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 590

def vendor_extension_fields(namespace, type_name, entry)
  type = @types[type_name] || raise("vendor #{namespace} extends unknown type #{type_name}")
  raise "vendor #{namespace} extends #{type_name}, which is not a record" unless type['kind'] == 'record'

  fields = entry['fields'].map { |field| hoist_vendor_enum(type_name, field) }
  @vendor_field_refs.concat(fields.flat_map { |field| refs_in_type(field['type']) })
  fields
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 761

def vendor_field(field, namespace, taken)
  stripped = field.merge('name' => field['name'].delete_prefix("#{namespace}:"))
  taken.include?(field_name(stripped, false)) ? field : stripped
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 619

def vendor_messages(kind)
  @vendor.values.flat_map { |section| section[kind] || [] }
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 714

def vendor_modules_for(domain)
  parent = BiDiGenerate.snake_to_class_name(BiDiGenerate.camel_to_snake(domain))
  @vendor_params.filter_map do |namespace, extended|
    overrides = extended.filter_map do |type_name, fields|
      cmd = params_command(type_name)
      build_vendor_override(cmd, type_name, fields, namespace) if cmd['domain'] == domain
    end
    added = vendor_added_commands(domain, namespace).map { |cmd| build_added_command(cmd, namespace, domain) }
    next if overrides.empty? && added.empty?

    VendorModule.new(name: BiDiGenerate.snake_to_class_name(namespace), namespace: namespace, parent: parent,
                     types: overrides.map(&:first), commands: overrides.map(&:last) + added)
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 819

def vendor_types_reached(domain)
  commands = @vendor.keys.flat_map { |namespace| vendor_added_commands(domain, namespace) }
  pending = commands.flat_map { |c| [c.dig('params', 'ref'), c.dig('result', 'ref')] }.compact + @vendor_field_refs
  reached = Set.new
  until pending.empty?
    name = pending.pop
    next if reached.include?(name) || !@vendor_types.key?(name)

    reached << name
    pending.concat(plain_refs(@types[name]) + (@types[name]['variants'] || []))
  end
  reached
end