corvus_json_schema 0.1.3 → 0.2.0

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

@@ -1,4 +1,6 @@
-//! `pattern`/`patternProperties` matching with ECMA-262 semantics (the `u` flag), as JSON Schema specifies.
+//! `pattern`/`patternProperties` matching with ECMA-262 semantics (the `u` flag), as JSON Schema specifies. A
+//! pattern that is valid only without the flag is accepted too, and matched as ECMA-262 says for it: by UTF-16
+//! code unit.
 //!
 //! A pattern gets the cheapest matcher that decides it exactly:
 //!
@@ -6,24 +8,78 @@
 //! - anchored sequences of quantified ASCII character classes and literals (`^[a-z][a-z0-9_]{0,29}$`, `^x-`,
 //!   `^[@$_#]`), matched in one pass over the string (the TypeScript evaluator's class-sequence fast path);
 //! - alternatives of such sequences once groups are multiplied out (`^([a|A]uto)|([n|N]one)$`,
-//!   `^[Ee][Ss]2015(\.([Cc]ore|[Pp]roxy))?$`), sets of literals, and separated lists (`^([a-z]+)(\.[a-z]+)*$`),
-//!   as the C# evaluator's pattern matchers do;
-//! - patterns within the common subset of ECMA-262 and the `regex` crate's syntax, translated with ECMA semantics
-//!   (`\d`/`\w` ASCII-only, ECMA's `\s` and `.`) and run by `regex`, which searches in linear time without
-//!   allocating per match;
-//! - anything else (lookarounds, backreferences, word boundaries, Unicode properties) by `regress`, a backtracking
-//!   ECMA-262 engine.
+//!   `^[Ee][Ss]2015(\.([Cc]ore|[Pp]roxy))?$`) and sets of literals, as the C# evaluator's pattern matchers do,
+//!   where they were measured faster than the engine (see [`MOST_LITERALS`]);
+//! - anything else by [Corvus.Regex.Ecma262](https://docs.rs/corvus-regex-ecma262), an ECMA-262 engine that answers
+//!   every pattern as V8 does, as the pattern is written, and matches a pattern with no backreference in time
+//!   proportional to the pattern's size times the string.
 //!
-//! Patterns compile once per process (a pattern is immutable, so identical patterns share one matcher).
+//! Whether a pattern is valid is the engine's answer, whichever matcher runs it, in the grammar of the edition the
+//! dialect reads patterns with (ECMAScript 2020 for draft 2019-09 and draft 2020-12, today's for the others; see
+//! [`Grammar`]), and so are the limits of size: a pattern over one is refused before any matcher reads it.
+//!
+//! Patterns compile once per process for each grammar (a pattern is immutable, so identical patterns share one
+//! matcher).
 
-use std::collections::HashMap;
+use std::collections::{HashMap, VecDeque};
 use std::fmt;
 use std::sync::{Arc, LazyLock, Mutex};
+use std::time::Duration;
+
+use corvus_regex_ecma262::{Edition, Flags, MatchError, Regex, RegexBuilder, UnicodeVersion};
+
+use crate::dialect::Dialect;
+use crate::options::{
+    CompileOptions, PatternMatchLimitError, PatternTooLargeError, SchemaCompilationError, SchemaCompilationErrorKind,
+};
+
+/// The grammar a pattern is read in: the edition of ECMA-262 and the version of Unicode.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub(crate) struct Grammar {
+    pub edition: Edition,
+    pub unicode_version: UnicodeVersion,
+}
+
+impl Grammar {
+    /// The grammar of a dialect's patterns: the edition the options give, or by default ECMAScript 2020 for draft
+    /// 2019-09 and draft 2020-12, which cite it, and today's for the earlier drafts; and the options' version of
+    /// Unicode.
+    pub(crate) fn of(dialect: Dialect, options: &CompileOptions) -> Grammar {
+        let edition = options.regex_edition.unwrap_or(if dialect >= Dialect::Draft201909 {
+            Edition::Es2020
+        } else {
+            Edition::Current
+        });
+        Grammar { edition, unicode_version: options.regex_unicode_version }
+    }
+
+    /// The flags of the grammar of the `u` flag, or of no flag.
+    fn flags(unicode: bool) -> Flags {
+        Flags { unicode, ..Flags::default() }
+    }
+
+    /// The pattern compiled in this grammar, with the `u` flag or with none.
+    fn build(self, pattern: &str, unicode: bool) -> Result<Regex, corvus_regex_ecma262::Error> {
+        RegexBuilder::new(pattern)
+            .with_flags(Grammar::flags(unicode))
+            .edition(self.edition)
+            .unicode_version(self.unicode_version)
+            .build()
+    }
+
+    /// Whether the pattern is valid in this grammar with the `u` flag.
+    fn is_valid_unicode(self, pattern: &str) -> bool {
+        Regex::is_valid_with(pattern, Grammar::flags(true), self.edition, self.unicode_version)
+    }
+}
 
 /// A compiled `pattern`.
 pub(crate) struct Pattern {
     pub source: String,
+    grammar: Grammar,
     matcher: Matcher,
+    /// What the pattern is counted as in the cache of compiled patterns, in bytes (see [`Cache`]).
+    retained: usize,
 }
 
 enum Matcher {
@@ -35,7 +91,6 @@ enum Matcher {
         whole: bool,
     },
     Sequence(Sequence),
-    SeparatedList(SeparatedList),
     /// `.+` (`^.+` with `start`): some (the first) character is not a line terminator.
     HasContent {
         start: bool,
@@ -55,12 +110,9 @@ enum Matcher {
         set: CharSet,
         bangs: bool,
     },
-    Regex(regex::Regex),
-    /// A pattern that is valid only without the `u` flag (an identity escape such as `\&`), so matching UTF-16 code
-    /// units: translated for `regex`, which decides it exactly on strings with no character beyond the Basic
-    /// Multilingual Plane (where code units are characters); regress decides the rest.
-    RegexBmp(regex::Regex, regress::Regex),
-    Regress(regress::Regex),
+    /// The `corvus-regex-ecma262` engine: by character for a pattern with the `u` flag, and by UTF-16 code unit for
+    /// one that is valid only without it.
+    Engine(Box<Regex>),
 }
 
 impl fmt::Debug for Pattern {
@@ -69,9 +121,71 @@ impl fmt::Debug for Pattern {
     }
 }
 
+/// The limit of a match, as a validator holds it.
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct PatternLimit {
+    /// The time one match may take, or `None` for no limit.
+    limit: Option<Duration>,
+}
+
+impl PatternLimit {
+    /// A limit of `limit` for each match. `None` and zero are no limit.
+    pub(crate) fn new(limit: Option<Duration>) -> PatternLimit {
+        PatternLimit { limit: limit.filter(|l| !l.is_zero()) }
+    }
+}
+
+/// What one evaluation, or the compilation of one schema, gives every match of a pattern: the time each may take.
+/// It notes the first match that reached a limit, after which every match is abandoned at once.
+pub(crate) struct PatternBudget {
+    limit: PatternLimit,
+    /// The match that reached a limit. It is boxed so that an evaluation, which holds a budget, stays small.
+    failure: Option<Box<PatternMatchLimitError>>,
+}
+
+impl PatternBudget {
+    #[inline(always)]
+    pub(crate) fn new(limit: PatternLimit) -> PatternBudget {
+        PatternBudget { limit, failure: None }
+    }
+
+    /// Whether a match has reached a limit, so that what the evaluation came to is not an answer.
+    #[inline(always)]
+    pub(crate) fn failed(&self) -> bool {
+        self.failure.is_some()
+    }
+
+    /// The error of the match that reached a limit, if one did.
+    pub(crate) fn take_failure(&mut self) -> Option<PatternMatchLimitError> {
+        self.failure.take().map(|e| *e)
+    }
+
+    /// Matches the string on the engine within the budget. When a limit is reached the answer is false, and it is
+    /// not an answer: the caller of the evaluation gets the error.
+    fn engine_match(&mut self, engine: &Regex, source: &str, s: &str) -> bool {
+        if self.failure.is_some() {
+            return false;
+        }
+        let result = match self.limit.limit {
+            Some(limit) => engine.is_match_within(s, limit),
+            None => engine.is_match(s),
+        };
+        result.unwrap_or_else(|e| {
+            self.failure = Some(Box::new(PatternMatchLimitError::new(
+                source,
+                self.limit.limit.unwrap_or_default(),
+                e == MatchError::Memory,
+            )));
+            false
+        })
+    }
+}
+
 impl Pattern {
+    /// Whether the pattern matches somewhere in the string. The engine matches within the budget. Every other
+    /// matcher reads the string once, or a bounded number of times, and has no limit.
     #[inline]
-    pub fn is_match(&self, s: &str) -> bool {
+    pub fn is_match(&self, s: &str, budget: &mut PatternBudget) -> bool {
         match &self.matcher {
             Matcher::Everything => true,
             Matcher::Literal { text, whole } => {
@@ -82,7 +196,6 @@ impl Pattern {
                 }
             }
             Matcher::Sequence(seq) => seq.is_match(s),
-            Matcher::SeparatedList(list) => list.is_match(s),
             Matcher::HasContent { start } => {
                 if *start {
                     s.chars().next().is_some_and(|c| !is_line_terminator(c))
@@ -115,20 +228,28 @@ impl Pattern {
                 }
                 word
             }
-            Matcher::Regex(re) => re.is_match(s),
-            // A UTF-8 lead byte of 0xF0 or above starts a character beyond the BMP.
-            Matcher::RegexBmp(re, fallback) => {
-                if s.bytes().any(|b| b >= 0xF0) {
-                    fallback.find(s).is_some()
-                } else {
-                    re.is_match(s)
-                }
-            }
-            Matcher::Regress(re) => re.find(s).is_some(),
+            Matcher::Engine(engine) => budget.engine_match(engine, &self.source, s),
         }
     }
 }
 
+/// The kind of matcher a pattern has, for the tables of which pattern goes where.
+#[cfg(test)]
+pub(crate) fn kind(p: &Pattern) -> &'static str {
+    match &p.matcher {
+        Matcher::Engine(engine) if engine.flags().unicode => "engine",
+        Matcher::Engine(_) => "engine-units",
+        Matcher::Everything => "everything",
+        Matcher::Literal { .. } => "literal",
+        Matcher::Sequence(_) => "sequence",
+        Matcher::HasContent { .. } => "has-content",
+        Matcher::Line { .. } => "line",
+        Matcher::Literals(_) => "literals",
+        Matcher::Alternatives(_) => "alternatives",
+        Matcher::ExcludedClassWithWord { .. } => "excluded-class",
+    }
+}
+
 /// ECMA-262 `LineTerminator`, which `.` does not match.
 #[inline]
 fn is_line_terminator(c: char) -> bool {
@@ -151,30 +272,34 @@ fn line_length(s: &str) -> Option<usize> {
     Some(n)
 }
 
-/// A set of strings: compared in turn when there are few, hashed otherwise.
-enum Literals {
-    Few(Box<[Box<str>]>),
-    Many(std::collections::HashSet<Box<str>>),
-}
+/// A set of at most [`MOST_LITERALS`] strings, compared in turn.
+struct Literals(Box<[Box<str>]>);
 
 impl Literals {
     fn new(texts: Vec<String>) -> Literals {
-        if texts.len() <= 8 {
-            Literals::Few(texts.into_iter().map(String::into_boxed_str).collect())
-        } else {
-            Literals::Many(texts.into_iter().map(String::into_boxed_str).collect())
-        }
+        Literals(texts.into_iter().map(String::into_boxed_str).collect())
     }
 
     #[inline]
     fn contains(&self, s: &str) -> bool {
-        match self {
-            Literals::Few(texts) => texts.iter().any(|t| **t == *s),
-            Literals::Many(set) => set.contains(s),
-        }
+        self.0.iter().any(|t| **t == *s)
     }
 }
 
+// What the dedicated matchers are kept for: each was timed against the engine, pattern by pattern, over the strings of
+// the jsonschema-benchmark corpora (`corpus_patterns::time_corpus_patterns`), and a form is kept only where its matcher
+// was the faster. Four literals compared in turn took 0.78 of the engine's time, and ten 3.2 times it. Two alternatives
+// of which neither is anchored at both ends (`^([a|A]uto)|([n|N]one)$`) took 0.21 of it, since the engine searches for
+// the unanchored one; three such took 1.4 to 1.6 times it, and every alternative anchored at both ends was faster on
+// the engine (by 1.1 to 2.7 times), which reads the whole string once whatever the alternatives. A separated list was
+// no faster than the engine (the same total time over the seven in the corpora), so it has no matcher of its own.
+
+/// The most literals of [`Matcher::Literals`].
+const MOST_LITERALS: usize = 4;
+
+/// The most alternatives of [`Matcher::Alternatives`].
+const MOST_ALTERNATIVES: usize = 2;
+
 /// One alternative of [`Matcher::Alternatives`]: a literal anchored at either end (or neither), a class sequence
 /// anchored at the start, or a fixed-width class sequence anchored at the end.
 enum Alternative {
@@ -237,43 +362,150 @@ impl Alternative {
     }
 }
 
-/// Compiles a pattern with the `u` flag, or (as many validators accept them) without it; the flag is returned.
-fn compile_regress(pattern: &str) -> Option<(regress::Regex, bool)> {
-    match regress::Regex::with_flags(pattern, "u") {
-        Ok(re) => Some((re, true)),
-        Err(_) => regress::Regex::new(pattern).ok().map(|re| (re, false)),
+/// The most patterns the process-wide cache holds.
+const MAX_CACHED_PATTERNS: usize = 1024;
+
+/// The most the patterns of the cache come to, in the bytes counted for each: 64 MiB. A pattern is counted as its
+/// source and an estimate of what its matcher holds (see [`compile`]).
+const MAX_CACHED_BYTES: usize = 64 << 20;
+
+/// A pattern counted as more than this is compiled for the schema that has it and not kept in the cache.
+const MAX_CACHED_PATTERN_BYTES: usize = MAX_CACHED_BYTES / 32;
+
+/// The compiled patterns of the process, so that identical patterns share one matcher. It is bounded in number and
+/// in size, since the patterns of a schema may come from outside: when it is over either bound the patterns that
+/// were compiled first go, oldest first. A validator holds the patterns of its schema itself, so a pattern that has
+/// left the cache is still matched by the validators that have it, and is compiled again only for a schema compiled
+/// later.
+#[derive(Default)]
+struct Cache {
+    patterns: HashMap<(Arc<str>, Grammar), Arc<Pattern>>,
+    /// The sources and their grammars in the order they were compiled.
+    order: VecDeque<(Arc<str>, Grammar)>,
+    /// The sum of what the patterns are counted as.
+    bytes: usize,
+}
+
+impl Cache {
+    fn get(&self, source: &str, grammar: Grammar) -> Option<Arc<Pattern>> {
+        self.patterns.get(&(Arc::from(source), grammar)).cloned()
+    }
+
+    /// Keeps a pattern, and returns the one to use: the pattern itself, or the one another thread kept for the same
+    /// source meanwhile.
+    fn insert(&mut self, pattern: Arc<Pattern>) -> Arc<Pattern> {
+        if pattern.retained > MAX_CACHED_PATTERN_BYTES {
+            return pattern;
+        }
+        let key: (Arc<str>, Grammar) = (Arc::from(pattern.source.as_str()), pattern.grammar);
+        if let Some(kept) = self.patterns.get(&key) {
+            return kept.clone();
+        }
+        self.bytes += pattern.retained;
+        self.patterns.insert(key.clone(), pattern.clone());
+        self.order.push_back(key);
+        while self.patterns.len() > MAX_CACHED_PATTERNS || self.bytes > MAX_CACHED_BYTES {
+            let Some(oldest) = self.order.pop_front() else { break };
+            if let Some(evicted) = self.patterns.remove(&oldest) {
+                self.bytes -= evicted.retained;
+            }
+        }
+        pattern
+    }
+}
+
+static CACHE: LazyLock<Mutex<Cache>> = LazyLock::new(|| Mutex::new(Cache::default()));
+
+fn cache() -> std::sync::MutexGuard<'static, Cache> {
+    CACHE.lock().unwrap_or_else(|e| e.into_inner())
+}
+
+/// Why a pattern does not compile.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum PatternError {
+    /// It is not a valid ECMA-262 regular expression.
+    Invalid,
+    /// It is over a limit of size. It was not read to its end, so nothing is known of whether it is valid.
+    TooLarge(corvus_regex_ecma262::TooLargeError),
+}
+
+impl PatternError {
+    /// The error of a schema whose keyword `keyword` holds the pattern `pattern`.
+    pub(crate) fn of(self, pattern: &str, keyword: &'static str) -> SchemaCompilationError {
+        match self {
+            PatternError::Invalid => SchemaCompilationError::of_kind(
+                format!("Invalid regular expression '{pattern}' in {keyword}."),
+                SchemaCompilationErrorKind::InvalidPattern,
+            ),
+            PatternError::TooLarge(large) => {
+                let error =
+                    PatternTooLargeError::new(pattern, keyword, large.limit.name(), large.value, large.to_string());
+                SchemaCompilationError::of_kind(error.to_string(), SchemaCompilationErrorKind::PatternTooLarge(error))
+            }
+        }
     }
 }
 
-static CACHE: LazyLock<Mutex<HashMap<String, Arc<Pattern>>>> = LazyLock::new(|| Mutex::new(HashMap::new()));
+impl From<corvus_regex_ecma262::Error> for PatternError {
+    fn from(e: corvus_regex_ecma262::Error) -> PatternError {
+        match e {
+            corvus_regex_ecma262::Error::TooLarge(large) => PatternError::TooLarge(large),
+            // Not valid in the grammar, or (not given here) flags that are not.
+            _ => PatternError::Invalid,
+        }
+    }
+}
 
-/// Compiles (or fetches from the process-wide cache) a pattern; `None` when it is not a valid ECMA-262 regex.
-pub(crate) fn compile(pattern: &str) -> Option<Arc<Pattern>> {
-    if let Some(p) = CACHE.lock().unwrap().get(pattern) {
-        return Some(p.clone());
+/// A pattern in quotes for a message, or its first 120 bytes and its length when it is longer.
+pub(crate) fn shown_pattern(pattern: &str) -> String {
+    const SHOWN: usize = 120;
+    if pattern.len() <= SHOWN {
+        return format!("'{pattern}'");
+    }
+    let mut cut = SHOWN;
+    while !pattern.is_char_boundary(cut) {
+        cut -= 1;
     }
-    // Validity is ECMA-262's: a pattern regress rejects is an error, whichever matcher would run it.
-    let (regress, unicode) = compile_regress(pattern)?;
-    let matcher = match choose(pattern, unicode) {
-        Some(m) => m,
-        None if !unicode => match translate(pattern, false).and_then(|t| regex::Regex::new(&t).ok()) {
-            Some(re) => Matcher::RegexBmp(re, regress),
-            None => Matcher::Regress(regress),
+    format!("'{}...' ({} bytes)", &pattern[..cut], pattern.len())
+}
+
+/// Compiles (or fetches from the process-wide cache) a pattern, in the grammar of its dialect.
+pub(crate) fn compile(pattern: &str, grammar: Grammar) -> Result<Arc<Pattern>, PatternError> {
+    if let Some(p) = cache().get(pattern, grammar) {
+        return Ok(p);
+    }
+    // Validity is ECMA-262's: a pattern the engine refuses is an error, whichever matcher would run it. A pattern is
+    // read with the u flag, and failing that with no flag, whose grammar (Annex B) many schemas need. A pattern valid
+    // with the flag that a dedicated matcher takes is read and never built: building the engine's program and
+    // automata costs far more than reading. The engine is built only for the patterns it matches, and for those over
+    // a limit of size, which it refuses (the reading refuses them too, without saying why).
+    let matcher = match grammar.is_valid_unicode(pattern).then(|| choose(pattern, true, grammar)).flatten() {
+        Some(shape) => shape,
+        None => match grammar.build(pattern, true) {
+            Ok(engine) => Matcher::Engine(Box::new(engine)),
+            Err(corvus_regex_ecma262::Error::TooLarge(large)) => return Err(PatternError::TooLarge(large)),
+            Err(_) => {
+                let engine = grammar.build(pattern, false)?;
+                choose(pattern, false, grammar).unwrap_or_else(|| Matcher::Engine(Box::new(engine)))
+            }
         },
-        None => Matcher::Regress(regress),
     };
-    let p = Arc::new(Pattern { source: pattern.to_string(), matcher });
-    CACHE.lock().unwrap().insert(pattern.to_string(), p.clone());
-    Some(p)
+    // What the cache counts for the pattern (see `MAX_CACHED_BYTES`): its source, and for the engine an estimate of
+    // its program and automata, which grow with the pattern.
+    let mut retained = pattern.len() + 256;
+    if matches!(matcher, Matcher::Engine(_)) {
+        retained += 16 * pattern.len();
+    }
+    Ok(cache().insert(Arc::new(Pattern { source: pattern.to_string(), grammar, matcher, retained })))
 }
 
-fn choose(pattern: &str, unicode: bool) -> Option<Matcher> {
+fn choose(pattern: &str, unicode: bool, grammar: Grammar) -> Option<Matcher> {
     // Unanchored (or start-anchored) `.*` finds an empty match in any string; `^.*$` does not (`.` stops at a line
     // terminator), so it is not listed.
     if matches!(pattern, "" | ".*" | "^.*" | ".*$" | "(.*)" | "^(.*)" | "[\\s\\S]*" | "^[\\s\\S]*" | "^[\\s\\S]*$") {
         return Some(Matcher::Everything);
     }
-    // Without the `u` flag, a pattern matches UTF-16 code units rather than characters: only regress has that.
+    // Without the `u` flag, a pattern matches UTF-16 code units rather than characters: only the engine has that.
     if !unicode {
         return None;
     }
@@ -288,7 +520,8 @@ fn choose(pattern: &str, unicode: bool) -> Option<Matcher> {
         && rest.len() > 1
         && !ends_with_escape(rest)
         && !rest.ends_with(['*', '+', '?', '}', '|', '(', '^'])
-        && let Some(m) = choose(rest, unicode)
+        && grammar.is_valid_unicode(rest)
+        && let Some(m) = choose(rest, true, grammar)
     {
         return Some(m);
     }
@@ -296,25 +529,28 @@ fn choose(pattern: &str, unicode: bool) -> Option<Matcher> {
         return Some(Matcher::Line { min, max });
     }
     if let Some(texts) = whole_alternatives(pattern) {
-        return Some(Matcher::Literals(Literals::new(texts)));
+        return (texts.len() <= MOST_LITERALS).then(|| Matcher::Literals(Literals::new(texts)));
     }
     if let Some(alts) = alternatives(pattern) {
-        return Some(Matcher::Alternatives(alts));
-    }
-    if let Some(list) = SeparatedList::parse(pattern) {
-        return Some(Matcher::SeparatedList(list));
+        let whole = |a: &Alternative| match a {
+            Alternative::Literal { start, end, .. } => *start && *end,
+            Alternative::Start(seq) => seq.to_end,
+            Alternative::End { .. } | Alternative::Anywhere { .. } => false,
+        };
+        return (alts.len() <= MOST_ALTERNATIVES && !alts.iter().any(whole)).then_some(Matcher::Alternatives(alts));
     }
     if let Some((set, bangs)) = excluded_class_with_word(pattern) {
         return Some(Matcher::ExcludedClassWithWord { set, bangs });
     }
     if let Some(seq) = Sequence::parse(pattern) {
         return Some(match seq.literal() {
+            // `^[a-z]*` with nothing it requires: every string.
+            Some(text) if text.is_empty() && !seq.to_end => Matcher::Everything,
             Some(text) => Matcher::Literal { text: text.into(), whole: seq.to_end },
             None => Matcher::Sequence(seq),
         });
     }
-    let translated = translate(pattern, true)?;
-    regex::Regex::new(&translated).ok().map(Matcher::Regex)
+    None
 }
 
 /// `^.{m,n}$` (and `^.*$`, `^.+$`, `^.{m}$`, `^.{m,}$`, each also as `^(.…)$`): the bounds on the length of a line.
@@ -393,12 +629,18 @@ const MAX_ALTERNATIVES: usize = 64;
 /// `regex` crate's single automaton pass (measured on jsconfig's case-folded `lib` names).
 const MAX_SEQUENCE_ALTERNATIVES: usize = 4;
 
+/// The widest class sequence, in characters, and the longest literal, in bytes, that is searched for at every
+/// position of a text. The search for a sequence takes the text times this, and these matchers have no limit, so a
+/// wider one is left to the engine, which has the limit of a match. (The rule is the Go module's, so that the ports
+/// give a pattern the same kind of matcher.)
+const MAX_ANYWHERE_WIDTH: usize = 64;
+
 /// Two or more alternatives once groups of alternatives (and optional groups) are expanded into whole alternatives
 /// (`^a|b|c$`, `^([a|A]uto)|([n|N]one)$`, `^[Ee][Ss]2015(\.([Cc]ore|[Pp]roxy))?$`), each a literal or a class
 /// sequence anchored where its own `^` and `$` say.
 fn alternatives(p: &str) -> Option<Box<[Alternative]>> {
     let c: Vec<char> = p.chars().collect();
-    let (parts, end) = expand(&c, 0)?;
+    let (parts, end) = expand(&c, 0, 0)?;
     // A single alternative is only new here when a group was expanded (Sequence::parse takes the rest).
     if end != c.len() || parts.is_empty() || (parts.len() == 1 && parts[0] == p) {
         return None;
@@ -412,6 +654,10 @@ fn alternatives(p: &str) -> Option<Box<[Alternative]>> {
                 _ => (false, part),
             };
             if let Some(text) = literal_text(body) {
+                // A literal that is anchored at neither end is searched for at every position of the text.
+                if !start && !end && text.len() > MAX_ANYWHERE_WIDTH {
+                    return None;
+                }
                 return Some(Alternative::Literal { text: text.into(), start, end });
             }
             let seq = Sequence::parse(&format!("^{body}{}", if end { "$" } else { "" }))?;
@@ -420,7 +666,11 @@ fn alternatives(p: &str) -> Option<Box<[Alternative]>> {
             }
             let width =
                 seq.items.iter().all(|i| i.min == i.max).then(|| seq.items.iter().map(|i| i.min as usize).sum())?;
-            Some(if end { Alternative::End { seq, width } } else { Alternative::Anywhere { seq, width } })
+            if end {
+                return Some(Alternative::End { seq, width });
+            }
+            // A sequence that is not anchored is tried at every position of the text, and reads its width at each.
+            (width <= MAX_ANYWHERE_WIDTH).then_some(Alternative::Anywhere { seq, width })
         })
         .collect::<Option<_>>()?;
     let sequences = alternatives.iter().any(|a| !matches!(a, Alternative::Literal { .. }));
@@ -432,10 +682,18 @@ fn ends_with_escape(t: &str) -> bool {
     t.bytes().rev().take_while(|&b| b == b'\\').count() % 2 == 1
 }
 
+/// The deepest nesting of groups that is multiplied out. `expand` goes a level deeper for each, and a pattern may
+/// nest a thousand deep, which the stack of a thread cannot be relied on to hold. A pattern that nests deeper than
+/// this is left to the matchers after this one.
+const MAX_EXPANDED_NESTING: usize = 32;
+
 /// Expands the alternatives from `i` up to an unmatched `)` or the end: groups of alternatives multiply out, a group
 /// quantified by `?` also contributes the empty alternative, and everything else is copied. `None` for lookarounds,
-/// other quantified groups, or too many alternatives.
-fn expand(c: &[char], mut i: usize) -> Option<(Vec<String>, usize)> {
+/// other quantified groups, too many alternatives, or groups nested deeper than `MAX_EXPANDED_NESTING`.
+fn expand(c: &[char], mut i: usize, depth: usize) -> Option<(Vec<String>, usize)> {
+    if depth > MAX_EXPANDED_NESTING {
+        return None;
+    }
     let mut all = Vec::new();
     let mut branch = vec![String::new()];
     while i < c.len() {
@@ -454,7 +712,7 @@ fn expand(c: &[char], mut i: usize) -> Option<(Vec<String>, usize)> {
                     }
                     i += 2;
                 }
-                let (mut inner, next) = expand(c, i)?;
+                let (mut inner, next) = expand(c, i, depth + 1)?;
                 if c.get(next) != Some(&')') {
                     return None;
                 }
@@ -550,9 +808,13 @@ fn excluded_class_with_word(p: &str) -> Option<(CharSet, bool)> {
         .then_some((excluded, bangs))
 }
 
-/// The `regex` format: a valid ECMA-262 regular expression (with the `u` flag).
-pub(crate) fn is_valid_ecma_regex(s: &str) -> bool {
-    regress::Regex::with_flags(s, "u").is_ok()
+/// The `regex` format: a valid ECMA-262 regular expression in the grammar of the `u` flag, of the edition and version
+/// of Unicode the dialect reads patterns with. It asks the grammar alone, as the .NET library's check does: the
+/// engine's limits of size belong to compiling a pattern, so a string too large to compile is valid when its grammar
+/// is. The engine's grammar-only reader takes time in proportion to the string and allocates nothing for one of
+/// ordinary size.
+pub(crate) fn is_valid_ecma_regex(s: &str, grammar: Grammar) -> bool {
+    Regex::is_valid_pattern_with(s, Grammar::flags(true), grammar.edition, grammar.unicode_version)
 }
 
 // ---------------------------------------------------------------------------------------------------------------------
@@ -710,6 +972,16 @@ impl Sequence {
                 }
             }
         }
+        if !to_end {
+            // Without `$` a match needs only the start of the string: items at the end that can match nothing are
+            // dropped, and the last of the rest needs only its least count (`^[a-z]+` is `^[a-z]`).
+            while items.last().is_some_and(|item| item.min == 0) {
+                items.pop();
+            }
+            if let Some(last) = items.last_mut() {
+                last.max = last.min;
+            }
+        }
         Some(Sequence { items: items.into_boxed_slice(), to_end })
     }
 
@@ -765,212 +1037,6 @@ impl Sequence {
         }
         !self.to_end || at == b.len()
     }
-
-    /// Greedily matches the items at the start of `s` (ignoring `to_end`): the bytes taken.
-    fn consume(&self, s: &str) -> Option<usize> {
-        let b = s.as_bytes();
-        let mut at = 0;
-        for item in self.items.iter() {
-            let mut n = 0u32;
-            while n < item.max && at < b.len() {
-                let c = b[at];
-                if c < 0x80 {
-                    if !item.set.has_ascii(c) {
-                        break;
-                    }
-                    at += 1;
-                } else {
-                    let ch = s[at..].chars().next()?;
-                    if !item.set.contains(ch) {
-                        break;
-                    }
-                    at += ch.len_utf8();
-                }
-                n += 1;
-            }
-            if n < item.min {
-                return None;
-            }
-        }
-        Some(at)
-    }
-
-    /// Whether greedy matching is exact when `next` can follow the items: every variable item is disjoint from the
-    /// items that can directly follow it (up to the first that cannot match nothing), `next` included.
-    fn greedy_before(items: &[Item], next: CharSet) -> bool {
-        items.iter().enumerate().all(|(i, item)| {
-            if item.min == item.max {
-                return true;
-            }
-            for following in &items[i + 1..] {
-                if !item.set.disjoint(following.set) {
-                    return false;
-                }
-                if following.min > 0 {
-                    return true;
-                }
-            }
-            item.set.disjoint(next)
-        })
-    }
-}
-
-/// A list of items between separators: `^I(SR)*$` or `^I(SR)+$` (`final_` is `None`), or `^(RS)*F$` and
-/// `^(RS)+F$`. The separator is a fixed sequence and no variable class can run into what follows it, so greedy
-/// matching splits the string exactly where the pattern does.
-#[derive(Debug)]
-struct SeparatedList {
-    /// `I` of the first form.
-    first: Option<Sequence>,
-    repeated: Sequence,
-    separator: Sequence,
-    /// `F` of the second form, matched against the whole remainder.
-    final_: Option<Sequence>,
-    min_repeats: u32,
-}
-
-impl SeparatedList {
-    fn is_match(&self, s: &str) -> bool {
-        let mut rest = s;
-        let mut repeats = 0;
-        if let Some(first) = &self.first {
-            let Some(n) = first.consume(rest) else { return false };
-            rest = &rest[n..];
-            loop {
-                if rest.is_empty() {
-                    return repeats >= self.min_repeats;
-                }
-                let Some(n) = self.separator.consume(rest) else { return false };
-                rest = &rest[n..];
-                let Some(n) = self.repeated.consume(rest) else { return false };
-                rest = &rest[n..];
-                repeats += 1;
-            }
-        }
-        let final_ = self.final_.as_ref().expect("a separated list has a first or a final item");
-        loop {
-            if repeats >= self.min_repeats && final_.is_match(rest) {
-                return true;
-            }
-            let Some(n) = self.repeated.consume(rest) else { return false };
-            let Some(m) = self.separator.consume(&rest[n..]) else { return false };
-            rest = &rest[n + m..];
-            repeats += 1;
-        }
-    }
-
-    fn parse(p: &str) -> Option<SeparatedList> {
-        let body = p.strip_prefix('^')?.strip_suffix('$')?;
-        if ends_with_escape(body) {
-            return None;
-        }
-        let b = body.as_bytes();
-        // Top-level groups: (start, end) of each, where end is the index of its `)`.
-        let mut groups = Vec::new();
-        let (mut depth, mut in_class, mut i, mut open) = (0usize, false, 0, 0);
-        while i < b.len() {
-            match b[i] {
-                b'\\' => i += 1,
-                b'[' if !in_class => in_class = true,
-                b']' if in_class => in_class = false,
-                b'(' if !in_class => {
-                    if depth == 0 {
-                        open = i;
-                    }
-                    depth += 1;
-                }
-                b')' if !in_class => {
-                    depth = depth.checked_sub(1)?;
-                    if depth == 0 {
-                        groups.push((open, i));
-                    }
-                }
-                _ => {}
-            }
-            i += 1;
-        }
-        let quantified: Vec<_> = groups.iter().filter(|&&(_, e)| matches!(b.get(e + 1), Some(b'*' | b'+'))).collect();
-        let &&(open, close) = quantified.first().filter(|_| quantified.len() == 1)?;
-        let min_repeats = u32::from(b[close + 1] == b'+');
-        let group = strip_group(&body[open..=close])?;
-        let before = &body[..open];
-        let after = &body[close + 2..];
-        let items = |t: &str| Sequence::parse(&format!("^{t}")).map(|s| s.items.into_vec());
-        let seq = |items: &[Item], to_end| Sequence { items: items.into(), to_end };
-        let fixed = |items: &[Item]| !items.is_empty() && items.iter().all(|i| i.min == i.max && i.min > 0);
-        let g = items(group)?;
-        match (before.is_empty(), after.is_empty()) {
-            // ^I(SR)*$
-            (false, true) => {
-                let first = items(unwrap_group(before)?)?;
-                (1..g.len()).find_map(|k| {
-                    let (separator, repeated) = g.split_at(k);
-                    let next = separator[0].set;
-                    (fixed(separator)
-                        && Sequence::greedy_before(&first, next)
-                        && Sequence::greedy_before(repeated, next))
-                    .then(|| SeparatedList {
-                        first: Some(seq(&first, false)),
-                        repeated: seq(repeated, false),
-                        separator: seq(separator, false),
-                        final_: None,
-                        min_repeats,
-                    })
-                })
-            }
-            // ^(RS)*F$
-            (true, false) => {
-                let final_ = Sequence::parse(&format!("^{}$", unwrap_group(after)?))?;
-                (1..g.len()).find_map(|k| {
-                    let (repeated, separator) = g.split_at(k);
-                    (fixed(separator) && Sequence::greedy_before(repeated, separator[0].set)).then(|| SeparatedList {
-                        first: None,
-                        repeated: seq(repeated, false),
-                        separator: seq(separator, false),
-                        final_: Some(Sequence { items: final_.items.clone(), to_end: true }),
-                        min_repeats,
-                    })
-                })
-            }
-            _ => None,
-        }
-    }
-}
-
-/// The inside of `(...)` or `(?:...)`; `None` for other groups.
-fn strip_group(g: &str) -> Option<&str> {
-    let inner = g.strip_prefix('(')?.strip_suffix(')')?;
-    match inner.strip_prefix("?:") {
-        Some(rest) => Some(rest),
-        None if inner.starts_with('?') => None,
-        None => Some(inner),
-    }
-}
-
-/// A text that is one group wrapping everything, unwrapped; otherwise the text itself.
-fn unwrap_group(t: &str) -> Option<&str> {
-    if t.starts_with('(') && t.ends_with(')') {
-        let inner = strip_group(t)?;
-        // Only when the parentheses enclose the whole text (`(a)(b)` is two groups).
-        let mut depth = 0i32;
-        let mut escaped = false;
-        for c in inner.chars() {
-            match c {
-                _ if escaped => escaped = false,
-                '\\' => escaped = true,
-                '(' => depth += 1,
-                ')' => {
-                    depth -= 1;
-                    if depth < 0 {
-                        return None;
-                    }
-                }
-                _ => {}
-            }
-        }
-        return Some(inner);
-    }
-    Some(t)
 }
 
 /// The set of a class escape (`\d`, `\w`, their negations, or an escaped punctuation character); `None` for `\s`
@@ -1090,280 +1156,26 @@ fn parse_quantifier(b: &[u8], mut i: usize) -> Option<(u32, u32, usize)> {
     Some((min, max, i))
 }
 
-// ---------------------------------------------------------------------------------------------------------------------
-// Translation to the regex crate
-
-/// ECMA-262 `\s`: WhiteSpace and LineTerminator.
-const ECMA_SPACE: &str =
-    r"\t\n\x{B}\x{C}\r \x{A0}\x{1680}\x{2000}-\x{200A}\x{2028}\x{2029}\x{202F}\x{205F}\x{3000}\x{FEFF}";
-
-/// Translates an ECMA-262 pattern to the `regex` crate's syntax with the same meaning, or `None` when it uses
-/// something outside the common subset. With `unicode` false, the pattern is read without the `u` flag (identity
-/// escapes of any non-alphanumeric character), and the translation has its meaning on strings within the BMP.
-fn translate(p: &str, unicode: bool) -> Option<String> {
-    let c: Vec<char> = p.chars().collect();
-    let mut out = String::with_capacity(p.len() * 2);
-    let mut i = 0;
-    while i < c.len() {
-        match c[i] {
-            '\\' => {
-                let (text, next) = escape(&c, i + 1, false, unicode)?;
-                out.push_str(&text);
-                i = next;
-            }
-            '[' => {
-                let (text, next) = class(&c, i + 1, unicode)?;
-                out.push_str(&text);
-                i = next;
-            }
-            '(' => {
-                if c.get(i + 1) == Some(&'?') {
-                    match (c.get(i + 2), c.get(i + 3)) {
-                        (Some(':'), _) => i += 3,
-                        // A named group; lookbehinds (`(?<=`, `(?<!`) are not supported.
-                        (Some('<'), Some(n)) if *n != '=' && *n != '!' => {
-                            i += 3 + c[i + 3..].iter().position(|&x| x == '>')? + 1;
-                        }
-                        _ => return None,
-                    }
-                } else {
-                    i += 1;
-                }
-                out.push_str("(?:");
-            }
-            '{' => {
-                let end = i + c[i..].iter().position(|&x| x == '}')?;
-                let body: String = c[i + 1..end].iter().collect();
-                if body.is_empty() || !body.chars().all(|x| x.is_ascii_digit() || x == ',') {
-                    return None;
-                }
-                out.push('{');
-                out.push_str(&body);
-                out.push('}');
-                i = end + 1;
-            }
-            '.' => {
-                out.push_str(r"[^\n\r\x{2028}\x{2029}]");
-                i += 1;
-            }
-            ch @ (')' | '|' | '^' | '$' | '*' | '+' | '?') => {
-                out.push(ch);
-                i += 1;
-            }
-            ch => {
-                push_literal(&mut out, ch);
-                i += 1;
-            }
-        }
-    }
-    Some(out)
-}
-
-fn push_literal(out: &mut String, ch: char) {
-    use std::fmt::Write;
-    let _ = write!(out, "\\x{{{:X}}}", ch as u32);
-}
-
-/// An escape after `\` at `i`: its translation and the index after it.
-fn escape(c: &[char], i: usize, in_class: bool, unicode: bool) -> Option<(String, usize)> {
-    let e = *c.get(i)?;
-    let mut out = String::new();
-    let next = match e {
-        'd' => {
-            out.push_str(if in_class { "0-9" } else { "[0-9]" });
-            i + 1
-        }
-        'D' => {
-            out.push_str("[^0-9]");
-            i + 1
-        }
-        'w' => {
-            out.push_str(if in_class { "0-9A-Za-z_" } else { "[0-9A-Za-z_]" });
-            i + 1
-        }
-        'W' => {
-            out.push_str("[^0-9A-Za-z_]");
-            i + 1
-        }
-        's' => {
-            if in_class {
-                out.push_str(ECMA_SPACE);
-            } else {
-                out.push('[');
-                out.push_str(ECMA_SPACE);
-                out.push(']');
-            }
-            i + 1
-        }
-        'S' => {
-            out.push_str("[^");
-            out.push_str(ECMA_SPACE);
-            out.push(']');
-            i + 1
-        }
-        'n' | 'r' | 't' | 'f' | 'v' => {
-            let ch = match e {
-                'n' => '\n',
-                'r' => '\r',
-                't' => '\t',
-                'f' => '\x0C',
-                _ => '\x0B',
-            };
-            push_literal(&mut out, ch);
-            i + 1
-        }
-        '0' if !c.get(i + 1).is_some_and(char::is_ascii_digit) => {
-            push_literal(&mut out, '\0');
-            i + 1
-        }
-        'b' if in_class => {
-            push_literal(&mut out, '\x08');
-            i + 1
-        }
-        // ECMA's word boundaries are between ASCII word characters and the rest.
-        'b' => {
-            out.push_str("(?-u:\\b)");
-            i + 1
-        }
-        'B' => {
-            out.push_str("(?-u:\\B)");
-            i + 1
-        }
-        // Unicode properties (validated as ECMA-262 names by regress) have the same names in the `regex` crate.
-        // Without the `u` flag `\p` is the letter.
-        'p' | 'P' if unicode && c.get(i + 1) == Some(&'{') => {
-            let end = i + 1 + c[i + 1..].iter().position(|&x| x == '}')?;
-            let body: String = c[i + 2..end].iter().collect();
-            if body.is_empty() || !body.chars().all(|x| x.is_ascii_alphanumeric() || x == '_' || x == '=') {
-                return None;
-            }
-            out.push('\\');
-            out.push(e);
-            out.push('{');
-            out.push_str(&body);
-            out.push('}');
-            end + 1
-        }
-        'x' => {
-            let hex: String = c.get(i + 1..i + 3)?.iter().collect();
-            push_literal(&mut out, char::from_u32(u32::from_str_radix(&hex, 16).ok()?)?);
-            i + 3
-        }
-        // Without the `u` flag, `\u{...}` is not a code point escape.
-        'u' if unicode || c.get(i + 1) != Some(&'{') => {
-            let (code, next) = unicode_escape(c, i + 1)?;
-            push_literal(&mut out, char::from_u32(code)?);
-            next
-        }
-        // Identity escapes of syntax characters and `/` (and `-` in a class).
-        '^' | '$' | '\\' | '.' | '*' | '+' | '?' | '(' | ')' | '[' | ']' | '{' | '}' | '|' | '/' | '-' => {
-            push_literal(&mut out, e);
-            i + 1
-        }
-        // Without the `u` flag, any other non-alphanumeric character escapes to itself.
-        e if !unicode && !e.is_ascii_alphanumeric() => {
-            push_literal(&mut out, e);
-            i + 1
-        }
-        // Backreferences, \c, \k and the rest.
-        _ => return None,
-    };
-    Some((out, next))
-}
-
-/// `\u` escapes after the `u`: `XXXX` (joining a surrogate pair) or `{X...}`.
-fn unicode_escape(c: &[char], i: usize) -> Option<(u32, usize)> {
-    if c.get(i) == Some(&'{') {
-        let end = i + c[i..].iter().position(|&x| x == '}')?;
-        let hex: String = c[i + 1..end].iter().collect();
-        return Some((u32::from_str_radix(&hex, 16).ok()?, end + 1));
-    }
-    let four = |at: usize| -> Option<u32> {
-        let hex: String = c.get(at..at + 4)?.iter().collect();
-        if hex.len() != 4 {
-            return None;
-        }
-        u32::from_str_radix(&hex, 16).ok()
-    };
-    let hi = four(i)?;
-    if (0xD800..0xDC00).contains(&hi) {
-        if c.get(i + 4) == Some(&'\\') && c.get(i + 5) == Some(&'u') {
-            let lo = four(i + 6)?;
-            if (0xDC00..0xE000).contains(&lo) {
-                return Some((0x10000 + ((hi - 0xD800) << 10) + (lo - 0xDC00), i + 10));
-            }
-        }
-        return None;
-    }
-    Some((hi, i + 4))
-}
-
-/// A class after `[` at `i`: its translation (every member spelled as an escape, so nothing in it is special to the
-/// `regex` crate) and the index after `]`.
-fn class(c: &[char], mut i: usize, unicode: bool) -> Option<(String, usize)> {
-    let mut out = String::from("[");
-    if c.get(i) == Some(&'^') {
-        out.push('^');
-        i += 1;
-    }
-    let mut members = 0;
-    loop {
-        let ch = *c.get(i)?;
-        if ch == ']' {
-            i += 1;
-            break;
-        }
-        // One atom: a character (which can start a range) or a class escape.
-        let (atom, single, next) = if ch == '\\' {
-            let e = *c.get(i + 1)?;
-            let (text, next) = escape(c, i + 1, true, unicode)?;
-            let single = match e {
-                'd' | 'D' | 'w' | 'W' | 's' | 'S' | 'p' | 'P' => None,
-                _ => Some(text.clone()),
-            };
-            (text, single, next)
-        } else {
-            let mut t = String::new();
-            push_literal(&mut t, ch);
-            (t.clone(), Some(t), i + 1)
-        };
-        i = next;
-        members += 1;
-        if c.get(i) == Some(&'-') && c.get(i + 1).is_some_and(|&n| n != ']') {
-            // A range: both ends single characters.
-            let lo = single?;
-            let (hi, next) = if c[i + 1] == '\\' {
-                let e = *c.get(i + 2)?;
-                if matches!(e, 'd' | 'D' | 'w' | 'W' | 's' | 'S' | 'p' | 'P') {
-                    return None;
-                }
-                escape(c, i + 2, true, unicode)?
-            } else {
-                let mut t = String::new();
-                push_literal(&mut t, c[i + 1]);
-                (t, i + 2)
-            };
-            out.push_str(&lo);
-            out.push('-');
-            out.push_str(&hi);
-            i = next;
-        } else {
-            out.push_str(&atom);
-        }
-    }
-    if members == 0 {
-        return None; // `[]` and `[^]` have no counterpart.
-    }
-    out.push(']');
-    Some((out, i))
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    const G: Grammar = Grammar { edition: Edition::Current, unicode_version: UnicodeVersion::Default };
+
+    /// A pattern compiled in today's grammar.
+    fn compile(p: &str) -> Result<Arc<Pattern>, PatternError> {
+        super::compile(p, G)
+    }
+
     const PATTERNS: &[&str] = &[
         "",
+        // Sequences without `$`, which need only the start of the string.
+        "^[a-z]+",
+        "^[a-z]*",
+        "^[a-zA-Z0-9_\\.\\-]*",
+        "^a[b-c]{2,5}",
+        "^[a-z]+[0-9]*",
+        "^[a-z]{0,3}[0-9]{2,4}",
         ".*",
         "^.*",
         ".*$",
@@ -1484,6 +1296,20 @@ mod tests {
         "^(é,)*a$",
         "^(?=!+[^!*,;{}[\\]~\\n]+$)(?=(.*\\w)).+$",
         "^(?=!+[^a]+$)(?=(.*\\w)).+$",
+        // Lists with an anchor or an assertion inside them, and with an escaped anchor.
+        "^x(,a$)*$",
+        "^a(,a$)+$",
+        "^x$(,a)*$",
+        "^(a$)(,a)*$",
+        "^$(,a)*$",
+        "^(a,$)*b$",
+        "^([a-z]+,$)+a$",
+        "^a(^,a)*$",
+        "^(^a,)*b$",
+        "^a(,a\\b)*$",
+        "^a(,a\\$)*$",
+        "^a\\$(,a)*$",
+        "^(a\\$,)*b$",
         // Valid only without the `u` flag (identity escapes), so matching code units.
         "^\\/[^\\*\\?\\&\\%]*(\\/\\*)?$",
         "^[\\&\\@\\_]+$",
@@ -1493,9 +1319,10 @@ mod tests {
         "\\uD83D\\uDE00|\\&",
     ];
 
-    /// Every matcher agrees with regress on strings over an alphabet that exercises classes, anchors and non-ASCII.
+    /// Every matcher agrees with the engine's backtracking matcher on strings over an alphabet that exercises
+    /// classes, anchors and non-ASCII.
     #[test]
-    fn matchers_agree_with_regress() {
+    fn matchers_agree_with_the_engine() {
         let alphabet = [
             "a", "b", "z", "A", "X", "Z", "0", "1", "5", "9", "_", "-", ".", ":", "/", "@", "#", "$", "*", "!", "{",
             "}", "|", " ", "\n", "\u{a0}", "é", "µ", "😀", "\u{2028}", "x-", "es", "ES", "ms", "txt", "Au", "to", "No",
@@ -1509,12 +1336,20 @@ mod tests {
             seed
         };
         for &p in PATTERNS {
-            let (reference, _) = compile_regress(p).unwrap();
+            let reference = G.build(p, true).or_else(|_| G.build(p, false)).unwrap();
             let compiled = compile(p).unwrap();
             for _ in 0..4000 {
                 let len = next() % 9;
                 let s: String = (0..len).map(|_| alphabet[(next() % alphabet.len() as u64) as usize]).collect();
-                assert_eq!(compiled.is_match(&s), reference.find(&s).is_some(), "{p:?} on {s:?}");
+                // Without the `u` flag the engine matches the UTF-16 code units of the string.
+                let found = reference.is_match(&s).unwrap();
+                for limit in [None, Some(Duration::from_secs(60)), Some(Duration::from_nanos(1))] {
+                    let mut budget = PatternBudget::new(PatternLimit::new(limit));
+                    let got = compiled.is_match(&s, &mut budget);
+                    // A match on the engine that reached its first check of the clock has no answer.
+                    assert!(got == found || budget.failed(), "{p:?} on {s:?} with a limit of {limit:?}");
+                    assert!(limit.is_some_and(|l| l.as_nanos() == 1) || !budget.failed(), "{p:?} on {s:?}");
+                }
             }
         }
     }
@@ -1527,70 +1362,284 @@ mod tests {
         for p in ["^x-", "^\\/", "^abc$"] {
             assert!(matches!(compile(p).unwrap().matcher, Matcher::Literal { .. }), "{p}");
         }
-        for p in ["^[a-z]*a$", "(base64key|awskms)://(.*)"] {
-            assert!(matches!(compile(p).unwrap().matcher, Matcher::Regex(_)), "{p}");
-        }
+        assert!(matches!(compile("^[a-z]*a$").unwrap().matcher, Matcher::Engine(_)));
         for p in [".+", "^.+", "(.+)"] {
             assert!(matches!(compile(p).unwrap().matcher, Matcher::HasContent { .. }), "{p}");
         }
         for p in ["^.{1,256}$", "^.+$", "^.*$", "^(.*)$", "^(.+)$"] {
             assert!(matches!(compile(p).unwrap().matcher, Matcher::Line { .. }), "{p}");
         }
-        for p in ["^(ab|cd)$", "^(?:es|ES|x-)$"] {
+        for p in ["^(ab|cd)$", "^(?:es|ES|x-)$", "^(CRLF|LF|crlf|lf)$"] {
             assert!(matches!(compile(p).unwrap().matcher, Matcher::Literals(_)), "{p}");
         }
+        // Without `$`, a sequence is read only as far as it must be.
+        for p in ["^[a-z]+", "^a[b-c]{2,5}"] {
+            assert!(
+                matches!(&compile(p).unwrap().matcher, Matcher::Sequence(seq) if seq.items.last().unwrap().max == seq.items.last().unwrap().min),
+                "{p}"
+            );
+        }
+        assert!(matches!(&compile("^[a-zA-Z0-9_\\.\\-]*").unwrap().matcher, Matcher::Everything));
+        // At most two alternatives, neither anchored at both ends.
+        for p in ["^ab|cd$", "a|b", "^([a|A][u|U][t|T][o|O])|([n|N][o|O][n|N][e|E])$", "(base64key|awskms)://(.*)"] {
+            assert!(matches!(compile(p).unwrap().matcher, Matcher::Alternatives(_)), "{p}");
+        }
+        // The engine is faster for more literals, more alternatives, an alternative anchored at both ends, and a
+        // separated list.
         for p in [
-            "^ab|cd$",
-            "a|b",
-            "^([a|A][u|U][t|T][o|O])|([n|N][o|O][n|N][e|E])$",
+            "^(schemas|responses|parameters|examples|requestBodies)$",
             "^[Ee][Ss]2015(\\.([Cc][Oo][Rr][Ee]|[Pp][Rr][Oo][Xx][Yy]))?$",
             "^[1-5](?:[0-9]{2}|XX)$",
             "(^([0-9]+)\\.([0-9]+)$)|(^\\{[A-F0-9]{8}(-[A-F0-9]{4}){3}-[A-F0-9]{12}\\}$)",
             "^([t|T][o|O][p|P])|([c|C][e|E][n|N][t|T][e|E][r|R])|([b|B][o|O][t|T][t|T][o|O][m|M])$",
             "^([A-Za-z_][-A-Za-z0-9_.:]*)$",
-        ] {
-            assert!(matches!(compile(p).unwrap().matcher, Matcher::Alternatives(_)), "{p}");
-        }
-        for p in [
+            "default|^[0-9]+$",
             "^([a-zA-Z0-9]{2,3})(-[a-zA-Z0-9]{1,6})*$",
             "^([a-zA-Z_$][a-zA-Z0-9_$]{0,39}\\.)*([a-zA-Z_$][a-zA-Z0-9_$]{0,39})$",
-            "^([a-z_$][a-z0-9_$]{0,39}\\.)*([a-zA-Z_$][a-zA-Z0-9_$]{0,39})$",
+            "^x(,a\\$)*$",
+            "^x(,a$)*$",
+            "^x(?=,)(,a)*$",
         ] {
-            assert!(matches!(compile(p).unwrap().matcher, Matcher::SeparatedList(_)), "{p}");
+            assert!(matches!(compile(p).unwrap().matcher, Matcher::Engine(_)), "{p}");
         }
         assert!(matches!(
             compile("^(?=[^!*,;{}[\\]~\\n]+$)(?=(.*\\w)).+$").unwrap().matcher,
             Matcher::ExcludedClassWithWord { .. }
         ));
         for p in ["\\bfoo", "^\\p{L}+$"] {
-            assert!(matches!(compile(p).unwrap().matcher, Matcher::Regex(_)), "{p}");
+            assert!(matches!(compile(p).unwrap().matcher, Matcher::Engine(_)), "{p}");
         }
         for p in ["^\\/[^\\*\\?\\&\\%]*(\\/\\*)?$", "a\\&.b", "^\\-a"] {
-            assert!(matches!(compile(p).unwrap().matcher, Matcher::RegexBmp(..)), "{p}");
+            assert!(matches!(&compile(p).unwrap().matcher, Matcher::Engine(engine) if !engine.flags().unicode), "{p}");
         }
-        for p in ["^((\\.(?!\\.)\\/)?\\w+\\/?)+$", "^\\1(a)", "^\\p{L}\\&"] {
-            assert!(matches!(compile(p).unwrap().matcher, Matcher::Regress(_)), "{p}");
+        for p in ["^((\\.(?!\\.)\\/)?\\w+\\/?)+$", "^\\1(a)", "\\Bs", "(?i:a)", "^[]", "\\cA"] {
+            assert!(matches!(compile(p).unwrap().matcher, Matcher::Engine(_)), "{p}");
+        }
+        // Valid only without the `u` flag, and not in the syntax `regex` takes: the engine, by code unit.
+        for p in ["^\\p{L}\\&", "^\\-?\u{10400}*$", "^\\-(?=a)"] {
+            let compiled = compile(p).unwrap();
+            assert!(matches!(&compiled.matcher, Matcher::Engine(engine) if !engine.flags().unicode), "{p}");
+        }
+    }
+}
+
+#[cfg(test)]
+mod limits {
+    use super::*;
+
+    const G: Grammar = Grammar { edition: Edition::Current, unicode_version: UnicodeVersion::Default };
+
+    /// A pattern compiled in today's grammar.
+    fn compile(p: &str) -> Result<Arc<Pattern>, PatternError> {
+        super::compile(p, G)
+    }
+
+    /// Which matcher a pattern gets (the Go module's `TestAWideSearchIsLeftToTheEngine`). A sequence or a literal
+    /// that would be searched for at every position of the text keeps its matcher up to 64 characters, and beyond
+    /// that is left to a matcher that takes time proportional to the text or has the limit of a match.
+    #[test]
+    fn a_wide_search_is_left_to_the_engine() {
+        let a = |n: usize| "a".repeat(n);
+        for (pattern, alternatives) in [
+            (r"[a-z]{64}[0-9]{0}|x".to_string(), true),
+            (r"[a-z]{63}[0-9]|x".to_string(), true),
+            (r"[a-z]{64}[0-9]|x".to_string(), false),
+            (r"[a-z]{50000}[0-9]|x".to_string(), false),
+            (r"^[a-z]{50000}[0-9]|x".to_string(), true),
+            (r"[a-z]{50000}[0-9]$|^x".to_string(), true),
+            (format!("{}|^x", a(64)), true),
+            (format!("{}|^x", a(65)), false),
+            (format!("^{}|^x", a(65)), true),
+            (format!("{}$|^x", a(65)), true),
+        ] {
+            let found = kind(&compile(&pattern).unwrap());
+            assert_eq!(found == "alternatives", alternatives, "{pattern:.30} has the matcher {found}");
+            assert!(alternatives || found == "engine", "{pattern:.30} has the matcher {found}");
         }
     }
+
+    /// The cache of compiled patterns is bounded in number and in size, and a pattern that has left it is still
+    /// matched by whoever holds it.
+    #[test]
+    fn the_cache_of_patterns_is_bounded() {
+        let mut budget = PatternBudget::new(PatternLimit::new(None));
+        let first = compile("^cache-bound-0+$").unwrap();
+        let held: Vec<Arc<Pattern>> =
+            (0..3 * MAX_CACHED_PATTERNS).map(|n| compile(&format!("^cache-bound-{n}(?=x)x$")).unwrap()).collect();
+        {
+            let cache = cache();
+            assert!(cache.patterns.len() <= MAX_CACHED_PATTERNS && cache.bytes <= MAX_CACHED_BYTES);
+            assert_eq!(cache.patterns.len(), cache.order.len());
+            assert_eq!(cache.bytes, cache.patterns.values().map(|p| p.retained).sum::<usize>());
+            assert!(cache.get("^cache-bound-0+$", G).is_none(), "the oldest pattern is still in the cache");
+        }
+        assert!(first.is_match("cache-bound-000", &mut budget));
+        assert!(held[0].is_match("cache-bound-0x", &mut budget) && !held[7].is_match("cache-bound-0x", &mut budget));
+        // The same source compiles again, to a matcher of its own.
+        let again = compile("^cache-bound-0+$").unwrap();
+        assert!(!Arc::ptr_eq(&first, &again) && again.is_match("cache-bound-0", &mut budget));
+        // Large patterns leave the cache by size, well before their number is the bound.
+        let class = r"[\u0100\u0102\u0104\u0106]".repeat(1500);
+        let large: Vec<Arc<Pattern>> = (0..200).map(|n| compile(&format!("^(?=large-{n}){class}$")).unwrap()).collect();
+        assert!(large[0].retained > 256 << 10, "a large pattern is counted as {} bytes", large[0].retained);
+        assert!(cache().bytes <= MAX_CACHED_BYTES);
+        // A pattern too large for the cache is not kept at all.
+        let huge = compile(&format!("^(?=huge){}$", class.repeat(4))).unwrap();
+        assert!(huge.retained > MAX_CACHED_PATTERN_BYTES && cache().get(&huge.source, G).is_none());
+    }
 }
 
 #[cfg(test)]
 mod corpus_patterns {
-    /// Lists which matcher each pattern in `CORVUS_PATTERNS` (corpus<TAB>pattern lines) gets.
+    use std::sync::Arc;
+
+    use super::{Edition, Grammar, Pattern, PatternError, UnicodeVersion};
+
+    const G: Grammar = Grammar { edition: Edition::Current, unicode_version: UnicodeVersion::Default };
+
+    /// A pattern compiled in today's grammar.
+    fn compile(p: &str) -> Result<Arc<Pattern>, PatternError> {
+        super::compile(p, G)
+    }
+
+    /// Lists which matcher each pattern in `CORVUS_PATTERNS` (corpus<TAB>pattern lines) gets, and what the cache
+    /// counts for it.
     #[test]
     #[ignore]
     fn classify_corpus_patterns() {
         let Ok(path) = std::env::var("CORVUS_PATTERNS") else { return };
         for line in std::fs::read_to_string(path).unwrap().lines() {
             let (corpus, p) = line.split_once('\t').unwrap();
-            let kind = super::compile(p)
-                .map(|c| match &c.matcher {
-                    super::Matcher::Regex(_) => "regex",
-                    super::Matcher::Regress(_) => "regress",
-                    _ => "fast",
-                })
-                .unwrap_or("invalid");
-            println!("{kind}\t{corpus}\t{p}");
+            let kind = compile(p).map(|c| super::kind(&c)).unwrap_or("invalid");
+            let retained = compile(p).map_or(0, |c| c.retained);
+            println!("{kind}\t{corpus}\t{p}\t{retained}");
+        }
+    }
+
+    /// Times each dedicated matcher against the engine over the corpora of jsonschema-benchmark in `CORVUS_CORPORA`
+    /// (a directory of `<name>-schema.json` and `<name>-instances.jsonl`), so that a matcher the engine beats can be
+    /// removed. The inputs of a pattern are the distinct strings of the corpus's instances (for `pattern`) or their
+    /// property names (for `patternProperties`), at most 1,000. Each figure is the least of 7 rounds of at least 20 ms,
+    /// after a warm-up of 200 ms, through `Pattern::is_match` with the default limit of a match. Run it with
+    /// `cargo test --release --lib time_corpus_patterns -- --ignored --nocapture --test-threads 1`.
+    #[test]
+    #[ignore]
+    fn time_corpus_patterns() {
+        use std::collections::BTreeSet;
+        use std::time::{Duration, Instant};
+
+        use super::{Literals, Matcher, PatternBudget, PatternLimit};
+
+        fn collect(v: &serde_json::Value, strings: &mut BTreeSet<String>, keys: &mut BTreeSet<String>) {
+            match v {
+                serde_json::Value::String(s) => {
+                    strings.insert(s.clone());
+                }
+                serde_json::Value::Array(a) => a.iter().for_each(|v| collect(v, strings, keys)),
+                serde_json::Value::Object(o) => o.iter().for_each(|(k, v)| {
+                    keys.insert(k.clone());
+                    collect(v, strings, keys);
+                }),
+                _ => {}
+            }
+        }
+        fn patterns(v: &serde_json::Value, out: &mut BTreeSet<(&'static str, String)>) {
+            match v {
+                serde_json::Value::Array(a) => a.iter().for_each(|v| patterns(v, out)),
+                serde_json::Value::Object(o) => {
+                    if let Some(serde_json::Value::String(p)) = o.get("pattern") {
+                        out.insert(("pattern", p.clone()));
+                    }
+                    if let Some(serde_json::Value::Object(pp)) = o.get("patternProperties") {
+                        pp.keys().for_each(|p| {
+                            out.insert(("patternProperties", p.clone()));
+                        });
+                    }
+                    o.values().for_each(|v| patterns(v, out));
+                }
+                _ => {}
+            }
+        }
+        fn time(p: &Pattern, inputs: &[String]) -> f64 {
+            let limit = PatternLimit::new(Some(crate::DEFAULT_PATTERN_MATCH_LIMIT));
+            let pass = || {
+                let mut budget = PatternBudget::new(limit);
+                inputs.iter().filter(|s| p.is_match(s, &mut budget)).count()
+            };
+            let warm = Instant::now();
+            while warm.elapsed() < Duration::from_millis(200) {
+                std::hint::black_box(pass());
+            }
+            let mut best = f64::MAX;
+            for _ in 0..7 {
+                let (start, mut calls) = (Instant::now(), 0usize);
+                while start.elapsed() < Duration::from_millis(20) {
+                    std::hint::black_box(pass());
+                    calls += inputs.len();
+                }
+                best = best.min(start.elapsed().as_nanos() as f64 / calls as f64);
+            }
+            best
+        }
+
+        let Ok(dir) = std::env::var("CORVUS_CORPORA") else { return };
+        let mut names: Vec<String> = std::fs::read_dir(&dir)
+            .unwrap()
+            .filter_map(|e| e.unwrap().file_name().to_str()?.strip_suffix("-schema.json").map(str::to_string))
+            .collect();
+        names.sort();
+        // The alternatives a matcher tries one after another.
+        fn alternatives(m: &Matcher) -> usize {
+            match m {
+                Matcher::Alternatives(a) => a.len(),
+                Matcher::Literals(Literals(t)) => t.len(),
+                _ => 1,
+            }
+        }
+        println!("corpus\trole\tkind\talternatives\tshape ns\tengine ns\tshape/engine\tinputs\tpattern");
+        for name in names {
+            let schema: serde_json::Value =
+                serde_json::from_str(&std::fs::read_to_string(format!("{dir}/{name}-schema.json")).unwrap()).unwrap();
+            let (mut strings, mut keys) = (BTreeSet::new(), BTreeSet::new());
+            for line in std::fs::read_to_string(format!("{dir}/{name}-instances.jsonl")).unwrap().lines() {
+                if !line.trim().is_empty() {
+                    collect(&serde_json::from_str(line).unwrap(), &mut strings, &mut keys);
+                }
+            }
+            let strings: Vec<String> = strings.into_iter().take(1000).collect();
+            let keys: Vec<String> = keys.into_iter().take(1000).collect();
+            let mut found = BTreeSet::new();
+            patterns(&schema, &mut found);
+            for (role, source) in found {
+                let Ok(shape) = compile(&source) else { continue };
+                if matches!(shape.matcher, Matcher::Engine(_)) {
+                    continue;
+                }
+                let inputs = if role == "pattern" { &strings } else { &keys };
+                if inputs.is_empty() {
+                    continue;
+                }
+                let regex = G.build(&source, true).or_else(|_| G.build(&source, false)).unwrap();
+                let engine = Pattern {
+                    source: source.clone(),
+                    grammar: G,
+                    matcher: Matcher::Engine(Box::new(regex)),
+                    retained: 0,
+                };
+                // The two must agree before their times mean anything.
+                let mut budget = PatternBudget::new(PatternLimit::new(None));
+                for s in inputs {
+                    assert_eq!(shape.is_match(s, &mut budget), engine.is_match(s, &mut budget), "{source:?} on {s:?}");
+                }
+                let (a, b) = (time(&shape, inputs), time(&engine, inputs));
+                println!(
+                    "{name}\t{role}\t{}\t{}\t{a:.1}\t{b:.1}\t{:.3}\t{}\t{source}",
+                    super::kind(&shape),
+                    alternatives(&shape.matcher),
+                    a / b,
+                    inputs.len()
+                );
+            }
         }
     }
 }