schemurai 3.1.0-aarch64-linux-gnu

data/lib/schemurai/meta_schemas/draft2019_09.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require_relative "../meta_schemas"
+
+module Schemurai
+  module Internal
+    module MetaSchemas
+      module Draft201909
+        META_SCHEMA_URI = "https://json-schema.org/draft/2019-09/schema"
+        SCHEMA = {
+          "$schema" => META_SCHEMA_URI,
+          "$id" => META_SCHEMA_URI,
+          "$recursiveAnchor" => true,
+          "type" => ["object", "boolean"],
+          "properties" => {
+            "$id" => {"type" => "string"},
+            "$schema" => {"type" => "string"},
+            "$ref" => {"type" => "string"},
+            "$anchor" => {"type" => "string", "pattern" => "^[A-Za-z][-A-Za-z0-9.:_]*$"},
+            "$recursiveRef" => {"type" => "string"},
+            "$recursiveAnchor" => {"type" => "boolean"},
+            "$vocabulary" => {"type" => "object", "additionalProperties" => {"type" => "boolean"}},
+            "$comment" => {"type" => "string"},
+            "$defs" => {"type" => "object", "additionalProperties" => {"$recursiveRef" => "#"}},
+            "definitions" => {"type" => "object", "additionalProperties" => {"$recursiveRef" => "#"}},
+            "items" => {
+              "anyOf" => [
+                {"$recursiveRef" => "#"},
+                {"type" => "array", "minItems" => 1, "items" => {"$recursiveRef" => "#"}}
+              ]
+            },
+            "additionalItems" => {"$recursiveRef" => "#"},
+            "contains" => {"$recursiveRef" => "#"},
+            "additionalProperties" => {"$recursiveRef" => "#"},
+            "unevaluatedItems" => {"$recursiveRef" => "#"},
+            "unevaluatedProperties" => {"$recursiveRef" => "#"},
+            "properties" => {"type" => "object", "additionalProperties" => {"$recursiveRef" => "#"}},
+            "patternProperties" => {"type" => "object", "additionalProperties" => {"$recursiveRef" => "#"}},
+            "dependentSchemas" => {"type" => "object", "additionalProperties" => {"$recursiveRef" => "#"}},
+            "dependencies" => {
+              "type" => "object",
+              "additionalProperties" => {
+                "anyOf" => [
+                  {"$recursiveRef" => "#"},
+                  {"type" => "array", "items" => {"type" => "string"}, "uniqueItems" => true}
+                ]
+              }
+            },
+            "propertyNames" => {"$recursiveRef" => "#"},
+            "if" => {"$recursiveRef" => "#"},
+            "then" => {"$recursiveRef" => "#"},
+            "else" => {"$recursiveRef" => "#"},
+            "allOf" => {"type" => "array", "minItems" => 1, "items" => {"$recursiveRef" => "#"}},
+            "anyOf" => {"type" => "array", "minItems" => 1, "items" => {"$recursiveRef" => "#"}},
+            "oneOf" => {"type" => "array", "minItems" => 1, "items" => {"$recursiveRef" => "#"}},
+            "not" => {"$recursiveRef" => "#"},
+            "type" => {
+              "anyOf" => [
+                {"enum" => ["null", "boolean", "object", "array", "number", "integer", "string"]},
+                {
+                  "type" => "array",
+                  "items" => {"enum" => ["null", "boolean", "object", "array", "number", "integer", "string"]},
+                  "minItems" => 1,
+                  "uniqueItems" => true
+                }
+              ]
+            },
+            "enum" => {"type" => "array"},
+            "multipleOf" => {"type" => "number", "exclusiveMinimum" => 0},
+            "maximum" => {"type" => "number"},
+            "exclusiveMaximum" => {"type" => "number"},
+            "minimum" => {"type" => "number"},
+            "exclusiveMinimum" => {"type" => "number"},
+            "minLength" => {"type" => "integer", "minimum" => 0},
+            "maxLength" => {"type" => "integer", "minimum" => 0},
+            "pattern" => {"type" => "string"},
+            "minItems" => {"type" => "integer", "minimum" => 0},
+            "maxItems" => {"type" => "integer", "minimum" => 0},
+            "uniqueItems" => {"type" => "boolean"},
+            "minContains" => {"type" => "integer", "minimum" => 0},
+            "maxContains" => {"type" => "integer", "minimum" => 0},
+            "minProperties" => {"type" => "integer", "minimum" => 0},
+            "maxProperties" => {"type" => "integer", "minimum" => 0},
+            "required" => {
+              "type" => "array",
+              "items" => {"type" => "string"},
+              "uniqueItems" => true
+            },
+            "dependentRequired" => {
+              "type" => "object",
+              "additionalProperties" => {
+                "type" => "array",
+                "items" => {"type" => "string"},
+                "uniqueItems" => true
+              }
+            },
+            "title" => {"type" => "string"},
+            "description" => {"type" => "string"},
+            "deprecated" => {"type" => "boolean"},
+            "readOnly" => {"type" => "boolean"},
+            "writeOnly" => {"type" => "boolean"},
+            "examples" => {"type" => "array"},
+            "format" => {"type" => "string"},
+            "contentEncoding" => {"type" => "string"},
+            "contentMediaType" => {"type" => "string"},
+            "contentSchema" => {"$recursiveRef" => "#"}
+          }
+        }.freeze
+
+        MetaSchemas.register(META_SCHEMA_URI, SCHEMA)
+
+        COMPONENT_KEYWORDS = {
+          "core" => %w[
+            $id $schema $ref $anchor $recursiveRef $recursiveAnchor $vocabulary $comment $defs
+          ],
+          "applicator" => %w[
+            additionalItems unevaluatedItems items contains additionalProperties
+            unevaluatedProperties properties patternProperties dependentSchemas propertyNames
+            if then else allOf anyOf oneOf not
+          ],
+          "validation" => %w[
+            type const enum multipleOf maximum exclusiveMaximum minimum exclusiveMinimum
+            maxLength minLength pattern maxItems minItems uniqueItems maxContains minContains
+            maxProperties minProperties required dependentRequired
+          ],
+          "meta-data" => %w[title description default deprecated readOnly writeOnly examples],
+          "format" => %w[format],
+          "content" => %w[contentEncoding contentMediaType contentSchema]
+        }.freeze
+
+        COMPONENT_KEYWORDS.each do |name, keywords|
+          uri = "https://json-schema.org/draft/2019-09/meta/#{name}"
+          component = {
+            "$schema" => META_SCHEMA_URI,
+            "$id" => uri,
+            "$recursiveAnchor" => true,
+            "type" => ["object", "boolean"],
+            "properties" => SCHEMA.fetch("properties").slice(*keywords)
+          }.freeze
+          MetaSchemas.register(uri, component)
+        end
+
+        private_constant :META_SCHEMA_URI, :SCHEMA, :COMPONENT_KEYWORDS
+      end
+    end
+  end
+
+  private_constant :Internal
+end

data/lib/schemurai/meta_schemas/draft2020_12.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require_relative "../meta_schemas"
+
+module Schemurai
+  module Internal
+    module MetaSchemas
+      module Draft202012
+        META_SCHEMA_URI = "https://json-schema.org/draft/2020-12/schema"
+        SCHEMA = {
+          "$schema" => META_SCHEMA_URI,
+          "$id" => META_SCHEMA_URI,
+          "$dynamicAnchor" => "meta",
+          "type" => ["object", "boolean"],
+          "properties" => {
+            "$id" => {"type" => "string"},
+            "$schema" => {"type" => "string"},
+            "$ref" => {"type" => "string"},
+            "$anchor" => {"type" => "string", "pattern" => "^[A-Za-z_][-A-Za-z0-9._]*$"},
+            "$dynamicRef" => {"type" => "string"},
+            "$dynamicAnchor" => {"type" => "string", "pattern" => "^[A-Za-z_][-A-Za-z0-9._]*$"},
+            "$recursiveRef" => {"type" => "string"},
+            "$recursiveAnchor" => {"type" => "string", "pattern" => "^[A-Za-z_][-A-Za-z0-9._]*$"},
+            "$vocabulary" => {"type" => "object", "additionalProperties" => {"type" => "boolean"}},
+            "$comment" => {"type" => "string"},
+            "$defs" => {"type" => "object", "additionalProperties" => {"$dynamicRef" => "#meta"}},
+            "definitions" => {"type" => "object", "additionalProperties" => {"$dynamicRef" => "#meta"}},
+            "prefixItems" => {
+              "type" => "array",
+              "minItems" => 1,
+              "items" => {"$dynamicRef" => "#meta"}
+            },
+            "items" => {"$dynamicRef" => "#meta"},
+            "contains" => {"$dynamicRef" => "#meta"},
+            "additionalProperties" => {"$dynamicRef" => "#meta"},
+            "properties" => {"type" => "object", "additionalProperties" => {"$dynamicRef" => "#meta"}},
+            "patternProperties" => {"type" => "object", "additionalProperties" => {"$dynamicRef" => "#meta"}},
+            "dependentSchemas" => {"type" => "object", "additionalProperties" => {"$dynamicRef" => "#meta"}},
+            "dependencies" => {
+              "type" => "object",
+              "additionalProperties" => {
+                "anyOf" => [
+                  {"$dynamicRef" => "#meta"},
+                  {"type" => "array", "items" => {"type" => "string"}, "uniqueItems" => true}
+                ]
+              }
+            },
+            "propertyNames" => {"$dynamicRef" => "#meta"},
+            "if" => {"$dynamicRef" => "#meta"},
+            "then" => {"$dynamicRef" => "#meta"},
+            "else" => {"$dynamicRef" => "#meta"},
+            "allOf" => {"type" => "array", "minItems" => 1, "items" => {"$dynamicRef" => "#meta"}},
+            "anyOf" => {"type" => "array", "minItems" => 1, "items" => {"$dynamicRef" => "#meta"}},
+            "oneOf" => {"type" => "array", "minItems" => 1, "items" => {"$dynamicRef" => "#meta"}},
+            "not" => {"$dynamicRef" => "#meta"},
+            "type" => {
+              "anyOf" => [
+                {"enum" => ["null", "boolean", "object", "array", "number", "integer", "string"]},
+                {
+                  "type" => "array",
+                  "items" => {"enum" => ["null", "boolean", "object", "array", "number", "integer", "string"]},
+                  "minItems" => 1,
+                  "uniqueItems" => true
+                }
+              ]
+            },
+            "enum" => {"type" => "array"},
+            "multipleOf" => {"type" => "number", "exclusiveMinimum" => 0},
+            "maximum" => {"type" => "number"},
+            "exclusiveMaximum" => {"type" => "number"},
+            "minimum" => {"type" => "number"},
+            "exclusiveMinimum" => {"type" => "number"},
+            "minLength" => {"type" => "integer", "minimum" => 0},
+            "maxLength" => {"type" => "integer", "minimum" => 0},
+            "pattern" => {"type" => "string"},
+            "minItems" => {"type" => "integer", "minimum" => 0},
+            "maxItems" => {"type" => "integer", "minimum" => 0},
+            "uniqueItems" => {"type" => "boolean"},
+            "minContains" => {"type" => "integer", "minimum" => 0},
+            "maxContains" => {"type" => "integer", "minimum" => 0},
+            "minProperties" => {"type" => "integer", "minimum" => 0},
+            "maxProperties" => {"type" => "integer", "minimum" => 0},
+            "required" => {
+              "type" => "array",
+              "items" => {"type" => "string"},
+              "uniqueItems" => true
+            },
+            "dependentRequired" => {
+              "type" => "object",
+              "additionalProperties" => {
+                "type" => "array",
+                "items" => {"type" => "string"},
+                "uniqueItems" => true
+              }
+            },
+            "title" => {"type" => "string"},
+            "description" => {"type" => "string"},
+            "deprecated" => {"type" => "boolean"},
+            "readOnly" => {"type" => "boolean"},
+            "writeOnly" => {"type" => "boolean"},
+            "examples" => {"type" => "array"},
+            "format" => {"type" => "string"},
+            "contentEncoding" => {"type" => "string"},
+            "contentMediaType" => {"type" => "string"},
+            "contentSchema" => {"$dynamicRef" => "#meta"}
+          }
+        }.freeze
+
+        MetaSchemas.register(META_SCHEMA_URI, SCHEMA)
+
+        COMPONENT_KEYWORDS = {
+          "core" => %w[
+            $id $schema $ref $anchor $dynamicRef $dynamicAnchor $vocabulary $comment $defs
+          ],
+          "applicator" => %w[
+            prefixItems items contains additionalProperties properties patternProperties
+            dependentSchemas propertyNames if then else allOf anyOf oneOf not
+          ],
+          "unevaluated" => %w[unevaluatedItems unevaluatedProperties],
+          "validation" => %w[
+            type const enum multipleOf maximum exclusiveMaximum minimum exclusiveMinimum
+            maxLength minLength pattern maxItems minItems uniqueItems maxContains minContains
+            maxProperties minProperties required dependentRequired
+          ],
+          "meta-data" => %w[title description default deprecated readOnly writeOnly examples],
+          "format-annotation" => %w[format],
+          "format-assertion" => %w[format],
+          "content" => %w[contentEncoding contentMediaType contentSchema]
+        }.freeze
+
+        COMPONENT_KEYWORDS.each do |name, keywords|
+          uri = "https://json-schema.org/draft/2020-12/meta/#{name}"
+          component = {
+            "$schema" => META_SCHEMA_URI,
+            "$id" => uri,
+            "$dynamicAnchor" => "meta",
+            "type" => ["object", "boolean"],
+            "properties" => SCHEMA.fetch("properties").slice(*keywords)
+          }.freeze
+          MetaSchemas.register(uri, component)
+        end
+
+        private_constant :META_SCHEMA_URI, :SCHEMA, :COMPONENT_KEYWORDS
+      end
+    end
+  end
+
+  private_constant :Internal
+end

data/lib/schemurai/meta_schemas/draft7.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative "../meta_schemas"
+
+module Schemurai
+  module Internal
+    module MetaSchemas
+      module Draft7
+        META_SCHEMA_URI = "http://json-schema.org/draft-07/schema"
+        SCHEMA = {
+          "$schema" => "#{META_SCHEMA_URI}#",
+          "$id" => "#{META_SCHEMA_URI}#",
+          "definitions" => {
+            "schemaArray" => {"type" => "array", "minItems" => 1, "items" => {"$ref" => "#"}},
+            "nonNegativeInteger" => {"type" => "integer", "minimum" => 0},
+            "nonNegativeIntegerDefault0" => {
+              "allOf" => [
+                {"$ref" => "#/definitions/nonNegativeInteger"},
+                {"default" => 0}
+              ]
+            },
+            "simpleTypes" => {"enum" => %w[array boolean integer null number object string]},
+            "stringArray" => {
+              "type" => "array",
+              "items" => {"type" => "string"},
+              "uniqueItems" => true,
+              "default" => []
+            }
+          },
+          "type" => ["object", "boolean"],
+          "properties" => {
+            "$id" => {"type" => "string", "format" => "uri-reference"},
+            "$schema" => {"type" => "string", "format" => "uri"},
+            "$ref" => {"type" => "string", "format" => "uri-reference"},
+            "$comment" => {"type" => "string"},
+            "title" => {"type" => "string"},
+            "description" => {"type" => "string"},
+            "default" => true,
+            "readOnly" => {"type" => "boolean", "default" => false},
+            "writeOnly" => {"type" => "boolean", "default" => false},
+            "examples" => {"type" => "array", "items" => true},
+            "multipleOf" => {"type" => "number", "exclusiveMinimum" => 0},
+            "maximum" => {"type" => "number"},
+            "exclusiveMaximum" => {"type" => "number"},
+            "minimum" => {"type" => "number"},
+            "exclusiveMinimum" => {"type" => "number"},
+            "maxLength" => {"$ref" => "#/definitions/nonNegativeInteger"},
+            "minLength" => {"$ref" => "#/definitions/nonNegativeIntegerDefault0"},
+            "pattern" => {"type" => "string", "format" => "regex"},
+            "additionalItems" => {"$ref" => "#"},
+            "items" => {
+              "anyOf" => [{"$ref" => "#"}, {"$ref" => "#/definitions/schemaArray"}],
+              "default" => true
+            },
+            "maxItems" => {"$ref" => "#/definitions/nonNegativeInteger"},
+            "minItems" => {"$ref" => "#/definitions/nonNegativeIntegerDefault0"},
+            "uniqueItems" => {"type" => "boolean", "default" => false},
+            "contains" => {"$ref" => "#"},
+            "maxProperties" => {"$ref" => "#/definitions/nonNegativeInteger"},
+            "minProperties" => {"$ref" => "#/definitions/nonNegativeIntegerDefault0"},
+            "required" => {"$ref" => "#/definitions/stringArray"},
+            "additionalProperties" => {"$ref" => "#"},
+            "definitions" => {
+              "type" => "object",
+              "additionalProperties" => {"$ref" => "#"},
+              "default" => {}
+            },
+            "properties" => {
+              "type" => "object",
+              "additionalProperties" => {"$ref" => "#"},
+              "default" => {}
+            },
+            "patternProperties" => {
+              "type" => "object",
+              "additionalProperties" => {"$ref" => "#"},
+              "propertyNames" => {"format" => "regex"},
+              "default" => {}
+            },
+            "dependencies" => {
+              "type" => "object",
+              "additionalProperties" => {
+                "anyOf" => [{"$ref" => "#"}, {"$ref" => "#/definitions/stringArray"}]
+              }
+            },
+            "propertyNames" => {"$ref" => "#"},
+            "const" => true,
+            "enum" => {"type" => "array", "items" => true, "minItems" => 1, "uniqueItems" => true},
+            "type" => {
+              "anyOf" => [
+                {"$ref" => "#/definitions/simpleTypes"},
+                {
+                  "type" => "array",
+                  "items" => {"$ref" => "#/definitions/simpleTypes"},
+                  "minItems" => 1,
+                  "uniqueItems" => true
+                }
+              ]
+            },
+            "format" => {"type" => "string"},
+            "contentMediaType" => {"type" => "string"},
+            "contentEncoding" => {"type" => "string"},
+            "if" => {"$ref" => "#"},
+            "then" => {"$ref" => "#"},
+            "else" => {"$ref" => "#"},
+            "allOf" => {"$ref" => "#/definitions/schemaArray"},
+            "anyOf" => {"$ref" => "#/definitions/schemaArray"},
+            "oneOf" => {"$ref" => "#/definitions/schemaArray"},
+            "not" => {"$ref" => "#"}
+          },
+          "default" => true
+        }.freeze
+
+        MetaSchemas.register(META_SCHEMA_URI, SCHEMA)
+
+        private_constant :META_SCHEMA_URI, :SCHEMA
+      end
+    end
+  end
+
+  private_constant :Internal
+end

data/lib/schemurai/meta_schemas.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Schemurai
+  module Internal
+    module MetaSchemas
+      class << self
+        def register(uri, schema)
+          registry[normalize_uri(uri)] = schema
+          schema
+        end
+
+        def resolve(uri)
+          registry[normalize_uri(uri)]
+        end
+
+        private def registry
+          @registry ||= {}
+        end
+
+        private def normalize_uri(uri)
+          uri.to_s.delete_suffix("#")
+        end
+      end
+    end
+  end
+
+  private_constant :Internal
+end

data/lib/schemurai/native/diagnostics.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Schemurai
+  module Native
+    # Render native diagnostic output using the messages shared by every backend.
+    # The instance remains an original Ruby object; this layer never traverses it.
+    module Diagnostics
+      TYPE_NAMES = {Protocol::OP_TYPE_NULL => "null", Protocol::OP_TYPE_BOOLEAN => "boolean", Protocol::OP_TYPE_OBJECT => "object",
+                    Protocol::OP_TYPE_ARRAY => "array", Protocol::OP_TYPE_NUMBER => "number", Protocol::OP_TYPE_INTEGER => "integer",
+                    Protocol::OP_TYPE_STRING => "string", Protocol::OP_TYPED_NUMBER => "number", Protocol::OP_TYPED_INTEGER => "integer",
+                    Protocol::OP_TYPED_STRING => "string", Protocol::OP_TYPED_ARRAY => "array", Protocol::OP_TYPED_OBJECT => "object"}.freeze
+      ATTRIBUTES = {"maximum" => :maximum, "minimum" => :minimum, "exclusiveMaximum" => :exclusive_maximum, "exclusiveMinimum" => :exclusive_minimum,
+                    "maxLength" => :max_length, "minLength" => :min_length, "maxItems" => :max_items, "minItems" => :min_items,
+                    "maxProperties" => :max_properties, "minProperties" => :min_properties}.freeze
+      private_constant :TYPE_NAMES, :ATTRIBUTES
+
+      module_function def error(row)
+        keyword, instance_path, schema_path, opcode, operand, instance, detail, rendered_message = row
+        ValidationError.new(keyword: keyword, instance_path: instance_path, schema_path: schema_path,
+          message: rendered_message || message(keyword, opcode, operand, instance, detail))
+      end
+
+      module_function def message(keyword, opcode, operand, instance, detail) # rubocop:disable Metrics/MethodLength
+        messages = Internal::ErrorMessage
+        case keyword
+        when "falseSchema" then messages.false_schema
+        when "type" then messages.type((opcode == Protocol::OP_TYPES) ? operand.names : TYPE_NAMES.fetch(opcode), instance)
+        when "const" then messages.const
+        when "enum" then messages.enum
+        when "maximum", "minimum", "exclusiveMaximum", "exclusiveMinimum"
+          messages.numeric_limit(keyword, operand.public_send(ATTRIBUTES.fetch(keyword)))
+        when "multipleOf" then messages.multiple_of(operand.multiple_of)
+        when "maxLength", "minLength", "maxItems", "minItems", "maxProperties", "minProperties"
+          messages.size(keyword, operand.public_send(ATTRIBUTES.fetch(keyword)), detail)
+        when "pattern" then (detail == 1) ? messages.invalid_pattern(operand.pattern) : messages.pattern(operand.pattern)
+        when "format" then messages.format(operand.format.name)
+        when "contentEncoding" then messages.content_encoding
+        when "contentMediaType" then messages.content_media_type
+        when "uniqueItems" then messages.unique_items
+        when "required" then messages.required(instance)
+        when "dependencies", "dependentRequired" then messages.dependent_required(operand, instance)
+        when "contains" then messages.contains(detail, operand.min_contains, operand.max_contains)
+        when "anyOf" then messages.any_of
+        when "oneOf" then messages.one_of(detail)
+        when "not" then messages.not
+        when "$ref", "$recursiveRef", "$dynamicRef" then operand
+        else raise "unknown native diagnostic #{keyword.inspect}"
+        end
+      end
+      private_class_method :message
+    end
+  end
+end

data/lib/schemurai/native/evaluator.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative "../decimal"
+require_relative "../number_checks"
+require_relative "../string_checks"
+require_relative "../value_equality"
+require_relative "../container_checks"
+require_relative "../type_checks"
+require_relative "../vm/compiler"
+require_relative "../evaluation_pool"
+require_relative "../limit_budget"
+require_relative "../ecma_regexp"
+require_relative "../json_pointer"
+require "schemurai_native"
+require_relative "diagnostics"
+require_relative "null_numeric"
+
+module Schemurai
+  module Native
+    class Evaluator
+      def backend = :native
+
+      def initialize(graph, compiler, root, content: false, format: false, compiled: nil)
+        @graph = graph
+        @compiler = compiler
+        @root = root
+        @content = content
+        @format = format
+        @graph_size = @graph.nodes.length
+        @compiled = compiled || Program.new(root, compiler, format, content)
+        @number_state = Internal::NumberChecks::State.new
+        @regexps = {}
+        @scope_state = []
+        @report_state = [nil, Internal::EvaluationPool.new]
+        @reference_state = []
+        @active_state = {}.compare_by_identity
+        @program = @compiled.runner(root)
+        @program.share_scalar_state(@number_state, @regexps, @scope_state, @reference_state, @active_state, @report_state)
+        @unresolved = @compiled.unresolved_references?
+      end
+
+      def valid?(instance, max_errors: nil, timeout: nil)
+        refresh_unresolved
+        if !max_errors.nil? || !timeout.nil?
+          budget = Internal::LimitBudget.new(max_errors: max_errors, timeout: timeout)
+          result = @program.valid_with_budget(instance, budget)
+          budget.check_deadline!
+          return result
+        end
+        @program.valid?(instance)
+      end
+
+      def validate(instance, max_errors: nil, timeout: nil)
+        refresh_unresolved
+        if !max_errors.nil? || !timeout.nil?
+          budget = Internal::LimitBudget.new(max_errors: max_errors, timeout: timeout)
+          rows = @program.diagnostics_with_budget(instance, budget)
+
+          errors = (rows == false) ? nil : rows.map do |row|
+            budget.reserve_error
+            Diagnostics.error(row)
+          end
+          budget.check_deadline!
+          return Result.new(errors)
+        end
+        rows = @program.diagnostics(instance)
+
+        return Result.new(nil) if rows == false
+
+        Result.new(rows.empty? ? rows : rows.map { |row| Diagnostics.error(row) })
+      end
+      private def refresh_unresolved
+        while @unresolved && @graph_size != @graph.nodes.length
+          graph_size = @graph.nodes.length
+          compiled = Program.new(@root, @compiler, @format, @content)
+          @program = compiled.runner(@root)
+          @program.share_scalar_state(@number_state, @regexps, @scope_state, @reference_state, @active_state, @report_state)
+          @compiled = compiled
+          @unresolved = @compiled.unresolved_references?
+          @graph_size = graph_size
+        end
+      end
+    end
+  end
+
+  private_constant :Native
+end

data/lib/schemurai/native/null_numeric.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Schemurai
+  module Native
+    # Native traversal selects one reached assertion and its comparison mode.
+    # Ruby dispatch preserves the exception and method visibility for nil.
+    module NullNumeric
+      module_function def valid?(value, bit, decimal)
+        actual = if decimal && !value.is_a?(Integer) && !value.is_a?(Rational)
+          Internal::Decimal.parse(value)
+        else
+          value
+        end
+        case bit
+        when Protocol::MAXIMUM, Protocol::MINIMUM, Protocol::EXCLUSIVE_MAXIMUM, Protocol::EXCLUSIVE_MINIMUM
+          Internal::NumberChecks.bound?(actual, bit, nil)
+        when Protocol::MULTIPLE_OF then nil.positive? && actual.remainder(nil).zero?
+        else raise "unknown null numeric assertion"
+        end
+      end
+    end
+  end
+end