senko 0.1.0

data/lib/senko/compiler.rb

@@ -0,0 +1,991 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+require 'set'
+
+require_relative 'compiler/instruction'
+require_relative 'compiler/optimizer'
+require_relative 'compiler/ref_resolver'
+require_relative 'dialect'
+require_relative 'errors'
+
+module Senko
+  class Compiler
+    DEFAULT_OPTIONS = {
+      draft: nil,
+      format: :annotation,
+      ref_resolver: nil,
+      schemas: {},
+      fail_fast: false,
+      validate_meta_schema: false,
+      custom_formats: {},
+      custom_keywords: {},
+      codegen: :auto,
+      messages: {}
+    }.freeze
+
+    APPLICATOR_KEYWORDS = %w[allOf anyOf oneOf].freeze
+    SCHEMA_ARRAY_KEYWORDS = %w[allOf anyOf oneOf prefixItems].freeze
+    SCHEMA_MAP_KEYWORDS = %w[properties patternProperties $defs definitions dependentSchemas].freeze
+    SCHEMA_VALUE_KEYWORDS = %w[
+      items additionalItems additionalProperties propertyNames contains not if then else
+      unevaluatedProperties unevaluatedItems
+    ].freeze
+    DATA_VALUE_KEYWORDS = %w[const enum default examples required dependentRequired].freeze
+
+    attr_reader :options
+
+    def initialize(options = {})
+      @options = DEFAULT_OPTIONS.merge(options)
+      @ref_cache = {}
+      @resolving = Set.new
+      @instruction_arrays = {}
+    end
+
+    def compile(schema)
+      stringified = deep_stringify(schema)
+      validate_meta_schema!(stringified) if @options[:validate_meta_schema]
+      @draft = Dialect.detect(stringified, @options[:draft])
+      @root_schema = normalize_schema(stringified, @draft)
+      @ref_resolver = RefResolver.new(
+        @root_schema,
+        schemas: @options[:schemas] || {},
+        ref_resolver: @options[:ref_resolver]
+      )
+      @root_scope = RefResolver::ROOT_SCOPE
+      @validation_vocabulary_enabled = validation_vocabulary_enabled?(@root_schema)
+
+      Optimizer.new.optimize(compile_schema(@root_schema, '', @root_scope))
+    end
+
+    private
+
+    def compile_schema(schema, path, scope)
+      case schema
+      when true
+        []
+      when false
+        [instruction(:false_schema, {}, path, schema)]
+      when Hash
+        compile_hash_schema(schema, path, scope)
+      else
+        raise CompileError, 'schema must be a Hash, true, or false'
+      end
+    end
+
+    def compile_hash_schema(schema, path, scope)
+      instructions = []
+      @instruction_arrays[[scope, path]] = instructions
+      instructions.concat(compile_ref(schema, path, scope))
+      instructions.concat(compile_dynamic_ref(schema, path, scope))
+      if @validation_vocabulary_enabled
+        compile_type(schema, path, instructions)
+        compile_enum(schema, path, instructions)
+        compile_const(schema, path, instructions)
+        compile_numeric(schema, path, instructions)
+        compile_string(schema, path, instructions)
+      end
+      compile_format(schema, path, instructions)
+      compile_array(schema, path, scope, instructions)
+      compile_object(schema, path, scope, instructions)
+      compile_applicators(schema, path, scope, instructions)
+      compile_unevaluated(schema, path, scope, instructions)
+      compile_custom_keywords(schema, path, instructions)
+      compile_dynamic_scope(schema, path, scope, instructions)
+      instructions
+    end
+
+    def compile_ref(schema, path, scope)
+      return [] unless schema.key?('$ref')
+
+      uri = schema.fetch('$ref').to_s
+      resolved = @ref_resolver.resolve(uri, from: path, scope: scope)
+      target_instructions = compile_ref_target(ref_cache_key(uri, resolved), resolved)
+
+      [
+        instruction(
+          :ref,
+          { uri: uri, instructions: target_instructions },
+          join_pointer(path, '$ref'),
+          schema['$ref']
+        )
+      ]
+    end
+
+    def compile_dynamic_ref(schema, path, scope)
+      return [] unless schema.key?('$dynamicRef')
+
+      uri = schema.fetch('$dynamicRef').to_s
+      resolved = @ref_resolver.resolve_dynamic(uri, from: path, scope: scope)
+      target_instructions = compile_ref_target(ref_cache_key(uri, resolved, prefix: 'dynamic'), resolved)
+      anchor = dynamic_ref_anchor(uri)
+      dynamic = anchor && resolved.schema.is_a?(Hash) && resolved.schema['$dynamicAnchor'] == anchor
+
+      [
+        instruction(
+          :dynamic_ref,
+          { uri: uri, anchor: anchor, dynamic: dynamic, instructions: target_instructions },
+          join_pointer(path, '$dynamicRef'),
+          schema['$dynamicRef']
+        )
+      ]
+    end
+
+    def compile_ref_target(uri, resolved)
+      return @ref_cache[uri] if @ref_cache.key?(uri)
+
+      placeholder = []
+      @ref_cache[uri] = placeholder
+      @resolving.add(uri)
+      normalized = normalize_schema(deep_stringify(resolved.schema), @draft)
+      target_draft = Dialect.schema_draft(normalized) || @draft
+      previous_draft = @draft
+      @draft = target_draft
+      normalized = normalize_schema(normalized, target_draft)
+      placeholder.replace(compile_schema(normalized, resolved.keyword_location, resolved.scope))
+      placeholder
+    rescue StandardError
+      @ref_cache.delete(uri) if @ref_cache[uri].equal?(placeholder)
+      raise
+    ensure
+      @draft = previous_draft if defined?(previous_draft) && previous_draft
+      @resolving.delete(uri)
+    end
+
+    def ref_cache_key(uri, resolved, prefix: 'ref')
+      "#{prefix}:#{resolved.scope}:#{resolved.base_uri}##{resolved.keyword_location}:#{uri}"
+    end
+
+    def compile_dynamic_scope(_schema, path, scope, instructions)
+      @instruction_arrays[[scope, path]] = instructions
+      base_uri = @ref_resolver.base_uri_for(path, scope)
+      anchors = @ref_resolver.dynamic_anchors_for(base_uri)
+      return if anchors.empty?
+
+      compiled = anchors.each_with_object({}) do |(anchor, resolved), result|
+        result[anchor] = @instruction_arrays[[resolved.scope, resolved.keyword_location]] ||
+                         compile_ref_target(ref_cache_key(anchor, resolved, prefix: 'dynamic-anchor'), resolved)
+      end
+
+      instructions.unshift(
+        instruction(
+          :dynamic_scope,
+          { base_uri: base_uri, anchors: compiled },
+          path,
+          nil
+        )
+      )
+    end
+
+    def dynamic_ref_anchor(uri)
+      _base, fragment = uri.to_s.split('#', 2)
+      return nil if fragment.nil? || fragment.empty? || fragment.start_with?('/')
+
+      URI::DEFAULT_PARSER.unescape(fragment)
+    end
+
+    def compile_type(schema, path, instructions)
+      return unless schema.key?('type')
+
+      type_value = schema.fetch('type')
+      types = type_value.is_a?(Array) ? type_value : [type_value]
+      mask = types.reduce(0) do |memo, type|
+        type_name = type.to_s
+        bit = Instructions::TYPE_MAP[type_name]
+        raise CompileError, "unsupported JSON Schema type: #{type.inspect}" unless bit
+
+        memo | bit
+      end
+
+      instructions << instruction(
+        :type,
+        { mask: mask, expected: types.map(&:to_s) },
+        join_pointer(path, 'type'),
+        type_value
+      )
+    end
+
+    def compile_enum(schema, path, instructions)
+      return unless schema.key?('enum')
+
+      values = schema.fetch('enum')
+      raise CompileError, 'enum must be an Array' unless values.is_a?(Array)
+
+      instructions << instruction(:enum, { values: values }, join_pointer(path, 'enum'), values)
+    end
+
+    def compile_const(schema, path, instructions)
+      return unless schema.key?('const')
+
+      instructions << instruction(:const, { value: schema.fetch('const') }, join_pointer(path, 'const'),
+                                  schema['const'])
+    end
+
+    def compile_numeric(schema, path, instructions)
+      if schema.key?('multipleOf')
+        factor = numeric_value!(schema.fetch('multipleOf'), 'multipleOf')
+        raise CompileError, 'multipleOf must be greater than 0' unless factor.positive?
+
+        instructions << instruction(:multiple_of, { factor: factor }, join_pointer(path, 'multipleOf'), factor)
+      end
+
+      if schema.key?('maximum')
+        limit = numeric_value!(schema.fetch('maximum'), 'maximum')
+        instructions << instruction(:maximum, { limit: limit, exclusive: false }, join_pointer(path, 'maximum'), limit)
+      end
+
+      if schema.key?('exclusiveMaximum')
+        limit = numeric_value!(schema.fetch('exclusiveMaximum'), 'exclusiveMaximum')
+        instructions << instruction(:maximum, { limit: limit, exclusive: true }, join_pointer(path, 'exclusiveMaximum'),
+                                    limit)
+      end
+
+      if schema.key?('minimum')
+        limit = numeric_value!(schema.fetch('minimum'), 'minimum')
+        instructions << instruction(:minimum, { limit: limit, exclusive: false }, join_pointer(path, 'minimum'), limit)
+      end
+
+      return unless schema.key?('exclusiveMinimum')
+
+      limit = numeric_value!(schema.fetch('exclusiveMinimum'), 'exclusiveMinimum')
+      instructions << instruction(:minimum, { limit: limit, exclusive: true }, join_pointer(path, 'exclusiveMinimum'),
+                                  limit)
+    end
+
+    def compile_string(schema, path, instructions)
+      if schema.key?('maxLength')
+        limit = non_negative_integer!(schema.fetch('maxLength'), 'maxLength')
+        instructions << instruction(:max_length, { limit: limit }, join_pointer(path, 'maxLength'), limit)
+      end
+
+      if schema.key?('minLength')
+        limit = non_negative_integer!(schema.fetch('minLength'), 'minLength')
+        instructions << instruction(:min_length, { limit: limit }, join_pointer(path, 'minLength'), limit)
+      end
+
+      return unless schema.key?('pattern')
+
+      pattern = schema.fetch('pattern').to_s
+      regexp = Regexp.new(Senko::Format.ecma_pattern_source(pattern))
+      instructions << instruction(:pattern, { pattern: regexp, source: pattern }, join_pointer(path, 'pattern'),
+                                  pattern)
+    rescue RegexpError => e
+      raise CompileError, "invalid pattern #{pattern.inspect}: #{e.message}"
+    end
+
+    def compile_format(schema, path, instructions)
+      return unless schema.key?('format')
+
+      format = schema.fetch('format').to_s
+      instructions << instruction(
+        :format,
+        { format: format, assertion: format_assertion_enabled? },
+        join_pointer(path, 'format'),
+        format
+      )
+    end
+
+    def compile_array(schema, path, scope, instructions)
+      if @validation_vocabulary_enabled
+        if schema.key?('maxItems')
+          limit = non_negative_integer!(schema.fetch('maxItems'), 'maxItems')
+          instructions << instruction(:max_items, { limit: limit }, join_pointer(path, 'maxItems'), limit)
+        end
+
+        if schema.key?('minItems')
+          limit = non_negative_integer!(schema.fetch('minItems'), 'minItems')
+          instructions << instruction(:min_items, { limit: limit }, join_pointer(path, 'minItems'), limit)
+        end
+
+        if schema['uniqueItems'] == true
+          instructions << instruction(:unique_items, {}, join_pointer(path, 'uniqueItems'),
+                                      true)
+        end
+      end
+
+      prefix_count = compile_prefix_items(schema, path, scope, instructions)
+      compile_items(schema, path, scope, prefix_count, instructions)
+      compile_contains(schema, path, scope, instructions)
+    end
+
+    def compile_prefix_items(schema, path, scope, instructions)
+      return 0 unless schema.key?('prefixItems')
+
+      prefix_items = schema.fetch('prefixItems')
+      raise CompileError, 'prefixItems must be an Array' unless prefix_items.is_a?(Array)
+
+      compiled = prefix_items.each_with_index.map do |subschema, index|
+        compile_schema(subschema, join_pointer(path, 'prefixItems', index.to_s), scope)
+      end
+
+      instructions << instruction(:prefix_items, { schemas: compiled }, join_pointer(path, 'prefixItems'), prefix_items)
+      compiled.length
+    end
+
+    def compile_items(schema, path, scope, prefix_count, instructions)
+      return unless schema.key?('items')
+
+      instructions << instruction(
+        :items,
+        { schema: compile_schema(schema.fetch('items'), join_pointer(path, 'items'), scope),
+          start_index: prefix_count },
+        join_pointer(path, 'items'),
+        schema['items']
+      )
+    end
+
+    def compile_contains(schema, path, scope, instructions)
+      return unless schema.key?('contains')
+
+      min = if @validation_vocabulary_enabled && schema.key?('minContains')
+              non_negative_integer!(schema.fetch('minContains'), 'minContains')
+            else
+              1
+            end
+      max = if @validation_vocabulary_enabled && schema.key?('maxContains')
+              non_negative_integer!(schema.fetch('maxContains'), 'maxContains')
+            end
+
+      instructions << instruction(
+        :contains,
+        {
+          schema: compile_schema(schema.fetch('contains'), join_pointer(path, 'contains'), scope),
+          min: min,
+          max: max
+        },
+        join_pointer(path, 'contains'),
+        schema['contains']
+      )
+    end
+
+    def compile_object(schema, path, scope, instructions)
+      if @validation_vocabulary_enabled
+        if schema.key?('maxProperties')
+          limit = non_negative_integer!(schema.fetch('maxProperties'), 'maxProperties')
+          instructions << instruction(:max_properties, { limit: limit }, join_pointer(path, 'maxProperties'), limit)
+        end
+
+        if schema.key?('minProperties')
+          limit = non_negative_integer!(schema.fetch('minProperties'), 'minProperties')
+          instructions << instruction(:min_properties, { limit: limit }, join_pointer(path, 'minProperties'), limit)
+        end
+
+        compile_required(schema, path, instructions)
+        compile_dependent_required(schema, path, instructions)
+      end
+
+      compile_properties(schema, path, scope, instructions)
+      compile_pattern_properties(schema, path, scope, instructions)
+      compile_additional_properties(schema, path, scope, instructions)
+      compile_property_names(schema, path, scope, instructions)
+      compile_dependent_schemas(schema, path, scope, instructions)
+    end
+
+    def compile_required(schema, path, instructions)
+      return unless schema.key?('required')
+
+      required = schema.fetch('required')
+      raise CompileError, 'required must be an Array' unless required.is_a?(Array)
+
+      instructions << instruction(
+        :required,
+        { keys: required.to_set(&:to_s) },
+        join_pointer(path, 'required'),
+        required
+      )
+    end
+
+    def compile_properties(schema, path, scope, instructions)
+      return unless schema.key?('properties')
+
+      properties = schema.fetch('properties')
+      raise CompileError, 'properties must be a Hash' unless properties.is_a?(Hash)
+
+      compiled = properties.each_with_object({}) do |(name, subschema), result|
+        key = name.to_s
+        result[key] = compile_schema(subschema, join_pointer(path, 'properties', key), scope)
+      end
+
+      instructions << instruction(:properties, { schemas: compiled }, join_pointer(path, 'properties'), properties)
+    end
+
+    def compile_pattern_properties(schema, path, scope, instructions)
+      return unless schema.key?('patternProperties')
+
+      pattern_properties = schema.fetch('patternProperties')
+      raise CompileError, 'patternProperties must be a Hash' unless pattern_properties.is_a?(Hash)
+
+      compiled = pattern_properties.map do |pattern, subschema|
+        regexp = Regexp.new(Senko::Format.ecma_pattern_source(pattern.to_s))
+        {
+          pattern: regexp,
+          source: pattern.to_s,
+          schema: compile_schema(subschema, join_pointer(path, 'patternProperties', pattern.to_s), scope)
+        }
+      rescue RegexpError => e
+        raise CompileError, "invalid patternProperties pattern #{pattern.inspect}: #{e.message}"
+      end
+
+      instructions << instruction(:pattern_properties, { patterns: compiled }, join_pointer(path, 'patternProperties'),
+                                  pattern_properties)
+    end
+
+    def compile_additional_properties(schema, path, scope, instructions)
+      return unless schema.key?('additionalProperties')
+
+      additional = schema.fetch('additionalProperties')
+
+      patterns = (schema['patternProperties'] || {}).keys.map { |pattern| Regexp.new(pattern.to_s) }
+      payload = {
+        known: (schema['properties'] || {}).keys.to_set(&:to_s),
+        patterns: patterns,
+        schema: (if additional == false
+                   false
+                 else
+                   compile_schema(additional, join_pointer(path, 'additionalProperties'),
+                                  scope)
+                 end)
+      }
+
+      instructions << instruction(:additional_properties, payload, join_pointer(path, 'additionalProperties'),
+                                  additional)
+    end
+
+    def compile_property_names(schema, path, scope, instructions)
+      return unless schema.key?('propertyNames')
+
+      instructions << instruction(
+        :property_names,
+        { schema: compile_schema(schema.fetch('propertyNames'), join_pointer(path, 'propertyNames'), scope) },
+        join_pointer(path, 'propertyNames'),
+        schema['propertyNames']
+      )
+    end
+
+    def compile_dependent_required(schema, path, instructions)
+      return unless schema.key?('dependentRequired')
+
+      requirements = schema.fetch('dependentRequired')
+      raise CompileError, 'dependentRequired must be a Hash' unless requirements.is_a?(Hash)
+
+      compiled = requirements.transform_values do |keys|
+        raise CompileError, 'dependentRequired values must be Arrays' unless keys.is_a?(Array)
+
+        keys.to_set(&:to_s)
+      end
+
+      instructions << instruction(:dependent_required, { requirements: compiled },
+                                  join_pointer(path, 'dependentRequired'), requirements)
+    end
+
+    def compile_dependent_schemas(schema, path, scope, instructions)
+      return unless schema.key?('dependentSchemas')
+
+      dependent_schemas = schema.fetch('dependentSchemas')
+      raise CompileError, 'dependentSchemas must be a Hash' unless dependent_schemas.is_a?(Hash)
+
+      compiled = dependent_schemas.each_with_object({}) do |(key, subschema), result|
+        name = key.to_s
+        result[name] = compile_schema(subschema, join_pointer(path, 'dependentSchemas', name), scope)
+      end
+
+      instructions << instruction(:dependent_schemas, { schemas: compiled }, join_pointer(path, 'dependentSchemas'),
+                                  dependent_schemas)
+    end
+
+    def compile_applicators(schema, path, scope, instructions)
+      APPLICATOR_KEYWORDS.each do |keyword|
+        next unless schema.key?(keyword)
+
+        subschemas = schema.fetch(keyword)
+        raise CompileError, "#{keyword} must be an Array" unless subschemas.is_a?(Array)
+
+        discriminator = detect_explicit_discriminator(schema, keyword, path, scope) || detect_discriminator(subschemas)
+        if discriminator && %w[anyOf oneOf].include?(keyword)
+          instructions << compile_discriminator(keyword, discriminator, path, scope, subschemas)
+          next
+        end
+
+        compiled = subschemas.each_with_index.map do |subschema, index|
+          compile_schema(subschema, join_pointer(path, keyword, index.to_s), scope)
+        end
+
+        instructions << instruction(keyword_to_op(keyword), { schemas: compiled }, join_pointer(path, keyword),
+                                    subschemas)
+      end
+
+      compile_not(schema, path, scope, instructions)
+      compile_if_then_else(schema, path, scope, instructions)
+    end
+
+    def compile_not(schema, path, scope, instructions)
+      return unless schema.key?('not')
+
+      instructions << instruction(
+        :not,
+        { schema: compile_schema(schema.fetch('not'), join_pointer(path, 'not'), scope) },
+        join_pointer(path, 'not'),
+        schema['not']
+      )
+    end
+
+    def detect_discriminator(subschemas)
+      candidates = discriminator_candidates(subschemas.first)
+      candidates.each do |property|
+        mapping = discriminator_mapping(subschemas, property)
+        return { property: property, mapping: mapping } if mapping && mapping.length == subschemas.length
+      end
+
+      nil
+    end
+
+    def detect_explicit_discriminator(schema, keyword, path, scope)
+      config = schema['discriminator']
+      return nil unless config.is_a?(Hash) && config['propertyName'].is_a?(String)
+
+      subschemas = schema[keyword]
+      property = config.fetch('propertyName')
+      mapping = explicit_discriminator_mapping(config.fetch('mapping', {}), subschemas, property, path, scope)
+      return nil unless mapping && !mapping.empty?
+
+      { property: property, mapping: mapping }
+    end
+
+    def explicit_discriminator_mapping(mapping_config, subschemas, property, path, scope)
+      if mapping_config.is_a?(Hash) && !mapping_config.empty?
+        return mapping_config.each_with_object({}) do |(value, ref), result|
+          resolved = @ref_resolver.resolve(ref.to_s, from: path, scope: scope)
+          result[value.to_s] = normalize_schema(deep_stringify(resolved.schema), @draft)
+        end
+      end
+
+      discriminator_mapping(subschemas, property)
+    end
+
+    def discriminator_candidates(schema)
+      return [] unless schema.is_a?(Hash)
+
+      required = Array(schema['required']).map(&:to_s)
+      properties = schema['properties']
+      return [] unless properties.is_a?(Hash)
+
+      properties.each_with_object([]) do |(property, subschema), result|
+        key = property.to_s
+        result << key if required.include?(key) && subschema.is_a?(Hash) && subschema.key?('const')
+      end
+    end
+
+    def discriminator_mapping(subschemas, property)
+      values = {}
+
+      subschemas.each do |subschema|
+        return nil unless subschema.is_a?(Hash)
+        return nil unless Array(subschema['required']).map(&:to_s).include?(property)
+
+        property_schema = subschema.fetch('properties', {})[property]
+        return nil unless property_schema.is_a?(Hash) && property_schema.key?('const')
+
+        value = property_schema.fetch('const')
+        return nil if values.key?(value)
+
+        values[value] = subschema
+      end
+
+      values
+    end
+
+    def compile_discriminator(keyword, discriminator, path, scope, subschemas)
+      mapping = discriminator[:mapping].transform_values.with_index do |subschema, index|
+        compile_schema(subschema, join_pointer(path, keyword, index.to_s), scope)
+      end
+
+      instruction(
+        :discriminator,
+        {
+          mode: keyword_to_op(keyword),
+          property: discriminator[:property],
+          mapping: mapping
+        },
+        join_pointer(path, keyword),
+        subschemas
+      )
+    end
+
+    def compile_if_then_else(schema, path, scope, instructions)
+      return unless schema.key?('if')
+
+      payload = {
+        if_schema: compile_schema(schema.fetch('if'), join_pointer(path, 'if'), scope),
+        then_schema: (compile_schema(schema.fetch('then'), join_pointer(path, 'then'), scope) if schema.key?('then')),
+        else_schema: (compile_schema(schema.fetch('else'), join_pointer(path, 'else'), scope) if schema.key?('else'))
+      }
+
+      instructions << instruction(:if_then_else, payload, join_pointer(path, 'if'), schema['if'])
+    end
+
+    def compile_unevaluated(schema, path, scope, instructions)
+      if schema.key?('unevaluatedProperties')
+        value = schema.fetch('unevaluatedProperties')
+        instructions << instruction(
+          :unevaluated_properties,
+          { schema: if value == false
+                      false
+                    else
+                      compile_schema(value, join_pointer(path, 'unevaluatedProperties'),
+                                     scope)
+                    end },
+          join_pointer(path, 'unevaluatedProperties'),
+          value
+        )
+      end
+
+      return unless schema.key?('unevaluatedItems')
+
+      value = schema.fetch('unevaluatedItems')
+      instructions << instruction(
+        :unevaluated_items,
+        { schema: value == false ? false : compile_schema(value, join_pointer(path, 'unevaluatedItems'), scope) },
+        join_pointer(path, 'unevaluatedItems'),
+        value
+      )
+    end
+
+    def compile_custom_keywords(schema, path, instructions)
+      (@options[:custom_keywords] || {}).each do |keyword, validator|
+        key = keyword.to_s
+        next unless schema.key?(key)
+
+        instructions << instruction(
+          :custom_keyword,
+          { keyword: key, value: schema.fetch(key), validator: validator },
+          join_pointer(path, key),
+          schema.fetch(key)
+        )
+      end
+    end
+
+    def normalize_schema(value, draft, schema_position: true)
+      case value
+      when Hash
+        normalized = normalize_openapi_nullable(normalize_schema_hash(value, draft))
+        schema_position ? normalize_legacy_schema(normalized, draft) : normalized
+      when Array
+        value.map { |child| normalize_schema(child, draft, schema_position: false) }
+      else
+        value
+      end
+    end
+
+    def validate_meta_schema!(schema, path = '')
+      case schema
+      when true, false
+        nil
+      when Hash
+        validate_schema_object!(schema, path)
+        schema.each do |key, child|
+          validate_meta_child!(key, child, join_pointer(path, key))
+        end
+      else
+        raise CompileError, "schema at #{path.empty? ? '/' : path} must be an object or boolean"
+      end
+    end
+
+    def validate_meta_child!(key, child, path)
+      if DATA_VALUE_KEYWORDS.include?(key)
+        validate_data_keyword!(key, child, path)
+      elsif key == 'items' && child.is_a?(Array)
+        child.each_with_index { |subschema, index| validate_meta_schema!(subschema, join_pointer(path, index.to_s)) }
+      elsif SCHEMA_ARRAY_KEYWORDS.include?(key)
+        validate_schema_array!(key, child, path)
+      elsif SCHEMA_MAP_KEYWORDS.include?(key)
+        validate_schema_map!(key, child, path)
+      elsif SCHEMA_VALUE_KEYWORDS.include?(key) || %w[$ref $dynamicRef $recursiveRef].include?(key)
+        validate_meta_schema!(child, path) unless %w[$ref $dynamicRef $recursiveRef].include?(key)
+      end
+    end
+
+    def validate_schema_object!(schema, path)
+      validate_type_keyword!(schema['type'], join_pointer(path, 'type')) if schema.key?('type')
+      validate_array_keyword!(schema, 'required', path, strings: true)
+      validate_array_keyword!(schema, 'enum', path)
+      validate_numeric_keyword!(schema, 'multipleOf', path, positive: true)
+      %w[maximum exclusiveMaximum minimum exclusiveMinimum].each do |keyword|
+        validate_numeric_keyword!(schema, keyword, path)
+      end
+      %w[maxLength minLength maxItems minItems maxProperties minProperties maxContains minContains].each do |keyword|
+        validate_non_negative_integer_keyword!(schema, keyword, path)
+      end
+      validate_boolean_keyword!(schema, 'uniqueItems', path)
+    end
+
+    def validate_data_keyword!(key, value, path)
+      return validate_array_value!(value, path, strings: true) if key == 'required'
+      return validate_schema_map_value!(value, path, arrays_of_strings: true) if key == 'dependentRequired'
+      return validate_array_value!(value, path) if key == 'enum'
+
+      true
+    end
+
+    def validate_schema_array!(key, value, path)
+      validate_array_value!(value, path)
+      value.each_with_index { |subschema, index| validate_meta_schema!(subschema, join_pointer(path, index.to_s)) }
+    rescue NoMethodError
+      raise CompileError, "#{key} at #{path} must be an array"
+    end
+
+    def validate_schema_map!(key, value, path)
+      validate_schema_map_value!(value, path)
+      value.each do |property, subschema|
+        validate_meta_schema!(subschema, join_pointer(path, property.to_s))
+      end
+    rescue NoMethodError
+      raise CompileError, "#{key} at #{path} must be an object"
+    end
+
+    def validate_type_keyword!(value, path)
+      values = value.is_a?(Array) ? value : [value]
+      raise CompileError, "type at #{path} must be a string or array" unless value.is_a?(String) || value.is_a?(Array)
+
+      values.each do |type|
+        raise CompileError, "type value at #{path} must be a string" unless type.is_a?(String)
+        unless Instructions::TYPE_MAP.key?(type)
+          raise CompileError, "unsupported JSON Schema type at #{path}: #{type.inspect}"
+        end
+      end
+    end
+
+    def validate_array_keyword!(schema, keyword, path, strings: false)
+      return unless schema.key?(keyword)
+
+      validate_array_value!(schema.fetch(keyword), join_pointer(path, keyword), strings: strings)
+    end
+
+    def validate_array_value!(value, path, strings: false)
+      raise CompileError, "#{path} must be an array" unless value.is_a?(Array)
+
+      return unless strings
+
+      value.each do |item|
+        raise CompileError, "#{path} must contain only strings" unless item.is_a?(String)
+      end
+    end
+
+    def validate_schema_map_value!(value, path, arrays_of_strings: false)
+      raise CompileError, "#{path} must be an object" unless value.is_a?(Hash)
+
+      return unless arrays_of_strings
+
+      value.each_value { |item| validate_array_value!(item, path, strings: true) }
+    end
+
+    def validate_numeric_keyword!(schema, keyword, path, positive: false)
+      return unless schema.key?(keyword)
+
+      value = schema.fetch(keyword)
+      raise CompileError, "#{keyword} at #{join_pointer(path, keyword)} must be numeric" unless value.is_a?(Numeric)
+      return unless positive && !value.positive?
+
+      raise CompileError,
+            "#{keyword} at #{join_pointer(path, keyword)} must be greater than 0"
+    end
+
+    def validate_non_negative_integer_keyword!(schema, keyword, path)
+      return unless schema.key?(keyword)
+
+      value = schema.fetch(keyword)
+      return if value.is_a?(Integer) && value >= 0
+
+      raise CompileError, "#{keyword} at #{join_pointer(path, keyword)} must be a non-negative integer"
+    end
+
+    def validate_boolean_keyword!(schema, keyword, path)
+      return unless schema.key?(keyword)
+      return if [true, false].include?(schema.fetch(keyword))
+
+      raise CompileError, "#{keyword} at #{join_pointer(path, keyword)} must be boolean"
+    end
+
+    def normalize_schema_hash(schema, draft)
+      schema.each_with_object({}) do |(key, child), result|
+        result[key] = normalize_schema_child(key, child, draft)
+      end
+    end
+
+    def normalize_schema_child(key, child, draft)
+      if DATA_VALUE_KEYWORDS.include?(key)
+        child
+      elsif key == 'items' && child.is_a?(Array)
+        child.map { |subschema| normalize_schema(subschema, draft) }
+      elsif SCHEMA_ARRAY_KEYWORDS.include?(key) && child.is_a?(Array)
+        child.map { |subschema| normalize_schema(subschema, draft) }
+      elsif SCHEMA_MAP_KEYWORDS.include?(key) && child.is_a?(Hash)
+        child.transform_values { |subschema| normalize_schema(subschema, draft) }
+      elsif SCHEMA_VALUE_KEYWORDS.include?(key)
+        normalize_schema(child, draft)
+      else
+        child
+      end
+    end
+
+    def validation_vocabulary_enabled?(schema)
+      return true unless schema.is_a?(Hash) && schema['$schema'].is_a?(String)
+
+      meta_schema = (@options[:schemas] || {})[schema['$schema']]
+      return true unless meta_schema.is_a?(Hash)
+
+      vocabulary = meta_schema['$vocabulary'] || meta_schema[:$vocabulary]
+      return true unless vocabulary.is_a?(Hash)
+
+      vocabulary.fetch('https://json-schema.org/draft/2020-12/vocab/validation', false) == true ||
+        vocabulary.fetch('https://json-schema.org/draft/2019-09/vocab/validation', false) == true
+    end
+
+    def format_assertion_enabled?
+      return true if @options[:format] == :assertion
+      return false unless @root_schema.is_a?(Hash) && @root_schema['$schema'].is_a?(String)
+
+      meta_schema = (@options[:schemas] || {})[@root_schema['$schema']]
+      return false unless meta_schema.is_a?(Hash)
+
+      vocabulary = meta_schema['$vocabulary'] || meta_schema[:$vocabulary]
+      return false unless vocabulary.is_a?(Hash)
+
+      vocabulary.key?('https://json-schema.org/draft/2020-12/vocab/format-assertion')
+    end
+
+    def normalize_legacy_schema(schema, draft)
+      normalized = schema.dup
+      normalize_recursive_keywords(normalized)
+      normalize_legacy_id(normalized, draft)
+      normalize_legacy_exclusive_bounds(normalized, draft)
+      normalize_legacy_dependencies(normalized)
+      return normalized if draft == :'2020-12'
+
+      normalized.delete('prefixItems')
+      if normalized.key?('definitions') && !normalized.key?('$defs')
+        normalized['$defs'] = normalized.delete('definitions')
+      end
+
+      normalize_legacy_items(normalized)
+      normalized
+    end
+
+    def normalize_recursive_keywords(schema)
+      schema['$dynamicRef'] ||= schema.delete('$recursiveRef') if schema.key?('$recursiveRef')
+      schema['$dynamicAnchor'] ||= '' if schema.delete('$recursiveAnchor') == true
+    end
+
+    def normalize_legacy_id(schema, draft)
+      return if draft == :'2020-12'
+      return unless schema.key?('id') && !schema.key?('$id')
+
+      schema['$id'] = schema.delete('id')
+    end
+
+    def normalize_legacy_exclusive_bounds(schema, draft)
+      return unless draft == :'draft-04'
+
+      if schema.key?('exclusiveMaximum') && boolean_value?(schema['exclusiveMaximum'])
+        exclusive = schema.delete('exclusiveMaximum')
+        schema['exclusiveMaximum'] = schema.delete('maximum') if exclusive && schema.key?('maximum')
+      end
+
+      return unless schema.key?('exclusiveMinimum') && boolean_value?(schema['exclusiveMinimum'])
+
+      exclusive = schema.delete('exclusiveMinimum')
+      schema['exclusiveMinimum'] = schema.delete('minimum') if exclusive && schema.key?('minimum')
+    end
+
+    def boolean_value?(value)
+      [true, false].include?(value)
+    end
+
+    def normalize_openapi_nullable(schema)
+      return schema unless schema['nullable'] == true && schema.key?('type')
+
+      normalized = schema.dup
+      type = normalized['type']
+      normalized['type'] = Array(type).map(&:to_s).tap do |types|
+        types << 'null' unless types.include?('null')
+      end
+      normalized
+    end
+
+    def normalize_legacy_items(schema)
+      return unless schema['items'].is_a?(Array)
+
+      schema['prefixItems'] ||= schema.delete('items')
+      schema['items'] = schema.delete('additionalItems') if schema.key?('additionalItems')
+    end
+
+    def normalize_legacy_dependencies(schema)
+      dependencies = schema.delete('dependencies')
+      return unless dependencies.is_a?(Hash)
+
+      dependent_required = schema['dependentRequired'] ||= {}
+      dependent_schemas = schema['dependentSchemas'] ||= {}
+
+      dependencies.each do |key, value|
+        if value.is_a?(Array)
+          dependent_required[key] = value
+        else
+          dependent_schemas[key] = normalize_schema(value, @draft)
+        end
+      end
+    end
+
+    def deep_stringify(value)
+      case value
+      when Hash
+        value.each_with_object({}) do |(key, child), result|
+          result[key.to_s] = deep_stringify(child)
+        end
+      when Array
+        value.map { |child| deep_stringify(child) }
+      else
+        value
+      end
+    end
+
+    def numeric_value!(value, keyword)
+      return value if value.is_a?(Numeric)
+
+      raise CompileError, "#{keyword} must be numeric"
+    end
+
+    def non_negative_integer!(value, keyword)
+      return value.to_i if integer_number?(value) && value >= 0
+
+      raise CompileError, "#{keyword} must be a non-negative integer"
+    end
+
+    def integer_number?(value)
+      case value
+      when Integer
+        true
+      when Float, BigDecimal
+        value.finite? && value == value.to_i
+      else
+        false
+      end
+    end
+
+    def instruction(op, payload, keyword_location, schema)
+      Instruction.new(op: op, payload: payload, keyword_location: keyword_location, schema: schema)
+    end
+
+    def keyword_to_op(keyword)
+      keyword.gsub(/([A-Z])/, '_\1').downcase.to_sym
+    end
+
+    def join_pointer(base, *tokens)
+      tokens.reduce(base) do |memo, token|
+        "#{memo}/#{escape_pointer_token(token)}"
+      end
+    end
+
+    def escape_pointer_token(token)
+      token.to_s.gsub('~', '~0').gsub('/', '~1')
+    end
+  end
+end