schemurai 2.2.3 → 3.0.0

data/lib/schemurai/version.rb

@@ -2,5 +2,5 @@
 
 module Schemurai
   # The installed Schemurai version.
-  VERSION = "2.2.3"
+  VERSION = "3.0.0"
 end

data/lib/schemurai/vm/compiler.rb

@@ -391,12 +391,16 @@ module Schemurai
         compiled.freeze unless compiled.empty?
       end
 
-      private def snapshot(value)
+      # Keep aliases inside one operand while copying away from caller-owned
+      # containers. A fresh identity table also rechecks later compilations.
+      private def snapshot(value, copies = {}.compare_by_identity)
+        return copies[value] if copies.key?(value)
+
         case value
         when Hash
-          value.to_h { |key, item| [snapshot(key), snapshot(item)] }.freeze
+          copies[value] = value.to_h { |key, item| [snapshot(key, copies), snapshot(item, copies)] }.freeze
         when Array
-          value.map { |item| snapshot(item) }.freeze
+          copies[value] = value.map { |item| snapshot(item, copies) }.freeze
         when String
           -value
         else

data/lib/schemurai/vm/evaluator.rb

@@ -127,6 +127,7 @@ module Schemurai
         end
         instruction_index = 1
         while (opcode = code[instruction_index])
+          @budget&.checkpoint
           operand = code[instruction_index + 1]
           case opcode
           when :boolean
@@ -178,6 +179,7 @@ module Schemurai
           when :oneOf
             matches = 0
             operand.each do |child|
+              @budget&.checkpoint
               matches += 1 if evaluate_valid(child, instance)
               return false if matches > 1
             end
@@ -237,6 +239,7 @@ module Schemurai
 
         instruction_index = 1
         while (opcode = code[instruction_index])
+          @budget&.checkpoint
           operand = code[instruction_index + 1]
           case opcode
           when :boolean
@@ -345,6 +348,7 @@ module Schemurai
         return target unless rules.fragment == "" && target.recursive_anchor?
 
         @dynamic_scope&.each do |resource|
+          @budget&.checkpoint
           compiled = @compiler.compile(resource.root)
           return compiled if compiled.recursive_anchor?
         end
@@ -359,6 +363,7 @@ module Schemurai
         return target unless target.dynamic_anchor == fragment
 
         Array(@dynamic_scope).each do |resource|
+          @budget&.checkpoint
           dynamic = @graph.dynamic_anchor(resource, fragment)
           return @compiler.compile(dynamic) if dynamic
         end
@@ -560,6 +565,7 @@ module Schemurai
 
         if (prefix_items = rules.prefix_items)
           prefix_items.each_with_index do |child, index|
+            @budget&.checkpoint
             break if index >= length
             return false unless evaluate_valid(child, value[index])
           end
@@ -568,12 +574,14 @@ module Schemurai
         items = rules.items
         if rules.items_list
           items.each_with_index do |child, index|
+            @budget&.checkpoint
             break if index >= length
             return false unless evaluate_valid(child, value[index])
           end
           if length > items.length && (additional = rules.additional)
             index = items.length
             while index < length
+              @budget&.checkpoint
               return false unless evaluate_valid(additional, value[index])
               index += 1
             end
@@ -582,6 +590,7 @@ module Schemurai
           start = rules.prefix_items&.length || 0
           index = start
           while index < length
+            @budget&.checkpoint
             return false unless evaluate_valid(items, value[index])
             index += 1
           end
@@ -618,6 +627,7 @@ module Schemurai
 
         if (prefix_items = rules.prefix_items)
           prefix_items.each_with_index do |child, index|
+            @budget&.checkpoint
             break if index >= value.length
             valid = evaluate_child_at(child, value[index], index, "prefixItems", index)
             return Evaluation.invalid if !valid && !@errors
@@ -628,6 +638,7 @@ module Schemurai
         items = rules.items
         if rules.items_list
           items.each_with_index do |child, index|
+            @budget&.checkpoint
             break if index >= value.length
             valid = evaluate_child_at(child, value[index], index, "items", index)
             return Evaluation.invalid if !valid && !@errors
@@ -635,6 +646,7 @@ module Schemurai
           end
           if value.length > items.length && (additional = rules.additional)
             (items.length...value.length).each do |index|
+              @budget&.checkpoint
               valid = evaluate_child_at(additional, value[index], index, "additionalItems")
               return Evaluation.invalid if !valid && !@errors
               (evaluation ||= tracked_evaluation).record_item(index)
@@ -643,6 +655,7 @@ module Schemurai
         elsif items
           start = rules.prefix_items&.length || 0
           (start...value.length).each do |index|
+            @budget&.checkpoint
             valid = evaluate_child_at(items, value[index], index, "items")
             return Evaluation.invalid if !valid && !@errors
             (evaluation ||= tracked_evaluation).record_item(index)
@@ -653,6 +666,7 @@ module Schemurai
           matched = nil
           index = 0
           while index < value.length
+            @budget&.checkpoint
             (matched ||= []) << index if trial(contains, value[index]).valid?
             index += 1
           end
@@ -673,6 +687,7 @@ module Schemurai
           prior_items = prior_evaluation.evaluated_items
           index = 0
           while index < value.length
+            @budget&.checkpoint
             if prior_items.include?(index) || evaluation&.evaluated_items&.include?(index)
               index += 1
               next
@@ -692,7 +707,10 @@ module Schemurai
         length = value.length
         return false if rules.max_properties && length > rules.max_properties
         return false if rules.min_properties && length < rules.min_properties
-        if rules.required && !rules.required.all? { |name| value.key?(name) }
+        if rules.required && !rules.required.all? do |name|
+          @budget&.checkpoint
+          value.key?(name)
+        end
           return false
         end
 
@@ -701,6 +719,7 @@ module Schemurai
         additional = rules.additional
         unless properties.empty? && patterns.nil? && additional.nil?
           value.each do |name, property_value|
+            @budget&.checkpoint
             matched = false
             if (child = properties[name])
               matched = true
@@ -708,6 +727,7 @@ module Schemurai
             end
             if patterns
               patterns.each do |pattern, child|
+                @budget&.checkpoint
                 next unless ecma_regexp(pattern).match?(name)
                 matched = true
                 return false unless evaluate_valid(child, property_value)
@@ -722,9 +742,13 @@ module Schemurai
         end
         if (dependencies = rules.dependencies)
           dependencies.each do |name, dependency|
+            @budget&.checkpoint
             next unless value.key?(name)
             if dependency.is_a?(Array)
-              return false unless dependency.all? { |required_name| value.key?(required_name) }
+              return false unless dependency.all? do |required_name|
+                @budget&.checkpoint
+                value.key?(required_name)
+              end
             else
               return false unless evaluate_valid(dependency, value)
             end
@@ -732,12 +756,17 @@ module Schemurai
         end
         if (dependent_required = rules.dependent_required)
           dependent_required.each do |name, required_names|
+            @budget&.checkpoint
             next unless value.key?(name)
-            return false unless required_names.all? { |required_name| value.key?(required_name) }
+            return false unless required_names.all? do |required_name|
+              @budget&.checkpoint
+              value.key?(required_name)
+            end
           end
         end
         if (dependent_schemas = rules.dependent_schemas)
           dependent_schemas.each do |name, child|
+            @budget&.checkpoint
             next unless value.key?(name)
             return false unless evaluate_valid(child, value)
           end
@@ -763,6 +792,7 @@ module Schemurai
         end
         if (required = rules.required)
           required.each do |name|
+            @budget&.checkpoint
             next if value.key?(name)
             return Evaluation.invalid unless @errors
 
@@ -773,6 +803,7 @@ module Schemurai
         properties = rules.properties
         patterns = rules.patterns
         value.each do |name, property_value|
+          @budget&.checkpoint
           matched = false
           if (child = properties[name])
             matched = true
@@ -782,6 +813,7 @@ module Schemurai
           end
           if patterns
             patterns.each do |pattern, child|
+              @budget&.checkpoint
               next unless ecma_regexp(pattern).match?(name)
               matched = true
               valid = evaluate_child_at(child, property_value, name, "patternProperties", pattern)
@@ -798,15 +830,18 @@ module Schemurai
 
         if (property_names = rules.property_names)
           value.each_key do |name|
+            @budget&.checkpoint
             valid = evaluate_child_at(property_names, name, name, "propertyNames")
             return Evaluation.invalid if !valid && !@errors
           end
         end
         if (dependencies = rules.dependencies)
           dependencies.each do |name, dependency|
+            @budget&.checkpoint
             next unless value.key?(name)
             if dependency.is_a?(Array)
               dependency.each do |required_name|
+                @budget&.checkpoint
                 unless value.key?(required_name)
                   return Evaluation.invalid unless @errors
 
@@ -817,6 +852,7 @@ module Schemurai
               result = evaluate_at(dependency, value, MISSING_SEGMENT, "dependencies", name)
               if result.valid? && !result.evaluated_properties.empty?
                 result.evaluated_properties.each do |property|
+                  @budget&.checkpoint
                   (evaluation ||= tracked_evaluation).record_property(property)
                 end
               end
@@ -825,8 +861,10 @@ module Schemurai
         end
         if (dependent_required = rules.dependent_required)
           dependent_required.each do |name, required_names|
+            @budget&.checkpoint
             next unless value.key?(name)
             required_names.each do |required_name|
+              @budget&.checkpoint
               unless value.key?(required_name)
                 return Evaluation.invalid unless @errors
 
@@ -837,10 +875,12 @@ module Schemurai
         end
         if (dependent_schemas = rules.dependent_schemas)
           dependent_schemas.each do |name, child|
+            @budget&.checkpoint
             next unless value.key?(name)
             result = evaluate_at(child, value, MISSING_SEGMENT, "dependentSchemas", name)
             if result.valid? && !result.evaluated_properties.empty?
               result.evaluated_properties.each do |property|
+                @budget&.checkpoint
                 (evaluation ||= tracked_evaluation).record_property(property)
               end
             end
@@ -849,6 +889,7 @@ module Schemurai
         if (unevaluated = rules.unevaluated)
           prior_properties = prior_evaluation.evaluated_properties
           value.each_key do |name|
+            @budget&.checkpoint
             next if prior_properties.include?(name) || evaluation&.evaluated_properties&.include?(name)
 
             valid = evaluate_child_at(unevaluated, value[name], name, "unevaluatedProperties")
@@ -867,6 +908,7 @@ module Schemurai
         when :allOf
           index = 0
           while index < operand.length
+            @budget&.checkpoint
             evaluation = evaluation.merge(evaluate_at(operand[index], value, MISSING_SEGMENT, "allOf", index))
             index += 1
           end
@@ -874,6 +916,7 @@ module Schemurai
           matches = 0
           index = 0
           while index < operand.length
+            @budget&.checkpoint
             result = trial(operand[index], value)
             if result.valid?
               matches += 1
@@ -887,6 +930,7 @@ module Schemurai
           matched_evaluation = nil
           index = 0
           while index < operand.length
+            @budget&.checkpoint
             result = trial(operand[index], value)
             if result.valid?
               matches += 1
@@ -989,6 +1033,7 @@ module Schemurai
         case left
         when Hash
           left.length == right.length && left.all? do |key, value|
+            @budget&.checkpoint
             right.key?(key) && json_equal?(value, right[key])
           end
         when Array
@@ -996,6 +1041,7 @@ module Schemurai
 
           index = 0
           while index < left.length
+            @budget&.checkpoint
             return false unless json_equal?(left[index], right[index])
             index += 1
           end
@@ -1024,6 +1070,7 @@ module Schemurai
         escaped = false
         in_class = false
         pattern.each_char do |character|
+          @budget&.checkpoint
           if escaped
             translated << case character
             when "d" then in_class ? "0-9" : "[0-9]"

data/lib/schemurai/vm/limited_evaluator.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative "../limit_exceeded"
+require_relative "../limit_budget"
+require_relative "evaluator"
+
+module Schemurai
+  module VM
+    # VM execution with invocation-local limits; no Ruby evaluator delegation.
+    class LimitedEvaluator < Evaluator
+      def validate(instance, max_errors: nil, timeout: nil, budget: nil)
+        @budget = budget || Internal::LimitBudget.new(max_errors: max_errors, timeout: timeout)
+        result = super(instance)
+        @budget.check_deadline!
+        result
+      ensure
+        @budget = nil
+      end
+
+      def valid?(instance, max_errors: nil, timeout: nil, budget: nil)
+        @budget = budget || Internal::LimitBudget.new(max_errors: max_errors, timeout: timeout)
+        result = super(instance)
+        @budget.check_deadline!
+        result
+      ensure
+        @budget = nil
+      end
+
+      private def evaluate(node, instance)
+        @budget.checkpoint
+        super
+      end
+
+      private def evaluate_valid(node, instance)
+        @budget.checkpoint
+        super
+      end
+
+      private def add_error(keyword, message = nil, append_keyword: true, &block)
+        @budget.reserve_error if @errors
+        super
+      end
+
+      private def valid_string?(node, value)
+        @budget.check_deadline!
+        result = super
+        @budget.check_deadline!
+        result
+      end
+
+      private def check_string(node, value)
+        @budget.check_deadline!
+        result = super
+        @budget.check_deadline!
+        result
+      end
+
+      private def decimal(value)
+        @budget.check_deadline!
+        result = super
+        @budget.check_deadline!
+        result
+      end
+
+      private def ecma_regexp(pattern)
+        @budget.check_deadline!
+        result = super
+        @budget.check_deadline!
+        result
+      end
+
+      private def valid_content?(schema, value)
+        @budget.check_deadline!
+        result = super
+        @budget.check_deadline!
+        result
+      end
+
+      private def check_content(schema, value)
+        @budget.check_deadline!
+        result = super
+        @budget.check_deadline!
+        result
+      end
+
+      private def json_equal?(left, right)
+        @budget.checkpoint
+        super
+      end
+
+      private def json_fingerprint(value)
+        @budget.checkpoint
+        super
+      end
+    end
+  end
+end

data/lib/schemurai.rb

@@ -11,6 +11,8 @@ module Schemurai
   # Base class for errors raised by Schemurai.
   class Error < StandardError; end
 
+  require_relative "schemurai/limited_evaluator"
+
   # Raised when a schema or URI cannot be resolved from a registry.
   class ResolutionError < Error; end
 
@@ -72,19 +74,19 @@ module Schemurai
   # Register every external schema with +schemas:+ before compiling. A registry
   # can be made shareable once registration and compilation are complete.
   class SchemaRegistry
-    # The selected backend, either +:ruby+ or +:vm+.
+    # The selected backend, +:ruby+, +:vm+, or +:native+.
     attr_reader :backend
 
     # Creates a registry.
     #
     # +schemas+ maps absolute URI strings to JSON-shaped Ruby schemas. Pass
     # +validate_schema: true+ to validate every registered and compiled schema
-    # against its meta-schema. +backend+ accepts +:ruby+, +:vm+, or +:default+.
+    # against its meta-schema. +backend+ accepts +:ruby+, +:vm+, +:native+, or +:default+.
     def initialize(schemas: {}, validate_schema: false, backend: Backend.requested)
       @backend = Backend.resolve(backend)
       @validate_schema = validate_schema
       @graph = Internal::SchemaGraph.new(schemas: schemas)
-      @compiler = VM::Compiler.new(@graph) if @backend == :vm
+      @compiler = VM::Compiler.new(@graph) if %i[vm native].include?(@backend)
       schemas.each_value { |schema| validate_schema!(schema) } if validate_schema?
     end
 
@@ -96,27 +98,31 @@ module Schemurai
     # Compiles +schema+ and returns a Validator.
     #
     # +base_uri+ supplies the schema's base URI. Pass +content: true+ or
-    # +format: true+ to enable the corresponding optional assertions.
-    def compile(schema, base_uri: nil, content: false, format: false)
+    # +format: true+ to enable the corresponding optional assertions. +max_errors:+ and +timeout:+
+    # configure per-call validation caps; schema compilation is not bounded.
+    def compile(schema, base_uri: nil, content: false, format: false, max_errors: nil, timeout: nil)
       raise Error, "cannot compile schemas after the registry is made shareable" if shareable?
 
       validate_schema!(schema) if validate_schema?
       root = @graph.compile(schema, base_uri: base_uri)
-      build_validator(root, content: content, format: format)
+      build_validator(root, content: content, format: format, max_errors: max_errors, timeout: timeout)
     end
 
     # Validates +schema+ against its declared meta-schema and returns a Result.
     # Schemas without +$schema+ are validated as Draft 7.
-    def validate_schema(schema)
+    def validate_schema(schema, max_errors: nil, timeout: nil)
       raise Error, "cannot validate schemas after the registry is made shareable" if shareable?
 
       root = @graph.meta_schema_root(schema)
-      build_validator(root, content: false, format: false).validate(schema)
+      build_validator(root, content: false, format: false, max_errors: max_errors, timeout: timeout).validate(schema)
     end
 
     # Returns whether +schema+ conforms to its declared meta-schema.
-    def valid_schema?(schema)
-      validate_schema(schema).valid?
+    def valid_schema?(schema, max_errors: nil, timeout: nil)
+      raise Error, "cannot validate schemas after the registry is made shareable" if shareable?
+
+      root = @graph.meta_schema_root(schema)
+      build_validator(root, content: false, format: false, max_errors: max_errors, timeout: timeout).valid?(schema)
     end
 
     # Resolves and freezes registered schemas, then makes the registry Ractor-shareable.
@@ -127,6 +133,13 @@ module Schemurai
 
       @graph.make_shareable
       @compiler&.compile_all
+      if @backend == :native
+        programs = @graph.nodes.map { |node| @compiler.compile(node) }
+        # Build every option variant before the registry becomes immutable.
+        @native_programs = [false, true].product([false, true]).to_h do |format, content|
+          [[format, content], Native::Program.new(programs, @compiler, format, content).make_shareable]
+        end
+      end
       Ractor.make_shareable(self)
     end
 
@@ -138,23 +151,36 @@ module Schemurai
     # Returns a Validator for the registered resource at +uri+.
     #
     # The registry must first be made shareable with #make_shareable.
-    def validator_for(uri, content: false, format: false)
+    def validator_for(uri, content: false, format: false, max_errors: nil, timeout: nil)
       raise Error, "make_shareable must be called before retrieving validators by URI" unless shareable?
 
       root = @graph.node_at(uri)
       raise ResolutionError, "unregistered schema URI #{uri.inspect}" unless root
 
-      build_validator(root, content: content, format: format)
+      build_validator(root, content: content, format: format, max_errors: max_errors, timeout: timeout)
     end
 
-    private def build_validator(root, content:, format:)
+    private def build_validator(root, content:, format:, max_errors: nil, timeout: nil)
       evaluator = if @compiler
         program = @compiler.compile(root)
-        VM::Evaluator.new(@graph, @compiler, program, content: content, format: format)
+        evaluator_class = (@backend == :native) ? Native::Evaluator : VM::Evaluator
+        if @native_programs
+          compiled = @native_programs.fetch([!!format, !!content])
+          Native::Evaluator.new(@graph, @compiler, program, content: content, format: format, compiled: compiled)
+        else
+          evaluator_class.new(@graph, @compiler, program, content: content, format: format)
+        end
       else
         Internal::Evaluator.new(@graph, root, content: content, format: format)
       end
-      Validator.new(evaluator)
+      bounded_evaluator = lambda do
+        case @backend
+        when :native then evaluator
+        when :vm then VM::LimitedEvaluator.new(@graph, @compiler, program, content: content, format: format)
+        else Internal::LimitedEvaluator.new(@graph, root, content: content, format: format)
+        end
+      end
+      Validator.new(evaluator, max_errors: max_errors, timeout: timeout, bounded_evaluator: bounded_evaluator)
     end
 
     private def validate_schema!(schema)
@@ -173,27 +199,46 @@ module Schemurai
     #
     # Applications should normally create validators through Schemurai.compile
     # or SchemaRegistry#compile.
-    def initialize(evaluator)
+    def initialize(evaluator, max_errors: nil, timeout: nil, bounded_evaluator: nil)
       @evaluator = evaluator
+      Internal::LimitBudget.validate_options!(max_errors, timeout)
+      @max_errors = max_errors
+      @timeout = timeout
+      @bounded_evaluator = bounded_evaluator
     end
 
-    # The backend reported by the evaluator, either +:ruby+ or +:vm+.
+    # The backend reported by the evaluator, +:ruby+, +:vm+, or +:native+.
     def backend
       @evaluator.backend
     end
 
     # Validates +instance+ and returns a Result containing all reported errors.
-    def validate(instance)
-      @evaluator.validate(instance)
+    # +max_errors:+ and +timeout:+ override compiled defaults. Raises LimitExceeded when evaluation
+    # cannot complete; no partial Result is returned.
+    def validate(instance, max_errors: @max_errors, timeout: @timeout)
+      Internal::LimitBudget.validate_options!(max_errors, timeout)
+      return @evaluator.validate(instance) if max_errors.nil? && timeout.nil?
+
+      limited_evaluator.validate(instance, max_errors: max_errors, timeout: timeout)
     end
 
     # Returns whether +instance+ is valid without building a detailed error list.
-    def valid?(instance)
-      @evaluator.valid?(instance)
+    # The timeout applies; the diagnostic count limit is ignored.
+    def valid?(instance, max_errors: @max_errors, timeout: @timeout)
+      Internal::LimitBudget.validate_options!(max_errors, timeout)
+      return @evaluator.valid?(instance) if timeout.nil?
+
+      limited_evaluator.valid?(instance, timeout: timeout)
+    end
+
+    private def limited_evaluator
+      raise ArgumentError, "this manually constructed Validator has no bounded evaluator" unless @bounded_evaluator
+
+      @bounded_evaluator.call
     end
   end
 
-  # Returns the backend selected by SCHEMURAI_BACKEND, either +:ruby+ or +:vm+.
+  # Returns the backend selected by SCHEMURAI_BACKEND, +:ruby+, +:vm+, or +:native+.
   module_function def backend
     Backend.resolve
   end
@@ -202,32 +247,33 @@ module Schemurai
   #
   # +schemas+ maps external URI strings to schemas. +base_uri+ supplies the
   # schema's base URI. Optional content and format assertions are disabled by
-  # default. +backend+ accepts +:ruby+, +:vm+, or +:default+.
-  module_function def compile(schema, schemas: {}, base_uri: nil, content: false, format: false, validate_schema: false, backend: Backend.requested)
+  # default. +backend+ accepts +:ruby+, +:vm+, +:native+, or +:default+.
+  module_function def compile(schema, schemas: {}, base_uri: nil, content: false, format: false, validate_schema: false, backend: Backend.requested, max_errors: nil, timeout: nil)
     SchemaRegistry.new(schemas: schemas, validate_schema: validate_schema, backend: backend).compile(
       schema,
       base_uri: base_uri,
       content: content,
-      format: format
+      format: format,
+      max_errors: max_errors, timeout: timeout
     )
   end
 
   # Validates +schema+ against its declared meta-schema and returns a Result.
   # Schemas without +$schema+ are validated as Draft 7.
-  module_function def validate_schema(schema, schemas: {}, backend: Backend.requested)
-    SchemaRegistry.new(schemas: schemas, backend: backend).validate_schema(schema)
+  module_function def validate_schema(schema, schemas: {}, backend: Backend.requested, max_errors: nil, timeout: nil)
+    SchemaRegistry.new(schemas: schemas, backend: backend).validate_schema(schema, max_errors: max_errors, timeout: timeout)
   end
 
   # Returns whether +schema+ conforms to its declared meta-schema.
-  module_function def valid_schema?(schema, schemas: {}, backend: Backend.requested)
-    validate_schema(schema, schemas: schemas, backend: backend).valid?
+  module_function def valid_schema?(schema, schemas: {}, backend: Backend.requested, max_errors: nil, timeout: nil)
+    SchemaRegistry.new(schemas: schemas, backend: backend).valid_schema?(schema, max_errors: max_errors, timeout: timeout)
   end
 
   # Validates +instance+ against +schema+ and returns a Result.
   #
   # This convenience method compiles the schema for each call. Use .compile
   # when validating multiple instances against the same schema.
-  module_function def validate(schema, instance, schemas: {}, base_uri: nil, content: false, format: false, validate_schema: false, backend: Backend.requested)
+  module_function def validate(schema, instance, schemas: {}, base_uri: nil, content: false, format: false, validate_schema: false, backend: Backend.requested, max_errors: nil, timeout: nil)
     compile(
       schema,
       schemas: schemas,
@@ -235,7 +281,8 @@ module Schemurai
       content: content,
       format: format,
       validate_schema: validate_schema,
-      backend: backend
+      backend: backend,
+      max_errors: max_errors, timeout: timeout
     ).validate(instance)
   end
 
@@ -243,7 +290,7 @@ module Schemurai
   #
   # This convenience method compiles the schema for each call. Use .compile
   # when validating multiple instances against the same schema.
-  module_function def valid?(schema, instance, schemas: {}, base_uri: nil, content: false, format: false, validate_schema: false, backend: Backend.requested)
+  module_function def valid?(schema, instance, schemas: {}, base_uri: nil, content: false, format: false, validate_schema: false, backend: Backend.requested, max_errors: nil, timeout: nil)
     compile(
       schema,
       schemas: schemas,
@@ -251,7 +298,8 @@ module Schemurai
       content: content,
       format: format,
       validate_schema: validate_schema,
-      backend: backend
+      backend: backend,
+      max_errors: max_errors, timeout: timeout
     ).valid?(instance)
   end