corvus_json_schema 0.1.3 → 0.1.4

data/ext/corvus_json_schema/vendor/corvus-json-schema/src/lib.rs

@@ -18,10 +18,52 @@
 //! assert!(validator.is_valid(&json!({ "id": 3 })));
 //! assert!(!validator.is_valid(&json!({ "id": 0 })));
 //! ```
+//!
+//! # Regular expressions and their limits
+//!
+//! `pattern`, `patternProperties` and the `regex` format follow ECMA-262. Simple patterns are matched by matchers of
+//! the crate's own and by the `regex` crate, and everything else (lookarounds, backreferences, modifier groups) by
+//! the crate's own ECMA-262 engine, as each pattern is written.
+//!
+//! A schema and an instance may both come from outside, so a pattern is bounded in what it costs. One match against
+//! one string may take [`CompileOptions::pattern_match_limit`], one second unless the options say otherwise. A match
+//! that reaches it is abandoned and the validation has no answer: [`Validator::try_validate`] and the other `try_`
+//! functions return [`SchemaEvaluationError::PatternMatchLimit`]. A pattern longer than 1,048,576 bytes, nested more
+//! than 1,000 groups deep or of more than about 16,000 terms does not compile, and
+//! [`SchemaCompilationError::kind`] is then [`SchemaCompilationErrorKind::PatternTooLarge`], which is not the kind
+//! of a pattern that is not valid.
+//!
+//! ```
+//! use std::time::Duration;
+//!
+//! use corvus_json_schema::{CompileOptions, SchemaCompilationErrorKind, SchemaEvaluationError, compile, compile_with};
+//! use serde_json::json;
+//!
+//! // A group read back inside a repetition: on this string the match would run for longer than anyone waits.
+//! let options = CompileOptions { pattern_match_limit: Some(Duration::from_millis(50)), ..CompileOptions::default() };
+//! let validator = compile_with(&json!({ "pattern": r"^(?:(a+)\1*)+$" }), &options).unwrap();
+//! let instance = json!("a".repeat(60) + "b");
+//! match validator.try_validate(&instance) {
+//!     Err(SchemaEvaluationError::PatternMatchLimit(e)) => {
+//!         assert_eq!(e.pattern(), r"^(?:(a+)\1*)+$");
+//!         assert_eq!(e.limit(), Duration::from_millis(50));
+//!     }
+//!     other => panic!("{other:?}"),
+//! }
+//! // is_valid has no way to say so, and answers false.
+//! assert!(!validator.is_valid(&instance));
+//!
+//! // A pattern over a limit of size is not a pattern that is not valid.
+//! let error = compile(&json!({ "pattern": "a".repeat(20000) })).unwrap_err();
+//! assert!(matches!(error.kind(), SchemaCompilationErrorKind::PatternTooLarge(large) if large.limit() == "size"));
+//! let error = compile(&json!({ "pattern": "a**" })).unwrap_err();
+//! assert_eq!(error.kind(), &SchemaCompilationErrorKind::InvalidPattern);
+//! ```
 
 mod compiler;
 mod dialect;
 mod document;
+mod ecmaregex;
 mod eval;
 mod formats;
 mod instance;
@@ -43,7 +85,9 @@ pub use dialect::Dialect;
 pub use document::{JsonDocument, JsonDocumentArray, JsonDocumentObject, JsonDocumentValue, JsonParseError};
 pub use instance::{ArrayView, Instance, Kind, ObjectView, View};
 pub use options::{
-    CompileOptions, DocumentResolver, FormatValidator, SchemaCompilationError, SchemaEvaluationDepthError,
+    CompileOptions, DEFAULT_PATTERN_MATCH_LIMIT, DocumentResolver, FormatValidator, PatternMatchLimitError,
+    PatternTooLargeError, SchemaCompilationError, SchemaCompilationErrorKind, SchemaEvaluationDepthError,
+    SchemaEvaluationError,
 };
 pub use results::{
     Annotation, JsonSchemaResultsCollector, ResultsLevel, SchemaResult, collect_annotations, encode_pointer_segment,
@@ -53,12 +97,16 @@ pub use results::{
 /// The version of this crate.
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");
 
-/// Why JSON text could not be validated.
+/// Why JSON text could not be validated, as [`Validator::validate_json`] and [`Validator::evaluate_json`] report it.
+/// [`Validator::try_validate_json`] and [`Validator::try_evaluate_json`] report a [`SchemaEvaluationError`], which
+/// also tells a match of a regular expression that reached its limit from the maximum depth.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum JsonValidationError {
     /// The text is not valid JSON.
     InvalidJson(JsonParseError),
-    /// Evaluation recursed in place beyond the maximum depth.
+    /// The validation was abandoned at a limit: it recursed in place beyond the maximum depth, or a match of a
+    /// regular expression reached its limit. The name is from when the depth was the one limit, and the message
+    /// names both (see [`without_the_limit`] for why the two are one here).
     DepthExceeded(SchemaEvaluationDepthError),
 }
 
@@ -80,6 +128,24 @@ impl std::error::Error for JsonValidationError {
     }
 }
 
+/// What the functions whose error type was fixed before the limit of a match existed report for an evaluation that
+/// was abandoned. Their type, [`SchemaEvaluationDepthError`], has one value, so a match that reached its limit is
+/// reported as that value too: an error, and so not an answer, though not one that says which limit it was. The
+/// `try_` functions say which. This is the one place that decides it.
+fn without_the_limit(e: SchemaEvaluationError) -> SchemaEvaluationDepthError {
+    match e {
+        SchemaEvaluationError::DepthExceeded(e) => e,
+        _ => SchemaEvaluationDepthError,
+    }
+}
+
+fn json_error(e: SchemaEvaluationError) -> JsonValidationError {
+    match e {
+        SchemaEvaluationError::InvalidJson(e) => JsonValidationError::InvalidJson(e),
+        other => JsonValidationError::DepthExceeded(without_the_limit(other)),
+    }
+}
+
 /// A compiled schema. Cheap to clone and safe to share between threads.
 #[derive(Clone)]
 pub struct Validator {
@@ -101,18 +167,21 @@ pub fn compile(schema: &Value) -> Result<Validator, SchemaCompilationError> {
 /// Compiles a schema.
 pub fn compile_with(schema: &Value, options: &CompileOptions) -> Result<Validator, SchemaCompilationError> {
     let compiled = compiler::SchemaCompiler::compile(schema.clone(), options)?;
-    Ok(Validator::from_compiled(compiled, options))
+    Validator::from_compiled(compiled, options)
 }
 
 /// Compiles the schema document at `uri`, fetched through `options.resolve_document` (or one of the standard
 /// metaschemas).
 pub fn compile_from_uri(uri: &str, options: &CompileOptions) -> Result<Validator, SchemaCompilationError> {
     let compiled = compiler::SchemaCompiler::compile_from_uri(uri, options)?;
-    Ok(Validator::from_compiled(compiled, options))
+    Validator::from_compiled(compiled, options)
 }
 
 impl Validator {
-    fn from_compiled(c: compiler::CompiledSchema, options: &CompileOptions) -> Validator {
+    fn from_compiled(
+        c: compiler::CompiledSchema,
+        options: &CompileOptions,
+    ) -> Result<Validator, SchemaCompilationError> {
         let program = eval::Program::new(
             c.nodes,
             c.root,
@@ -122,68 +191,134 @@ impl Validator {
             c.documents,
             c.annotation_sources,
             options.assert_format.is_some(),
+            pattern::PatternLimit::new(options.pattern_match_limit),
         );
-        Validator { program: Arc::new(program) }
+        // Compiling matches each pattern of patternProperties against the property names the schema declares.
+        let failure = program.compile_budget.lock().unwrap_or_else(|e| e.into_inner()).take_failure();
+        if let Some(e) = failure {
+            return Err(SchemaCompilationError::of_kind(
+                e.to_string(),
+                SchemaCompilationErrorKind::PatternMatchLimit(e),
+            ));
+        }
+        Ok(Validator { program: Arc::new(program) })
     }
 
-    /// Whether the instance is valid. A schema that recursed in place beyond the maximum depth is reported as
-    /// invalid; use [`Validator::validate`] to tell the two apart.
+    /// Whether the instance is valid. It has no way to report an error, so it fails closed: it reports false both
+    /// for a schema that recursed in place beyond the maximum depth and for a match of a regular expression that
+    /// reached its limit (see [`CompileOptions::pattern_match_limit`]). A limit is never reported as valid. In
+    /// neither case is the instance known to be not valid. Use [`Validator::try_validate`] to tell them from an
+    /// instance that is not valid.
     #[inline]
     pub fn is_valid(&self, instance: &Value) -> bool {
         eval::Evaluator::new(&self.program, None).validate(instance)
     }
 
-    /// Whether the instance is valid, or an error if evaluation recursed in place beyond the maximum depth.
-    pub fn validate(&self, instance: &Value) -> Result<bool, SchemaEvaluationDepthError> {
+    /// Whether the instance is valid, or why the evaluation gave no answer: it recursed in place beyond the maximum
+    /// depth, or a match of a regular expression reached its limit.
+    pub fn try_validate(&self, instance: &Value) -> Result<bool, SchemaEvaluationError> {
+        self.try_validate_instance(instance)
+    }
+
+    /// [`Validator::try_validate`] for any [`Instance`]: a value read in place, such as a host language's own
+    /// objects, with no conversion to `serde_json::Value`.
+    pub fn try_validate_instance<'a, I: Instance<'a>>(&self, instance: I) -> Result<bool, SchemaEvaluationError> {
         let mut e = eval::Evaluator::new(&self.program, None);
         let ok = e.validate(instance);
-        if e.depth_exceeded { Err(SchemaEvaluationDepthError) } else { Ok(ok) }
+        e.outcome(ok)
+    }
+
+    /// Whether the JSON text is valid, or why there is no answer. The text is parsed into the thread's reused
+    /// buffers and evaluated in place: in the steady state nothing is allocated. Use [`JsonDocument`] to validate
+    /// the same text more than once.
+    pub fn try_validate_json(&self, json: &str) -> Result<bool, SchemaEvaluationError> {
+        JsonDocument::with_document(json, |d| self.try_validate_instance(d.root()))
+            .map_err(SchemaEvaluationError::InvalidJson)?
+    }
+
+    /// Evaluates the instance exhaustively, reporting to the collector. Returns whether it is valid, or why the
+    /// evaluation gave no answer. With an error the collector's results are not complete.
+    pub fn try_evaluate(
+        &self,
+        instance: &Value,
+        collector: &mut JsonSchemaResultsCollector,
+    ) -> Result<bool, SchemaEvaluationError> {
+        self.try_evaluate_instance(instance, collector)
+    }
+
+    /// [`Validator::try_evaluate`] for any [`Instance`].
+    pub fn try_evaluate_instance<'a, I: Instance<'a>>(
+        &self,
+        instance: I,
+        collector: &mut JsonSchemaResultsCollector,
+    ) -> Result<bool, SchemaEvaluationError> {
+        let mut e = eval::Evaluator::new(&self.program, Some(collector));
+        let ok = e.evaluate(instance);
+        e.outcome(ok)
     }
 
-    /// Evaluates the instance exhaustively, reporting to the collector. Returns whether it is valid.
+    /// [`Validator::try_evaluate`] for JSON text, parsed as [`Validator::try_validate_json`] parses it.
+    pub fn try_evaluate_json(
+        &self,
+        json: &str,
+        collector: &mut JsonSchemaResultsCollector,
+    ) -> Result<bool, SchemaEvaluationError> {
+        JsonDocument::with_document(json, |d| self.try_evaluate_instance(d.root(), collector))
+            .map_err(SchemaEvaluationError::InvalidJson)?
+    }
+
+    /// Whether the instance is valid, or an error if the validation was abandoned at a limit. The error type has
+    /// one value, whose message names both limits, so it does not say whether the evaluation recursed in place
+    /// beyond the maximum depth or a match of a regular expression reached its limit: [`Validator::try_validate`]
+    /// does.
+    pub fn validate(&self, instance: &Value) -> Result<bool, SchemaEvaluationDepthError> {
+        self.try_validate(instance).map_err(without_the_limit)
+    }
+
+    /// Evaluates the instance exhaustively, reporting to the collector. Returns whether it is valid. The error is
+    /// that of [`Validator::validate`], for a validation abandoned at either limit: [`Validator::try_evaluate`]
+    /// says which.
     pub fn evaluate(
         &self,
         instance: &Value,
         collector: &mut JsonSchemaResultsCollector,
     ) -> Result<bool, SchemaEvaluationDepthError> {
-        self.evaluate_instance(instance, collector)
+        self.try_evaluate(instance, collector).map_err(without_the_limit)
     }
 
     /// [`Validator::validate`] for any [`Instance`]: a value read in place, such as a host language's own objects,
-    /// with no conversion to `serde_json::Value`.
+    /// with no conversion to `serde_json::Value`. The error is that of [`Validator::validate`], for a validation
+    /// abandoned at either limit: [`Validator::try_validate_instance`] says which.
     pub fn validate_instance<'a, I: Instance<'a>>(&self, instance: I) -> Result<bool, SchemaEvaluationDepthError> {
-        let mut e = eval::Evaluator::new(&self.program, None);
-        let ok = e.validate(instance);
-        if e.depth_exceeded { Err(SchemaEvaluationDepthError) } else { Ok(ok) }
+        self.try_validate_instance(instance).map_err(without_the_limit)
     }
 
     /// Whether the JSON text is valid. The text is parsed into the thread's reused buffers and evaluated in place: in
-    /// the steady state nothing is allocated. Use [`JsonDocument`] to validate the same text more than once.
+    /// the steady state nothing is allocated. Use [`JsonDocument`] to validate the same text more than once. An
+    /// evaluation that was abandoned is reported as [`JsonValidationError::DepthExceeded`], whichever limit it
+    /// reached: [`Validator::try_validate_json`] says which.
     pub fn validate_json(&self, json: &str) -> Result<bool, JsonValidationError> {
-        JsonDocument::with_document(json, |d| self.validate_instance(d.root()))
-            .map_err(JsonValidationError::InvalidJson)?
-            .map_err(JsonValidationError::DepthExceeded)
+        self.try_validate_json(json).map_err(json_error)
     }
 
-    /// [`Validator::evaluate`] for JSON text, parsed as [`Validator::validate_json`] parses it.
+    /// [`Validator::evaluate`] for JSON text, parsed as [`Validator::validate_json`] parses it. An evaluation that
+    /// was abandoned is [`JsonValidationError::DepthExceeded`], whichever limit it reached:
+    /// [`Validator::try_evaluate_json`] says which.
     pub fn evaluate_json(
         &self,
         json: &str,
         collector: &mut JsonSchemaResultsCollector,
     ) -> Result<bool, JsonValidationError> {
-        JsonDocument::with_document(json, |d| self.evaluate_instance(d.root(), collector))
-            .map_err(JsonValidationError::InvalidJson)?
-            .map_err(JsonValidationError::DepthExceeded)
+        self.try_evaluate_json(json, collector).map_err(json_error)
     }
 
-    /// [`Validator::evaluate`] for any [`Instance`].
+    /// [`Validator::evaluate`] for any [`Instance`]. The error is that of [`Validator::validate`], for a validation
+    /// abandoned at either limit: [`Validator::try_evaluate_instance`] says which.
     pub fn evaluate_instance<'a, I: Instance<'a>>(
         &self,
         instance: I,
         collector: &mut JsonSchemaResultsCollector,
     ) -> Result<bool, SchemaEvaluationDepthError> {
-        let mut e = eval::Evaluator::new(&self.program, Some(collector));
-        let ok = e.evaluate(instance);
-        if e.depth_exceeded { Err(SchemaEvaluationDepthError) } else { Ok(ok) }
+        self.try_evaluate_instance(instance, collector).map_err(without_the_limit)
     }
 }

data/ext/corvus_json_schema/vendor/corvus-json-schema/src/loader.rs

@@ -231,11 +231,11 @@ impl<'o> SchemaLoader<'o> {
         if self.documents_by_uri.contains_key(absolute_uri) {
             return Ok(true);
         }
-        if let Some(resolver) = &self.options.resolve_document {
-            if let Some(doc) = resolver(absolute_uri) {
-                self.add_document(absolute_uri.to_string(), doc)?;
-                return Ok(true);
-            }
+        if let Some(resolver) = &self.options.resolve_document
+            && let Some(doc) = resolver(absolute_uri)
+        {
+            self.add_document(absolute_uri.to_string(), doc)?;
+            return Ok(true);
         }
         if let Some(text) = metaschema(absolute_uri) {
             let doc: Value = serde_json::from_str(text).expect("embedded metaschemas are valid JSON");
@@ -304,10 +304,8 @@ impl<'o> SchemaLoader<'o> {
             let r = &self.resources[resource as usize];
             (r.dialect, r.vocabularies)
         };
-        if !is_resource_root {
-            if let Some(Value::String(s)) = map.get("$schema") {
-                (dialect, vocabularies) = self.get_dialect_info(s)?;
-            }
+        if !is_resource_root && let Some(Value::String(s)) = map.get("$schema") {
+            (dialect, vocabularies) = self.get_dialect_info(s)?;
         }
 
         let legacy_ref_overrides_siblings = dialect.is_legacy() && matches!(map.get("$ref"), Some(Value::String(_)));
@@ -335,19 +333,19 @@ impl<'o> SchemaLoader<'o> {
                     }
                 }
             }
-            if dialect >= Dialect::Draft201909 {
-                if let Some(Value::String(a)) = map.get("$anchor") {
-                    self.add_anchor(resource, a, &pointer);
-                }
+            if dialect >= Dialect::Draft201909
+                && let Some(Value::String(a)) = map.get("$anchor")
+            {
+                self.add_anchor(resource, a, &pointer);
             }
-            if dialect >= Dialect::Draft202012 {
-                if let Some(Value::String(name)) = map.get("$dynamicAnchor") {
-                    self.resources[resource as usize]
-                        .dynamic_anchors
-                        .entry(name.clone())
-                        .or_insert_with(|| pointer.clone());
-                    self.add_anchor(resource, name, &pointer);
-                }
+            if dialect >= Dialect::Draft202012
+                && let Some(Value::String(name)) = map.get("$dynamicAnchor")
+            {
+                self.resources[resource as usize]
+                    .dynamic_anchors
+                    .entry(name.clone())
+                    .or_insert_with(|| pointer.clone());
+                self.add_anchor(resource, name, &pointer);
             }
             if dialect == Dialect::Draft201909
                 && is_resource_root

data/ext/corvus_json_schema/vendor/corvus-json-schema/src/numbers.rs

@@ -140,7 +140,7 @@ fn divides_scaled(m: u128, shift: u32, d: u128) -> bool {
     let mut rest = d / gcd(m, d);
     for f in [2u128, 5] {
         let mut count = 0u32;
-        while rest % f == 0 {
+        while rest.is_multiple_of(f) {
             rest /= f;
             count += 1;
         }

data/ext/corvus_json_schema/vendor/corvus-json-schema/src/options.rs

@@ -3,6 +3,7 @@
 use std::collections::HashMap;
 use std::fmt;
 use std::sync::Arc;
+use std::time::Duration;
 
 use serde_json::Value;
 
@@ -36,8 +37,23 @@ pub struct CompileOptions {
     pub entry_point: Option<String>,
     /// Maximum depth of in-place recursion on a cycle before evaluation is abandoned. Defaults to 128.
     pub max_depth: u32,
+    /// The time one match of a `pattern` or `patternProperties` regular expression against one string may take.
+    /// Defaults to [`DEFAULT_PATTERN_MATCH_LIMIT`], one second. A match that takes longer is abandoned, and the
+    /// validation it belongs to reports a [`PatternMatchLimitError`]. `None`, or a limit of zero, turns the limit
+    /// off, for a caller who trusts both the schema and the instances. Without the limit a match also has no limit
+    /// on its memory.
+    ///
+    /// The limit is on each match, not on the validation. Only the backtracking matcher can take long, and it
+    /// reads the clock every 4,096 steps, so a match is abandoned within tens of microseconds of the limit. The
+    /// matchers that take time proportional to the string are not stopped: a string is given to one only when it
+    /// can answer within the limit.
+    pub pattern_match_limit: Option<Duration>,
 }
 
+/// The time one match of a `pattern` or `patternProperties` regular expression against one string may take, unless
+/// [`CompileOptions::pattern_match_limit`] says otherwise.
+pub const DEFAULT_PATTERN_MATCH_LIMIT: Duration = Duration::from_secs(1);
+
 impl Default for CompileOptions {
     fn default() -> Self {
         CompileOptions {
@@ -50,6 +66,7 @@ impl Default for CompileOptions {
             base_uri: None,
             entry_point: None,
             max_depth: 128,
+            pattern_match_limit: Some(DEFAULT_PATTERN_MATCH_LIMIT),
         }
     }
 }
@@ -66,25 +83,53 @@ impl fmt::Debug for CompileOptions {
             .field("base_uri", &self.base_uri)
             .field("entry_point", &self.entry_point)
             .field("max_depth", &self.max_depth)
+            .field("pattern_match_limit", &self.pattern_match_limit)
             .finish()
     }
 }
 
-/// A schema could not be compiled (an unresolvable reference, an invalid pattern).
+/// A schema could not be compiled (an unresolvable reference, an invalid pattern, a pattern over a limit of size).
+/// [`SchemaCompilationError::kind`] tells the errors of a regular expression apart.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct SchemaCompilationError {
     message: String,
+    kind: SchemaCompilationErrorKind,
+}
+
+/// What kind of error a [`SchemaCompilationError`] is.
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum SchemaCompilationErrorKind {
+    /// Any error that is not about a regular expression: an unresolvable reference, for one.
+    Other,
+    /// A `pattern`, or a key of `patternProperties`, is not a valid ECMA-262 regular expression.
+    InvalidPattern,
+    /// A regular expression is over a limit of size. It is not the error of one that is not valid: the pattern was
+    /// not read to its end, so nothing is known of whether it is valid.
+    PatternTooLarge(PatternTooLargeError),
+    /// Matching a regular expression against a property name the schema declares, which is done once when the
+    /// schema is compiled, reached the limit of a match (see [`CompileOptions::pattern_match_limit`]).
+    PatternMatchLimit(PatternMatchLimitError),
 }
 
 impl SchemaCompilationError {
     pub(crate) fn new(message: impl Into<String>) -> Self {
-        SchemaCompilationError { message: message.into() }
+        SchemaCompilationError { message: message.into(), kind: SchemaCompilationErrorKind::Other }
+    }
+
+    pub(crate) fn of_kind(message: impl Into<String>, kind: SchemaCompilationErrorKind) -> Self {
+        SchemaCompilationError { message: message.into(), kind }
     }
 
     /// The reason compilation failed.
     pub fn message(&self) -> &str {
         &self.message
     }
+
+    /// The kind of error, which tells a regular expression that is too large from one that is not valid.
+    pub fn kind(&self) -> &SchemaCompilationErrorKind {
+        &self.kind
+    }
 }
 
 impl fmt::Display for SchemaCompilationError {
@@ -95,14 +140,164 @@ impl fmt::Display for SchemaCompilationError {
 
 impl std::error::Error for SchemaCompilationError {}
 
-/// Evaluation recursed in place beyond `max_depth` (a schema that loops without consuming the instance).
+/// A regular expression of a schema is over a limit of size, so the schema was not compiled.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct PatternTooLargeError {
+    pattern: String,
+    keyword: &'static str,
+    limit: &'static str,
+    value: usize,
+    reason: String,
+}
+
+impl PatternTooLargeError {
+    pub(crate) fn new(pattern: &str, keyword: &'static str, limit: &'static str, value: usize, reason: String) -> Self {
+        PatternTooLargeError { pattern: pattern.to_string(), keyword, limit, value, reason }
+    }
+
+    /// The regular expression.
+    pub fn pattern(&self) -> &str {
+        &self.pattern
+    }
+
+    /// The keyword that holds it, `pattern` or `patternProperties`.
+    pub fn keyword(&self) -> &str {
+        self.keyword
+    }
+
+    /// The name of the limit: `length` (the bytes of the pattern, 1,048,576 at most), `nesting` (the depth of its
+    /// groups, 1,000 at most) or `size` (the bytes counted for it as it is read, 1,048,576 at most).
+    pub fn limit(&self) -> &str {
+        self.limit
+    }
+
+    /// The value of that limit.
+    pub fn value(&self) -> usize {
+        self.value
+    }
+}
+
+impl fmt::Display for PatternTooLargeError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "The regular expression {} in {} is too large to read as an ECMA-262 regular expression: {}.",
+            crate::pattern::shown_pattern(&self.pattern),
+            self.keyword,
+            self.reason
+        )
+    }
+}
+
+impl std::error::Error for PatternTooLargeError {}
+
+/// A validation was abandoned because one match of a `pattern` or `patternProperties` regular expression reached
+/// its limit. The instance is then neither valid nor not valid.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct PatternMatchLimitError {
+    pattern: String,
+    limit: Duration,
+    memory: bool,
+}
+
+impl PatternMatchLimitError {
+    pub(crate) fn new(pattern: &str, limit: Duration, memory: bool) -> Self {
+        PatternMatchLimitError { pattern: pattern.to_string(), limit, memory }
+    }
+
+    /// The regular expression.
+    pub fn pattern(&self) -> &str {
+        &self.pattern
+    }
+
+    /// The time the match was allowed (see [`CompileOptions::pattern_match_limit`]).
+    pub fn limit(&self) -> Duration {
+        self.limit
+    }
+
+    /// Whether the match was abandoned for the memory of its backtracking, not for its time: it held 1,048,576
+    /// choices, which is 24 MB.
+    pub fn is_memory(&self) -> bool {
+        self.memory
+    }
+}
+
+impl fmt::Display for PatternMatchLimitError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let pattern = crate::pattern::shown_pattern(&self.pattern);
+        if self.memory {
+            write!(
+                f,
+                "A match of the regular expression {pattern} was abandoned: it needed more than the limit of \
+                 1,048,576 backtracking entries."
+            )
+        } else {
+            write!(
+                f,
+                "A match of the regular expression {pattern} was abandoned: it took longer than the limit of {:?}.",
+                self.limit
+            )
+        }
+    }
+}
+
+impl std::error::Error for PatternMatchLimitError {}
+
+/// The validation was abandoned at a limit, and gave no answer. It is the error of the functions whose error type
+/// was there before the limit of a match was (`validate`, `validate_instance`, `evaluate`, `evaluate_instance`, and
+/// inside [`crate::JsonValidationError::DepthExceeded`] `validate_json` and `evaluate_json`).
+///
+/// The name is from when there was one limit: an evaluation that recursed in place beyond `max_depth` (a schema
+/// that loops without consuming the instance). A match of a regular expression that reached its limit (see
+/// [`CompileOptions::pattern_match_limit`]) is reported as this error too. The type has one value, so it does not
+/// say which limit it was, and its message names both. The `try_` functions (`Validator::try_validate` and the
+/// rest) return a [`SchemaEvaluationError`], which says which.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct SchemaEvaluationDepthError;
 
 impl fmt::Display for SchemaEvaluationDepthError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("The schema recursed in place beyond the maximum depth.")
+        f.write_str(
+            "The validation was abandoned at a limit: the schema recursed in place beyond the maximum depth, or a \
+             match of a regular expression reached its limit. The try_ functions say which.",
+        )
     }
 }
 
 impl std::error::Error for SchemaEvaluationDepthError {}
+
+/// Why an evaluation gave no answer. The instance is then neither valid nor not valid.
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum SchemaEvaluationError {
+    /// The text is not valid JSON (the functions that take JSON text).
+    InvalidJson(crate::JsonParseError),
+    /// Evaluation recursed in place beyond the maximum depth.
+    DepthExceeded(SchemaEvaluationDepthError),
+    /// A match of a regular expression reached its limit.
+    PatternMatchLimit(PatternMatchLimitError),
+}
+
+impl fmt::Display for SchemaEvaluationError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            SchemaEvaluationError::InvalidJson(e) => write!(f, "invalid JSON: {e}"),
+            // Not the message of the value inside, which is the one error of the functions that cannot say which
+            // limit it was, and so names both.
+            SchemaEvaluationError::DepthExceeded(_) => {
+                f.write_str("The schema recursed in place beyond the maximum depth.")
+            }
+            SchemaEvaluationError::PatternMatchLimit(e) => e.fmt(f),
+        }
+    }
+}
+
+impl std::error::Error for SchemaEvaluationError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            SchemaEvaluationError::InvalidJson(e) => Some(e),
+            SchemaEvaluationError::DepthExceeded(e) => Some(e),
+            SchemaEvaluationError::PatternMatchLimit(e) => Some(e),
+        }
+    }
+}