senko 0.1.0

data/lib/senko/validator.rb

@@ -0,0 +1,1391 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+require 'set'
+
+require_relative 'compiler/instruction'
+require_relative 'errors'
+require_relative 'format'
+require_relative 'result'
+
+module Senko
+  class Validator
+    MESSAGES = {
+      false_schema: 'boolean schema false does not allow any value',
+      type: 'expected %{expected}, got %{actual}',
+      required: "missing required property '%{property}'",
+      minimum: 'value must be >= %{minimum}',
+      exclusive_minimum: 'value must be > %{minimum}',
+      maximum: 'value must be <= %{maximum}',
+      exclusive_maximum: 'value must be < %{maximum}',
+      min_length: 'string length must be >= %{min_length}',
+      max_length: 'string length must be <= %{max_length}',
+      pattern: "string does not match pattern '%{pattern}'",
+      min_items: 'array length must be >= %{min_items}',
+      max_items: 'array length must be <= %{max_items}',
+      unique_items: 'array items must be unique',
+      min_contains: 'array must contain at least %{min_contains} matching item(s)',
+      max_contains: 'array must contain at most %{max_contains} matching item(s)',
+      min_properties: 'object must have >= %{min_properties} properties',
+      max_properties: 'object must have <= %{max_properties} properties',
+      enum: 'value must be one of: %{values}',
+      const: 'value must be %{const}',
+      multiple_of: 'value must be a multiple of %{multiple_of}',
+      format: "value does not match format '%{format}'",
+      not: 'value should not match the schema',
+      one_of_none: 'value must match exactly one schema in oneOf (matched none)',
+      one_of_multiple: 'value must match exactly one schema in oneOf (matched %{count})',
+      any_of: 'value must match at least one schema in anyOf',
+      discriminator: "value does not match discriminator property '%{property}'",
+      additional_properties: "unexpected property '%{property}'",
+      property_names: "property name '%{property}' is invalid",
+      dependent_required: "property '%{property}' requires property '%{dependency}'",
+      unevaluated_properties: "unevaluated property '%{property}'",
+      unevaluated_items: 'unevaluated item at index %{index}',
+      custom_keyword: "value failed custom keyword '%{keyword}'"
+    }.freeze
+
+    class EvaluationContext
+      EMPTY_EVALUATED = {}.freeze
+
+      def initialize(dynamic_scopes = [])
+        @dynamic_scopes = dynamic_scopes.dup
+      end
+
+      def evaluated_properties_by_location
+        @evaluated_properties_by_location || EMPTY_EVALUATED
+      end
+
+      def evaluated_items_by_location
+        @evaluated_items_by_location || EMPTY_EVALUATED
+      end
+
+      def mark_property(location, name)
+        evaluated_properties_for_write[location][name.to_s] = true
+      end
+
+      def track_evaluation?
+        true
+      end
+
+      def mark_item(location, index)
+        evaluated_items_for_write[location][index] = true
+      end
+
+      def property_evaluated?(location, name)
+        return false unless @evaluated_properties_by_location
+
+        properties = @evaluated_properties_by_location.fetch(location, nil)
+        properties ? properties.key?(name.to_s) : false
+      end
+
+      def item_evaluated?(location, index)
+        return false unless @evaluated_items_by_location
+
+        items = @evaluated_items_by_location.fetch(location, nil)
+        items ? items.key?(index) : false
+      end
+
+      def evaluation_empty?
+        (!@evaluated_properties_by_location || @evaluated_properties_by_location.empty?) &&
+          (!@evaluated_items_by_location || @evaluated_items_by_location.empty?)
+      end
+
+      def push_dynamic_scope(anchors)
+        @dynamic_scopes << anchors
+      end
+
+      def pop_dynamic_scope
+        @dynamic_scopes.pop
+      end
+
+      def dynamic_target(anchor)
+        scope = @dynamic_scopes.find { |candidate| candidate.key?(anchor) }
+        scope&.fetch(anchor)
+      end
+
+      def fork(track_evaluation: true)
+        track_evaluation ? self.class.new(@dynamic_scopes) : NoopEvaluationContext.new(@dynamic_scopes)
+      end
+
+      def merge(child)
+        child.evaluated_properties_by_location.each do |location, properties|
+          evaluated_properties_for_write[location].update(properties)
+        end
+        child.evaluated_items_by_location.each do |location, items|
+          evaluated_items_for_write[location].update(items)
+        end
+      end
+
+      private
+
+      def evaluated_properties_for_write
+        @evaluated_properties_by_location ||= Hash.new { |hash, location| hash[location] = {} }
+      end
+
+      def evaluated_items_for_write
+        @evaluated_items_by_location ||= Hash.new { |hash, location| hash[location] = {} }
+      end
+    end
+
+    class NoopEvaluationContext
+      def initialize(dynamic_scopes = [])
+        @dynamic_scopes = dynamic_scopes.dup
+      end
+
+      def mark_property(_location, _name); end
+
+      def track_evaluation?
+        false
+      end
+
+      def mark_item(_location, _index); end
+
+      def property_evaluated?(_location, _name)
+        false
+      end
+
+      def item_evaluated?(_location, _index)
+        false
+      end
+
+      def evaluation_empty?
+        true
+      end
+
+      def push_dynamic_scope(anchors)
+        @dynamic_scopes << anchors
+      end
+
+      def pop_dynamic_scope
+        @dynamic_scopes.pop
+      end
+
+      def dynamic_target(anchor)
+        scope = @dynamic_scopes.find { |candidate| candidate.key?(anchor) }
+        scope&.fetch(anchor)
+      end
+
+      def fork(track_evaluation: false)
+        track_evaluation ? EvaluationContext.new(@dynamic_scopes) : self.class.new(@dynamic_scopes)
+      end
+
+      def merge(_child); end
+    end
+
+    class << self
+      def requires_evaluation_tracking?(instructions, seen = {})
+        return false unless instructions.is_a?(Array)
+        return false if seen[instructions.object_id]
+
+        seen[instructions.object_id] = true
+        instructions.any? { |instruction| instruction_requires_evaluation_tracking?(instruction, seen) }
+      end
+
+      private
+
+      def instruction_requires_evaluation_tracking?(instruction, seen)
+        return true if %i[unevaluated_properties unevaluated_items].include?(instruction.op)
+        return true if instruction.op == :dynamic_ref && instruction.payload[:dynamic]
+
+        nested_instruction_sets(instruction).any? do |child_instructions|
+          requires_evaluation_tracking?(child_instructions, seen)
+        end
+      end
+
+      def nested_instruction_sets(instruction)
+        payload = instruction.payload
+
+        case instruction.op
+        when :prefix_items, :all_of, :any_of, :one_of
+          payload[:schemas]
+        when :properties, :dependent_schemas, :discriminator
+          payload[:schemas]&.values || payload[:mapping]&.values || []
+        when :pattern_properties
+          payload[:patterns].map { |entry| entry[:schema] }
+        when :items, :contains, :property_names, :not, :additional_properties
+          [payload[:schema]].grep(Array)
+        when :if_then_else
+          [payload[:if_schema], payload[:then_schema], payload[:else_schema]].compact
+        when :ref, :dynamic_ref
+          [payload[:instructions]]
+        when :dynamic_scope
+          payload[:anchors].values
+        else
+          []
+        end
+      end
+    end
+
+    def initialize(options = {})
+      @options = options
+      @custom_formats = options[:custom_formats] || {}
+      @messages = MESSAGES.merge(symbolized_messages(options[:messages] || {}))
+      @tracking_cache = {}
+    end
+
+    def validate(instructions, data, fail_fast: false)
+      result = Result.new(fail_fast: fail_fast)
+      validate_instructions(instructions, data, result, '', EvaluationContext.new)
+      result
+    end
+
+    def valid?(instructions, data, track_evaluation: self.class.requires_evaluation_tracking?(instructions))
+      context = track_evaluation ? EvaluationContext.new : NoopEvaluationContext.new
+      valid_instructions?(instructions, data, '', context)
+    end
+
+    private
+
+    def validate_instructions(instructions, data, result, instance_location, context)
+      start_error_count = result.errors.length
+      pushed_scopes = push_dynamic_scopes(instructions, context)
+
+      begin
+        instructions.each do |instruction|
+          next if instruction.op == :dynamic_scope
+
+          execute(instruction, data, result, instance_location, context)
+          return false if result.fail_fast? && result.errors.length > start_error_count
+        end
+
+        result.errors.length == start_error_count
+      ensure
+        pushed_scopes.times { context.pop_dynamic_scope }
+      end
+    end
+
+    def execute(instruction, data, result, instance_location, context)
+      case instruction.op
+      when :false_schema then add_error(result, instruction, data, :false_schema, {}, instance_location)
+      when :type then execute_type(instruction, data, result, instance_location)
+      when :enum then execute_enum(instruction, data, result, instance_location)
+      when :const then execute_const(instruction, data, result, instance_location)
+      when :multiple_of then execute_multiple_of(instruction, data, result, instance_location)
+      when :maximum then execute_maximum(instruction, data, result, instance_location)
+      when :minimum then execute_minimum(instruction, data, result, instance_location)
+      when :max_length then execute_max_length(instruction, data, result, instance_location)
+      when :min_length then execute_min_length(instruction, data, result, instance_location)
+      when :pattern then execute_pattern(instruction, data, result, instance_location)
+      when :format then execute_format(instruction, data, result, instance_location)
+      when :max_items then execute_max_items(instruction, data, result, instance_location)
+      when :min_items then execute_min_items(instruction, data, result, instance_location)
+      when :unique_items then execute_unique_items(instruction, data, result, instance_location)
+      when :prefix_items then execute_prefix_items(instruction, data, result, instance_location, context)
+      when :items then execute_items(instruction, data, result, instance_location, context)
+      when :contains then execute_contains(instruction, data, result, instance_location, context)
+      when :max_properties then execute_max_properties(instruction, data, result, instance_location)
+      when :min_properties then execute_min_properties(instruction, data, result, instance_location)
+      when :required then execute_required(instruction, data, result, instance_location)
+      when :properties then execute_properties(instruction, data, result, instance_location, context)
+      when :pattern_properties then execute_pattern_properties(instruction, data, result, instance_location, context)
+      when :additional_properties then execute_additional_properties(instruction, data, result, instance_location,
+                                                                     context)
+      when :property_names then execute_property_names(instruction, data, result, instance_location, context)
+      when :dependent_required then execute_dependent_required(instruction, data, result, instance_location)
+      when :dependent_schemas then execute_dependent_schemas(instruction, data, result, instance_location, context)
+      when :all_of then execute_all_of(instruction, data, result, instance_location, context)
+      when :any_of then execute_any_of(instruction, data, result, instance_location, context)
+      when :one_of then execute_one_of(instruction, data, result, instance_location, context)
+      when :not then execute_not(instruction, data, result, instance_location, context)
+      when :if_then_else then execute_if_then_else(instruction, data, result, instance_location, context)
+      when :discriminator then execute_discriminator(instruction, data, result, instance_location, context)
+      when :ref then validate_instructions(instruction.payload[:instructions], data, result, instance_location, context)
+      when :dynamic_ref then execute_dynamic_ref(instruction, data, result, instance_location, context)
+      when :unevaluated_properties then execute_unevaluated_properties(instruction, data, result, instance_location,
+                                                                       context)
+      when :unevaluated_items then execute_unevaluated_items(instruction, data, result, instance_location, context)
+      when :custom_keyword then execute_custom_keyword(instruction, data, result, instance_location)
+      end
+    end
+
+    def valid_instructions?(instructions, data, instance_location, context)
+      unless dynamic_scope_prefix?(instructions)
+        return valid_unscoped_instructions?(instructions, data, instance_location,
+                                            context)
+      end
+
+      valid_scoped_instructions?(instructions, data, instance_location, context)
+    end
+
+    def valid_unscoped_instructions?(instructions, data, instance_location, context)
+      instructions.each do |instruction|
+        return false unless valid_instruction?(instruction, data, instance_location, context)
+      end
+
+      true
+    end
+
+    def valid_scoped_instructions?(instructions, data, instance_location, context)
+      pushed_scopes = push_dynamic_scopes(instructions, context)
+
+      begin
+        instructions.each do |instruction|
+          next if instruction.op == :dynamic_scope
+
+          return false unless valid_instruction?(instruction, data, instance_location, context)
+        end
+
+        true
+      ensure
+        pushed_scopes.times { context.pop_dynamic_scope }
+      end
+    end
+
+    def dynamic_scope_prefix?(instructions)
+      !instructions.empty? && instructions.first.op == :dynamic_scope
+    end
+
+    def valid_instruction?(instruction, data, instance_location, context)
+      payload = instruction.payload
+
+      case instruction.op
+      when :false_schema
+        false
+      when :type
+        type_mask_for(data).anybits?(payload[:mask])
+      when :enum
+        payload[:values].any? { |value| json_equal?(value, data) }
+      when :const
+        json_equal?(payload[:value], data)
+      when :multiple_of
+        !numeric_instance?(data) || multiple_of?(data, payload[:factor])
+      when :maximum
+        return true unless numeric_instance?(data)
+
+        payload[:exclusive] ? native_numeric_lt?(data, payload[:limit]) : native_numeric_lte?(data, payload[:limit])
+      when :minimum
+        return true unless numeric_instance?(data)
+
+        payload[:exclusive] ? native_numeric_gt?(data, payload[:limit]) : native_numeric_gte?(data, payload[:limit])
+      when :max_length
+        !data.is_a?(String) || string_length(data) <= payload[:limit]
+      when :min_length
+        !data.is_a?(String) || string_length(data) >= payload[:limit]
+      when :pattern
+        !data.is_a?(String) || data.match?(payload[:pattern])
+      when :format
+        !data.is_a?(String) || !payload[:assertion] || Senko::Format.valid?(payload[:format], data, @custom_formats)
+      when :max_items
+        !data.is_a?(Array) || data.length <= payload[:limit]
+      when :min_items
+        !data.is_a?(Array) || data.length >= payload[:limit]
+      when :unique_items
+        !data.is_a?(Array) || unique_items?(data)
+      when :prefix_items
+        valid_prefix_items?(payload, data, instance_location, context)
+      when :items
+        valid_items?(payload, data, instance_location, context)
+      when :contains
+        valid_contains?(payload, data, instance_location, context)
+      when :max_properties
+        !data.is_a?(Hash) || data.length <= payload[:limit]
+      when :min_properties
+        !data.is_a?(Hash) || data.length >= payload[:limit]
+      when :required
+        !data.is_a?(Hash) || payload[:keys].all? { |key| data.key?(key) }
+      when :properties
+        valid_properties?(payload, data, instance_location, context)
+      when :pattern_properties
+        valid_pattern_properties?(payload, data, instance_location, context)
+      when :additional_properties
+        valid_additional_properties?(payload, data, instance_location, context)
+      when :property_names
+        valid_property_names?(payload, data, instance_location, context)
+      when :dependent_required
+        valid_dependent_required?(payload, data)
+      when :dependent_schemas
+        valid_dependent_schemas?(payload, data, instance_location, context)
+      when :all_of
+        valid_all_of?(payload, data, instance_location, context)
+      when :any_of
+        valid_any_of?(payload, data, instance_location, context)
+      when :one_of
+        valid_one_of?(payload, data, instance_location, context)
+      when :not
+        child_context = context.track_evaluation? ? context.fork : context
+        !valid_instructions?(payload[:schema], data, instance_location, child_context)
+      when :if_then_else
+        valid_if_then_else?(payload, data, instance_location, context)
+      when :discriminator
+        valid_discriminator?(payload, data, instance_location, context)
+      when :ref
+        valid_instructions?(payload[:instructions], data, instance_location, context)
+      when :dynamic_ref
+        valid_dynamic_ref?(payload, data, instance_location, context)
+      when :unevaluated_properties
+        valid_unevaluated_properties?(payload, data, instance_location, context)
+      when :unevaluated_items
+        valid_unevaluated_items?(payload, data, instance_location, context)
+      when :custom_keyword
+        custom_keyword_result(instruction, data) == true
+      else
+        true
+      end
+    end
+
+    def valid_prefix_items?(payload, data, instance_location, context)
+      return true unless data.is_a?(Array)
+
+      payload[:schemas].each_with_index do |schema, index|
+        break if index >= data.length
+
+        child_location = child_instance_location(context, instance_location, index)
+        return false unless valid_child_instance_schema?(schema, data[index], child_location, context)
+
+        context.mark_item(instance_location, index)
+      end
+
+      true
+    end
+
+    def valid_items?(payload, data, instance_location, context)
+      return true unless data.is_a?(Array)
+
+      data.each_with_index do |item, index|
+        next if index < payload[:start_index]
+
+        child_location = child_instance_location(context, instance_location, index)
+        return false unless valid_child_instance_schema?(payload[:schema], item, child_location, context)
+
+        context.mark_item(instance_location, index)
+      end
+
+      true
+    end
+
+    def valid_contains?(payload, data, instance_location, context)
+      return true unless data.is_a?(Array)
+
+      count = 0
+      data.each_with_index do |item, index|
+        child_location = child_instance_location(context, instance_location, index)
+        child_context = context.track_evaluation? ? context.fork : context
+        next unless valid_instructions?(payload[:schema], item, child_location, child_context)
+
+        count += 1
+        context.mark_item(instance_location, index)
+        context.merge(child_context) if context.track_evaluation?
+      end
+
+      count >= payload[:min] && (!payload[:max] || count <= payload[:max])
+    end
+
+    def valid_properties?(payload, data, instance_location, context)
+      return true unless data.is_a?(Hash)
+
+      payload[:schemas].each do |key, schema|
+        next unless data.key?(key)
+
+        child_location = child_instance_location(context, instance_location, key)
+        return false unless valid_child_instance_schema?(schema, data[key], child_location, context)
+
+        context.mark_property(instance_location, key)
+      end
+
+      true
+    end
+
+    def valid_pattern_properties?(payload, data, instance_location, context)
+      return true unless data.is_a?(Hash)
+
+      data.each do |key, value|
+        payload[:patterns].each do |entry|
+          next unless key.match?(entry[:pattern])
+
+          child_location = child_instance_location(context, instance_location, key)
+          return false unless valid_child_instance_schema?(entry[:schema], value, child_location, context)
+
+          context.mark_property(instance_location, key)
+        end
+      end
+
+      true
+    end
+
+    def valid_additional_properties?(payload, data, instance_location, context)
+      return true unless data.is_a?(Hash)
+
+      data.each do |key, value|
+        next if payload[:known].include?(key)
+        next if payload[:patterns].any? { |pattern| key.match?(pattern) }
+        return false if payload[:schema] == false
+
+        child_location = child_instance_location(context, instance_location, key)
+        return false unless valid_child_instance_schema?(payload[:schema], value, child_location, context)
+
+        context.mark_property(instance_location, key)
+      end
+
+      true
+    end
+
+    def valid_property_names?(payload, data, instance_location, context)
+      return true unless data.is_a?(Hash)
+
+      data.each_key do |key|
+        child_location = child_instance_location(context, instance_location, key)
+        child_context = context.track_evaluation? ? context.fork : context
+        return false unless valid_instructions?(payload[:schema], key, child_location, child_context)
+      end
+
+      true
+    end
+
+    def valid_dependent_required?(payload, data)
+      return true unless data.is_a?(Hash)
+
+      payload[:requirements].each do |property, dependencies|
+        next unless data.key?(property)
+
+        dependencies.each do |dependency|
+          return false unless data.key?(dependency)
+        end
+      end
+
+      true
+    end
+
+    def valid_dependent_schemas?(payload, data, instance_location, context)
+      return true unless data.is_a?(Hash)
+
+      payload[:schemas].each do |property, schema|
+        next unless data.key?(property)
+
+        return false unless valid_child_schema?(schema, data, instance_location, context)
+      end
+
+      true
+    end
+
+    def valid_all_of?(payload, data, instance_location, context)
+      if payload[:schemas].length == 1 && context.evaluation_empty?
+        return valid_instructions?(payload[:schemas].first, data, instance_location, context)
+      end
+
+      payload[:schemas].each do |schema|
+        return false unless valid_child_schema?(schema, data, instance_location, context)
+      end
+
+      true
+    end
+
+    def valid_any_of?(payload, data, instance_location, context)
+      unless context.track_evaluation?
+        return payload[:schemas].any? { |schema| valid_instructions?(schema, data, instance_location, context) }
+      end
+
+      valid_contexts = []
+
+      payload[:schemas].each do |schema|
+        child_context = context.fork
+        valid_contexts << child_context if valid_instructions?(schema, data, instance_location, child_context)
+      end
+
+      return false if valid_contexts.empty?
+
+      valid_contexts.each { |child_context| context.merge(child_context) }
+      true
+    end
+
+    def valid_one_of?(payload, data, instance_location, context)
+      unless context.track_evaluation?
+        matches = 0
+        payload[:schemas].each do |schema|
+          next unless valid_instructions?(schema, data, instance_location, context)
+
+          matches += 1
+          return false if matches > 1
+        end
+
+        return matches == 1
+      end
+
+      match_context = nil
+
+      payload[:schemas].each do |schema|
+        child_context = context.fork
+        next unless valid_instructions?(schema, data, instance_location, child_context)
+        return false if match_context
+
+        match_context = child_context
+      end
+
+      return false unless match_context
+
+      context.merge(match_context)
+      true
+    end
+
+    def valid_if_then_else?(payload, data, instance_location, context)
+      condition_context = context.track_evaluation? ? context.fork : context
+      condition_passed = valid_instructions?(payload[:if_schema], data, instance_location, condition_context)
+      selected_schema = condition_passed ? payload[:then_schema] : payload[:else_schema]
+
+      unless selected_schema
+        context.merge(condition_context) if condition_passed
+        return true
+      end
+
+      return false unless valid_child_schema?(selected_schema, data, instance_location, context)
+
+      context.merge(condition_context) if condition_passed
+      true
+    end
+
+    def valid_discriminator?(payload, data, instance_location, context)
+      property = payload[:property]
+      return false unless data.is_a?(Hash) && data.key?(property)
+
+      schema = payload[:mapping][data[property]] || payload[:mapping][data[property].to_s]
+      return false unless schema
+
+      return false unless valid_child_schema?(schema, data, instance_location, context)
+
+      true
+    end
+
+    def valid_dynamic_ref?(payload, data, instance_location, context)
+      target = (context.dynamic_target(payload[:anchor]) if payload[:dynamic] && payload[:anchor])
+      target ||= payload[:instructions]
+
+      valid_instructions?(target, data, instance_location, context)
+    end
+
+    def valid_unevaluated_properties?(payload, data, instance_location, context)
+      return true unless data.is_a?(Hash)
+
+      data.each do |key, value|
+        next if context.property_evaluated?(instance_location, key)
+        return false if payload[:schema] == false
+
+        return false unless valid_child_instance_schema?(payload[:schema], value,
+                                                         join_instance(instance_location, key), context)
+
+        context.mark_property(instance_location, key)
+      end
+
+      true
+    end
+
+    def valid_unevaluated_items?(payload, data, instance_location, context)
+      return true unless data.is_a?(Array)
+
+      data.each_with_index do |item, index|
+        next if context.item_evaluated?(instance_location, index)
+        return false if payload[:schema] == false
+
+        return false unless valid_child_instance_schema?(payload[:schema], item,
+                                                         join_instance(instance_location, index), context)
+
+        context.mark_item(instance_location, index)
+      end
+
+      true
+    end
+
+    def push_dynamic_scopes(instructions, context)
+      pushed = 0
+      instructions.each do |instruction|
+        break unless instruction.op == :dynamic_scope
+
+        context.push_dynamic_scope(instruction.payload[:anchors])
+        pushed += 1
+      end
+      pushed
+    end
+
+    def execute_type(instruction, data, result, instance_location)
+      return if type_mask_for(data).anybits?(instruction.payload[:mask])
+
+      add_error(
+        result,
+        instruction,
+        data,
+        :type,
+        { expected: instruction.payload[:expected].join(' or '), actual: actual_type(data) },
+        instance_location
+      )
+    end
+
+    def execute_enum(instruction, data, result, instance_location)
+      return if instruction.payload[:values].any? { |value| json_equal?(value, data) }
+
+      add_error(result, instruction, data, :enum, { values: instruction.payload[:values].inspect }, instance_location)
+    end
+
+    def execute_const(instruction, data, result, instance_location)
+      return if json_equal?(instruction.payload[:value], data)
+
+      add_error(result, instruction, data, :const, { const: instruction.payload[:value].inspect }, instance_location)
+    end
+
+    def execute_multiple_of(instruction, data, result, instance_location)
+      return unless numeric_instance?(data)
+      return if multiple_of?(data, instruction.payload[:factor])
+
+      add_error(result, instruction, data, :multiple_of, { multiple_of: instruction.payload[:factor] },
+                instance_location)
+    end
+
+    def execute_maximum(instruction, data, result, instance_location)
+      return unless numeric_instance?(data)
+
+      limit = instruction.payload[:limit]
+      exclusive = instruction.payload[:exclusive]
+      return if exclusive ? native_numeric_lt?(data, limit) : native_numeric_lte?(data, limit)
+
+      key = exclusive ? :exclusive_maximum : :maximum
+      add_error(result, instruction, data, key, { maximum: limit }, instance_location)
+    end
+
+    def execute_minimum(instruction, data, result, instance_location)
+      return unless numeric_instance?(data)
+
+      limit = instruction.payload[:limit]
+      exclusive = instruction.payload[:exclusive]
+      return if exclusive ? native_numeric_gt?(data, limit) : native_numeric_gte?(data, limit)
+
+      key = exclusive ? :exclusive_minimum : :minimum
+      add_error(result, instruction, data, key, { minimum: limit }, instance_location)
+    end
+
+    def execute_max_length(instruction, data, result, instance_location)
+      return unless data.is_a?(String)
+      return if string_length(data) <= instruction.payload[:limit]
+
+      add_error(result, instruction, data, :max_length, { max_length: instruction.payload[:limit] }, instance_location)
+    end
+
+    def execute_min_length(instruction, data, result, instance_location)
+      return unless data.is_a?(String)
+      return if string_length(data) >= instruction.payload[:limit]
+
+      add_error(result, instruction, data, :min_length, { min_length: instruction.payload[:limit] }, instance_location)
+    end
+
+    def execute_pattern(instruction, data, result, instance_location)
+      return unless data.is_a?(String)
+      return if data.match?(instruction.payload[:pattern])
+
+      add_error(result, instruction, data, :pattern, { pattern: instruction.payload[:source] }, instance_location)
+    end
+
+    def execute_format(instruction, data, result, instance_location)
+      return unless data.is_a?(String)
+
+      if instruction.payload[:assertion]
+        return if Senko::Format.valid?(instruction.payload[:format], data, @custom_formats)
+
+        add_error(result, instruction, data, :format, { format: instruction.payload[:format] }, instance_location)
+      else
+        result.add_annotation(
+          'keywordLocation' => instruction.keyword_location,
+          'instanceLocation' => instance_location,
+          'annotation' => instruction.payload[:format]
+        )
+      end
+    end
+
+    def execute_max_items(instruction, data, result, instance_location)
+      return unless data.is_a?(Array)
+      return if data.length <= instruction.payload[:limit]
+
+      add_error(result, instruction, data, :max_items, { max_items: instruction.payload[:limit] }, instance_location)
+    end
+
+    def execute_min_items(instruction, data, result, instance_location)
+      return unless data.is_a?(Array)
+      return if data.length >= instruction.payload[:limit]
+
+      add_error(result, instruction, data, :min_items, { min_items: instruction.payload[:limit] }, instance_location)
+    end
+
+    def execute_unique_items(instruction, data, result, instance_location)
+      return unless data.is_a?(Array)
+      return if unique_items?(data)
+
+      add_error(result, instruction, data, :unique_items, {}, instance_location)
+    end
+
+    def execute_prefix_items(instruction, data, result, instance_location, context)
+      return unless data.is_a?(Array)
+
+      instruction.payload[:schemas].each_with_index do |schema, index|
+        break if index >= data.length
+
+        child_context = context.fork
+        before = result.errors.length
+        valid = validate_instructions(schema, data[index], result, join_instance(instance_location, index),
+                                      child_context)
+        if valid
+          context.mark_item(instance_location, index)
+          context.merge(child_context)
+        end
+        return if result.fail_fast? && result.errors.length > before
+      end
+    end
+
+    def execute_items(instruction, data, result, instance_location, context)
+      return unless data.is_a?(Array)
+
+      data.each_with_index do |item, index|
+        next if index < instruction.payload[:start_index]
+
+        child_context = context.fork
+        before = result.errors.length
+        valid = validate_instructions(instruction.payload[:schema], item, result,
+                                      join_instance(instance_location, index), child_context)
+        if valid
+          context.mark_item(instance_location, index)
+          context.merge(child_context)
+        end
+        return if result.fail_fast? && result.errors.length > before
+      end
+    end
+
+    def execute_contains(instruction, data, result, instance_location, context)
+      return unless data.is_a?(Array)
+
+      count = 0
+      data.each_with_index do |item, index|
+        child_context = context.fork
+        next unless schema_valid?(instruction.payload[:schema], item, join_instance(instance_location, index),
+                                  child_context)
+
+        count += 1
+        context.mark_item(instance_location, index)
+        context.merge(child_context)
+      end
+
+      min = instruction.payload[:min]
+      max = instruction.payload[:max]
+
+      if count < min
+        add_error(result, instruction, data, :min_contains, { min_contains: min }, instance_location)
+      elsif max && count > max
+        add_error(result, instruction, data, :max_contains, { max_contains: max }, instance_location)
+      end
+    end
+
+    def execute_max_properties(instruction, data, result, instance_location)
+      return unless data.is_a?(Hash)
+      return if data.length <= instruction.payload[:limit]
+
+      add_error(result, instruction, data, :max_properties, { max_properties: instruction.payload[:limit] },
+                instance_location)
+    end
+
+    def execute_min_properties(instruction, data, result, instance_location)
+      return unless data.is_a?(Hash)
+      return if data.length >= instruction.payload[:limit]
+
+      add_error(result, instruction, data, :min_properties, { min_properties: instruction.payload[:limit] },
+                instance_location)
+    end
+
+    def execute_required(instruction, data, result, instance_location)
+      return unless data.is_a?(Hash)
+
+      instruction.payload[:keys].each do |key|
+        next if data.key?(key)
+
+        add_error(result, instruction, data, :required, { property: key }, instance_location)
+        return if result.fail_fast?
+      end
+    end
+
+    def execute_properties(instruction, data, result, instance_location, context)
+      return unless data.is_a?(Hash)
+
+      instruction.payload[:schemas].each do |key, schema|
+        next unless data.key?(key)
+
+        child_context = context.fork
+        before = result.errors.length
+        valid = validate_instructions(schema, data[key], result, join_instance(instance_location, key), child_context)
+        if valid
+          context.mark_property(instance_location, key)
+          context.merge(child_context)
+        end
+        return if result.fail_fast? && result.errors.length > before
+      end
+    end
+
+    def execute_pattern_properties(instruction, data, result, instance_location, context)
+      return unless data.is_a?(Hash)
+
+      data.each do |key, value|
+        instruction.payload[:patterns].each do |entry|
+          next unless key.match?(entry[:pattern])
+
+          child_context = context.fork
+          before = result.errors.length
+          valid = validate_instructions(entry[:schema], value, result, join_instance(instance_location, key),
+                                        child_context)
+          if valid
+            context.mark_property(instance_location, key)
+            context.merge(child_context)
+          end
+          return if result.fail_fast? && result.errors.length > before
+        end
+      end
+    end
+
+    def execute_additional_properties(instruction, data, result, instance_location, context)
+      return unless data.is_a?(Hash)
+
+      data.each do |key, value|
+        next if instruction.payload[:known].include?(key)
+        next if instruction.payload[:patterns].any? { |pattern| key.match?(pattern) }
+
+        if instruction.payload[:schema] == false
+          add_error(
+            result,
+            instruction,
+            value,
+            :additional_properties,
+            { property: key },
+            join_instance(instance_location, key)
+          )
+          return if result.fail_fast?
+        else
+          child_context = context.fork
+          before = result.errors.length
+          valid = validate_instructions(instruction.payload[:schema], value, result,
+                                        join_instance(instance_location, key), child_context)
+          if valid
+            context.mark_property(instance_location, key)
+            context.merge(child_context)
+          end
+          return if result.fail_fast? && result.errors.length > before
+        end
+      end
+    end
+
+    def execute_property_names(instruction, data, result, instance_location, context)
+      return unless data.is_a?(Hash)
+
+      data.each_key do |key|
+        next if schema_valid?(instruction.payload[:schema], key, join_instance(instance_location, key), context.fork)
+
+        add_error(result, instruction, key, :property_names, { property: key }, join_instance(instance_location, key))
+        return if result.fail_fast?
+      end
+    end
+
+    def execute_dependent_required(instruction, data, result, instance_location)
+      return unless data.is_a?(Hash)
+
+      instruction.payload[:requirements].each do |property, dependencies|
+        next unless data.key?(property)
+
+        dependencies.each do |dependency|
+          next if data.key?(dependency)
+
+          add_error(
+            result,
+            instruction,
+            data,
+            :dependent_required,
+            { property: property, dependency: dependency },
+            instance_location
+          )
+          return if result.fail_fast?
+        end
+      end
+    end
+
+    def execute_dependent_schemas(instruction, data, result, instance_location, context)
+      return unless data.is_a?(Hash)
+
+      instruction.payload[:schemas].each do |property, schema|
+        next unless data.key?(property)
+
+        child_context = context.fork
+        before = result.errors.length
+        valid = validate_instructions(schema, data, result, instance_location, child_context)
+        context.merge(child_context) if valid
+        return if result.fail_fast? && result.errors.length > before
+      end
+    end
+
+    def execute_all_of(instruction, data, result, instance_location, context)
+      instruction.payload[:schemas].each do |schema|
+        child_context = context.fork
+        before = result.errors.length
+        valid = validate_instructions(schema, data, result, instance_location, child_context)
+        context.merge(child_context) if valid
+        return if result.fail_fast? && result.errors.length > before
+      end
+    end
+
+    def execute_any_of(instruction, data, result, instance_location, context)
+      valid_contexts = []
+
+      instruction.payload[:schemas].each do |schema|
+        child_context = context.fork
+        valid_contexts << child_context if schema_valid?(schema, data, instance_location, child_context)
+      end
+
+      if valid_contexts.empty?
+        add_error(result, instruction, data, :any_of, {}, instance_location)
+      else
+        valid_contexts.each { |child_context| context.merge(child_context) }
+      end
+    end
+
+    def execute_one_of(instruction, data, result, instance_location, context)
+      matches = []
+
+      instruction.payload[:schemas].each do |schema|
+        child_context = context.fork
+        next unless schema_valid?(schema, data, instance_location, child_context)
+
+        matches << child_context
+        break if result.fail_fast? && matches.length > 1
+      end
+
+      if matches.length == 1
+        context.merge(matches.first)
+      elsif matches.empty?
+        add_error(result, instruction, data, :one_of_none, {}, instance_location)
+      else
+        add_error(result, instruction, data, :one_of_multiple, { count: matches.length }, instance_location)
+      end
+    end
+
+    def execute_not(instruction, data, result, instance_location, context)
+      return unless schema_valid?(instruction.payload[:schema], data, instance_location, context.fork)
+
+      add_error(result, instruction, data, :not, {}, instance_location)
+    end
+
+    def execute_discriminator(instruction, data, result, instance_location, context)
+      property = instruction.payload[:property]
+      unless data.is_a?(Hash) && data.key?(property)
+        add_discriminator_error(instruction, data, result, instance_location, property)
+        return
+      end
+
+      schema = instruction.payload[:mapping][data[property]] || instruction.payload[:mapping][data[property].to_s]
+      unless schema
+        add_discriminator_error(instruction, data, result, instance_location, property)
+        return
+      end
+
+      child_context = context.fork
+      valid = validate_instructions(schema, data, result, instance_location, child_context)
+      context.merge(child_context) if valid
+    end
+
+    def execute_dynamic_ref(instruction, data, result, instance_location, context)
+      target = if instruction.payload[:dynamic] && instruction.payload[:anchor]
+                 context.dynamic_target(instruction.payload[:anchor])
+               end
+      target ||= instruction.payload[:instructions]
+
+      validate_instructions(target, data, result, instance_location, context)
+    end
+
+    def add_discriminator_error(instruction, data, result, instance_location, property)
+      key = instruction.payload[:mode] == :any_of ? :any_of : :one_of_none
+      values = key == :any_of ? {} : { property: property }
+      add_error(result, instruction, data, key, values, instance_location)
+    end
+
+    def execute_if_then_else(instruction, data, result, instance_location, context)
+      condition_context = context.fork
+      condition_passed = schema_valid?(instruction.payload[:if_schema], data, instance_location, condition_context)
+      selected_schema = condition_passed ? instruction.payload[:then_schema] : instruction.payload[:else_schema]
+      if selected_schema.nil?
+        context.merge(condition_context) if condition_passed
+        return
+      end
+
+      child_context = context.fork
+      before = result.errors.length
+      valid = validate_instructions(selected_schema, data, result, instance_location, child_context)
+      if valid
+        context.merge(condition_context) if condition_passed
+        context.merge(child_context)
+      end
+      nil unless result.fail_fast? && result.errors.length > before
+    end
+
+    def execute_unevaluated_properties(instruction, data, result, instance_location, context)
+      return unless data.is_a?(Hash)
+
+      data.each do |key, value|
+        next if context.property_evaluated?(instance_location, key)
+
+        if instruction.payload[:schema] == false
+          add_error(
+            result,
+            instruction,
+            value,
+            :unevaluated_properties,
+            { property: key },
+            join_instance(instance_location, key)
+          )
+          return if result.fail_fast?
+        else
+          child_context = context.fork
+          before = result.errors.length
+          valid = validate_instructions(instruction.payload[:schema], value, result,
+                                        join_instance(instance_location, key), child_context)
+          if valid
+            context.mark_property(instance_location, key)
+            context.merge(child_context)
+          end
+          return if result.fail_fast? && result.errors.length > before
+        end
+      end
+    end
+
+    def execute_unevaluated_items(instruction, data, result, instance_location, context)
+      return unless data.is_a?(Array)
+
+      data.each_with_index do |item, index|
+        next if context.item_evaluated?(instance_location, index)
+
+        if instruction.payload[:schema] == false
+          add_error(result, instruction, item, :unevaluated_items, { index: index },
+                    join_instance(instance_location, index))
+          return if result.fail_fast?
+        else
+          child_context = context.fork
+          before = result.errors.length
+          valid = validate_instructions(instruction.payload[:schema], item, result,
+                                        join_instance(instance_location, index), child_context)
+          if valid
+            context.mark_item(instance_location, index)
+            context.merge(child_context)
+          end
+          return if result.fail_fast? && result.errors.length > before
+        end
+      end
+    end
+
+    def execute_custom_keyword(instruction, data, result, instance_location)
+      valid = custom_keyword_result(instruction, data)
+
+      return if valid == true
+
+      message = valid.is_a?(String) ? valid : nil
+      add_error(
+        result,
+        instruction,
+        data,
+        :custom_keyword,
+        { keyword: instruction.payload[:keyword] },
+        instance_location,
+        message
+      )
+    end
+
+    def schema_valid?(instructions, data, instance_location, context)
+      valid_instructions?(instructions, data, instance_location, context)
+    end
+
+    def add_error(result, instruction, data, key, values, instance_location, explicit_message = nil)
+      result.add_error(
+        Error.new(
+          message: explicit_message || Kernel.format(@messages.fetch(key), values),
+          instance_location: instance_location,
+          keyword_location: instruction.keyword_location,
+          keyword: instruction.keyword,
+          schema: instruction.schema,
+          data: data
+        )
+      )
+    end
+
+    def custom_keyword_result(instruction, data)
+      validator = instruction.payload[:validator]
+      return true unless validator.respond_to?(:call)
+
+      keyword_value = instruction.payload[:value]
+      case validator.arity
+      when 1 then validator.call(data)
+      when 2 then validator.call(data, keyword_value)
+      else validator.call(data, keyword_value, instruction)
+      end
+    end
+
+    def multiple_of?(value, factor)
+      if value.is_a?(Integer) && factor.is_a?(Integer)
+        (value % factor).zero?
+      else
+        (decimal(value) % decimal(factor)).zero?
+      end
+    end
+
+    def decimal(value)
+      BigDecimal(value.to_s)
+    end
+
+    def unique_items?(items)
+      return Senko::Native.unique_array?(items) if native_available?
+      return small_unique_items?(items) if items.length <= 16
+
+      seen = {}
+      items.each do |item|
+        key = canonical_json(item)
+        return false if seen.key?(key)
+
+        seen[key] = true
+      end
+      true
+    end
+
+    def small_unique_items?(items)
+      items.each_with_index do |left, left_index|
+        ((left_index + 1)...items.length).each do |right_index|
+          return false if json_equal?(left, items[right_index])
+        end
+      end
+      true
+    end
+
+    def canonical_json(value)
+      case value
+      when Hash
+        ['object', value.keys.sort.map { |key| [key, canonical_json(value[key])] }]
+      when Array
+        ['array', value.map { |item| canonical_json(item) }]
+      when Integer, Float, BigDecimal
+        ['number', decimal(value).to_s('F')]
+      else
+        [value.class.name, value]
+      end
+    end
+
+    def json_equal?(left, right)
+      left == right
+    end
+
+    def numeric_instance?(value)
+      value.is_a?(Integer) || value.is_a?(Float) || value.is_a?(BigDecimal)
+    end
+
+    def integer_number?(value)
+      case value
+      when Integer
+        true
+      when Float, BigDecimal
+        value.finite? && value == value.to_i
+      else
+        false
+      end
+    end
+
+    def type_mask_for(value)
+      return Senko::Native.type_mask(value) if native_available?
+
+      case value
+      when NilClass
+        Instructions::TYPE_NULL
+      when TrueClass, FalseClass
+        Instructions::TYPE_BOOLEAN
+      when Integer
+        Instructions::TYPE_INTEGER
+      when Float, BigDecimal
+        integer_number?(value) ? Instructions::TYPE_INTEGER : (Instructions::TYPE_NUMBER & ~Instructions::TYPE_INTEGER)
+      when String
+        Instructions::TYPE_STRING
+      when Array
+        Instructions::TYPE_ARRAY
+      when Hash
+        Instructions::TYPE_OBJECT
+      else
+        0
+      end
+    end
+
+    def actual_type(value)
+      case value
+      when NilClass then 'null'
+      when TrueClass, FalseClass then 'boolean'
+      when Integer then 'integer'
+      when Float, BigDecimal then integer_number?(value) ? 'integer' : 'number'
+      when String then 'string'
+      when Array then 'array'
+      when Hash then 'object'
+      else value.class.name
+      end
+    end
+
+    def string_length(value)
+      native_available? ? Senko::Native.string_length(value) : value.length
+    end
+
+    def native_numeric_lte?(left, right)
+      native_available? ? Senko::Native.numeric_lte?(left, right) : left <= right
+    end
+
+    def native_numeric_lt?(left, right)
+      native_available? ? Senko::Native.numeric_lt?(left, right) : left < right
+    end
+
+    def native_numeric_gte?(left, right)
+      native_available? ? Senko::Native.numeric_gte?(left, right) : left >= right
+    end
+
+    def native_numeric_gt?(left, right)
+      native_available? ? Senko::Native.numeric_gt?(left, right) : left > right
+    end
+
+    def native_available?
+      defined?(Senko::Native) &&
+        Senko::Native.respond_to?(:type_mask) &&
+        Senko::Native.respond_to?(:unique_array?)
+    end
+
+    def symbolized_messages(messages)
+      messages.each_with_object({}) do |(key, value), result|
+        result[key.to_sym] = value
+      end
+    end
+
+    def child_instance_location(context, base, token)
+      context.track_evaluation? ? join_instance(base, token) : base
+    end
+
+    def valid_child_schema?(schema, data, instance_location, context)
+      return valid_instructions?(schema, data, instance_location, context) unless context.track_evaluation?
+
+      child_context = context.fork
+      return false unless valid_instructions?(schema, data, instance_location, child_context)
+
+      context.merge(child_context)
+      true
+    end
+
+    def valid_child_instance_schema?(schema, data, instance_location, context)
+      return valid_instructions?(schema, data, instance_location, context) unless context.track_evaluation?
+      if schema_requires_evaluation_tracking?(schema)
+        return valid_child_schema?(schema, data, instance_location,
+                                   context)
+      end
+
+      valid_instructions?(schema, data, instance_location, context.fork(track_evaluation: false))
+    end
+
+    def schema_requires_evaluation_tracking?(schema)
+      return false unless schema.is_a?(Array)
+
+      @tracking_cache.fetch(schema.object_id) do
+        @tracking_cache[schema.object_id] = self.class.requires_evaluation_tracking?(schema)
+      end
+    end
+
+    def join_instance(base, token)
+      "#{base}/#{escape_pointer_token(token)}"
+    end
+
+    def escape_pointer_token(token)
+      token.to_s.gsub('~', '~0').gsub('/', '~1')
+    end
+  end
+end