schemurai 2.3.0 → 3.0.0

data/ext/schemurai_native/src/diagnostics.rs

@@ -17,9 +17,25 @@ pub struct Report {
     errors: Vec<Error>,
     instance_path: String,
     schema_path: String,
+    // Explicit failure signal for the current evaluation, independent of the
+    // number or rendering of diagnostic records. Child evaluations isolate it.
+    failed: bool,
+    limits: budget::Limits,
+    limit_hit: (u32, usize),
 }
 impl Report {
-    fn add(&mut self, keyword: &'static str, source: (i32, Value), instance: Value, detail: usize) {
+    fn add(
+        &mut self,
+        keyword: &'static str,
+        source: (i32, Value),
+        instance: Value,
+        detail: usize,
+    ) -> Result<(), Verdict> {
+        if self.limits.enabled & 1 != 0 && self.errors.len() >= self.limits.max_errors {
+            self.limit_hit = (1, self.errors.len().saturating_add(1));
+            return Err(Unsupported);
+        }
+        self.failed = true;
         let schema_path = if keyword == "falseSchema" {
             self.schema_path.clone()
         } else {
@@ -34,13 +50,14 @@ impl Report {
             instance,
             detail,
         });
+        Ok(())
     }
-    fn scoped(
+    fn scoped<T>(
         &mut self,
         segment: &str,
         instance: Option<usize>,
-        visit: impl FnOnce(&mut Self) -> Result<(), Verdict>,
-    ) -> Result<(), Verdict> {
+        visit: impl FnOnce(&mut Self) -> Result<T, Verdict>,
+    ) -> Result<T, Verdict> {
         use std::fmt::Write;
         let schema_len = self.schema_path.len();
         let instance_len = self.instance_path.len();
@@ -54,13 +71,13 @@ impl Report {
         self.instance_path.truncate(instance_len);
         result
     }
-    fn property(
+    fn property<T>(
         &mut self,
         segment: &str,
         key: Value,
         schema_key: Option<Value>,
-        visit: impl FnOnce(&mut Self) -> Result<(), Verdict>,
-    ) -> Result<(), Verdict> {
+        visit: impl FnOnce(&mut Self) -> Result<T, Verdict>,
+    ) -> Result<T, Verdict> {
         let name = pointer_name(key)?;
         let segment = if let Some(key) = schema_key {
             format!("{segment}/{}", pointer_name(key)?)
@@ -91,22 +108,75 @@ fn pointer_name(value: Value) -> Result<String, Verdict> {
     Ok(name.replace('~', "~0").replace('/', "~1"))
 }
 
-impl Engine {
-    fn collect(
+impl Execution<'_> {
+    fn collect<const ANNOTATIONS: bool>(
         &self,
         report: &mut Report,
         node: usize,
         value: Value,
         depth: usize,
         active: scope::Context<'_>,
-    ) -> Result<(), Verdict> {
+    ) -> Result<Tracked, Verdict> {
         if depth > MAX_EVALUATION_DEPTH {
             return Err(Unsupported);
         }
+        if !self.budget.checkpoint() {
+            return Err(Unsupported);
+        }
         let kind = unsafe { sn_kind(value) };
         if kind == TYPE_UNSUPPORTED {
             return Err(Unsupported);
         }
+        self.collect_kind::<ANNOTATIONS>(report, node, value, depth, active, kind)
+    }
+    fn collect_kind<const ANNOTATIONS: bool>(
+        &self,
+        report: &mut Report,
+        node: usize,
+        value: Value,
+        depth: usize,
+        active: scope::Context<'_>,
+        kind: i32,
+    ) -> Result<Tracked, Verdict> {
+        // A diagnostic success is established by complete traversal, never by
+        // a short-circuit validity result. Keep exported annotations and the
+        // collection policy separate; failures retain their path-specific errors.
+        if !self.budget.checkpoint() {
+            return Err(Unsupported);
+        }
+        let key = self
+            .memo
+            .key(self, node, value, depth, active, &self.budget);
+        if self.budget.hit.get().0 != 0 {
+            return Err(Unsupported);
+        }
+        if let Some(key) = key
+            && let Some(result) = self.memo.diagnostic_success(key, ANNOTATIONS)
+        {
+            return Ok(result);
+        }
+        let result = self.collect_uncached::<ANNOTATIONS>(report, node, value, depth, active, kind);
+        if let Some(key) = key
+            && let Ok(coverage) = &result
+            && coverage.status == Valid
+        {
+            self.memo
+                .record_diagnostic_success(key, ANNOTATIONS, coverage);
+        }
+        result
+    }
+    fn collect_uncached<const ANNOTATIONS: bool>(
+        &self,
+        report: &mut Report,
+        node: usize,
+        value: Value,
+        depth: usize,
+        active: scope::Context<'_>,
+        kind: i32,
+    ) -> Result<Tracked, Verdict> {
+        if depth > MAX_EVALUATION_DEPTH {
+            return Err(Unsupported);
+        }
         let frame = scope::ScopeFrame {
             resource: self.metadata[node].resource,
             parent: active.scope,
@@ -116,19 +186,23 @@ impl Engine {
                 .or(self.metadata[node].primary_binding),
         };
         let active = self.enter_scope(node, active, &frame);
-        let tracked = self.tracks[node];
+        let tracked = ANNOTATIONS || self.tracks[node];
+        let parent_failed = std::mem::replace(&mut report.failed, false);
         let mut prior = Tracked::new(Valid);
         for (op, &source) in self.nodes[node].iter().zip(&self.error_operands[node]) {
+            if !self.budget.checkpoint() {
+                return Err(Unsupported);
+            }
             match op {
                 Op::Unsupported => return Err(Unsupported),
                 Op::Boolean(false) => {
-                    report.add("falseSchema", source, value, 0);
+                    report.add("falseSchema", source, value, 0)?;
                     prior = Tracked::new(Invalid);
                 }
                 Op::Boolean(true) => {}
                 Op::Type(mask) => {
                     if kind & mask == 0 {
-                        report.add("type", source, value, 0);
+                        report.add("type", source, value, 0)?;
                     }
                 }
                 Op::Const(..) | Op::Enum(..) => match self.leaf(op, kind, value, depth) {
@@ -142,12 +216,12 @@ impl Engine {
                         source,
                         value,
                         0,
-                    ),
+                    )?,
                     Valid => {}
                 },
                 Op::Number(required, rules) => {
                     if *required != 0 && kind & required == 0 {
-                        report.add("type", source, value, 0);
+                        report.add("type", source, value, 0)?;
                     }
                     if kind & TYPE_NUMBER != 0 {
                         let bits = rules.failures(value)?;
@@ -158,15 +232,18 @@ impl Engine {
                             (EXCLUSIVE_MINIMUM, "exclusiveMinimum"),
                             (MULTIPLE_OF, "multipleOf"),
                         ] {
+                            if !self.budget.checkpoint() {
+                                return Err(Unsupported);
+                            }
                             if bits & bit != 0 {
-                                report.add(keyword, source, value, 0);
+                                report.add(keyword, source, value, 0)?;
                             }
                         }
                     }
                 }
                 Op::String(required, rules) => {
                     if *required != 0 && kind != TYPE_STRING {
-                        report.add("type", source, value, 0);
+                        report.add("type", source, value, 0)?;
                     }
                     if kind == TYPE_STRING {
                         let len = if rules.min.is_some() || rules.max.is_some() {
@@ -175,22 +252,22 @@ impl Engine {
                             0
                         };
                         if rules.max.is_some_and(|max| len > max) {
-                            report.add("maxLength", source, value, len);
+                            report.add("maxLength", source, value, len)?;
                         }
                         if rules.min.is_some_and(|min| len < min) {
-                            report.add("minLength", source, value, len);
+                            report.add("minLength", source, value, len)?;
                         }
                         if let Some(pattern) = &rules.pattern {
-                            match pattern.eval(value) {
+                            match pattern.eval(self.caches, value) {
                                 Unsupported => return Err(Unsupported),
-                                Invalid => report.add("pattern", source, value, 0),
+                                Invalid => report.add("pattern", source, value, 0)?,
                                 Valid => {}
                             }
                         }
                         if let Some(format) = &rules.format {
                             match format.eval(value) {
                                 Unsupported => return Err(Unsupported),
-                                Invalid => report.add("format", source, value, 0),
+                                Invalid => report.add("format", source, value, 0)?,
                                 Valid => {}
                             }
                         }
@@ -206,15 +283,18 @@ impl Engine {
                                     source,
                                     value,
                                     0,
-                                ),
+                                )?,
                                 Valid => {}
                             }
                         }
                     }
                 }
                 Op::Array(required, rules) => {
+                    if kind == TYPE_ARRAY && !self.budget.checkpoint() {
+                        return Err(Unsupported);
+                    }
                     if *required != 0 && kind != TYPE_ARRAY {
-                        report.add("type", source, value, 0);
+                        report.add("type", source, value, 0)?;
                     }
                     if kind != TYPE_ARRAY {
                         continue;
@@ -222,24 +302,27 @@ impl Engine {
                     let mut coverage = Tracked::new(Valid);
                     let len = unsafe { sn_len(value) };
                     if rules.max.is_some_and(|max| len > max) {
-                        report.add("maxItems", source, value, len);
+                        report.add("maxItems", source, value, len)?;
                     }
                     if rules.min.is_some_and(|min| len < min) {
-                        report.add("minItems", source, value, len);
+                        report.add("minItems", source, value, len)?;
                     }
                     if rules.unique {
-                        match unique(value, depth, self.fixnum_flag) {
+                        match unique(value, depth, self.fixnum_flag, &self.budget) {
                             Unsupported => return Err(Unsupported),
-                            Invalid => report.add("uniqueItems", source, value, 0),
+                            Invalid => report.add("uniqueItems", source, value, 0)?,
                             Valid => {}
                         }
                     }
                     for (index, &child) in rules.prefix.iter().take(len).enumerate() {
+                        if !self.budget.checkpoint() {
+                            return Err(Unsupported);
+                        }
                         if tracked {
                             coverage.item(index);
                         }
                         report.scoped(&format!("prefixItems/{index}"), Some(index), |r| {
-                            self.collect(
+                            self.collect::<false>(
                                 r,
                                 child,
                                 unsafe { sn_entry(value, index) },
@@ -250,11 +333,14 @@ impl Engine {
                     }
                     if rules.list {
                         for (index, &child) in rules.items.iter().take(len).enumerate() {
+                            if !self.budget.checkpoint() {
+                                return Err(Unsupported);
+                            }
                             if tracked {
                                 coverage.item(index);
                             }
                             report.scoped(&format!("items/{index}"), Some(index), |r| {
-                                self.collect(
+                                self.collect::<false>(
                                     r,
                                     child,
                                     unsafe { sn_entry(value, index) },
@@ -265,11 +351,14 @@ impl Engine {
                         }
                         if let Some(child) = rules.additional {
                             for index in rules.items.len()..len {
+                                if !self.budget.checkpoint() {
+                                    return Err(Unsupported);
+                                }
                                 if tracked {
                                     coverage.item(index);
                                 }
                                 report.scoped("additionalItems", Some(index), |r| {
-                                    self.collect(
+                                    self.collect::<false>(
                                         r,
                                         child,
                                         unsafe { sn_entry(value, index) },
@@ -300,6 +389,7 @@ impl Engine {
                             }
                             _ => None,
                         };
+                        let pattern = pattern.filter(|_| !self.budget.timed());
                         let number = match self.nodes[child].as_slice() {
                             [Op::Number(required, number)] if depth < MAX_EVALUATION_DEPTH => {
                                 Some((*required, number))
@@ -312,81 +402,58 @@ impl Engine {
                             }
                             _ => None,
                         };
+                        let format = format.filter(|_| !self.budget.timed());
                         let content = match self.nodes[child].as_slice() {
                             [Op::String(required, string)] if depth < MAX_EVALUATION_DEPTH => {
                                 string.content_only().map(|content| (*required, content))
                             }
                             _ => None,
                         };
-                        if let Some((required, pattern)) = pattern {
+                        let content = content.filter(|_| !self.budget.timed());
+                        if pattern.is_some() || format.is_some() || content.is_some() {
                             let start = rules.prefix.len().min(len);
                             if tracked {
                                 for index in start..len {
+                                    if !self.budget.checkpoint() {
+                                        return Err(Unsupported);
+                                    }
                                     coverage.item(index);
                                 }
                             }
-                            let status = pattern.visit_invalid_items(
-                                required,
-                                &values[start..],
-                                |index, item| match report.scoped(
-                                    "items",
-                                    Some(start + index),
-                                    |r| self.collect(r, child, item, depth + 1, active),
-                                ) {
-                                    Ok(()) => Valid,
-                                    Err(status) => status,
-                                },
-                            );
-                            if status != Valid {
-                                return Err(status);
-                            }
-                        } else if let Some((required, format)) = format {
-                            let start = rules.prefix.len().min(len);
-                            if tracked {
-                                for index in start..len {
-                                    coverage.item(index);
+                            // The invalid callback is shared, but each scanner retains
+                            // its statically selected parser and guarded byte views.
+                            let invalid = |index, item| match report.scoped(
+                                "items",
+                                Some(start + index),
+                                |r| self.collect::<false>(r, child, item, depth + 1, active),
+                            ) {
+                                Ok(_) => Valid,
+                                Err(status) => status,
+                            };
+                            let status = match (pattern, format, content) {
+                                (Some((required, pattern)), _, _) => pattern.visit_invalid_items(
+                                    self.caches,
+                                    required,
+                                    &values[start..],
+                                    invalid,
+                                ),
+                                (_, Some((required, format)), _) => {
+                                    format.visit_invalid_items(required, &values[start..], invalid)
                                 }
-                            }
-                            let status = format.visit_invalid_items(
-                                required,
-                                &values[start..],
-                                |index, item| match report.scoped(
-                                    "items",
-                                    Some(start + index),
-                                    |r| self.collect(r, child, item, depth + 1, active),
-                                ) {
-                                    Ok(()) => Valid,
-                                    Err(status) => status,
-                                },
-                            );
-                            if status != Valid {
-                                return Err(status);
-                            }
-                        } else if let Some((required, content)) = content {
-                            let start = rules.prefix.len().min(len);
-                            if tracked {
-                                for index in start..len {
-                                    coverage.item(index);
+                                (_, _, Some((required, content))) => {
+                                    content.visit_invalid_items(required, &values[start..], invalid)
                                 }
-                            }
-                            let status = content.visit_invalid_items(
-                                required,
-                                &values[start..],
-                                |index, item| match report.scoped(
-                                    "items",
-                                    Some(start + index),
-                                    |r| self.collect(r, child, item, depth + 1, active),
-                                ) {
-                                    Ok(()) => Valid,
-                                    Err(status) => status,
-                                },
-                            );
+                                _ => unreachable!("a scalar item scanner was selected"),
+                            };
                             if status != Valid {
                                 return Err(status);
                             }
                         } else {
                             for (index, &item) in values.iter().enumerate().skip(rules.prefix.len())
                             {
+                                if !self.budget.checkpoint() {
+                                    return Err(Unsupported);
+                                }
                                 if tracked {
                                     coverage.item(index);
                                 }
@@ -417,29 +484,37 @@ impl Engine {
                                     continue;
                                 }
                                 report.scoped("items", Some(index), |r| {
-                                    self.collect(r, child, item, depth + 1, active)
+                                    self.collect::<false>(r, child, item, depth + 1, active)
                                 })?;
                             }
                         }
                     }
                     if let Some(child) = rules.contains {
-                        let mut matches = 0;
                         let values = if len == 0 {
                             &[]
                         } else {
                             unsafe { std::slice::from_raw_parts(sn_array_data(value), len) }
                         };
-                        for (index, &item) in values.iter().enumerate() {
-                            if !self.needs_diagnostics(child, item, depth + 1, active)? {
-                                matches += 1;
+                        let matches = evaluation::scan_contains(
+                            len,
+                            |index| match self.needs_diagnostics(
+                                child,
+                                values[index],
+                                depth + 1,
+                                active,
+                            ) {
+                                Ok(needs) => verdict(!needs),
+                                Err(status) => status,
+                            },
+                            |index| {
                                 if tracked {
                                     coverage.item(index);
                                 }
-                            }
-                        }
+                            },
+                        )?;
                         if bounds(matches, Some(rules.min_contains), rules.max_contains) == Invalid
                         {
-                            report.add("contains", source, value, matches);
+                            report.add("contains", source, value, matches)?;
                         }
                     }
                     if let Some(child) = rules
@@ -447,11 +522,14 @@ impl Engine {
                         .filter(|_| prior.item_count() < len && coverage.item_count() < len)
                     {
                         for index in 0..len {
+                            if !self.budget.checkpoint() {
+                                return Err(Unsupported);
+                            }
                             if prior.contains_item(index) || coverage.contains_item(index) {
                                 continue;
                             }
                             report.scoped("unevaluatedItems", Some(index), |r| {
-                                self.collect(
+                                self.collect::<false>(
                                     r,
                                     child,
                                     unsafe { sn_entry(value, index) },
@@ -467,8 +545,11 @@ impl Engine {
                     }
                 }
                 Op::Object(required, rules) => {
+                    if kind == TYPE_OBJECT && !self.budget.checkpoint() {
+                        return Err(Unsupported);
+                    }
                     if *required != 0 && kind != TYPE_OBJECT {
-                        report.add("type", source, value, 0);
+                        report.add("type", source, value, 0)?;
                     }
                     if kind != TYPE_OBJECT {
                         continue;
@@ -476,14 +557,17 @@ impl Engine {
                     let mut coverage = Tracked::new(Valid);
                     let len = unsafe { sn_len(value) };
                     if rules.max.is_some_and(|max| len > max) {
-                        report.add("maxProperties", source, value, len);
+                        report.add("maxProperties", source, value, len)?;
                     }
                     if rules.min.is_some_and(|min| len < min) {
-                        report.add("minProperties", source, value, len);
+                        report.add("minProperties", source, value, len)?;
                     }
                     for &name in &rules.required_order {
+                        if !self.budget.checkpoint() {
+                            return Err(Unsupported);
+                        }
                         if missing(value, name, self.undefined) {
-                            report.add("required", source, name, 0);
+                            report.add("required", source, name, 0)?;
                         }
                     }
                     let mut context = ObjectDiagnostics {
@@ -525,14 +609,20 @@ impl Engine {
                         }
                     }
                     for dependency in &rules.diagnostic_dependencies {
+                        if !self.budget.checkpoint() {
+                            return Err(Unsupported);
+                        }
                         match dependency {
                             DiagnosticDependency::Required(name, names, keyword) => {
                                 if missing(value, *name, self.undefined) {
                                     continue;
                                 }
                                 for &required in names {
+                                    if !self.budget.checkpoint() {
+                                        return Err(Unsupported);
+                                    }
                                     if missing(value, required, self.undefined) {
-                                        report.add(keyword, (source.0, *name), required, 0);
+                                        report.add(keyword, (source.0, *name), required, 0)?;
                                     }
                                 }
                             }
@@ -540,27 +630,42 @@ impl Engine {
                                 if missing(value, *name, self.undefined) {
                                     continue;
                                 }
-                                if self.needs_diagnostics(*child, value, depth + 1, active)? {
-                                    report.scoped(
+                                if tracked {
+                                    let result = report.scoped(
                                         &format!("{keyword}/{}", pointer_name(*name)?),
                                         None,
-                                        |r| self.collect(r, *child, value, depth + 1, active),
+                                        |r| {
+                                            self.collect::<true>(
+                                                r,
+                                                *child,
+                                                value,
+                                                depth + 1,
+                                                active,
+                                            )
+                                        },
                                     )?;
-                                }
-                                if tracked {
-                                    let result = self.eval_tracked_kind(
-                                        *child,
-                                        value,
-                                        depth + 1,
-                                        active,
-                                        kind,
-                                    );
-                                    if result.status == Unsupported {
-                                        return Err(Unsupported);
-                                    }
                                     if result.status == Valid {
                                         coverage.merge(result);
                                     }
+                                } else if self.needs_diagnostics(
+                                    *child,
+                                    value,
+                                    depth + 1,
+                                    active,
+                                )? {
+                                    report.scoped(
+                                        &format!("{keyword}/{}", pointer_name(*name)?),
+                                        None,
+                                        |r| {
+                                            self.collect::<false>(
+                                                r,
+                                                *child,
+                                                value,
+                                                depth + 1,
+                                                active,
+                                            )
+                                        },
+                                    )?;
                                 }
                             }
                         }
@@ -599,17 +704,18 @@ impl Engine {
                 Op::All(nodes) => {
                     let mut coverage = Tracked::new(Valid);
                     for (index, &child) in nodes.iter().enumerate() {
-                        report.scoped(&format!("allOf/{index}"), None, |r| {
-                            self.collect(r, child, value, depth + 1, active)
+                        if !self.budget.checkpoint() {
+                            return Err(Unsupported);
+                        }
+                        let result = report.scoped(&format!("allOf/{index}"), None, |r| {
+                            if tracked {
+                                self.collect_kind::<true>(r, child, value, depth + 1, active, kind)
+                            } else {
+                                self.collect_kind::<false>(r, child, value, depth + 1, active, kind)
+                            }
                         })?;
                         if tracked {
-                            coverage.merge_diagnostics(self.eval_tracked_kind(
-                                child,
-                                value,
-                                depth + 1,
-                                active,
-                                kind,
-                            ))?;
+                            coverage.merge_diagnostics(result)?;
                         }
                     }
                     if tracked {
@@ -617,52 +723,56 @@ impl Engine {
                     }
                 }
                 Op::Any(nodes) | Op::One(nodes) => {
-                    let mut matches = 0;
-                    let mut coverage = Tracked::new(Valid);
-                    for &(child, multiplicity) in nodes {
-                        let branch = if tracked {
-                            self.eval_tracked_kind(child, value, depth + 1, active, kind)
-                        } else {
-                            Tracked::new(self.eval(child, value, depth + 1, active))
-                        };
-                        match branch.status {
-                            Unsupported => return Err(Unsupported),
-                            Valid => {
-                                matches += multiplicity;
-                                if tracked {
-                                    coverage.merge(branch);
-                                }
-                            }
-                            Invalid => {}
-                        }
-                    }
-                    if (matches!(op, Op::Any(_)) && matches == 0)
-                        || (matches!(op, Op::One(_)) && matches != 1)
-                    {
-                        report.add(
-                            if matches!(op, Op::Any(_)) {
-                                "anyOf"
-                            } else {
-                                "oneOf"
+                    let branch_kind = if matches!(op, Op::Any(_)) {
+                        evaluation::BranchKind::Any
+                    } else {
+                        evaluation::BranchKind::One
+                    };
+                    // Complete scanning preserves exact oneOf counts and VM
+                    // exceptions from branches after an anyOf success.
+                    let result = if tracked {
+                        evaluation::scan_branches(
+                            nodes,
+                            evaluation::BranchPolicy::Complete,
+                            |child| self.eval_tracked_kind(child, value, depth + 1, active, kind),
+                        )?
+                    } else {
+                        let result = evaluation::scan_branches(
+                            nodes,
+                            evaluation::BranchPolicy::Complete,
+                            |child| {
+                                self.eval_with_kind(child, value, depth + 1, active, Some(kind))
                             },
-                            source,
-                            value,
-                            matches,
-                        );
+                        )?;
+                        evaluation::BranchMatches {
+                            matches: result.matches,
+                            coverage: Tracked::new(Valid),
+                        }
+                    };
+                    if !branch_kind.accepts(result.matches) {
+                        report.add(branch_kind.keyword(), source, value, result.matches)?;
                     } else if tracked {
-                        prior.merge_diagnostics(coverage)?;
+                        prior.merge_diagnostics(result.coverage)?;
+                    }
+                }
+                Op::Not(child) => {
+                    match self.eval_with_kind(*child, value, depth + 1, active, Some(kind)) {
+                        Unsupported => return Err(Unsupported),
+                        Valid => report.add("not", source, value, 0)?,
+                        Invalid => {}
                     }
                 }
-                Op::Not(child) => match self.eval(*child, value, depth + 1, active) {
-                    Unsupported => return Err(Unsupported),
-                    Valid => report.add("not", source, value, 0),
-                    Invalid => {}
-                },
                 Op::Conditional(condition, yes, no) => {
                     let condition = if tracked {
                         self.eval_tracked_kind(*condition, value, depth + 1, active, kind)
                     } else {
-                        Tracked::new(self.eval(*condition, value, depth + 1, active))
+                        Tracked::new(self.eval_with_kind(
+                            *condition,
+                            value,
+                            depth + 1,
+                            active,
+                            Some(kind),
+                        ))
                     };
                     let mut coverage = Tracked::new(Valid);
                     let (child, segment) = match condition.status {
@@ -676,17 +786,22 @@ impl Engine {
                         Invalid => (no, "else"),
                     };
                     if let Some(child) = child {
-                        report.scoped(segment, None, |r| {
-                            self.collect(r, *child, value, depth + 1, active)
+                        let result = report.scoped(segment, None, |r| {
+                            if tracked {
+                                self.collect_kind::<true>(r, *child, value, depth + 1, active, kind)
+                            } else {
+                                self.collect_kind::<false>(
+                                    r,
+                                    *child,
+                                    value,
+                                    depth + 1,
+                                    active,
+                                    kind,
+                                )
+                            }
                         })?;
                         if tracked {
-                            coverage.merge_diagnostics(self.eval_tracked_kind(
-                                *child,
-                                value,
-                                depth + 1,
-                                active,
-                                kind,
-                            ))?;
+                            coverage.merge_diagnostics(result)?;
                         }
                     }
                     if tracked {
@@ -707,34 +822,29 @@ impl Engine {
                         OP_DYNAMIC_REF => "$dynamicRef",
                         _ => "$ref",
                     };
-                    report.scoped(keyword, None, |r| {
-                        self.collect(
-                            r,
-                            self.reference_target(*target, active),
-                            value,
-                            depth + 1,
-                            scope::Context {
-                                active: Some(&frame),
-                                ..active
-                            },
-                        )
+                    let target = self.reference_target(*target, active);
+                    let active = scope::Context {
+                        active: Some(&frame),
+                        ..active
+                    };
+                    let result = report.scoped(keyword, None, |r| {
+                        if tracked {
+                            self.collect_kind::<true>(r, target, value, depth + 1, active, kind)
+                        } else {
+                            self.collect_kind::<false>(r, target, value, depth + 1, active, kind)
+                        }
                     })?;
                     if tracked {
-                        prior.merge_diagnostics(self.eval_tracked_kind(
-                            self.reference_target(*target, active),
-                            value,
-                            depth + 1,
-                            scope::Context {
-                                active: Some(&frame),
-                                ..active
-                            },
-                            kind,
-                        ))?;
+                        prior.merge_diagnostics(result)?;
                     }
                 }
             }
         }
-        Ok(())
+        let failed = report.failed;
+        report.failed |= parent_failed;
+        // Diagnostic coverage keeps local attempted locations for subsequent
+        // unevaluated checks; only a successful evaluation exports annotations.
+        Ok(if failed { Tracked::new(Invalid) } else { prior })
     }
 
     fn needs_diagnostics(
@@ -744,6 +854,9 @@ impl Engine {
         depth: usize,
         active: scope::Context<'_>,
     ) -> Result<bool, Verdict> {
+        if !self.budget.checkpoint() {
+            return Err(Unsupported);
+        }
         let status = match self.nodes[node].as_slice() {
             [Op::Number(required, rules)] if depth <= MAX_EVALUATION_DEPTH => {
                 rules.eval_guarded(*required, value)
@@ -773,7 +886,7 @@ impl Engine {
 }
 
 struct ObjectDiagnostics<'a, 'b, 'c> {
-    engine: &'a Engine,
+    engine: &'a Execution<'a>,
     report: &'b mut Report,
     rules: &'a Object,
     depth: usize,
@@ -787,10 +900,13 @@ struct ObjectDiagnostics<'a, 'b, 'c> {
 unsafe extern "C" fn object_diagnostic(context: *mut c_void, key: Value, value: Value) -> i32 {
     catch_unwind(AssertUnwindSafe(|| {
         let c = unsafe { &mut *context.cast::<ObjectDiagnostics<'_, '_, '_>>() };
+        if !c.engine.budget.checkpoint() {
+            return Unsupported as i32;
+        }
         let visit = |report: &mut Report, child: usize, item: Value, segment: &str, schema_key| {
             if c.engine.needs_diagnostics(child, item, c.depth, c.active)? {
                 report.property(segment, key, schema_key, |r| {
-                    c.engine.collect(r, child, item, c.depth, c.active)
+                    c.engine.collect::<false>(r, child, item, c.depth, c.active)
                 })?;
             }
             Ok::<_, Verdict>(())
@@ -818,28 +934,14 @@ unsafe extern "C" fn object_diagnostic(context: *mut c_void, key: Value, value:
                 c.coverage.property(c.engine, key);
                 return Ok(());
             }
-            let mut matched = false;
-            if !c.rules.properties.is_empty()
-                && let Some(&(name, child)) =
-                    c.rules.property_targets.get(&tracking::JsonKey::new(key))
-            {
-                matched = true;
-                visit(c.report, child, value, "properties", Some(name))?;
-            }
-            for ((pattern, child), &name) in c.rules.patterns.iter().zip(&c.rules.pattern_names) {
-                match pattern.eval(key) {
-                    Unsupported => return Err(Unsupported),
-                    Valid => {
-                        matched = true;
-                        visit(c.report, *child, value, "patternProperties", Some(name))?;
-                    }
-                    Invalid => {}
-                }
-            }
-            if !matched && let Some(child) = c.rules.additional {
-                visit(c.report, child, value, "additionalProperties", None)?;
-            }
-            if c.tracked && (matched || c.rules.additional.is_some()) {
+            let evaluated = c.rules.visit_value_rules::<true>(
+                c.engine.caches,
+                &c.engine.budget,
+                key,
+                None,
+                |segment, name, child| visit(c.report, child, value, segment, name),
+            )?;
+            if c.tracked && evaluated {
                 c.coverage.property(c.engine, key);
             }
             Ok(())
@@ -866,23 +968,28 @@ pub struct Record {
     detail: usize,
 }
 /// # Safety
-/// Engine and status must be live under the GVL; instance must be a Ruby VALUE.
+/// Engine/status must be live under the GVL; root must be in bounds and
+/// instance live. Caches must be null or live, validator-owned and not in use.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn sn_diagnose(
     engine: *const Engine,
+    caches: *const pattern::Caches,
+    root: usize,
     instance: Value,
     status: *mut i32,
 ) -> *mut Report {
     let result = catch_unwind(AssertUnwindSafe(|| {
         let engine = unsafe { &*engine };
+        let local = pattern::Caches::default();
+        let caches = unsafe { caches.as_ref() }.unwrap_or(&local);
+        let execution = Execution {
+            engine,
+            caches,
+            memo: memo::Memo::default(),
+            budget: budget::Budget::default(),
+        };
         let mut report = Report::default();
-        engine.collect(
-            &mut report,
-            engine.root,
-            instance,
-            0,
-            scope::Context::default(),
-        )?;
+        execution.collect::<false>(&mut report, root, instance, 0, scope::Context::default())?;
         Ok::<_, Verdict>(Box::into_raw(Box::new(report)))
     }));
     match result {
@@ -903,6 +1010,69 @@ pub unsafe extern "C" fn sn_diagnose(
     }
 }
 /// # Safety
+/// Same requirements as sn_diagnose; all limit/output pointers must be live.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_diagnose_with_limits(
+    engine: *const Engine,
+    caches: *const pattern::Caches,
+    root: usize,
+    instance: Value,
+    status: *mut i32,
+    limits: *const budget::Limits,
+    outcome: *mut budget::Outcome,
+) -> *mut Report {
+    let result = catch_unwind(AssertUnwindSafe(|| {
+        let local = pattern::Caches::default();
+        let caches = unsafe { caches.as_ref() }.unwrap_or(&local);
+        let limits = unsafe { *limits };
+        let execution = Execution {
+            engine: unsafe { &*engine },
+            caches,
+            memo: memo::Memo::default(),
+            budget: budget::Budget::new(limits),
+        };
+        let mut report = Report {
+            limits,
+            ..Report::default()
+        };
+        let result = if execution.budget.check_deadline() {
+            execution.collect::<false>(&mut report, root, instance, 0, scope::Context::default())
+        } else {
+            Err(Unsupported)
+        };
+        let result = if execution.budget.check_deadline() {
+            result
+        } else {
+            Err(Unsupported)
+        };
+        let hit = if report.limit_hit.0 != 0 {
+            report.limit_hit
+        } else {
+            execution.budget.hit.get()
+        };
+        unsafe {
+            ((*outcome).kind, (*outcome).attempted) = hit;
+        }
+        result.map(|_| Box::into_raw(Box::new(report)))
+    }));
+    match result {
+        Ok(Ok(report)) => {
+            unsafe { *status = VERDICT_VALID };
+            report
+        }
+        other => {
+            unsafe {
+                *status = if other.is_err() {
+                    STATUS_PANIC
+                } else {
+                    VERDICT_UNSUPPORTED
+                }
+            };
+            std::ptr::null_mut()
+        }
+    }
+}
+/// # Safety
 /// Report must be live under the GVL.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn sn_report_len(report: *const Report) -> usize {