schemurai 2.3.0 → 3.0.1

data/ext/schemurai_native/src/lib.rs

@@ -5,9 +5,17 @@ use std::collections::HashMap;
 use std::ffi::{c_char, c_void};
 use std::hash::{BuildHasherDefault, Hasher};
 use std::panic::{AssertUnwindSafe, catch_unwind};
+mod budget;
 mod content;
 mod diagnostics;
+mod enumeration;
+mod evaluation;
 mod format;
+mod graph;
+mod instance_graph;
+mod integer_scan;
+mod memo;
+mod memo_scope;
 mod number;
 mod pattern;
 // Some shared constants are consumed only by C or Ruby.
@@ -17,6 +25,7 @@ mod protocol {
 }
 use protocol::*;
 mod scope;
+mod structural;
 mod tracking;
 type Value = usize;
 unsafe extern "C" {
@@ -55,7 +64,6 @@ unsafe extern "C" {
     fn sn_big_equal(big: Value, other: Value) -> i32;
     fn sn_big_order(left: Value, right: Value) -> i32;
     fn sn_wide_integer_compare(value: Value, bound: Value) -> i32;
-    fn sn_integer_bytes(value: Value) -> usize;
     fn sn_float(value: Value) -> f64;
     fn sn_is_float(value: Value) -> i32;
     fn sn_is_rational(value: Value) -> i32;
@@ -80,6 +88,8 @@ unsafe extern "C" {
     fn sn_resolve(compiler: Value, program: Value, reference: Value, result: *mut Value) -> i32;
     fn sn_resolution_error(error: Value) -> i32;
     fn sn_resource_program(compiler: Value, resource: Value, result: *mut Value) -> i32;
+    fn sn_anchor_count(resource: Value) -> usize;
+    fn sn_anchor_names(compiler: Value, resource: Value, result: *mut Value) -> i32;
     fn sn_anchor_program(compiler: Value, resource: Value, name: Value, result: *mut Value) -> i32;
     fn sn_hash_each(
         value: Value,
@@ -114,7 +124,7 @@ enum Op {
     Ref(scope::Reference),
     Type(i32),
     Const(Value),
-    Enum(Vec<Value>),
+    Enum(Box<enumeration::Enumeration>),
     All(Vec<usize>),
     Any(Vec<(usize, usize)>),
     One(Vec<(usize, usize)>),
@@ -190,7 +200,7 @@ impl StringRules {
     fn eval_length_guarded(&self, required: i32, value: Value) -> Verdict {
         length_guarded(value, required, self.min, self.max)
     }
-    fn eval_guarded(&self, required: i32, value: Value) -> Verdict {
+    fn eval_guarded(&self, caches: &pattern::Caches, required: i32, value: Value) -> Verdict {
         let mut data = std::ptr::null();
         let mut len = 0;
         let encoding = unsafe { sn_pattern_item_view(value, &mut data, &mut len) };
@@ -200,14 +210,15 @@ impl StringRules {
             verdict(required == 0)
         } else {
             let bytes = unsafe { byte_view(data, len) };
-            self.eval_with_view::<true>(value, Some((bytes, encoding)))
+            self.eval_with_view::<true>(caches, value, Some((bytes, encoding)))
         }
     }
-    fn eval(&self, value: Value) -> Verdict {
-        self.eval_with_view::<false>(value, None)
+    fn eval(&self, caches: &pattern::Caches, value: Value) -> Verdict {
+        self.eval_with_view::<false>(caches, value, None)
     }
     fn eval_with_view<const BORROWED: bool>(
         &self,
+        caches: &pattern::Caches,
         value: Value,
         view: Option<(&[u8], i32)>,
     ) -> Verdict {
@@ -221,8 +232,8 @@ impl StringRules {
         }
         if let Some(pattern) = &self.pattern {
             let result = match view {
-                Some((bytes, encoding)) => pattern.eval_bytes(bytes, encoding),
-                None => pattern.eval(value),
+                Some((bytes, encoding)) => pattern.eval_bytes(caches, bytes, encoding),
+                None => pattern.eval(caches, value),
             };
             if result != Valid {
                 return result;
@@ -248,6 +259,12 @@ enum DiagnosticDependency {
     Required(Value, Vec<Value>, &'static str),
     Schema(Value, usize, &'static str),
 }
+#[derive(Clone, Copy, Debug)]
+struct PropertyTarget {
+    name: Value,
+    child: usize,
+    index: usize,
+}
 #[derive(Debug)]
 struct Object {
     record: Option<RecordObject>,
@@ -256,10 +273,12 @@ struct Object {
     required: Vec<Value>,
     required_order: Vec<Value>,
     properties: Vec<(Value, usize)>,
-    property_targets: HashMap<tracking::JsonKey, (Value, usize), BuildHasherDefault<BucketHasher>>,
+    property_targets: HashMap<tracking::JsonKey, PropertyTarget, BuildHasherDefault<BucketHasher>>,
     patterns: Vec<(pattern::Pattern, usize)>,
     pattern_names: Vec<Value>,
+    pattern_group: Option<pattern::PatternGroup>,
     required_properties: Vec<bool>,
+    required_property_indices: Vec<usize>,
     property_keys: tracking::KeySet,
     property_indices: Vec<usize>,
     additional: Option<usize>,
@@ -331,6 +350,203 @@ impl RecordShortIndex {
     }
 }
 impl Object {
+    // Keep these calls at their original evaluation positions: property
+    // failures and unsupported children must retain their ordering.
+    #[inline]
+    fn check_required(&self, value: Value, undefined: Value, budget: &budget::Budget) -> Verdict {
+        Self::check_keys(&self.required, value, undefined, budget)
+    }
+    #[inline]
+    fn check_keys(
+        keys: &[Value],
+        value: Value,
+        undefined: Value,
+        budget: &budget::Budget,
+    ) -> Verdict {
+        for &key in keys {
+            if !budget.checkpoint() {
+                return Unsupported;
+            }
+            if missing(value, key, undefined) {
+                return Invalid;
+            }
+        }
+        Valid
+    }
+    #[inline]
+    fn check_dependent_required(
+        &self,
+        value: Value,
+        undefined: Value,
+        budget: &budget::Budget,
+    ) -> Verdict {
+        for (name, required) in &self.dependent_required {
+            if !budget.checkpoint() {
+                return Unsupported;
+            }
+            if !missing(value, *name, undefined) {
+                let status = Self::check_keys(required, value, undefined, budget);
+                if status != Valid {
+                    return status;
+                }
+            }
+        }
+        Valid
+    }
+    fn visit_properties(
+        &self,
+        value: Value,
+        len: usize,
+        undefined: Value,
+        budget: &budget::Budget,
+        mut visit: impl FnMut(usize, usize, Value) -> Verdict,
+    ) -> Result<usize, Verdict> {
+        let mut found = 0;
+        if self.properties.len() > len.saturating_mul(4).max(8)
+            && self.property_targets.len() == self.properties.len()
+        {
+            // Discover only present schema fields, then retain schema order for
+            // validity, including required failures and unsupported children.
+            let mut candidates = PropertyCandidates {
+                rules: self,
+                budget,
+                indices: Vec::with_capacity(len.min(self.properties.len())),
+            };
+            let status = decode(unsafe {
+                sn_hash_each(
+                    value,
+                    (&mut candidates as *mut PropertyCandidates).cast(),
+                    property_candidate,
+                )
+            });
+            if status != Valid {
+                return Err(status);
+            }
+            candidates.indices.sort_unstable();
+            candidates.indices.dedup();
+            let mut missing_required = None;
+            for &index in &self.required_property_indices {
+                if !budget.checkpoint() {
+                    return Err(Unsupported);
+                }
+                if missing(value, self.properties[index].0, undefined) {
+                    missing_required = Some(index);
+                    break;
+                }
+            }
+            for index in candidates.indices {
+                if !budget.checkpoint() {
+                    return Err(Unsupported);
+                }
+                if missing_required.is_some_and(|missing| missing <= index) {
+                    return Err(Invalid);
+                }
+                let (key, child) = self.properties[index];
+                // Use the schema handle for the final lookup to retain identity
+                // Hash semantics, even when an equal input key found the index.
+                let item = unsafe { sn_lookup(value, key) };
+                if item == undefined {
+                    continue;
+                }
+                found += 1;
+                match visit(index, child, item) {
+                    Valid => {}
+                    status => return Err(status),
+                }
+            }
+            if missing_required.is_some() {
+                return Err(Invalid);
+            }
+        } else {
+            for (index, &(key, child)) in self.properties.iter().enumerate() {
+                if !budget.checkpoint() {
+                    return Err(Unsupported);
+                }
+                let item = unsafe { sn_lookup(value, key) };
+                if item == undefined {
+                    if self.required_properties[index] {
+                        return Err(Invalid);
+                    }
+                    continue;
+                }
+                found += 1;
+                match visit(index, child, item) {
+                    Valid => {}
+                    status => return Err(status),
+                }
+            }
+        }
+        Ok(found)
+    }
+
+    // All execution policies use the same property/pattern/additional routing.
+    // Schema-order validity scans have already visited declared properties;
+    // input-order diagnostic scans visit them here as well.
+    fn visit_value_rules<const PROPERTIES: bool>(
+        &self,
+        caches: &pattern::Caches,
+        budget: &budget::Budget,
+        key: Value,
+        location: Option<tracking::JsonKey>,
+        mut visit: impl FnMut(&'static str, Option<Value>, usize) -> Result<(), Verdict>,
+    ) -> Result<bool, Verdict> {
+        // Tracked scans already fingerprinted this key for location lookup.
+        // Reuse that result, and skip hashing for pattern-only object rules.
+        let mut matched = if self.properties.is_empty() {
+            false
+        } else if PROPERTIES {
+            if let Some(target) = self
+                .property_targets
+                .get(&location.unwrap_or_else(|| tracking::JsonKey::new(key)))
+            {
+                visit("properties", Some(target.name), target.child)?;
+                true
+            } else {
+                false
+            }
+        } else {
+            self.property_keys
+                .contains(&location.unwrap_or_else(|| tracking::JsonKey::new(key)))
+        };
+        if let Some(mut matches) = self
+            .pattern_group
+            .as_ref()
+            .and_then(|group| group.matches(key))
+        {
+            while matches != 0 {
+                if !budget.checkpoint() {
+                    return Err(Unsupported);
+                }
+                let index = matches.trailing_zeros() as usize;
+                matches &= matches - 1;
+                matched = true;
+                visit(
+                    "patternProperties",
+                    Some(self.pattern_names[index]),
+                    self.patterns[index].1,
+                )?;
+            }
+        } else {
+            for ((pattern, child), &name) in self.patterns.iter().zip(&self.pattern_names) {
+                if !budget.checkpoint() {
+                    return Err(Unsupported);
+                }
+                match pattern.eval(caches, key) {
+                    Unsupported => return Err(Unsupported),
+                    Invalid => {}
+                    Valid => {
+                        matched = true;
+                        visit("patternProperties", Some(name), *child)?;
+                    }
+                }
+            }
+        }
+        if !matched && let Some(child) = self.additional {
+            visit("additionalProperties", None, child)?;
+        }
+        Ok(matched || self.additional.is_some())
+    }
+
     fn with_record(mut self) -> Self {
         if self.required_order.len() > 64
             || !self.patterns.is_empty()
@@ -394,16 +610,27 @@ impl Object {
 #[derive(Default)]
 pub struct Roots {
     values: Vec<Value>,
+    binding_names: Vec<Value>,
 }
 #[derive(Default)]
 pub struct Engine {
     nodes: Vec<Vec<Op>>,
+    pattern_cache_count: usize,
     error_operands: Vec<Vec<(i32, Value)>>,
     tracks: Vec<bool>,
+    memoizable: Vec<bool>,
+    memo_contextual: Vec<bool>,
+    memo_guarded: Vec<bool>,
+    memo_guard_sources: Vec<bool>,
+    memo_guard_same_sources: Vec<bool>,
+    memo_guard_scalar_sources: Vec<bool>,
+    memo_guard_scalar_amplification: Vec<bool>,
+    memo_scope_projection: memo_scope::Projection,
     metadata: Vec<scope::Metadata>,
     resources: HashMap<Value, usize>,
-    dynamic_bindings: HashMap<(Value, usize), Option<usize>>,
+    dynamic_bindings: HashMap<(Value, usize), usize>,
     anchor_names: Vec<tracking::JsonKey>,
+    anchor_ids: HashMap<tracking::JsonKey, usize, BuildHasherDefault<BucketHasher>>,
     anchor_tables: Vec<Vec<(Value, usize)>>,
     property_ids: HashMap<tracking::JsonKey, usize, BuildHasherDefault<BucketHasher>>,
     indices: HashMap<Value, usize>,
@@ -580,7 +807,10 @@ impl Engine {
                     Op::Type(unsafe { sn_integer(mask) } as i32)
                 }
                 OP_CONST => Op::Const(operand),
-                OP_ENUM => Op::Enum(self.values(operand)),
+                OP_ENUM => Op::Enum(Box::new(enumeration::Enumeration::compile(
+                    self.values(operand),
+                    self.fixnum_flag,
+                ))),
                 OP_ALL_OF => Op::All(self.children(operand)?),
                 OP_ANY_OF => Op::Any(self.branches(operand)?),
                 OP_ONE_OF => Op::One(self.branches(operand)?),
@@ -652,7 +882,10 @@ impl Engine {
                                 pattern: if unsafe { sn_same(pattern, sn_nil()) } != 0 {
                                     None
                                 } else {
-                                    Some(pattern::Pattern::compile(pattern))
+                                    Some(pattern::Pattern::compile(
+                                        pattern,
+                                        &mut self.pattern_cache_count,
+                                    ))
                                 },
                             }),
                         )
@@ -698,11 +931,18 @@ impl Engine {
                     let dependencies = self.field(operand, b"dependencies\0")?;
                     {
                         let patterns = self.compile_map(patterns)?;
-                        let pattern_names = patterns.iter().map(|&(key, _)| key).collect();
-                        let patterns = patterns
+                        let pattern_names: Vec<_> = patterns.iter().map(|&(key, _)| key).collect();
+                        let patterns: Vec<_> = patterns
                             .into_iter()
-                            .map(|(key, child)| (pattern::Pattern::compile(key), child))
+                            .map(|(key, child)| {
+                                (
+                                    pattern::Pattern::compile(key, &mut self.pattern_cache_count),
+                                    child,
+                                )
+                            })
                             .collect();
+                        let pattern_group =
+                            pattern::PatternGroup::compile(&pattern_names, &patterns);
                         let required = self.field(operand, b"required\0")?;
                         let required = self.values(required);
                         let required_order = required.clone();
@@ -716,10 +956,17 @@ impl Engine {
                             ops.push(Op::Unsupported);
                             continue;
                         }
-                        let property_targets = properties
-                            .iter()
-                            .map(|&(key, child)| (tracking::JsonKey::new(key), (key, child)))
-                            .collect();
+                        let property_targets: HashMap<_, _, BuildHasherDefault<BucketHasher>> =
+                            properties
+                                .iter()
+                                .enumerate()
+                                .map(|(index, &(name, child))| {
+                                    (
+                                        tracking::JsonKey::new(name),
+                                        PropertyTarget { name, child, index },
+                                    )
+                                })
+                                .collect();
                         let property_locations: Vec<_> = properties
                             .iter()
                             .map(|&(key, _)| tracking::JsonKey::new(key))
@@ -732,20 +979,43 @@ impl Engine {
                                 *self.property_ids.entry(key).or_insert(next)
                             })
                             .collect();
-                        let required_properties = properties
+                        // Keep tiny schemas allocation-cheap; larger joins use
+                        // content-keyed sets and the already compiled property index.
+                        let indexed_required = properties.len().saturating_mul(required.len()) > 64;
+                        let required_keys: Option<tracking::KeySet> = indexed_required.then(|| {
+                            required
+                                .iter()
+                                .map(|&name| tracking::JsonKey::new(name))
+                                .collect()
+                        });
+                        let required_properties: Vec<bool> = property_locations
                             .iter()
-                            .map(|&(key, _)| {
-                                required
-                                    .iter()
-                                    .any(|&name| unsafe { sn_string_equal(key, name) } != 0)
+                            .map(|key| {
+                                required_keys.as_ref().map_or_else(
+                                    || {
+                                        required.iter().any(
+                                            |&name| unsafe { sn_string_equal(key.0, name) } != 0,
+                                        )
+                                    },
+                                    |names| names.contains(key),
+                                )
                             })
                             .collect();
+                        let required_property_indices = required_properties
+                            .iter()
+                            .enumerate()
+                            .filter_map(|(index, &required)| required.then_some(index))
+                            .collect();
                         let required = required
                             .into_iter()
                             .filter(|&name| {
-                                !properties
-                                    .iter()
-                                    .any(|&(key, _)| unsafe { sn_string_equal(key, name) } != 0)
+                                if indexed_required {
+                                    !property_targets.contains_key(&tracking::JsonKey::new(name))
+                                } else {
+                                    !properties
+                                        .iter()
+                                        .any(|&(key, _)| unsafe { sn_string_equal(key, name) } != 0)
+                                }
                             })
                             .collect();
                         let dependent = self.field(operand, b"dependent_required\0")?;
@@ -811,7 +1081,9 @@ impl Engine {
                             property_targets,
                             patterns,
                             pattern_names,
+                            pattern_group,
                             required_properties,
+                            required_property_indices,
                             property_keys,
                             property_indices,
                             additional: self.child(operand, b"additional\0")?,
@@ -894,7 +1166,65 @@ impl Engine {
         self.error_operands[index] = error_operands;
         Ok(index)
     }
+}
+
+// A view of immutable compiled data and validator-owned regex search caches.
+struct Execution<'a> {
+    engine: &'a Engine,
+    caches: &'a pattern::Caches,
+    memo: memo::Memo,
+    budget: budget::Budget,
+}
+impl std::ops::Deref for Execution<'_> {
+    type Target = Engine;
+    fn deref(&self) -> &Engine {
+        self.engine
+    }
+}
+impl Execution<'_> {
     fn eval(&self, node: usize, value: Value, depth: usize, active: scope::Context<'_>) -> Verdict {
+        self.eval_with_kind(node, value, depth, active, None)
+    }
+    // Same-location applicators borrow an immutable instance under the GVL.
+    // A full key guard can be reused; descendants at other locations recheck.
+    fn eval_with_kind(
+        &self,
+        node: usize,
+        value: Value,
+        depth: usize,
+        active: scope::Context<'_>,
+        known_kind: Option<i32>,
+    ) -> Verdict {
+        if !self.budget.checkpoint() {
+            return Unsupported;
+        }
+        let Some(key) = self
+            .memo
+            .key(self, node, value, depth, active, &self.budget)
+        else {
+            if self.budget.hit.get().0 != 0 {
+                return Unsupported;
+            }
+            return self.eval_uncached(node, value, depth, active, known_kind);
+        };
+        if self.budget.hit.get().0 != 0 {
+            return Unsupported;
+        }
+        if let Some(status) = self.memo.verdict(key) {
+            return status;
+        }
+        let status = self.eval_uncached(node, value, depth, active, known_kind);
+        self.memo.record_verdict(key, status);
+        status
+    }
+    fn eval_uncached(
+        &self,
+        node: usize,
+        value: Value,
+        depth: usize,
+        active: scope::Context<'_>,
+        known_kind: Option<i32>,
+    ) -> Verdict {
         let frame = scope::ScopeFrame {
             resource: self.metadata[node].resource,
             parent: active.scope,
@@ -905,7 +1235,13 @@ impl Engine {
         };
         let active = self.enter_scope(node, active, &frame);
         if self.tracks[node] {
-            return self.eval_tracked(node, value, depth, active).status;
+            return match known_kind {
+                Some(kind) => {
+                    self.eval_tracked_kind(node, value, depth, active, kind)
+                        .status
+                }
+                None => self.eval_tracked(node, value, depth, active).status,
+            };
         }
         if depth > MAX_EVALUATION_DEPTH {
             return Unsupported;
@@ -913,17 +1249,22 @@ impl Engine {
         if let [Op::String(required, rules)] = self.nodes[node].as_slice()
             && rules.pattern.is_some()
         {
-            return rules.eval_guarded(*required, value);
+            return rules.eval_guarded(self.caches, *required, value);
         }
-        let kind = if value & self.fixnum_flag != 0 {
-            TYPE_INTEGRAL_NUMBER
-        } else {
-            self.instance_kind(node, value)
-        };
+        let kind = known_kind.unwrap_or_else(|| {
+            if value & self.fixnum_flag != 0 {
+                TYPE_INTEGRAL_NUMBER
+            } else {
+                self.instance_kind(node, value)
+            }
+        });
         if kind == TYPE_UNSUPPORTED {
             return Unsupported;
         }
         for op in &self.nodes[node] {
+            if !self.budget.checkpoint() {
+                return Unsupported;
+            }
             let outcome = match op {
                 Op::Ref(target) => {
                     if RefFrame::contains(active.active, node, value) {
@@ -934,7 +1275,7 @@ impl Engine {
                             value,
                             parent: active.active,
                         };
-                        self.eval(
+                        self.eval_with_kind(
                             self.reference_target(*target, active),
                             value,
                             depth + 1,
@@ -942,13 +1283,17 @@ impl Engine {
                                 active: Some(&frame),
                                 ..active
                             },
+                            Some(kind),
                         )
                     }
                 }
                 Op::All(nodes) => {
                     let mut outcome = Valid;
                     for &n in nodes {
-                        outcome = self.eval(n, value, depth + 1, active);
+                        if !self.budget.checkpoint() {
+                            return Unsupported;
+                        }
+                        outcome = self.eval_with_kind(n, value, depth + 1, active, Some(kind));
                         if outcome != Valid {
                             break;
                         }
@@ -956,46 +1301,36 @@ impl Engine {
                     outcome
                 }
                 Op::Any(nodes) | Op::One(nodes) => {
-                    let mut matches = 0;
-                    let mut unknown = false;
-                    for &(n, multiplicity) in nodes {
-                        match self.eval(n, value, depth + 1, active) {
-                            Valid => matches += multiplicity,
-                            Unsupported => {
-                                unknown = true;
-                                break;
-                            }
-                            Invalid => {}
-                        }
-                        if matches > 0 && matches!(op, Op::Any(_)) {
-                            break;
-                        }
-                        if matches > 1 && matches!(op, Op::One(_)) {
-                            break;
-                        }
-                    }
-                    if unknown {
-                        Unsupported
+                    let branch_kind = if matches!(op, Op::Any(_)) {
+                        evaluation::BranchKind::Any
                     } else {
-                        verdict(if matches!(op, Op::Any(_)) {
-                            matches > 0
-                        } else {
-                            matches == 1
-                        })
+                        evaluation::BranchKind::One
+                    };
+                    match evaluation::scan_branches(
+                        nodes,
+                        evaluation::BranchPolicy::Validity(branch_kind),
+                        |child| self.eval_with_kind(child, value, depth + 1, active, Some(kind)),
+                    ) {
+                        Ok(result) => verdict(branch_kind.accepts(result.matches)),
+                        Err(status) => status,
                     }
                 }
-                Op::Not(n) => match self.eval(*n, value, depth + 1, active) {
+                Op::Not(n) => match self.eval_with_kind(*n, value, depth + 1, active, Some(kind)) {
                     Valid => Invalid,
                     Invalid => Valid,
                     Unsupported => Unsupported,
                 },
-                Op::Conditional(c, yes, no) => match self.eval(*c, value, depth + 1, active) {
-                    Unsupported => Unsupported,
-                    result => match if result == Valid { yes } else { no } {
-                        Some(n) => self.eval(*n, value, depth + 1, active),
-                        None => Valid,
-                    },
-                },
+                Op::Conditional(c, yes, no) => {
+                    match self.eval_with_kind(*c, value, depth + 1, active, Some(kind)) {
+                        Unsupported => Unsupported,
+                        result => match if result == Valid { yes } else { no } {
+                            Some(n) => {
+                                self.eval_with_kind(*n, value, depth + 1, active, Some(kind))
+                            }
+                            None => Valid,
+                        },
+                    }
+                }
                 Op::Array(required, rules) => {
                     if *required != 0 && kind != TYPE_ARRAY {
                         Invalid
@@ -1027,17 +1362,8 @@ impl Engine {
             Op::Unsupported => Unsupported,
             Op::Boolean(v) => verdict(*v),
             Op::Type(mask) => verdict(kind & mask != 0),
-            Op::Const(v) => equal(*v, value, depth),
-            Op::Enum(values) => {
-                let mut outcome = Invalid;
-                for &v in values {
-                    outcome = equal(v, value, depth);
-                    if outcome != Invalid {
-                        break;
-                    }
-                }
-                outcome
-            }
+            Op::Const(v) => equal_budgeted(*v, value, depth, &self.budget),
+            Op::Enum(values) => values.eval(value, kind, depth, self.fixnum_flag, &self.budget),
             Op::Number(required, rules) => {
                 if *required != 0 && kind & required == 0 {
                     Invalid
@@ -1053,24 +1379,30 @@ impl Engine {
                 } else if kind != TYPE_STRING {
                     Valid
                 } else {
-                    rules.eval(value)
+                    rules.eval(self.caches, value)
                 }
             }
             _ => unreachable!("applicators must be evaluated with their context"),
         }
     }
     fn array(&self, r: &Array, value: Value, depth: usize, active: scope::Context<'_>) -> Verdict {
+        if !self.budget.checkpoint() {
+            return Unsupported;
+        }
         let len = unsafe { sn_len(value) };
         if bounds(len, r.min, r.max) == Invalid {
             return Invalid;
         }
         if r.unique {
-            let result = unique(value, depth, self.fixnum_flag);
+            let result = unique(value, depth, self.fixnum_flag, &self.budget);
             if result != Valid {
                 return result;
             }
         }
         for (i, &child) in r.prefix.iter().take(len).enumerate() {
+            if !self.budget.checkpoint() {
+                return Unsupported;
+            }
             let result = self.eval(child, unsafe { sn_entry(value, i) }, depth, active);
             if result != Valid {
                 return result;
@@ -1078,6 +1410,9 @@ impl Engine {
         }
         if r.list {
             for (i, &child) in r.items.iter().take(len).enumerate() {
+                if !self.budget.checkpoint() {
+                    return Unsupported;
+                }
                 let result = self.eval(child, unsafe { sn_entry(value, i) }, depth, active);
                 if result != Valid {
                     return result;
@@ -1085,6 +1420,9 @@ impl Engine {
             }
             if let Some(child) = r.additional {
                 for i in r.items.len()..len {
+                    if !self.budget.checkpoint() {
+                        return Unsupported;
+                    }
                     let result = self.eval(child, unsafe { sn_entry(value, i) }, depth, active);
                     if result != Valid {
                         return result;
@@ -1142,16 +1480,29 @@ impl Engine {
             };
             let object_active = self.enter_scope(child, active, &frame);
             let pattern = string.and_then(|(required, rules)| {
-                rules.pattern_only().map(|pattern| (required, pattern))
+                rules
+                    .pattern_only()
+                    .map(|pattern| (required, pattern))
+                    .filter(|_| !self.budget.timed())
+            });
+            let format = string.and_then(|(required, rules)| {
+                rules
+                    .format_only()
+                    .map(|format| (required, format))
+                    .filter(|_| !self.budget.timed())
             });
-            let format = string
-                .and_then(|(required, rules)| rules.format_only().map(|format| (required, format)));
             let content = string.and_then(|(required, rules)| {
-                rules.content_only().map(|content| (required, content))
+                rules
+                    .content_only()
+                    .map(|content| (required, content))
+                    .filter(|_| !self.budget.timed())
             });
             if let Some((required, pattern)) = pattern {
-                let result =
-                    pattern.eval_items(required, values.get(r.prefix.len()..).unwrap_or(&[]));
+                let result = pattern.eval_items(
+                    self.caches,
+                    required,
+                    values.get(r.prefix.len()..).unwrap_or(&[]),
+                );
                 if result != Valid {
                     return result;
                 }
@@ -1191,11 +1542,14 @@ impl Engine {
                 }
             } else {
                 for &item in values.iter().skip(r.prefix.len()) {
+                    if !self.budget.checkpoint() {
+                        return Unsupported;
+                    }
                     let result = if let Some((required, rules)) = number {
                         rules.eval_guarded(required, item)
                     } else if let Some((required, rules)) = string {
                         if rules.pattern.is_some() {
-                            rules.eval_guarded(required, item)
+                            rules.eval_guarded(self.caches, required, item)
                         } else if rules.length_only() {
                             rules.eval_length_guarded(required, item)
                         } else {
@@ -1205,7 +1559,7 @@ impl Engine {
                             } else if kind != TYPE_STRING {
                                 verdict(required == 0)
                             } else {
-                                rules.eval(item)
+                                rules.eval(self.caches, item)
                             }
                         }
                     } else {
@@ -1218,20 +1572,64 @@ impl Engine {
             }
         }
         if let Some(child) = r.contains {
-            let mut matches = 0;
-            for i in 0..len {
-                match self.eval(child, unsafe { sn_entry(value, i) }, depth, active) {
-                    Valid => matches += 1,
-                    Unsupported => return Unsupported,
-                    Invalid => {}
-                }
+            if let Some(status) = self.fixnum_contains(r, child, value, len, depth) {
+                return status;
             }
+            let matches = match evaluation::scan_contains(
+                len,
+                |index| self.eval(child, unsafe { sn_entry(value, index) }, depth, active),
+                |_| {},
+            ) {
+                Ok(matches) => matches,
+                Err(status) => return status,
+            };
             if bounds(matches, Some(r.min_contains), r.max_contains) == Invalid {
                 return Invalid;
             }
         }
         Valid
     }
+    fn fixnum_contains(
+        &self,
+        rules: &Array,
+        child: usize,
+        value: Value,
+        len: usize,
+        depth: usize,
+    ) -> Option<Verdict> {
+        if depth > MAX_EVALUATION_DEPTH || self.tracks[child] || self.budget.timed() {
+            return None;
+        }
+        let [op] = self.nodes[child].as_slice() else {
+            return None;
+        };
+        let total = match op {
+            Op::Type(_) | Op::Boolean(_) => true,
+            Op::Const(expected) => expected & self.fixnum_flag != 0,
+            Op::Number(_, rules) => rules.fast_limits.is_some(),
+            _ => false,
+        };
+        if !total {
+            return None;
+        }
+        let values = if len == 0 {
+            &[]
+        } else {
+            unsafe { std::slice::from_raw_parts(sn_array_data(value), len) }
+        };
+        // Preserve later Unsupported/fallback results: no predicate work may
+        // be skipped until all values are proven to be supported Fixnums.
+        // This guard stays linear, but is far cheaper than full node evaluation.
+        if !values.iter().all(|&item| item & self.fixnum_flag != 0) {
+            return None;
+        }
+        Some(evaluation::contains_validity(
+            len,
+            rules.min_contains,
+            rules.max_contains,
+            |index| self.leaf(op, TYPE_INTEGRAL_NUMBER, values[index], depth) == Valid,
+        ))
+    }
     #[inline(never)]
     fn integer_items(
         &self,
@@ -1261,7 +1659,15 @@ impl Engine {
             }
             _ => None,
         };
-        for &value in values {
+        let prefix = if self.budget.timed() {
+            0
+        } else {
+            integer_scan::valid_prefix(values, min, max, self.fixnum_flag)
+        };
+        for &value in &values[prefix..] {
+            if !self.budget.checkpoint() {
+                return Unsupported;
+            }
             let result = if value & self.fixnum_flag != 0 {
                 let n = immediate_integer(value);
                 verdict(n >= min && n <= max)
@@ -1286,6 +1692,9 @@ impl Engine {
         active: scope::Context<'_>,
     ) -> Verdict {
         for &value in values {
+            if !self.budget.checkpoint() {
+                return Unsupported;
+            }
             let kind = if value & self.fixnum_flag != 0 {
                 TYPE_INTEGRAL_NUMBER
             } else {
@@ -1311,6 +1720,9 @@ impl Engine {
         depth: usize,
         active: scope::Context<'_>,
     ) -> Verdict {
+        if !self.budget.checkpoint() {
+            return Unsupported;
+        }
         if let Some(record) = &r.record {
             // C initializes only the written key/value pairs. The untouched
             // tail is never read, including empty and unsupported records.
@@ -1357,6 +1769,9 @@ impl Engine {
                 status,
             };
             for entry in entries.as_chunks::<2>().0 {
+                if !self.budget.checkpoint() {
+                    return Unsupported;
+                }
                 if record_entry(&mut context, entry[0], entry[1]) != Valid {
                     return Unsupported;
                 }
@@ -1390,26 +1805,20 @@ impl Engine {
         if bounds(len, r.min, r.max) == Invalid {
             return Invalid;
         }
-        for &key in &r.required {
-            if missing(value, key, self.undefined) {
-                return Invalid;
-            }
-        }
-        let mut found = 0;
-        for (index, &(key, child)) in r.properties.iter().enumerate() {
-            let item = unsafe { sn_lookup(value, key) };
-            if item == self.undefined {
-                if r.required_properties[index] {
-                    return Invalid;
-                }
-                continue;
-            }
-            found += 1;
-            let result = self.eval(child, item, depth, active);
-            if result != Valid {
-                return result;
-            }
-        }
+        let status = r.check_required(value, self.undefined, &self.budget);
+        if status != Valid {
+            return status;
+        }
+        let found = match r.visit_properties(
+            value,
+            len,
+            self.undefined,
+            &self.budget,
+            |_, child, item| self.eval(child, item, depth, active),
+        ) {
+            Ok(found) => found,
+            Err(status) => return status,
+        };
         if r.names.is_some() || !r.patterns.is_empty() || (r.additional.is_some() && found < len) {
             let mut context = ObjectContext {
                 engine: self,
@@ -1423,16 +1832,14 @@ impl Engine {
                 return if result == 0 { Invalid } else { Unsupported };
             }
         }
-        for (name, required) in &r.dependent_required {
-            if !missing(value, *name, self.undefined) {
-                for &key in required {
-                    if missing(value, key, self.undefined) {
-                        return Invalid;
-                    }
-                }
-            }
+        let status = r.check_dependent_required(value, self.undefined, &self.budget);
+        if status != Valid {
+            return status;
         }
         for &(name, child) in &r.dependent_schemas {
+            if !self.budget.checkpoint() {
+                return Unsupported;
+            }
             if !missing(value, name, self.undefined) {
                 let result = self.eval(child, value, depth, active);
                 if result != Valid {
@@ -1456,6 +1863,9 @@ impl Engine {
         depth: usize,
         active: scope::Context<'_>,
     ) -> Verdict {
+        if !self.budget.checkpoint() {
+            return Unsupported;
+        }
         match self.nodes[node].as_slice() {
             [Op::String(required, rules)]
                 if depth <= MAX_EVALUATION_DEPTH && rules.length_only() =>
@@ -1465,7 +1875,7 @@ impl Engine {
             [Op::String(required, rules)]
                 if depth <= MAX_EVALUATION_DEPTH && rules.pattern.is_some() =>
             {
-                rules.eval_guarded(*required, value)
+                rules.eval_guarded(self.caches, *required, value)
             }
             [
                 op @ (Op::Type(_)
@@ -1491,7 +1901,7 @@ impl Engine {
     }
 }
 struct RecordContext<'a, 'b> {
-    engine: &'a Engine,
+    engine: &'a Execution<'a>,
     rules: &'a Object,
     record: &'a RecordObject,
     indexed: bool,
@@ -1614,7 +2024,19 @@ fn length_guarded(value: Value, required: i32, min: Option<usize>, max: Option<u
 fn immediate_integer(value: Value) -> i64 {
     (value as isize >> 1) as i64
 }
-fn equal(a: Value, b: Value, depth: usize) -> Verdict {
+fn equal_budgeted(a: Value, b: Value, depth: usize, budget: &budget::Budget) -> Verdict {
+    equal_cached(a, b, depth, &mut structural::Cache::new(depth), budget)
+}
+fn equal_cached(
+    a: Value,
+    b: Value,
+    depth: usize,
+    memo: &mut structural::Cache<(Value, Value, usize), Verdict>,
+    budget: &budget::Budget,
+) -> Verdict {
+    if !budget.checkpoint() {
+        return Unsupported;
+    }
     if depth > MAX_EVALUATION_DEPTH {
         return Unsupported;
     }
@@ -1677,7 +2099,15 @@ fn equal(a: Value, b: Value, depth: usize) -> Verdict {
     if unsafe { sn_same_class(a, b) } == 0 {
         return Invalid;
     }
-    match ka {
+    let container = ka == TYPE_ARRAY || ka == TYPE_OBJECT;
+    let key = (a, b, depth);
+    if container
+        && memo.eligible(depth)
+        && let Some(result) = memo.get(key)
+    {
+        return result;
+    }
+    let result = match ka {
         TYPE_STRING => verdict(unsafe { sn_string_equal(a, b) } != 0),
         TYPE_ARRAY => {
             let len = unsafe { sn_len(a) };
@@ -1685,10 +2115,12 @@ fn equal(a: Value, b: Value, depth: usize) -> Verdict {
                 return Invalid;
             }
             for i in 0..len {
-                let result = equal(
+                let result = equal_cached(
                     unsafe { sn_entry(a, i) },
                     unsafe { sn_entry(b, i) },
                     depth + 1,
+                    memo,
+                    budget,
                 );
                 if result != Valid {
                     return result;
@@ -1703,18 +2135,24 @@ fn equal(a: Value, b: Value, depth: usize) -> Verdict {
             let mut context = EqualityContext {
                 other: b,
                 depth: depth + 1,
+                memo,
+                budget,
             };
             decode(unsafe {
                 sn_hash_each(
                     a,
-                    (&mut context as *mut EqualityContext).cast(),
+                    (&mut context as *mut EqualityContext<'_>).cast(),
                     equal_entry,
                 )
             })
         }
         TYPE_UNSUPPORTED => Unsupported,
         _ => Invalid,
+    };
+    if container && memo.eligible(depth) {
+        memo.record(key, result);
     }
+    result
 }
 fn decode(result: i32) -> Verdict {
     match result {
@@ -1723,21 +2161,26 @@ fn decode(result: i32) -> Verdict {
         _ => Unsupported,
     }
 }
-struct EqualityContext {
+struct EqualityContext<'a> {
     other: Value,
     depth: usize,
+    memo: &'a mut structural::Cache<(Value, Value, usize), Verdict>,
+    budget: &'a budget::Budget,
 }
 unsafe extern "C" fn equal_entry(context: *mut c_void, key: Value, value: Value) -> i32 {
     catch_unwind(AssertUnwindSafe(|| {
-        let c = unsafe { &*context.cast::<EqualityContext>() };
+        let c = unsafe { &mut *context.cast::<EqualityContext<'_>>() };
         if unsafe { sn_kind(key) } != TYPE_STRING {
             return Unsupported as i32;
         }
+        if !c.budget.checkpoint() {
+            return Unsupported as i32;
+        }
         let other = unsafe { sn_lookup(c.other, key) };
         if unsafe { sn_missing(other) } != 0 {
             Invalid as i32
         } else {
-            equal(value, other, c.depth) as i32
+            equal_cached(value, other, c.depth, c.memo, c.budget) as i32
         }
     }))
     .unwrap_or(Unsupported as i32)
@@ -1816,7 +2259,33 @@ fn bytes_fingerprint(bytes: &[u8]) -> u64 {
     }
     mix(result ^ TYPE_STRING as u64)
 }
-fn fingerprint(value: Value, depth: usize, fixnum_flag: Value, big_hint: bool) -> Option<u64> {
+fn fingerprint_budgeted(
+    value: Value,
+    depth: usize,
+    fixnum_flag: Value,
+    big_hint: bool,
+    budget: &budget::Budget,
+) -> Option<u64> {
+    fingerprint_cached(
+        value,
+        depth,
+        fixnum_flag,
+        big_hint,
+        &mut structural::Cache::new(depth),
+        budget,
+    )
+}
+fn fingerprint_cached(
+    value: Value,
+    depth: usize,
+    fixnum_flag: Value,
+    big_hint: bool,
+    memo: &mut structural::Cache<(Value, usize), Option<u64>>,
+    budget: &budget::Budget,
+) -> Option<u64> {
+    if !budget.checkpoint() {
+        return None;
+    }
     if depth > MAX_EVALUATION_DEPTH {
         return None;
     }
@@ -1846,7 +2315,18 @@ fn fingerprint(value: Value, depth: usize, fixnum_flag: Value, big_hint: bool) -
         }
         return Some(mix(n.to_bits() ^ TYPE_NUMBER as u64));
     }
-    match kind {
+    let container = kind == TYPE_ARRAY || kind == TYPE_OBJECT;
+    // Batch reuse pays for wide shared containers immediately. Small shallow
+    // records keep the original cheap traversal, expanding at most four levels
+    // before the depth-based cache handles deeper shared graphs.
+    let cacheable = container && memo.eligible_container(depth, unsafe { len.assume_init() });
+    let key = (value, depth);
+    if cacheable
+        && let Some(result) = memo.get(key)
+    {
+        return result;
+    }
+    let result = match kind {
         TYPE_INTEGRAL_NUMBER => Some(number::integer_fingerprint(value)),
         TYPE_NULL => Some(mix(TYPE_NULL as u64)),
         TYPE_BOOLEAN => Some(mix(if unsafe { len.assume_init() } != 0 {
@@ -1868,7 +2348,9 @@ fn fingerprint(value: Value, depth: usize, fixnum_flag: Value, big_hint: bool) -
             // All descendants are read under the GVL without allocating Ruby
             // objects or invoking Ruby callbacks, so the borrowed view is stable.
             for &item in values {
-                hash = mix(hash ^ fingerprint(item, depth + 1, fixnum_flag, false)?);
+                hash =
+                    mix(hash
+                        ^ fingerprint_cached(item, depth + 1, fixnum_flag, false, memo, budget)?);
             }
             Some(hash)
         }
@@ -1878,23 +2360,31 @@ fn fingerprint(value: Value, depth: usize, fixnum_flag: Value, big_hint: bool) -
                 hash: 0,
                 depth: depth + 1,
                 fixnum_flag,
+                memo,
+                budget,
             };
             let status = unsafe {
                 sn_hash_each_key_view(
                     value,
-                    (&mut c as *mut FingerprintContext).cast(),
+                    (&mut c as *mut FingerprintContext<'_>).cast(),
                     fingerprint_entry,
                 )
             };
             (status == VERDICT_VALID).then(|| mix(c.hash ^ len as u64 ^ TYPE_OBJECT as u64))
         }
         _ => None,
+    };
+    if cacheable {
+        memo.record(key, result);
     }
+    result
 }
-struct FingerprintContext {
+struct FingerprintContext<'a> {
     hash: u64,
     depth: usize,
     fixnum_flag: Value,
+    memo: &'a mut structural::Cache<(Value, usize), Option<u64>>,
+    budget: &'a budget::Budget,
 }
 unsafe extern "C" fn fingerprint_entry(
     context: *mut c_void,
@@ -1903,8 +2393,12 @@ unsafe extern "C" fn fingerprint_entry(
     value: Value,
 ) -> i32 {
     catch_unwind(AssertUnwindSafe(|| {
-        let c = unsafe { &mut *context.cast::<FingerprintContext>() };
-        let Some(hash) = fingerprint(value, c.depth, c.fixnum_flag, false) else {
+        let c = unsafe { &mut *context.cast::<FingerprintContext<'_>>() };
+        if !c.budget.checkpoint() {
+            return Unsupported as i32;
+        }
+        let Some(hash) = fingerprint_cached(value, c.depth, c.fixnum_flag, false, c.memo, c.budget)
+        else {
             return Unsupported as i32;
         };
         c.hash ^= mix(bytes_fingerprint(unsafe { byte_view(data, len) }) ^ hash.rotate_left(17));
@@ -1929,15 +2423,19 @@ impl Hasher for BucketHasher {
         }
     }
 }
-fn unique(value: Value, depth: usize, fixnum_flag: Value) -> Verdict {
+fn unique(value: Value, depth: usize, fixnum_flag: Value, budget: &budget::Budget) -> Verdict {
     let len = unsafe { sn_len(value) };
+    if !budget.checkpoint() {
+        return Unsupported;
+    }
     if len <= 16 {
         for i in 0..len {
             for previous in 0..i {
-                match equal(
+                match equal_budgeted(
                     unsafe { sn_entry(value, previous) },
                     unsafe { sn_entry(value, i) },
                     depth,
+                    budget,
                 ) {
                     Valid => return Invalid,
                     Unsupported => return Unsupported,
@@ -1951,30 +2449,35 @@ fn unique(value: Value, depth: usize, fixnum_flag: Value) -> Verdict {
     // This is a checked optimization hint, not an instance shape assumption.
     let big_hint = unsafe { sn_is_bignum(values[0]) } != 0;
     if big_hint
+        && !budget.timed()
         && depth <= MAX_EVALUATION_DEPTH
         && let Some(result) = number::ordered_big_unique(values)
     {
         return result;
     }
     if big_hint && depth <= MAX_EVALUATION_DEPTH {
-        let result = unordered_big_unique(values);
+        let result = unordered_big_unique(values, budget);
         if result != Unsupported {
             return result;
         }
     }
+    let mut fingerprints = structural::Cache::batch(depth);
     indexed_unique(
         values,
-        |item| fingerprint(item, depth, fixnum_flag, big_hint),
-        |a, b| equal(a, b, depth),
+        |item| fingerprint_cached(item, depth, fixnum_flag, big_hint, &mut fingerprints, budget),
+        |a, b| equal_budgeted(a, b, depth, budget),
     )
 }
 // Keep Big-only sampling and retry state out of the common scalar path.
 #[inline(never)]
-fn unordered_big_unique(values: &[Value]) -> Verdict {
+fn unordered_big_unique(values: &[Value], budget: &budget::Budget) -> Verdict {
     let mut all_big = true;
     let result = indexed_unique_short(
         values,
         |item| {
+            if !budget.checkpoint() {
+                return None;
+            }
             let hash = number::big_low_fingerprint(item);
             if hash.is_none() {
                 all_big = false;
@@ -1982,6 +2485,9 @@ fn unordered_big_unique(values: &[Value]) -> Verdict {
             hash
         },
         |a, b| {
+            if !budget.checkpoint() {
+                return Unsupported;
+            }
             // Distinct integers sharing the short sample need the wider pass.
             if unsafe { sn_big_equal(a, b) } != 0 {
                 Valid
@@ -1994,15 +2500,41 @@ fn unordered_big_unique(values: &[Value]) -> Verdict {
         return result;
     }
     if all_big {
-        let result = indexed_unique_impl::<true>(values, number::big_low64_fingerprint, |a, b| {
-            verdict(unsafe { sn_big_equal(a, b) } != 0)
-        });
+        let result = indexed_unique_impl::<true>(
+            values,
+            |item| {
+                if !budget.checkpoint() {
+                    None
+                } else {
+                    number::big_low64_fingerprint(item)
+                }
+            },
+            |a, b| {
+                if !budget.checkpoint() {
+                    return Unsupported;
+                }
+                verdict(unsafe { sn_big_equal(a, b) } != 0)
+            },
+        );
         if result != Unsupported {
             return result;
         }
-        let result = indexed_unique(values, number::big_only_fingerprint, |a, b| {
-            verdict(unsafe { sn_big_equal(a, b) } != 0)
-        });
+        let result = indexed_unique(
+            values,
+            |item| {
+                if !budget.checkpoint() {
+                    None
+                } else {
+                    number::big_only_fingerprint(item)
+                }
+            },
+            |a, b| {
+                if !budget.checkpoint() {
+                    return Unsupported;
+                }
+                verdict(unsafe { sn_big_equal(a, b) } != 0)
+            },
+        );
         if result != Unsupported {
             return result;
         }
@@ -2157,13 +2689,16 @@ fn indexed_unique_slots<S: UniqueSlot, const BOUNDED: bool>(
                 slots[at] = S::new(hash, i);
                 break;
             };
-            if BOUNDED {
-                // Bound total bucket probing as well as equal fingerprints.
-                // A poor sampled-word distribution restarts with full hashes.
-                probes += 1;
-                if probes > values.len().saturating_mul(2) {
+            // A full fingerprint can still have adversarial low table bits.
+            // Bound probing independently of exact fingerprint collisions.
+            probes += 1;
+            if probes > values.len().saturating_mul(2) {
+                if BOUNDED {
                     return Unsupported;
                 }
+                // Release the hash table before allocating the flat index.
+                drop(slots);
+                return sorted_unique(values, fingerprint, equal);
             }
             if slot.matches(hash) {
                 match equal(values[previous], item) {
@@ -2184,6 +2719,56 @@ fn indexed_unique_slots<S: UniqueSlot, const BOUNDED: bool>(
     }
     Valid
 }
+fn sorted_unique(
+    values: &[Value],
+    mut fingerprint: impl FnMut(Value) -> Option<u64>,
+    mut equal: impl FnMut(Value, Value) -> Verdict,
+) -> Verdict {
+    let Some(bytes) = values
+        .len()
+        .checked_mul(std::mem::size_of::<(u64, usize)>())
+    else {
+        return Unsupported;
+    };
+    if bytes > MAX_UNIQUE_INDEX_BYTES {
+        return Unsupported;
+    }
+    let mut entries = Vec::new();
+    if entries.try_reserve_exact(values.len()).is_err() {
+        return Unsupported;
+    }
+    for (index, &value) in values.iter().enumerate() {
+        let Some(hash) = fingerprint(value) else {
+            break;
+        };
+        entries.push((hash, index));
+    }
+    let complete = entries.len() == values.len();
+    // O(n log n) sorting replaces quadratic slot probing. Exact equality is
+    // needed only within identical full fingerprints, in original array order.
+    entries.sort_unstable();
+    let mut decisive: Option<(usize, Verdict)> = None;
+    for group in entries.chunk_by(|a, b| a.0 == b.0) {
+        for at in 1..group.len() {
+            let index = group[at].1;
+            if decisive.is_some_and(|(earlier, _)| earlier <= index) {
+                break;
+            }
+            for &(_, previous) in &group[..at] {
+                let status = equal(values[previous], values[index]);
+                if status != Invalid {
+                    decisive = Some((index, status));
+                    break;
+                }
+            }
+        }
+    }
+    // A duplicate in the successfully fingerprinted prefix must precede a
+    // later unavailable fingerprint, just as it does in the streaming index.
+    decisive.map_or(if complete { Valid } else { Unsupported }, |(_, status)| {
+        if status == Valid { Invalid } else { status }
+    })
+}
 fn allocate_unique_slots<S: UniqueSlot>(capacity: usize) -> Option<Vec<S>> {
     let bytes = capacity.checked_mul(std::mem::size_of::<S>())?;
     if bytes > MAX_UNIQUE_INDEX_BYTES {
@@ -2194,8 +2779,30 @@ fn allocate_unique_slots<S: UniqueSlot>(capacity: usize) -> Option<Vec<S>> {
     slots.resize(capacity, S::EMPTY);
     Some(slots)
 }
+struct PropertyCandidates<'a> {
+    rules: &'a Object,
+    indices: Vec<usize>,
+    budget: &'a budget::Budget,
+}
+unsafe extern "C" fn property_candidate(context: *mut c_void, key: Value, _: Value) -> i32 {
+    catch_unwind(AssertUnwindSafe(|| {
+        let c = unsafe { &mut *context.cast::<PropertyCandidates<'_>>() };
+        if !c.budget.checkpoint() {
+            return Unsupported as i32;
+        }
+        if unsafe { sn_kind(key) } != TYPE_STRING {
+            return Unsupported as i32;
+        }
+        if let Some(target) = c.rules.property_targets.get(&tracking::JsonKey::new(key)) {
+            c.indices.push(target.index);
+        }
+        Valid as i32
+    }))
+    .unwrap_or(Unsupported as i32)
+}
+
 struct ObjectContext<'a> {
-    engine: &'a Engine,
+    engine: &'a Execution<'a>,
     rules: &'a Object,
     depth: usize,
     active: scope::Context<'a>,
@@ -2207,6 +2814,9 @@ struct ObjectContext<'a> {
 pub unsafe extern "C" fn sn_object_entry(context: *const c_void, key: Value, value: Value) -> i32 {
     catch_unwind(AssertUnwindSafe(|| {
         let c = unsafe { &*context.cast::<ObjectContext>() };
+        if !c.engine.budget.checkpoint() {
+            return Unsupported as i32;
+        }
         if unsafe { sn_kind(key) } != TYPE_STRING {
             return Unsupported as i32;
         }
@@ -2216,24 +2826,19 @@ pub unsafe extern "C" fn sn_object_entry(context: *const c_void, key: Value, val
                 return result as i32;
             }
         }
-        let mut matched = c.rules.property_keys.contains(&tracking::JsonKey::new(key));
-        for (pattern, child) in &c.rules.patterns {
-            match pattern.eval(key) {
-                Unsupported => return Unsupported as i32,
-                Invalid => {}
-                Valid => {
-                    matched = true;
-                    let result = c.engine.eval(*child, value, c.depth, c.active);
-                    if result != Valid {
-                        return result as i32;
-                    }
-                }
-            }
+        match c.rules.visit_value_rules::<false>(
+            c.engine.caches,
+            &c.engine.budget,
+            key,
+            None,
+            |_, _, child| match c.engine.eval(child, value, c.depth, c.active) {
+                Valid => Ok(()),
+                status => Err(status),
+            },
+        ) {
+            Ok(_) => Valid as i32,
+            Err(status) => status as i32,
         }
-        if !matched && let Some(child) = c.rules.additional {
-            return c.engine.eval(child, value, c.depth, c.active) as i32;
-        }
-        Valid as i32
     }))
     .unwrap_or(Unsupported as i32)
 }
@@ -2247,7 +2852,8 @@ pub extern "C" fn sn_new() -> *mut Engine {
     }))
 }
 /// # Safety
-/// Engine and error must be valid writable pointers; program must be a live VM Program under the GVL.
+/// Engine/error must be writable. Program must be a live VM Program (or Array
+/// of Programs when multiple is set), and compiler must be live under the GVL.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn sn_compile(
     engine: *mut Engine,
@@ -2255,6 +2861,7 @@ pub unsafe extern "C" fn sn_compile(
     compiler: Value,
     format: i32,
     content: i32,
+    multiple: i32,
     error: *mut Value,
 ) -> i32 {
     match catch_unwind(AssertUnwindSafe(|| {
@@ -2262,8 +2869,16 @@ pub unsafe extern "C" fn sn_compile(
         e.validate_format = format != 0;
         e.validate_content = content != 0;
         e.compiler = e.retain(compiler);
-        e.root = e.compile(program)?;
+        if multiple != 0 {
+            for program in e.values(program) {
+                e.compile(program)?;
+            }
+        } else {
+            e.root = e.compile(program)?;
+        }
         e.bind_dynamic_anchors()?;
+        e.simplify_dynamic_references();
+        e.compile_memoization();
         Ok::<_, Value>(())
     })) {
         Ok(Ok(())) => VERDICT_VALID,
@@ -2275,16 +2890,96 @@ pub unsafe extern "C" fn sn_compile(
     }
 }
 /// # Safety
-/// Engine must be initialized and value must be a live Ruby VALUE under the GVL.
+/// Engine must be fully initialized and program must be live.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_node_index(engine: *const Engine, program: Value) -> usize {
+    unsafe { &*engine }
+        .indices
+        .get(&program)
+        .copied()
+        .unwrap_or(usize::MAX)
+}
+/// # Safety
+/// Engine must be initialized.
 #[unsafe(no_mangle)]
-pub unsafe extern "C" fn sn_valid(engine: *const Engine, value: Value) -> i32 {
+pub unsafe extern "C" fn sn_root_index(engine: *const Engine) -> usize {
+    unsafe { &*engine }.root
+}
+/// # Safety
+/// Roots must be live and compilation must have finished.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_root_count(roots: *const Roots) -> usize {
+    unsafe { &*roots }.values.len()
+}
+/// # Safety
+/// Roots must be live and index in bounds, outside compilation.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_root_at(roots: *const Roots, index: usize) -> Value {
+    unsafe { &*roots }.values[index]
+}
+/// # Safety
+/// Engine must be initialized, root in bounds and value live under the GVL.
+/// Caches must be null or live, owned by this validator and not in use.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_valid(
+    engine: *const Engine,
+    caches: *const pattern::Caches,
+    root: usize,
+    value: Value,
+) -> i32 {
     catch_unwind(AssertUnwindSafe(|| {
         let e = unsafe { &*engine };
-        e.eval(e.root, value, 0, scope::Context::default()) as i32
+        let local = pattern::Caches::default();
+        let caches = unsafe { caches.as_ref() }.unwrap_or(&local);
+        Execution {
+            engine: e,
+            caches,
+            memo: memo::Memo::default(),
+            budget: budget::Budget::default(),
+        }
+        .eval(root, value, 0, scope::Context::default()) as i32
     }))
     .unwrap_or(STATUS_PANIC)
 }
 /// # Safety
+/// Same requirements as sn_valid; all limit/output pointers must be live.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_valid_with_limits(
+    engine: *const Engine,
+    caches: *const pattern::Caches,
+    root: usize,
+    value: Value,
+    limits: *const budget::Limits,
+    outcome: *mut budget::Outcome,
+) -> i32 {
+    let budget = budget::Budget::new(unsafe { *limits });
+    let result = catch_unwind(AssertUnwindSafe(|| {
+        let local = pattern::Caches::default();
+        let caches = unsafe { caches.as_ref() }.unwrap_or(&local);
+        let execution = Execution {
+            engine: unsafe { &*engine },
+            caches,
+            memo: memo::Memo::default(),
+            budget,
+        };
+        let result = if execution.budget.check_deadline() {
+            execution.eval(root, value, 0, scope::Context::default())
+        } else {
+            Unsupported
+        };
+        let result = if execution.budget.check_deadline() {
+            result
+        } else {
+            Unsupported
+        };
+        unsafe {
+            ((*outcome).kind, (*outcome).attempted) = execution.budget.hit.get();
+        }
+        result as i32
+    }));
+    result.unwrap_or(STATUS_PANIC)
+}
+/// # Safety
 /// Engine must be an owned pointer returned by sn_new, freed exactly once.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn sn_free(engine: *mut Engine) {
@@ -2303,7 +2998,11 @@ pub unsafe extern "C" fn sn_roots(engine: *const Engine) -> *const Roots {
 /// No mutable root borrow can be live across a Ruby allocation/callback.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn sn_roots_mark(roots: *const Roots) {
-    for &value in &unsafe { &*roots }.values {
+    for &value in unsafe { &*roots }
+        .values
+        .iter()
+        .chain(&unsafe { &*roots }.binding_names)
+    {
         unsafe { sn_pin(value) };
     }
 }
@@ -2312,7 +3011,8 @@ pub unsafe extern "C" fn sn_roots_mark(roots: *const Roots) {
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn sn_roots_size(roots: *const Roots) -> usize {
     std::mem::size_of::<Roots>()
-        + unsafe { &*roots }.values.capacity() * std::mem::size_of::<Value>()
+        + (unsafe { &*roots }.values.capacity() + unsafe { &*roots }.binding_names.capacity())
+            * std::mem::size_of::<Value>()
 }
 #[unsafe(no_mangle)]
 pub extern "C" fn sn_engine_header_size() -> usize {
@@ -2324,7 +3024,22 @@ pub extern "C" fn sn_engine_header_size() -> usize {
 pub unsafe extern "C" fn sn_size(engine: *const Engine) -> usize {
     let nodes = unsafe { &*std::ptr::addr_of!((*engine).nodes) };
     let operands = unsafe { &*std::ptr::addr_of!((*engine).error_operands) };
+    let contextual = unsafe { &*std::ptr::addr_of!((*engine).memo_contextual) };
+    let guarded = unsafe { &*std::ptr::addr_of!((*engine).memo_guarded) };
+    let sources = unsafe { &*std::ptr::addr_of!((*engine).memo_guard_sources) };
+    let same = unsafe { &*std::ptr::addr_of!((*engine).memo_guard_same_sources) };
+    let scalar = unsafe { &*std::ptr::addr_of!((*engine).memo_guard_scalar_sources) };
+    let amplification = unsafe { &*std::ptr::addr_of!((*engine).memo_guard_scalar_amplification) };
+    let projection = unsafe { &*std::ptr::addr_of!((*engine).memo_scope_projection) };
     std::mem::size_of::<Engine>()
+        + projection.memory_usage()
+        + (contextual.capacity()
+            + guarded.capacity()
+            + sources.capacity()
+            + same.capacity()
+            + scalar.capacity()
+            + amplification.capacity())
+            * std::mem::size_of::<bool>()
         + nodes.capacity() * std::mem::size_of::<Vec<Op>>()
         + operands.capacity() * std::mem::size_of::<Vec<(i32, Value)>>()
         + operands
@@ -2339,6 +3054,7 @@ pub unsafe extern "C" fn sn_size(engine: *const Engine) -> usize {
             .iter()
             .flatten()
             .map(|op| match op {
+                Op::Enum(values) => values.memory_usage(),
                 Op::String(_, rules) => {
                     std::mem::size_of::<StringRules>()
                         + rules
@@ -2347,7 +3063,12 @@ pub unsafe extern "C" fn sn_size(engine: *const Engine) -> usize {
                             .map_or(0, pattern::Pattern::memory_usage)
                 }
                 Op::Object(_, rules) => {
-                    rules.patterns.capacity() * std::mem::size_of::<(pattern::Pattern, usize)>()
+                    rules
+                        .pattern_group
+                        .as_ref()
+                        .map_or(0, pattern::PatternGroup::memory_usage)
+                        + rules.patterns.capacity()
+                            * std::mem::size_of::<(pattern::Pattern, usize)>()
                         + rules
                             .patterns
                             .iter()
@@ -2363,6 +3084,54 @@ pub unsafe extern "C" fn sn_size(engine: *const Engine) -> usize {
 mod tests {
     use super::*;
 
+    #[test]
+    fn falls_back_for_clustered_slots_without_comparing_distinct_fingerprints() {
+        let values: Vec<_> = (1..=4096).collect();
+        let mut hashes = 0;
+        assert_eq!(
+            indexed_unique(
+                &values,
+                |value| {
+                    hashes += 1;
+                    Some((value as u64) << 32)
+                },
+                |_, _| panic!("distinct full fingerprints cannot require equality"),
+            ),
+            Valid
+        );
+        assert!(hashes > values.len());
+        assert!(hashes <= values.len() * 2);
+    }
+
+    #[test]
+    fn sorted_collisions_preserve_exact_equality_and_early_results() {
+        let hash = |value| (value != 99).then_some(value as u64 % 2);
+        let equal = |a, b| verdict(a == b);
+        assert_eq!(sorted_unique(&[0, 2, 4, 1, 3, 5], hash, equal), Valid);
+        assert_eq!(sorted_unique(&[0, 2, 0, 99], hash, equal), Invalid);
+        assert_eq!(sorted_unique(&[0, 2, 99, 0], hash, equal), Unsupported);
+        assert_eq!(
+            sorted_unique(&[0, 1, 1, 2], hash, |a, b| {
+                if (a, b) == (0, 2) {
+                    Unsupported
+                } else {
+                    equal(a, b)
+                }
+            }),
+            Invalid
+        );
+        assert_eq!(
+            sorted_unique(&[0, 2, 1, 1], hash, |a, b| {
+                if (a, b) == (0, 2) {
+                    Unsupported
+                } else {
+                    equal(a, b)
+                }
+            }),
+            Unsupported
+        );
+    }
+
     #[test]
     fn bounds_unique_index_allocation() {
         assert_eq!(