tungsten-runtime 0.1.2

data/lib/tungsten/runtime/options.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+# SPDX-License-Identifier: Apache-2.0
+
+module Tungsten
+  module Runtime
+    # Raised when a client cannot be built (a bad base URL, an option of the
+    # wrong type). Calls never raise; they return Err.
+    class ConfigError < StandardError; end
+
+    # Defaults of ClientOptions.
+    DEFAULT_TIMEOUT_MS = 30_000
+    DEFAULT_MAX_EVENT_BYTES = 1024 * 1024
+    DEFAULT_MAX_COLLECT_BYTES = 4 * 1024 * 1024
+    DEFAULT_MAX_COLLECT_MS = 60_000
+    DEFAULT_MAX_RECONNECTS = 3
+    DEFAULT_RECONNECT_MAX_MS = 30_000
+
+    # Retry settings, field by field (nil fields are unset): `max` attempts
+    # after the first, `base_ms` and `max_ms` of the backoff, `jitter`
+    # (`"none"`, `"full"`, `"equal"`), `honor_retry_after`.
+    RetryOptions = Data.define(:max, :base_ms, :max_ms, :jitter, :honor_retry_after) do
+      def initialize(max: nil, base_ms: nil, max_ms: nil, jitter: nil, honor_retry_after: nil) = super
+
+      # From nil, a Hash or RetryOptions.
+      def self.from(value)
+        case value
+        when nil then new
+        when RetryOptions then value
+        when Hash then new(**value.transform_keys(&:to_sym).slice(:max, :base_ms, :max_ms, :jitter, :honor_retry_after))
+        else raise ConfigError, "retries must be a Hash or Tungsten::Runtime::RetryOptions"
+        end
+      end
+    end
+
+    # Client options (every keyword optional):
+    #
+    # - `redirects`: `"same_origin_read"` or `"none"`; `"none"` in either the API or options wins;
+    # - `base_url`: defaults to the API's first server;
+    # - `auth`: credentials by auth scheme name: a String for bearer, API key
+    #   and basic (`"user:password"`) schemes, a Hash for a composite profile
+    #   (by cookie name or config key), for OAuth2 client credentials
+    #   (`client_id`, `client_secret`) or the authorization-code flow
+    #   (`flow: "authorizationCode"`, `client_id`, `client_secret`,
+    #   `redirect_uri`);
+    # - `token_store`: where authorization-code tokens live (memory by default);
+    # - `timeout_ms`: the per-attempt timeout (30 s);
+    # - `retries`: RetryOptions over the API's per-tier defaults;
+    # - `idempotency_store`: anything with `get(scope, id)` and `put(scope, id,
+    #   key)` (memory by default);
+    # - `middleware`: objects with any of `on_request(ctx)`,
+    #   `on_response(ctx, response)`, `on_retry(ctx, reason)`;
+    # - `validate_responses`: `"warn"` (default), `"strict"` or `"off"`;
+    # - `on_diagnostic`: called with warning envelopes;
+    # - `headers`: sent on every request;
+    # - `max_event_bytes` (1 MiB), `max_collect_bytes` (4 MiB), `max_collect_ms`
+    #   (60 s), `max_reconnects` (3), `reconnect_max_ms` (30 s),
+    #   `idle_timeout_ms` (none): event streams;
+    # - `confirmation_key`: signs confirmation tokens (random per client);
+    # - `now` (epoch milliseconds) and `random` (in [0, 1)): callables for tests.
+    ClientOptions = Data.define(
+      :redirects, :base_url, :auth, :token_store, :timeout_ms, :retries, :idempotency_store, :middleware,
+      :validate_responses, :on_diagnostic, :headers, :max_event_bytes, :max_collect_bytes, :max_collect_ms,
+      :max_reconnects, :reconnect_max_ms, :idle_timeout_ms, :confirmation_key, :now, :random
+    ) do
+      def initialize(redirects: nil, base_url: nil, auth: {}, token_store: nil, timeout_ms: nil, retries: nil, idempotency_store: nil,
+                     middleware: [], validate_responses: "warn", on_diagnostic: nil, headers: {}, max_event_bytes: nil,
+                     max_collect_bytes: nil, max_collect_ms: nil, max_reconnects: nil, reconnect_max_ms: nil,
+                     idle_timeout_ms: nil, confirmation_key: nil, now: nil, random: nil)
+        super
+      end
+
+      # Options from nil, a Hash or ClientOptions, with keywords over them.
+      def self.from(options = nil, **keywords)
+        base =
+          case options
+          when nil then {}
+          when ClientOptions then options.to_h
+          when Hash then options.transform_keys(&:to_sym)
+          else raise ConfigError, "client options must be a Hash or Tungsten::Runtime::ClientOptions"
+          end
+        merged = base.merge(keywords.transform_keys(&:to_sym))
+        unknown = merged.keys - members
+        raise ConfigError, "unknown client option #{unknown.first}" unless unknown.empty?
+
+        new(**merged)
+      end
+    end
+
+    # Options of one call:
+    #
+    # - `idempotency_key`: required for caller-owned operations that persist
+    #   a key; generate it once per intent and reuse it on every retry;
+    # - `confirm`: `true` (a destructive operation only) or the
+    #   `confirmation_token` of a preview, bound to the exact arguments;
+    # - `refuse_confirm_yes`: `confirm: true` confirms nothing and
+    #   remediation never offers it (callers that only forward tokens);
+    # - `timeout_ms`: the per-attempt timeout;
+    # - `verify`: run the operation's verification hook after success;
+    # - `headers`: sent with this call.
+    CallOptions = Data.define(:idempotency_key, :confirm, :refuse_confirm_yes, :timeout_ms, :verify, :headers) do
+      def initialize(idempotency_key: nil, confirm: nil, refuse_confirm_yes: false, timeout_ms: nil, verify: false,
+                     headers: {})
+        super
+      end
+
+      # Options from nil, a Hash or CallOptions.
+      def self.from(value)
+        case value
+        when nil then new
+        when CallOptions then value
+        when Hash
+          given = value.transform_keys(&:to_sym)
+          unknown = given.keys - members
+          raise ArgumentError, "unknown call option #{unknown.first}" unless unknown.empty?
+
+          new(**given)
+        else raise ArgumentError, "call options must be a Hash or Tungsten::Runtime::CallOptions"
+        end
+      end
+
+      def key? = idempotency_key.is_a?(String) && !idempotency_key.empty?
+      def confirm_yes? = confirm == true
+      def token = confirm.is_a?(String) && !confirm.empty? ? confirm : nil
+
+      # Never shows keys or tokens.
+      def inspect
+        shown = { idempotency_key: key? ? REDACTED : nil, confirm: confirm == true ? true : (token ? REDACTED : nil),
+                  timeout_ms: timeout_ms, verify: verify, headers: (headers || {}).keys }
+        "#<Tungsten::Runtime::CallOptions #{shown}>"
+      end
+      alias_method :to_s, :inspect
+    end
+
+    # What middleware sees of one attempt; secrets are redacted. `body` is
+    # the body as JSON when it is JSON, a text rendering otherwise, UNSET
+    # without one.
+    RequestContext = Data.define(:operation, :attempt, :http_method, :url, :headers, :body)
+
+    # What middleware sees of an answer.
+    ResponseContext = Data.define(:status, :headers)
+  end
+end

data/lib/tungsten/runtime/pages.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+# SPDX-License-Identifier: Apache-2.0
+
+module Tungsten
+  module Runtime
+    class ClientCore
+      # Where a pagination is: the arguments of the next page, the URL of a
+      # Link header page, the last cursor seen, and an error to report next.
+      PageState = Struct.new(:args, :override_url, :previous_cursor, :done, :pending_error)
+
+      # Every page of a paginated operation, fetched as the enumeration
+      # proceeds: each item is Ok (whose value is a Page) or, last, Err.
+      #
+      # @return [Enumerator<Ok, Err>]
+      def pages(op, args = {}, opts = nil)
+        Enumerator.new do |y|
+          result = with_options(op, opts) do |d, o|
+            state = new_page_state(args)
+            loop do
+              page = page_step(d, state, o, nil)
+              break if page.nil?
+
+              y << page
+              break if page.is_a?(Err)
+            end
+            nil
+          end
+          y << result if result.is_a?(Err)
+        end
+      end
+
+      private
+
+      def new_page_state(args)
+        converted =
+          begin
+            Json.from_ruby(args.nil? ? {} : args)
+          rescue ArgumentError
+            args
+          end
+        PageState.new(converted.is_a?(Hash) ? converted.dup : converted, nil, UNSET, false, nil)
+      end
+
+      def set_arg(args, key, value)
+        args[key] = value if args.is_a?(Hash)
+      end
+
+      def arg_at(args, key) = args.is_a?(Hash) ? args.fetch(key, UNSET) : UNSET
+
+      # The next page (Ok or Err), or nil after the last one.
+      def page_step(op, state, opts, claim)
+        if state.pending_error
+          err = state.pending_error
+          state.pending_error = nil
+          state.done = true
+          return err
+        end
+        return nil if state.done
+
+        response = call_with(op, state.args, opts, state.override_url, claim)
+        if response.is_a?(Err)
+          state.done = true
+          return response
+        end
+        body = response.raw.nil? ? UNSET : response.raw
+        pg = op.pagination
+        items_field = pg ? pg["items_field"].to_s : ""
+        found = items_field.empty? ? body : Util.get_path_str(body, items_field)
+        items = found.is_a?(Array) ? found.dup : []
+        next_page = nil
+        case pg && pg["style"]
+        when "cursor"
+          usable = ->(v) { !UNSET.equal?(v) && !v.nil? && v != "" }
+          cursor = UNSET
+          if pg["response_field"].to_s != ""
+            v = Util.get_path_str(body, pg["response_field"])
+            cursor = v if usable.call(v)
+          end
+          if UNSET.equal?(cursor) && pg["cursor_item_field"].to_s != "" && !items.empty?
+            v = Util.get_path_str(items.last, pg["cursor_item_field"])
+            cursor = v if usable.call(v)
+          end
+          finished = false
+          if pg["has_more_field"].to_s != ""
+            v = Util.get_path_str(body, pg["has_more_field"])
+            finished = v == false
+          end
+          repeated = !UNSET.equal?(state.previous_cursor) && !UNSET.equal?(cursor) &&
+                     Json.canonical(state.previous_cursor) == Json.canonical(cursor)
+          if !UNSET.equal?(cursor) && !finished && !repeated
+            next_page = cursor
+            state.previous_cursor = cursor
+            set_arg(state.args, op.arg_name(pg["request_param"]), cursor)
+          end
+        when "offset"
+          offset_key = op.arg_name(pg["offset_param"])
+          limit = arg_at(state.args, op.arg_name(pg["limit_param"]))
+          offset = Util.bounded(arg_at(state.args, offset_key), 0, 0, Util::MAX_SAFE_INTEGER)
+          short = limit.is_a?(Numeric) && items.length < limit
+          if !items.empty? && !short
+            next_page = Util.as_number(offset + items.length)
+            set_arg(state.args, offset_key, next_page)
+          end
+        when "page"
+          page_key = op.arg_name(pg["page_param"])
+          size = arg_at(state.args, op.arg_name(pg["size_param"]))
+          page = Util.bounded(arg_at(state.args, page_key), 1, 0, Util::MAX_SAFE_INTEGER)
+          short = size.is_a?(Numeric) && items.length < size
+          if !items.empty? && !short
+            next_page = Util.as_number(page + 1)
+            set_arg(state.args, page_key, next_page)
+          end
+        when "link_header"
+          link = Transport.next_link(response.meta.headers["link"])
+          if link
+            target = link_target(state.override_url || @base_url, link)
+            if target
+              state.override_url = target
+              next_page = target
+            else
+              state.pending_error = Runtime.diag(op.id, "UNEXPECTED_RESPONSE").status(response.meta.status)
+                                           .request_id(response.meta.request_id)
+                                           .remedy("The next-page Link header points to another origin; it is not followed so credentials never leave the API's host. Stop paginating here.")
+                                           .attempts(response.meta.attempts).err
+            end
+          end
+        end
+        err = check_items(op, items_field, items, response)
+        if err
+          state.done = true
+          return err
+        end
+        state.done = true if next_page.nil?
+        Ok.new(value: Page.new(items: items, body: UNSET.equal?(body) ? nil : body, next_page: next_page), meta: response.meta)
+      end
+
+      def link_target(base, link)
+        origin = URI.parse(base)
+        return nil if origin.scheme.nil?
+
+        resolved = origin.merge(link)
+        same_origin?(origin, resolved) ? resolved.to_s : nil
+      rescue URI::Error
+        nil
+      end
+
+      # Page items checked with the operation's page item validator.
+      def check_items(op, items_field, items, response)
+        return nil if op.page_item.nil? || @validate_responses == "off"
+
+        items.each_with_index do |item, index|
+          issues = judge(op.page_item, item)
+          next if issues.empty?
+
+          issue = issues.first
+          path = "response"
+          path += ".#{items_field}" unless items_field.empty?
+          path += "[#{index}]"
+          issue.path.each { |seg| path += seg.is_a?(Integer) ? "[#{seg}]" : ".#{seg}" }
+          d = Runtime.diag(op.id, "UNEXPECTED_RESPONSE").status(response.meta.status).request_id(response.meta.request_id)
+                     .param(path).expected(issue.message)
+                     .remedy("A page item does not match the API description at #{path} (#{issue.message}).")
+                     .attempts(response.meta.attempts).build
+          return Err.new(error: d) if @validate_responses == "strict"
+
+          emit(d)
+          return nil
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/tungsten/runtime/schema.rb

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+# SPDX-License-Identifier: Apache-2.0
+
+module Tungsten
+  module Runtime
+    # One validation problem: the path of the offending value (member names
+    # and array indexes) and a message.
+    Issue = Data.define(:path, :message)
+
+    # The validator of the runtime schema form of the SDK descriptor
+    # document (`tungsten_emit::sdk::descriptors` specifies it): arguments
+    # before any network call, success bodies, page items and events after.
+    #
+    # Issues come structure first, then constraint violations, then unknown
+    # members. Types are strict (no coercion); string lengths count UTF-16
+    # code units. `pattern` is an ECMAScript expression run on Onigmo, Ruby's
+    # engine: `^` and `$` outside a character class are anchored to the
+    # whole string (`\A`, `\z`) as in ECMAScript without the `m` flag; other
+    # differences (Unicode property and case-folding details, `\d`, `\w` and
+    # `\s` being ASCII-only in Ruby) are Onigmo's, and a pattern Onigmo
+    # cannot compile is not checked.
+    class Schema
+      DATE = "(?:(?:[0-9][0-9][2468][048]|[0-9][0-9][13579][26]|[0-9][0-9]0[48]|[02468][048]00" \
+             "|[13579][26]00)-02-29|[0-9]{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12][0-9]|3[01])" \
+             "|(?:0[469]|11)-(?:0[1-9]|[12][0-9]|30)|(?:02)-(?:0[1-9]|1[0-9]|2[0-8])))"
+      IPV4_PART = "(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])"
+      IPV6 = ("(?:(?:H:){7}H|(?:H:){1,7}:|(?:H:){1,6}:H|(?:H:){1,5}(?::H){1,2}" \
+              "|(?:H:){1,4}(?::H){1,3}|(?:H:){1,3}(?::H){1,4}|(?:H:){1,2}(?::H){1,5}" \
+              "|H:(?:(?::H){1,6})|:(?:(?::H){1,7}|:))").gsub("H", "[0-9a-fA-F]{1,4}")
+      FORMATS = {
+        "uuid" => "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}",
+        "email" => "[^\\s@\"]{1,64}@[^\\s@]{1,255}",
+        "date-time" => "#{DATE}T(?:[01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](?:\\.[0-9]+)?(?:Z|[+-](?:[01][0-9]|2[0-3]):[0-5][0-9])",
+        "date" => DATE,
+        "ipv4" => "(?:#{IPV4_PART}\\.){3}#{IPV4_PART}",
+        "ipv6" => IPV6
+      }.transform_values { |src| Regexp.new("\\A(?:#{src})\\z") }.freeze
+
+      @patterns = {}
+      @patterns_lock = Mutex.new
+
+      class << self
+        # The compiled pattern of an ECMAScript source, or nil when Onigmo
+        # cannot compile it.
+        def pattern(source)
+          @patterns_lock.synchronize do
+            return @patterns[source] if @patterns.key?(source)
+
+            @patterns[source] = begin
+              Regexp.new(translate(source))
+            rescue RegexpError, ArgumentError
+              nil
+            end
+          end
+        end
+
+        # `^` and `$` outside a character class as `\A` and `\z`.
+        def translate(source)
+          out = +""
+          in_class = false
+          escaped = false
+          source.each_char do |c|
+            if escaped
+              out << c
+              escaped = false
+            elsif c == "\\"
+              out << c
+              escaped = true
+            elsif in_class
+              in_class = false if c == "]"
+              out << c
+            elsif c == "["
+              in_class = true
+              out << c
+            elsif c == "^"
+              out << "\\A"
+            elsif c == "$"
+              out << "\\z"
+            else
+              out << c
+            end
+          end
+          out
+        end
+      end
+
+      # A validator of `schema` (a Hash of the runtime schema form) whose
+      # `ref`s resolve in `defs`.
+      def initialize(schema, defs)
+        @schema = schema
+        @defs = defs || {}
+      end
+
+      # The issues of a value, none when it is valid.
+      def validate(value)
+        run(@schema, value)
+      end
+
+      # Whether the value is valid.
+      def accepts?(value) = validate(value).empty?
+
+      def run(schema, value)
+        # Descriptors share validators across clients. Keep each validation's
+        # issue lists on its own worker, including recursive union probes.
+        self.class.new(schema, @defs).send(:run_validation, schema, value)
+      end
+
+      # Whether `schema` admits `value`, in a fresh run (union variants).
+      def admits?(schema, value)
+        run(schema, value).empty?
+      end
+
+      private
+
+      def run_validation(schema, value)
+        @structure = []
+        @constraints = []
+        @unknown = []
+        check(schema, value, [], 0)
+        @structure + @constraints + @unknown
+      end
+
+      def bad(path, message) = @structure << Issue.new(path: path, message: message)
+      def limit(path, message) = @constraints << Issue.new(path: path, message: message)
+
+      def describe(value)
+        case value
+        when nil then "null"
+        when true, false then "a boolean"
+        when Numeric then "a number"
+        when String then "a string"
+        when Array then "an array"
+        when Hash then "an object"
+        when Binary then "binary data"
+        else "a value"
+        end
+      end
+
+      def check(schema, value, path, depth)
+        return if schema.nil?
+        return bad(path, "the value is nested too deeply") if depth > 512
+
+        case schema["kind"]
+        when nil, "any" then nil
+        when "never" then bad(path, "no value is allowed here")
+        when "nullable" then check(schema["inner"], value, path, depth + 1) unless value.nil?
+        when "ref"
+          target = @defs[schema["ref"]]
+          check(target, value, path, depth + 1) if target
+        when "string"
+          return bad(path, "expected a string, found #{describe(value)}") unless value.is_a?(String)
+
+          string_limits(schema, value, path)
+        when "bytes"
+          bad(path, "expected binary data, found #{describe(value)}") unless value.is_a?(Binary) || value.is_a?(String) || !UNSET.equal?(Json.binary_of(value))
+        when "boolean"
+          bad(path, "expected a boolean, found #{describe(value)}") unless [true, false].include?(value)
+        when "integer" then integer(schema, value, path)
+        when "number"
+          return bad(path, "expected a number, found #{describe(value)}") unless value.is_a?(Integer) || value.is_a?(Float)
+
+          number_limits(schema, value, path)
+        when "enum"
+          values = schema["values"] || []
+          bad(path, "must be one of #{Json.text(values)}") unless values.any? { |v| Json.same?(v, value) }
+        when "const"
+          values = schema["values"] || []
+          bad(path, "must be #{Json.text(values[0])}") if !values.empty? && !Json.same?(values[0], value)
+        when "array" then array(schema, value, path, depth)
+        when "map"
+          return bad(path, "expected an object, found #{describe(value)}") unless value.is_a?(Hash)
+
+          value.each { |k, v| check(schema["items"], v, path + [k], depth + 1) }
+        when "object"
+          return bad(path, "expected an object, found #{describe(value)}") unless value.is_a?(Hash)
+
+          object(schema, value, path, depth)
+        when "union" then union(schema, value, path, depth)
+        when "all" then (schema["variants"] || []).each { |m| check(m, value, path, depth + 1) }
+        when "limits"
+          case value
+          when String then string_limits(schema, value, path)
+          when Integer, Float then number_limits(schema, value, path)
+          end
+        else bad(path, "unknown schema kind #{schema['kind']}")
+        end
+      end
+
+      def integer(schema, value, path)
+        unless value.is_a?(Integer)
+          return bad(path, "expected an integer, found #{Json.js_number(value)}") if value.is_a?(Float)
+
+          return bad(path, "expected an integer, found #{describe(value)}")
+        end
+        return bad(path, "expected a 32-bit integer") if schema["bits"] == 32 && !value.between?(-(2**31), (2**31) - 1)
+
+        number_limits(schema, value, path)
+      end
+
+      def array(schema, value, path, depth)
+        return bad(path, "expected an array, found #{describe(value)}") unless value.is_a?(Array)
+
+        n = value.length
+        limit(path, "must have at least #{schema['min_items']} items") if schema["min_items"] && n < schema["min_items"]
+        if schema["max_items"] && n > schema["max_items"]
+          # Reject an oversized array before traversing or comparing its items.
+          return limit(path, "must have at most #{schema['max_items']} items")
+        end
+
+        value.each_with_index { |item, i| check(schema["items"], item, path + [i], depth + 1) }
+        return unless schema["unique"]
+
+        seen = {}
+        repeated = value.any? do |item|
+          bucket = (seen[uniqueness_hash(item)] ||= [])
+          duplicate = bucket.any? { |other| Json.same?(item, other) }
+          bucket << item unless duplicate
+          duplicate
+        end
+        limit(path, "items must be unique") if repeated
+      end
+
+      # Hash structurally equal JSON values alike, then confirm matches with
+      # same? so hash collisions never turn distinct values into duplicates.
+      # Numeric forms and Binary metadata differ from Ruby's Hash equality.
+      def uniqueness_hash(value)
+        case value
+        when Integer, Float then [:number, value.to_f].hash
+        when Binary then [:binary, value.data].hash
+        when Array then [:array, value.map { |item| uniqueness_hash(item) }].hash
+        when Hash then [:object, value.transform_values { |item| uniqueness_hash(item) }].hash
+        else [value.class, value].hash
+        end
+      end
+
+      def object(schema, value, path, depth)
+        fields = schema["fields"] || []
+        known = {}
+        fields.each do |f|
+          name = f["name"]
+          known[name] = true
+          at = path + [name]
+          if !value.key?(name)
+            bad(at, "missing required member #{name}") if f["required"]
+          elsif value[name].nil? && f["nullable"]
+            nil
+          else
+            check(f["schema"], value[name], at, depth + 1)
+          end
+        end
+        value.each do |k, v|
+          next if known[k]
+
+          if schema["extra"]
+            check(schema["extra"], v, path + [k], depth + 1)
+          elsif schema["additional"] == "closed"
+            @unknown << Issue.new(path: path + [k], message: "unknown member #{k}")
+          end
+        end
+      end
+
+      def union(schema, value, path, depth)
+        variants = schema["variants"] || []
+        if (tag = schema["tag"])
+          return bad(path, "expected an object, found #{describe(value)}") unless value.is_a?(Hash)
+
+          text = value[tag]
+          return bad(path + [tag], "missing the discriminator #{tag}") unless text.is_a?(String)
+
+          tags = schema["tags"] || []
+          index = tags.index(text)
+          return check(variants[index], value, path, depth + 1) if index && index < variants.length
+
+          return bad(path + [tag], "must be one of #{Json.text(tags)}")
+        end
+        return if variants.any? { |v| admits?(v, value) }
+
+        bad(path, "does not match any variant")
+      end
+
+      def bound_text(value)
+        value.is_a?(Float) && value == value.truncate && value.abs < Json::MAX_SAFE ? value.to_i.to_s : Json.number_text(value)
+      end
+
+      def string_limits(schema, text, path)
+        n = Json.utf16_length(text)
+        limit(path, "must have at least #{schema['min_length']} characters") if schema["min_length"] && n < schema["min_length"]
+        limit(path, "must have at most #{schema['max_length']} characters") if schema["max_length"] && n > schema["max_length"]
+        if (source = schema["pattern"]) && (re = Schema.pattern(source)) && !re.match?(text)
+          limit(path, "must match the pattern /#{source}/")
+        end
+        format = FORMATS[schema["format"]]
+        limit(path, "must be a valid #{schema['format']}") if format && !format.match?(text)
+      end
+
+      def number_limits(schema, number, path)
+        limit(path, "must be at least #{bound_text(schema['minimum'])}") if schema["minimum"] && number < schema["minimum"]
+        limit(path, "must be at most #{bound_text(schema['maximum'])}") if schema["maximum"] && number > schema["maximum"]
+        if schema["exclusive_minimum"] && number <= schema["exclusive_minimum"]
+          limit(path, "must be greater than #{bound_text(schema['exclusive_minimum'])}")
+        end
+        if schema["exclusive_maximum"] && number >= schema["exclusive_maximum"]
+          limit(path, "must be less than #{bound_text(schema['exclusive_maximum'])}")
+        end
+        step = schema["multiple_of"]
+        return unless step.is_a?(Numeric) && step != 0
+
+        q = number.to_f / step
+        return unless (q - q.round).abs > 1e-9 * [q.abs, 1].max
+
+        limit(path, "must be a multiple of #{bound_text(step)}")
+      end
+    end
+
+    # The path of an issue as .key and [index] segments.
+    def self.issue_path(path)
+      path.map { |seg| seg.is_a?(Integer) || Util.index?(seg) ? "[#{seg}]" : ".#{seg}" }.join
+    end
+  end
+end