schemurai 3.0.1 → 3.1.0

data/ext/schemurai_native/src/diagnostics.rs

@@ -2,113 +2,569 @@
 //! returning to C are the output records materialized as Ruby objects.
 use super::*;
 use tracking::Tracked;
+mod array;
+mod object;
 
+fn reference_keyword(opcode: i32) -> &'static str {
+    match opcode {
+        OP_RECURSIVE_REF => "$recursiveRef",
+        OP_DYNAMIC_REF => "$dynamicRef",
+        _ => "$ref",
+    }
+}
+
+#[derive(Clone)]
 struct Error {
     keyword: &'static str,
-    instance_path: String,
-    schema_path: String,
+    instance_path: pointer::Rendered,
+    schema_path: pointer::Rendered,
     opcode: i32,
     operand: Value,
     instance: Value,
     detail: usize,
+    message: Value,
 }
-#[derive(Default)]
+#[derive(Clone)]
+struct ErrorEntry {
+    source: (i32, Value),
+    instance: Value,
+    keyword: &'static str,
+    frame: Value,
+}
+#[derive(Clone, Default)]
 pub struct Report {
     errors: Vec<Error>,
-    instance_path: String,
-    schema_path: String,
+    annotations: bool,
+    evaluation: Option<Tracked>,
+    container_prior: Option<Tracked>,
+    entry: Option<ErrorEntry>,
+    attempts: usize,
+    collection_reset: usize,
+    reset_path_pops: bool,
+    instance_path: pointer::Path,
+    schema_path: pointer::Path,
     // Explicit failure signal for the current evaluation, independent of the
     // number or rendering of diagnostic records. Child evaluations isolate it.
     failed: bool,
+    silent: bool,
+    render_messages: bool,
     limits: budget::Limits,
     limit_hit: (u32, usize),
 }
 impl Report {
+    pub(super) fn same_collection_policy(&self, other: &Self) -> bool {
+        self.silent == other.silent
+    }
+
+    fn finish_runtime<T>(
+        &mut self,
+        caches: &runtime::Caches,
+        result: Result<T, Verdict>,
+    ) -> Result<T, Verdict> {
+        caches.apply_report_effects(self);
+        if matches!(result, Err(Unsupported)) {
+            caches.capture_report(self);
+        }
+        result
+    }
+
+    pub(super) fn complete_callback(&mut self, valid: bool) {
+        self.evaluation = Some(Tracked::new(if valid { Valid } else { Invalid }));
+    }
+
+    pub(super) fn clear_collection(&mut self, paths_nil: bool) {
+        self.collection_reset = self.collection_reset.saturating_add(1);
+        self.reset_path_pops = paths_nil;
+        self.errors.clear();
+        self.attempts = 0;
+        self.failed = false;
+        self.silent = true;
+        self.instance_path = pointer::Path::default();
+        self.schema_path = pointer::Path::default();
+    }
+    pub(super) fn effect_since(&self, before: &Self) -> Option<Self> {
+        if self.collection_reset != before.collection_reset {
+            return Some(Self {
+                errors: self.errors.clone(),
+                attempts: self.attempts,
+                collection_reset: self.collection_reset,
+                reset_path_pops: self.reset_path_pops,
+                failed: self.failed,
+                silent: self.silent,
+                instance_path: self.instance_path.clone(),
+                schema_path: self.schema_path.clone(),
+                ..Self::default()
+            });
+        }
+        let errors = self.errors.get(before.errors.len()..)?.to_vec();
+        let attempts = self.attempts.saturating_sub(before.attempts);
+        let failed = self.failed && !before.failed;
+        (!errors.is_empty() || attempts != 0 || failed).then_some(Self {
+            errors,
+            attempts,
+            failed,
+            ..Self::default()
+        })
+    }
+    pub(super) fn apply_effect(&mut self, effect: Self) {
+        if effect.collection_reset != 0 {
+            self.collection_reset = effect.collection_reset;
+            self.reset_path_pops = effect.reset_path_pops;
+            self.errors = effect.errors;
+            self.attempts = effect.attempts;
+            self.failed = effect.failed;
+            self.silent = effect.silent;
+            self.instance_path = effect.instance_path;
+            self.schema_path = effect.schema_path;
+            return;
+        }
+        self.errors.extend(effect.errors);
+        self.attempts = self.attempts.saturating_add(effect.attempts);
+        self.failed |= effect.failed;
+    }
+
+    pub(super) fn continuation(&self, annotations: bool) -> Self {
+        let mut report = self.clone();
+        report.annotations = annotations;
+        report.evaluation = None;
+        report.container_prior = None;
+        report.entry = None;
+        report
+    }
+    pub(super) fn adopt(&mut self, mut completed: Self) -> Tracked {
+        let evaluation = completed
+            .evaluation
+            .take()
+            .expect("completed native report");
+        completed.annotations = self.annotations;
+        completed.evaluation = self.evaluation.take();
+        completed.container_prior = self.container_prior.take();
+        let instance_path = std::mem::take(&mut self.instance_path);
+        let schema_path = std::mem::take(&mut self.schema_path);
+        *self = completed;
+        self.instance_path = instance_path;
+        self.schema_path = schema_path;
+        evaluation
+    }
+    pub(super) fn memory_usage(&self) -> usize {
+        self.errors.capacity() * std::mem::size_of::<Error>()
+            + self.instance_path.memory_usage()
+            + self.schema_path.memory_usage()
+            + self
+                .errors
+                .iter()
+                .map(|e| e.instance_path.memory_usage() + e.schema_path.memory_usage())
+                .sum::<usize>()
+            + self.evaluation.as_ref().map_or(0, Tracked::memory_usage)
+            + self
+                .container_prior
+                .as_ref()
+                .map_or(0, Tracked::memory_usage)
+    }
+    pub(super) fn mark(&self) {
+        for path in [&self.instance_path, &self.schema_path] {
+            for &(_, value) in &path.names {
+                unsafe {
+                    sn_pin(value);
+                }
+            }
+        }
+        for error in &self.errors {
+            unsafe {
+                sn_pin(error.instance_path.value());
+                sn_pin(error.schema_path.value());
+                sn_pin(error.operand);
+                sn_pin(error.instance);
+                sn_pin(error.message);
+            }
+        }
+        if let Some(evaluation) = &self.evaluation {
+            evaluation.mark();
+        }
+        if let Some(prior) = &self.container_prior {
+            prior.mark();
+        }
+        if let Some(entry) = &self.entry {
+            unsafe {
+                sn_pin(entry.source.1);
+                sn_pin(entry.instance);
+                sn_pin(entry.frame);
+            }
+        }
+    }
+    fn container_error(
+        &self,
+        engine: &Engine,
+        node: usize,
+        instance: Value,
+        keyword: &'static str,
+        frame: Value,
+        object: bool,
+    ) -> Self {
+        let source = engine.nodes[node]
+            .iter()
+            .zip(&engine.error_operands[node])
+            .find_map(|(op, &source)| {
+                (if object {
+                    matches!(op, Op::Object(..))
+                } else {
+                    matches!(op, Op::Array(..))
+                })
+                .then_some(source)
+            })
+            .expect("container source");
+        let mut seed = self.continuation(false);
+        seed.entry = Some(ErrorEntry {
+            source,
+            instance,
+            keyword,
+            frame,
+        });
+        seed
+    }
+    pub(super) fn container_continuation(&self, annotations: bool, prior: &Tracked) -> Self {
+        let mut report = self.continuation(annotations);
+        report.container_prior = Some(prior.clone());
+        report.evaluation = Some(Tracked::new(Valid));
+        report
+    }
     fn add(
         &mut self,
+        caches: &runtime::Caches,
         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));
+        self.add_with_frame(caches, keyword, source, instance, detail, None)
+    }
+    fn collect_header(
+        &mut self,
+        caches: &runtime::Caches,
+        header: &container::Header,
+        required: i32,
+        value: Value,
+        source: (i32, Value),
+    ) -> Result<bool, Verdict> {
+        let silent = self.silent;
+        let applied = header.failures(caches, required, value, silent, |keyword, frame| {
+            self.add_frame(caches, keyword, source, value, frame)
+        })?;
+        Ok(applied && silent && self.failed)
+    }
+    fn add_frame(
+        &mut self,
+        caches: &runtime::Caches,
+        keyword: &'static str,
+        source: (i32, Value),
+        instance: Value,
+        frame: Value,
+    ) -> Result<(), Verdict> {
+        self.add_with_frame(caches, keyword, source, instance, 0, Some(frame))
+    }
+    fn add_string(
+        &mut self,
+        caches: &runtime::Caches,
+        keyword: &'static str,
+        source: (i32, Value),
+        instance: Value,
+        frame: Value,
+        rescued: bool,
+    ) -> Result<(), Verdict> {
+        if !self.silent && !rescued && keyword != "type" {
+            if !caches.begin_string_error(frame, self.errors.len(), keyword) {
+                self.reserve_error()?;
+                return Err(Invalid);
+            }
+        } else {
+            caches.end_string_error();
+        }
+        let result = self.add_with_frame(
+            caches,
+            keyword,
+            source,
+            instance,
+            usize::from(rescued),
+            Some(frame),
+        );
+        if result != Err(Unsupported) {
+            caches.end_string_error();
+        }
+        result
+    }
+    fn reserve_error(&mut self) -> Result<(), Verdict> {
+        if self.limits.enabled & 1 != 0 && self.attempts >= self.limits.max_errors {
+            self.limit_hit = (1, self.attempts.saturating_add(1));
             return Err(Unsupported);
         }
+        self.attempts = self.attempts.saturating_add(1);
         self.failed = true;
-        let schema_path = if keyword == "falseSchema" {
-            self.schema_path.clone()
+        Ok(())
+    }
+    fn add_with_frame(
+        &mut self,
+        caches: &runtime::Caches,
+        keyword: &'static str,
+        source: (i32, Value),
+        instance: Value,
+        detail: usize,
+        frame: Option<Value>,
+    ) -> Result<(), Verdict> {
+        caches.apply_report_effects(self);
+        if self.silent {
+            self.failed = true;
+            return Ok(());
+        }
+        self.reserve_error()?;
+        caches.frame_error(frame.is_some());
+        let instance_path = self.instance_path.render(caches, None)?;
+        caches.apply_report_effects(self);
+        let keyword_segment = (!matches!(
+            keyword,
+            "falseSchema" | "$ref" | "$recursiveRef" | "$dynamicRef"
+        ))
+        .then_some(keyword);
+        let schema_path = self.schema_path.render(caches, keyword_segment)?;
+        caches.apply_report_effects(self);
+        let message = if self.render_messages || caches.dynamic_calls() {
+            if let Some(frame) = frame {
+                caches.frame_message(
+                    keyword,
+                    source,
+                    instance,
+                    frame,
+                    self.errors.len(),
+                    detail != 0,
+                )?
+            } else {
+                caches.error_message(keyword, source, instance, detail, self.errors.len())?
+            }
         } else {
-            format!("{}/{keyword}", self.schema_path)
+            unsafe { sn_nil() }
         };
+        caches.apply_report_effects(self);
         self.errors.push(Error {
             keyword,
-            instance_path: self.instance_path.clone(),
+            instance_path,
             schema_path,
             opcode: source.0,
             operand: source.1,
             instance,
             detail,
+            message,
         });
+        caches.frame_error(false);
         Ok(())
     }
+    fn cleanup_reset_paths<T>(
+        &mut self,
+        caches: &runtime::Caches,
+        reset: usize,
+        result: Result<T, Verdict>,
+        count: usize,
+    ) -> Result<T, Verdict> {
+        if self.collection_reset != reset
+            && self.reset_path_pops
+            && !matches!(result, Err(Unsupported))
+        {
+            for _ in 0..count {
+                caches.path_pop()?;
+            }
+        }
+        result
+    }
     fn scoped<T>(
         &mut self,
+        caches: &runtime::Caches,
         segment: &str,
         instance: Option<usize>,
         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();
-        self.schema_path.push('/');
+        if self.silent {
+            return visit(self);
+        }
+
+        let reset = self.collection_reset;
+        let schema_len = self.schema_path.checkpoint();
+        let instance_len = self.instance_path.checkpoint();
+        self.schema_path.push_str("/");
         self.schema_path.push_str(segment);
         if let Some(index) = instance {
-            write!(self.instance_path, "/{index}").unwrap();
+            self.instance_path.index(index);
         }
         let result = visit(self);
+        let result = self.cleanup_reset_paths(
+            caches,
+            reset,
+            result,
+            segment.split('/').count() + usize::from(instance.is_some()),
+        );
         self.schema_path.truncate(schema_len);
         self.instance_path.truncate(instance_len);
         result
     }
     fn property<T>(
         &mut self,
+        caches: &runtime::Caches,
         segment: &str,
         key: Value,
         schema_key: Option<Value>,
         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)?)
+        if self.silent {
+            return visit(self);
+        }
+
+        let reset = self.collection_reset;
+        let instance_len = self.instance_path.checkpoint();
+        self.instance_path.name(key)?;
+        let result = if let Some(key) = schema_key {
+            self.schema_name(caches, segment, key, visit)
         } else {
-            segment.to_owned()
+            self.scoped(caches, segment, None, visit)
         };
-        let instance_len = self.instance_path.len();
-        self.instance_path.push('/');
-        self.instance_path.push_str(&name);
-        let result = self.scoped(&segment, None, visit);
+        let result = self.cleanup_reset_paths(caches, reset, result, 1);
         self.instance_path.truncate(instance_len);
         result
     }
-}
 
-fn pointer_name(value: Value) -> Result<String, Verdict> {
-    if unsafe { sn_kind(value) } != TYPE_STRING {
-        return Err(Unsupported);
-    }
-    let mut data = std::ptr::null();
-    let mut len = 0;
-    let encoding = unsafe { sn_string_view(value, &mut data, &mut len) };
-    let bytes = unsafe { std::slice::from_raw_parts(data, len) };
-    if encoding == ENCODING_OTHER || (encoding == ENCODING_ASCII && !bytes.is_ascii()) {
-        return Err(Unsupported);
+    fn schema_name<T>(
+        &mut self,
+        caches: &runtime::Caches,
+        segment: &str,
+        key: Value,
+        visit: impl FnOnce(&mut Self) -> Result<T, Verdict>,
+    ) -> Result<T, Verdict> {
+        if self.silent {
+            return visit(self);
+        }
+
+        self.scoped(caches, segment, None, |report| {
+            report.schema_path.name(key)?;
+            let reset = report.collection_reset;
+            let result = visit(report);
+            report.cleanup_reset_paths(caches, reset, result, 1)
+        })
     }
-    let name = std::str::from_utf8(bytes).map_err(|_| Unsupported)?;
-    Ok(name.replace('~', "~0").replace('/', "~1"))
 }
 
 impl Execution<'_> {
+    pub(super) fn should_continue_report(&self, depth: usize) -> bool {
+        depth >= MAX_EVALUATION_DEPTH && self.caches.report_continuations_allowed()
+    }
+    fn collect_report(
+        &self,
+        report: &mut Report,
+        root: usize,
+        instance: Value,
+    ) -> Result<Tracked, Verdict> {
+        let result = self.collect_report_inner(report, root, instance);
+        report.finish_runtime(self.caches, result)
+    }
+    fn collect_report_inner(
+        &self,
+        report: &mut Report,
+        root: usize,
+        instance: Value,
+    ) -> Result<Tracked, Verdict> {
+        if let Some(entry) = report.entry.take() {
+            report.add_with_frame(
+                self.caches,
+                entry.keyword,
+                entry.source,
+                entry.instance,
+                0,
+                Some(entry.frame),
+            )?;
+            return Ok(Tracked::new(Invalid));
+        }
+        if report.annotations {
+            self.collect::<true>(report, root, instance, 0, scope::Context::default())
+        } else {
+            self.collect::<false>(report, root, instance, 0, scope::Context::default())
+        }
+    }
+    // Scalar trials export no annotations and need no evaluation memo entry.
+    // Keep this before memo admission, especially for contains over scalar arrays.
+    pub(super) fn trial_scalar(
+        &self,
+        node: usize,
+        value: Value,
+        depth: usize,
+        kind: i32,
+    ) -> Option<Verdict> {
+        if self.caches.scalar_callback() {
+            return None;
+        }
+        match self.nodes[node].as_slice() {
+            [Op::Number(required, rules)]
+                if kind != TYPE_UNSUPPORTED
+                    && !self.caches.dynamic_calls()
+                    && !rules.runtime_operands() =>
+            {
+                // A typed-integer failure still performs numeric conversion in
+                // a trial, so preserve nonfinite decimal exceptions as well.
+                let status = if kind & TYPE_NUMBER != 0 {
+                    let status = rules.eval(self.caches, value, &self.budget);
+                    if status != Unsupported && *required != 0 && kind & required == 0 {
+                        Invalid
+                    } else {
+                        status
+                    }
+                } else {
+                    verdict(*required == 0)
+                };
+                Some(status)
+            }
+            [op @ (Op::Boolean(_) | Op::Type(..))] => Some(self.leaf(op, kind, value, depth)),
+            [op @ Op::String(_, rules)]
+                if kind != TYPE_UNSUPPORTED
+                    && !self.caches.dynamic_calls()
+                    && (kind != TYPE_STRING
+                        || rules.length_only()
+                        || rules.pattern_only().is_some()
+                        || rules.format_only().is_some()
+                        || rules.content_only().is_some()) =>
+            {
+                Some(self.leaf(op, kind, value, depth))
+            }
+            _ => None,
+        }
+    }
+    pub(super) fn collect_trial(
+        &self,
+        node: usize,
+        value: Value,
+        depth: usize,
+        active: scope::Context<'_>,
+        kind_state: &InstanceKind,
+    ) -> Tracked {
+        if self.should_continue_report(depth) {
+            let mut report = Report {
+                silent: true,
+                ..Report::default()
+            };
+            return self
+                .caches
+                .report_child(node, value, &mut report, true)
+                .unwrap_or_else(Tracked::new);
+        }
+        let kind = kind_state.get();
+        if depth > MAX_EVALUATION_DEPTH || self.unsupported_kind(node, kind) {
+            return Tracked::new(Unsupported);
+        }
+        if !self.caches.scalar_callback()
+            && let [op @ (Op::Const(_) | Op::Enum(_))] = self.nodes[node].as_slice()
+        {
+            return Tracked::new(self.leaf(op, kind, value, depth));
+        }
+        let mut report = Report {
+            silent: true,
+            ..Report::default()
+        };
+        self.collect_uncached::<true>(&mut report, node, value, depth, active, kind_state)
+            .unwrap_or_else(Tracked::new)
+    }
     fn collect<const ANNOTATIONS: bool>(
         &self,
         report: &mut Report,
@@ -117,17 +573,21 @@ impl Execution<'_> {
         depth: usize,
         active: scope::Context<'_>,
     ) -> Result<Tracked, Verdict> {
+        if self.should_continue_report(depth) {
+            return self.caches.report_child(node, value, report, ANNOTATIONS);
+        }
         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 {
+        let kind_state = InstanceKind::new(TYPE_UNCHECKED);
+        let kind = self.diagnostic_kind(node, value, &kind_state);
+        if self.unsupported_kind(node, kind) {
             return Err(Unsupported);
         }
-        self.collect_kind::<ANNOTATIONS>(report, node, value, depth, active, kind)
+        self.collect_kind::<ANNOTATIONS>(report, node, value, depth, active, &kind_state)
     }
     fn collect_kind<const ANNOTATIONS: bool>(
         &self,
@@ -136,8 +596,31 @@ impl Execution<'_> {
         value: Value,
         depth: usize,
         active: scope::Context<'_>,
-        kind: i32,
+        kind_state: &InstanceKind,
     ) -> Result<Tracked, Verdict> {
+        let result =
+            self.collect_kind_inner::<ANNOTATIONS>(report, node, value, depth, active, kind_state);
+        report.finish_runtime(self.caches, result)
+    }
+    fn collect_kind_inner<const ANNOTATIONS: bool>(
+        &self,
+        report: &mut Report,
+        node: usize,
+        value: Value,
+        depth: usize,
+        active: scope::Context<'_>,
+        kind_state: &InstanceKind,
+    ) -> Result<Tracked, Verdict> {
+        if self.should_continue_report(depth) {
+            return self.caches.report_child(node, value, report, ANNOTATIONS);
+        }
+        let kind = self.diagnostic_kind(node, value, kind_state);
+        if self.unsupported_kind(node, kind) {
+            return Err(Unsupported);
+        }
+        // Silent children share this collection's failure state. Only actual
+        // trials create a fresh report in collect_trial; another isolated trial
+        // here would discard earlier failures when a Ruby caller rescues a raise.
         // 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.
@@ -155,7 +638,8 @@ impl Execution<'_> {
         {
             return Ok(result);
         }
-        let result = self.collect_uncached::<ANNOTATIONS>(report, node, value, depth, active, kind);
+        let result =
+            self.collect_uncached::<ANNOTATIONS>(report, node, value, depth, active, kind_state);
         if let Some(key) = key
             && let Ok(coverage) = &result
             && coverage.status == Valid
@@ -172,11 +656,41 @@ impl Execution<'_> {
         value: Value,
         depth: usize,
         active: scope::Context<'_>,
-        kind: i32,
+        kind_state: &InstanceKind,
+    ) -> Result<Tracked, Verdict> {
+        let result = self
+            .collect_uncached_inner::<ANNOTATIONS>(report, node, value, depth, active, kind_state);
+        report.finish_runtime(self.caches, result)
+    }
+    fn collect_uncached_inner<const ANNOTATIONS: bool>(
+        &self,
+        report: &mut Report,
+        node: usize,
+        value: Value,
+        depth: usize,
+        active: scope::Context<'_>,
+        kind_state: &InstanceKind,
     ) -> Result<Tracked, Verdict> {
+        let kind = kind_state.get();
+        // Callback results currently carry validity only. Preserve the existing
+        // diagnostic guard before any other assertion invokes Ruby methods.
+        if kind == TYPE_UNSUPPORTED
+            && (self.callback_container_node(node)
+                || self.nodes[node].iter().any(|op| match op {
+                    Op::Array(_, rules) => !rules.header_only(),
+                    Op::Object(_, rules) => !rules.header_only(),
+                    _ => false,
+                }))
+            && !self.caches.report_continuations_allowed()
+        {
+            return Err(Unsupported);
+        }
         if depth > MAX_EVALUATION_DEPTH {
             return Err(Unsupported);
         }
+        if self.caches.callback_checkpoint(value) != Valid {
+            return Err(Unsupported);
+        }
         let frame = scope::ScopeFrame {
             resource: self.metadata[node].resource,
             parent: active.scope,
@@ -186,28 +700,111 @@ impl Execution<'_> {
                 .or(self.metadata[node].primary_binding),
         };
         let active = self.enter_scope(node, active, &frame);
+        let _scope = self
+            .caches
+            .scope_guard(frame.resource, self.metadata[node].enters_scope);
         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.caches.callback_checkpoint(value) != Valid {
+                return Err(Unsupported);
+            }
             if !self.budget.checkpoint() {
                 return Err(Unsupported);
             }
+            // Container entry policy is shared; child traversal stays specific
+            // to each container's paths, assertions and annotation coverage.
+            let container = match op {
+                Op::Array(required, rules) => {
+                    Some((*required, &rules.header, rules.header_only(), TYPE_ARRAY))
+                }
+                Op::Object(required, rules) => {
+                    Some((*required, &rules.header, rules.header_only(), TYPE_OBJECT))
+                }
+                _ => None,
+            };
+            if let Some((required, header, header_only, expected_kind)) = container {
+                if self.caches.report_continuations_allowed()
+                    && !header_only
+                    && (kind == TYPE_UNSUPPORTED
+                        || self.caches.dynamic_calls()
+                        || prior.has_runtime_properties())
+                {
+                    let result = self.caches.container_report(
+                        node,
+                        value,
+                        (source.1, required, expected_kind == TYPE_OBJECT),
+                        report,
+                        &prior,
+                        tracked,
+                    )?;
+                    if tracked {
+                        prior.merge_diagnostics(self, result)?;
+                    }
+                    if report.silent && report.failed {
+                        break;
+                    }
+                    continue;
+                }
+                if header_only && header.runtime_required(self.caches, kind) {
+                    if report.collect_header(self.caches, header, required, value, source)? {
+                        break;
+                    }
+                    continue;
+                }
+                if kind == expected_kind && !self.budget.checkpoint() {
+                    return Err(Unsupported);
+                }
+                if required != 0 && kind != expected_kind {
+                    report.add(self.caches, "type", source, value, 0)?;
+                }
+                if kind != expected_kind {
+                    continue;
+                }
+                if report.silent {
+                    let status = match op {
+                        Op::Array(_, rules) => {
+                            self.array_tracked(rules, value, depth + 1, active, &mut prior)
+                        }
+                        Op::Object(_, rules) => {
+                            self.object_tracked(rules, value, depth + 1, active, &mut prior)
+                        }
+                        _ => unreachable!("container entry"),
+                    };
+                    if status == Unsupported {
+                        return Err(Unsupported);
+                    }
+                    report.failed |= status == Invalid;
+                    if report.failed {
+                        break;
+                    }
+                    continue;
+                }
+            }
             match op {
                 Op::Unsupported => return Err(Unsupported),
+                Op::UnresolvedRef(message) => {
+                    let keyword = reference_keyword(source.0);
+                    report.add(self.caches, keyword, (source.0, *message), value, 0)?;
+                    prior = Tracked::new(Invalid);
+                }
                 Op::Boolean(false) => {
-                    report.add("falseSchema", source, value, 0)?;
+                    report.add(self.caches, "falseSchema", source, value, 0)?;
                     prior = Tracked::new(Invalid);
                 }
                 Op::Boolean(true) => {}
-                Op::Type(mask) => {
-                    if kind & mask == 0 {
-                        report.add("type", source, value, 0)?;
+                Op::Type(mask, union) => match self.type_verdict(*mask, *union, kind, value) {
+                    Unsupported => return Err(Unsupported),
+                    Valid => {}
+                    Invalid => {
+                        report.add(self.caches, "type", source, value, 0)?;
                     }
-                }
+                },
                 Op::Const(..) | Op::Enum(..) => match self.leaf(op, kind, value, depth) {
                     Unsupported => return Err(Unsupported),
                     Invalid => report.add(
+                        self.caches,
                         if matches!(op, Op::Const(_)) {
                             "const"
                         } else {
@@ -220,30 +817,42 @@ impl Execution<'_> {
                     Valid => {}
                 },
                 Op::Number(required, rules) => {
+                    if kind == TYPE_UNSUPPORTED || self.caches.dynamic_calls() {
+                        rules.runtime_failures(self.caches, *required, value, |keyword| {
+                            report.add(self.caches, keyword, source, value, 0)
+                        })?;
+                        continue;
+                    }
                     if *required != 0 && kind & required == 0 {
-                        report.add("type", source, value, 0)?;
+                        report.add(self.caches, "type", source, value, 0)?;
                     }
                     if kind & TYPE_NUMBER != 0 {
-                        let bits = rules.failures(value)?;
-                        for (bit, keyword) in [
-                            (MAXIMUM, "maximum"),
-                            (MINIMUM, "minimum"),
-                            (EXCLUSIVE_MAXIMUM, "exclusiveMaximum"),
-                            (EXCLUSIVE_MINIMUM, "exclusiveMinimum"),
-                            (MULTIPLE_OF, "multipleOf"),
-                        ] {
-                            if !self.budget.checkpoint() {
-                                return Err(Unsupported);
-                            }
-                            if bits & bit != 0 {
-                                report.add(keyword, source, value, 0)?;
-                            }
-                        }
+                        rules.visit_failures(self.caches, value, &self.budget, |keyword| {
+                            report.add(self.caches, keyword, source, value, 0)
+                        })?;
                     }
                 }
                 Op::String(required, rules) => {
+                    if kind == TYPE_UNSUPPORTED || self.caches.dynamic_calls() {
+                        rules.runtime_failures(
+                            self.caches,
+                            *required,
+                            value,
+                            |keyword, frame, rescued| {
+                                report.add_string(
+                                    self.caches,
+                                    keyword,
+                                    source,
+                                    value,
+                                    frame,
+                                    rescued,
+                                )
+                            },
+                        )?;
+                        continue;
+                    }
                     if *required != 0 && kind != TYPE_STRING {
-                        report.add("type", source, value, 0)?;
+                        report.add(self.caches, "type", source, value, 0)?;
                     }
                     if kind == TYPE_STRING {
                         let len = if rules.min.is_some() || rules.max.is_some() {
@@ -252,29 +861,42 @@ impl Execution<'_> {
                             0
                         };
                         if rules.max.is_some_and(|max| len > max) {
-                            report.add("maxLength", source, value, len)?;
+                            report.add(self.caches, "maxLength", source, value, len)?;
                         }
                         if rules.min.is_some_and(|min| len < min) {
-                            report.add("minLength", source, value, len)?;
+                            report.add(self.caches, "minLength", source, value, len)?;
                         }
                         if let Some(pattern) = &rules.pattern {
-                            match pattern.eval(self.caches, value) {
+                            match pattern.assertion(self.caches, value) {
                                 Unsupported => return Err(Unsupported),
-                                Invalid => report.add("pattern", source, value, 0)?,
+                                Invalid => {
+                                    let invalid = pattern.invalid(self.caches, value);
+                                    report.add(
+                                        self.caches,
+                                        "pattern",
+                                        source,
+                                        value,
+                                        usize::from(invalid),
+                                    )?;
+                                    if invalid {
+                                        continue;
+                                    }
+                                }
                                 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(self.caches, "format", source, value, 0)?,
                                 Valid => {}
                             }
                         }
                         if let Some(content) = &rules.content {
-                            match content.eval(value) {
+                            match content.eval(self.caches, value) {
                                 Unsupported => return Err(Unsupported),
                                 Invalid => report.add(
+                                    self.caches,
                                     if content.base64 {
                                         "contentEncoding"
                                     } else {
@@ -289,28 +911,19 @@ impl Execution<'_> {
                         }
                     }
                 }
-                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)?;
-                    }
-                    if kind != TYPE_ARRAY {
-                        continue;
-                    }
+                Op::Array(_, rules) => {
                     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(self.caches, "maxItems", source, value, len)?;
                     }
                     if rules.min.is_some_and(|min| len < min) {
-                        report.add("minItems", source, value, len)?;
+                        report.add(self.caches, "minItems", source, value, len)?;
                     }
                     if rules.unique {
-                        match unique(value, depth, self.fixnum_flag, &self.budget) {
+                        match self.unique_values(value, depth) {
                             Unsupported => return Err(Unsupported),
-                            Invalid => report.add("uniqueItems", source, value, 0)?,
+                            Invalid => report.add(self.caches, "uniqueItems", source, value, 0)?,
                             Valid => {}
                         }
                     }
@@ -321,15 +934,20 @@ impl Execution<'_> {
                         if tracked {
                             coverage.item(index);
                         }
-                        report.scoped(&format!("prefixItems/{index}"), Some(index), |r| {
-                            self.collect::<false>(
-                                r,
-                                child,
-                                unsafe { sn_entry(value, index) },
-                                depth + 1,
-                                active,
-                            )
-                        })?;
+                        report.scoped(
+                            self.caches,
+                            &format!("prefixItems/{index}"),
+                            Some(index),
+                            |r| {
+                                self.collect::<false>(
+                                    r,
+                                    child,
+                                    unsafe { sn_entry(value, index) },
+                                    depth + 1,
+                                    active,
+                                )
+                            },
+                        )?;
                     }
                     if rules.list {
                         for (index, &child) in rules.items.iter().take(len).enumerate() {
@@ -339,15 +957,20 @@ impl Execution<'_> {
                             if tracked {
                                 coverage.item(index);
                             }
-                            report.scoped(&format!("items/{index}"), Some(index), |r| {
-                                self.collect::<false>(
-                                    r,
-                                    child,
-                                    unsafe { sn_entry(value, index) },
-                                    depth + 1,
-                                    active,
-                                )
-                            })?;
+                            report.scoped(
+                                self.caches,
+                                &format!("items/{index}"),
+                                Some(index),
+                                |r| {
+                                    self.collect::<false>(
+                                        r,
+                                        child,
+                                        unsafe { sn_entry(value, index) },
+                                        depth + 1,
+                                        active,
+                                    )
+                                },
+                            )?;
                         }
                         if let Some(child) = rules.additional {
                             for index in rules.items.len()..len {
@@ -357,20 +980,25 @@ impl Execution<'_> {
                                 if tracked {
                                     coverage.item(index);
                                 }
-                                report.scoped("additionalItems", Some(index), |r| {
-                                    self.collect::<false>(
-                                        r,
-                                        child,
-                                        unsafe { sn_entry(value, index) },
-                                        depth + 1,
-                                        active,
-                                    )
-                                })?;
+                                report.scoped(
+                                    self.caches,
+                                    "additionalItems",
+                                    Some(index),
+                                    |r| {
+                                        self.collect::<false>(
+                                            r,
+                                            child,
+                                            unsafe { sn_entry(value, index) },
+                                            depth + 1,
+                                            active,
+                                        )
+                                    },
+                                )?;
                             }
                         }
                     } else if let Some(&child) = rules.items.first() {
                         let primitive = match self.nodes[child].as_slice() {
-                            [Op::Type(mask)]
+                            [Op::Type(mask, _)]
                                 if mask & TYPE_NUMBER != 0 || mask & TYPE_INTEGER != 0 =>
                             {
                                 Some(&[][..])
@@ -378,6 +1006,7 @@ impl Execution<'_> {
                             [Op::Number(_, rules)] => rules.fast_limits.as_deref(),
                             _ => None,
                         };
+                        let primitive = primitive.filter(|_| !self.caches.dynamic_calls());
                         let values = if len == 0 {
                             &[]
                         } else {
@@ -389,9 +1018,12 @@ impl Execution<'_> {
                             }
                             _ => None,
                         };
-                        let pattern = pattern.filter(|_| !self.budget.timed());
+                        let pattern = pattern
+                            .filter(|_| !self.budget.timed() && !self.caches.dynamic_calls());
                         let number = match self.nodes[child].as_slice() {
-                            [Op::Number(required, number)] if depth < MAX_EVALUATION_DEPTH => {
+                            [Op::Number(required, number)]
+                                if depth < MAX_EVALUATION_DEPTH && !self.caches.dynamic_calls() =>
+                            {
                                 Some((*required, number))
                             }
                             _ => None,
@@ -402,14 +1034,16 @@ impl Execution<'_> {
                             }
                             _ => None,
                         };
-                        let format = format.filter(|_| !self.budget.timed());
+                        let format =
+                            format.filter(|_| !self.budget.timed() && !self.caches.dynamic_calls());
                         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,
                         };
-                        let content = content.filter(|_| !self.budget.timed());
+                        let content = content
+                            .filter(|_| !self.budget.timed() && !self.caches.dynamic_calls());
                         if pattern.is_some() || format.is_some() || content.is_some() {
                             let start = rules.prefix.len().min(len);
                             if tracked {
@@ -423,6 +1057,7 @@ impl Execution<'_> {
                             // The invalid callback is shared, but each scanner retains
                             // its statically selected parser and guarded byte views.
                             let invalid = |index, item| match report.scoped(
+                                self.caches,
                                 "items",
                                 Some(start + index),
                                 |r| self.collect::<false>(r, child, item, depth + 1, active),
@@ -440,9 +1075,12 @@ impl Execution<'_> {
                                 (_, Some((required, format)), _) => {
                                     format.visit_invalid_items(required, &values[start..], invalid)
                                 }
-                                (_, _, Some((required, content))) => {
-                                    content.visit_invalid_items(required, &values[start..], invalid)
-                                }
+                                (_, _, Some((required, content))) => content.visit_invalid_items(
+                                    self.caches,
+                                    required,
+                                    &values[start..],
+                                    invalid,
+                                ),
                                 _ => unreachable!("a scalar item scanner was selected"),
                             };
                             if status != Valid {
@@ -472,18 +1110,25 @@ impl Execution<'_> {
                                         _ => n > limit,
                                     })
                                 } else if let Some((required, number)) = number {
-                                    match number.eval_guarded(required, item) {
+                                    match number.eval_guarded(
+                                        self.caches,
+                                        required,
+                                        item,
+                                        &self.budget,
+                                    ) {
                                         Valid => false,
                                         Invalid => true,
-                                        Unsupported => return Err(Unsupported),
+                                        Unsupported => {
+                                            self.needs_diagnostics(child, item, depth + 1)?
+                                        }
                                     }
                                 } else {
-                                    self.needs_diagnostics(child, item, depth + 1, active)?
+                                    self.needs_diagnostics(child, item, depth + 1)?
                                 };
                                 if !needs {
                                     continue;
                                 }
-                                report.scoped("items", Some(index), |r| {
+                                report.scoped(self.caches, "items", Some(index), |r| {
                                     self.collect::<false>(r, child, item, depth + 1, active)
                                 })?;
                             }
@@ -497,15 +1142,8 @@ impl Execution<'_> {
                         };
                         let matches = evaluation::scan_contains(
                             len,
-                            |index| match self.needs_diagnostics(
-                                child,
-                                values[index],
-                                depth + 1,
-                                active,
-                            ) {
-                                Ok(needs) => verdict(!needs),
-                                Err(status) => status,
-                            },
+                            evaluation::ContainsPolicy::AllMatches,
+                            |index| self.trial_status(child, values[index], depth + 1, active),
                             |index| {
                                 if tracked {
                                     coverage.item(index);
@@ -514,7 +1152,7 @@ impl Execution<'_> {
                         )?;
                         if bounds(matches, Some(rules.min_contains), rules.max_contains) == Invalid
                         {
-                            report.add("contains", source, value, matches)?;
+                            report.add(self.caches, "contains", source, value, matches)?;
                         }
                     }
                     if let Some(child) = rules
@@ -528,7 +1166,7 @@ impl Execution<'_> {
                             if prior.contains_item(index) || coverage.contains_item(index) {
                                 continue;
                             }
-                            report.scoped("unevaluatedItems", Some(index), |r| {
+                            report.scoped(self.caches, "unevaluatedItems", Some(index), |r| {
                                 self.collect::<false>(
                                     r,
                                     child,
@@ -541,33 +1179,24 @@ impl Execution<'_> {
                         }
                     }
                     if tracked {
-                        prior.merge_diagnostics(coverage)?;
+                        prior.merge_diagnostics(self, coverage)?;
                     }
                 }
-                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)?;
-                    }
-                    if kind != TYPE_OBJECT {
-                        continue;
-                    }
+                Op::Object(_, rules) => {
                     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(self.caches, "maxProperties", source, value, len)?;
                     }
                     if rules.min.is_some_and(|min| len < min) {
-                        report.add("minProperties", source, value, len)?;
+                        report.add(self.caches, "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)?;
+                        if name.missing(self.caches, value, self.undefined)? {
+                            report.add(self.caches, "required", source, name.name, 0)?;
                         }
                     }
                     let mut context = ObjectDiagnostics {
@@ -621,8 +1250,14 @@ impl Execution<'_> {
                                     if !self.budget.checkpoint() {
                                         return Err(Unsupported);
                                     }
-                                    if missing(value, required, self.undefined) {
-                                        report.add(keyword, (source.0, *name), required, 0)?;
+                                    if required.missing(self.caches, value, self.undefined)? {
+                                        report.add(
+                                            self.caches,
+                                            keyword,
+                                            (source.0, *name),
+                                            required.name,
+                                            0,
+                                        )?;
                                     }
                                 }
                             }
@@ -631,10 +1266,8 @@ impl Execution<'_> {
                                     continue;
                                 }
                                 if tracked {
-                                    let result = report.scoped(
-                                        &format!("{keyword}/{}", pointer_name(*name)?),
-                                        None,
-                                        |r| {
+                                    let result =
+                                        report.schema_name(self.caches, keyword, *name, |r| {
                                             self.collect::<true>(
                                                 r,
                                                 *child,
@@ -642,30 +1275,16 @@ impl Execution<'_> {
                                                 depth + 1,
                                                 active,
                                             )
-                                        },
-                                    )?;
-                                    if result.status == Valid {
-                                        coverage.merge(result);
+                                        })?;
+                                    if result.status == Valid
+                                        && coverage.merge_runtime(self, result) == Unsupported
+                                    {
+                                        return Err(Unsupported);
                                     }
-                                } 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,
-                                            )
-                                        },
-                                    )?;
+                                } else if self.needs_diagnostics(*child, value, depth + 1)? {
+                                    report.schema_name(self.caches, keyword, *name, |r| {
+                                        self.collect::<false>(r, *child, value, depth + 1, active)
+                                    })?;
                                 }
                             }
                         }
@@ -698,7 +1317,7 @@ impl Execution<'_> {
                         }
                     }
                     if tracked {
-                        prior.merge_diagnostics(coverage)?;
+                        prior.merge_diagnostics(self, coverage)?;
                     }
                 }
                 Op::All(nodes) => {
@@ -707,19 +1326,34 @@ impl Execution<'_> {
                         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)
-                            }
-                        })?;
+                        let result =
+                            report.scoped(self.caches, &format!("allOf/{index}"), None, |r| {
+                                if tracked {
+                                    self.collect_kind::<true>(
+                                        r,
+                                        child,
+                                        value,
+                                        depth + 1,
+                                        active,
+                                        kind_state,
+                                    )
+                                } else {
+                                    self.collect_kind::<false>(
+                                        r,
+                                        child,
+                                        value,
+                                        depth + 1,
+                                        active,
+                                        kind_state,
+                                    )
+                                }
+                            })?;
                         if tracked {
-                            coverage.merge_diagnostics(result)?;
+                            coverage.merge_diagnostics(self, result)?;
                         }
                     }
                     if tracked {
-                        prior.merge_diagnostics(coverage)?;
+                        prior.merge_diagnostics(self, coverage)?;
                     }
                 }
                 Op::Any(nodes) | Op::One(nodes) => {
@@ -728,67 +1362,68 @@ impl Execution<'_> {
                     } 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))
-                            },
-                        )?;
-                        evaluation::BranchMatches {
-                            matches: result.matches,
-                            coverage: Tracked::new(Valid),
-                        }
-                    };
+                    // Trials execute complete scalar checks without retaining
+                    // errors or paths; ordinary validity may stop earlier.
+                    let result = evaluation::scan_branches(
+                        nodes,
+                        evaluation::BranchPolicy::Complete,
+                        self.caches.dynamic_calls(),
+                        |child| self.eval_tracked_kind(child, value, depth + 1, active, kind_state),
+                        |coverage, branch| {
+                            if coverage.merge_runtime(self, branch) == Unsupported {
+                                Err(Unsupported)
+                            } else {
+                                Ok(())
+                            }
+                        },
+                    )?;
                     if !branch_kind.accepts(result.matches) {
-                        report.add(branch_kind.keyword(), source, value, result.matches)?;
+                        report.add(
+                            self.caches,
+                            branch_kind.keyword(),
+                            source,
+                            value,
+                            result.matches,
+                        )?;
                     } else if tracked {
-                        prior.merge_diagnostics(result.coverage)?;
+                        prior.merge_diagnostics(self, result.coverage)?;
                     }
                 }
                 Op::Not(child) => {
-                    match self.eval_with_kind(*child, value, depth + 1, active, Some(kind)) {
+                    match self
+                        .eval_tracked_kind(*child, value, depth + 1, active, kind_state)
+                        .status
+                    {
                         Unsupported => return Err(Unsupported),
-                        Valid => report.add("not", source, value, 0)?,
+                        Valid => report.add(self.caches, "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_with_kind(
-                            *condition,
-                            value,
-                            depth + 1,
-                            active,
-                            Some(kind),
-                        ))
-                    };
+                    let condition =
+                        self.eval_tracked_kind(*condition, value, depth + 1, active, kind_state);
                     let mut coverage = Tracked::new(Valid);
                     let (child, segment) = match condition.status {
                         Unsupported => return Err(Unsupported),
                         Valid => {
-                            if tracked {
-                                coverage.merge(condition);
+                            if tracked && coverage.merge_runtime(self, condition) == Unsupported {
+                                return Err(Unsupported);
                             }
                             (yes, "then")
                         }
                         Invalid => (no, "else"),
                     };
                     if let Some(child) = child {
-                        let result = report.scoped(segment, None, |r| {
+                        let result = report.scoped(self.caches, segment, None, |r| {
                             if tracked {
-                                self.collect_kind::<true>(r, *child, value, depth + 1, active, kind)
+                                self.collect_kind::<true>(
+                                    r,
+                                    *child,
+                                    value,
+                                    depth + 1,
+                                    active,
+                                    kind_state,
+                                )
                             } else {
                                 self.collect_kind::<false>(
                                     r,
@@ -796,20 +1431,24 @@ impl Execution<'_> {
                                     value,
                                     depth + 1,
                                     active,
-                                    kind,
+                                    kind_state,
                                 )
                             }
                         })?;
                         if tracked {
-                            coverage.merge_diagnostics(result)?;
+                            coverage.merge_diagnostics(self, result)?;
                         }
                     }
                     if tracked {
-                        prior.merge_diagnostics(coverage)?;
+                        prior.merge_diagnostics(self, coverage)?;
                     }
                 }
                 Op::Ref(target) => {
-                    if RefFrame::contains(active.active, node, value) {
+                    let target = self.resolve_reference(*target, value, active)?;
+                    let program = self.programs[node];
+                    if RefFrame::contains(active.active, node, value)
+                        || self.caches.reference_active(program, value)
+                    {
                         continue;
                     }
                     let frame = RefFrame {
@@ -817,29 +1456,51 @@ impl Execution<'_> {
                         value,
                         parent: active.active,
                     };
-                    let keyword = match source.0 {
-                        OP_RECURSIVE_REF => "$recursiveRef",
-                        OP_DYNAMIC_REF => "$dynamicRef",
-                        _ => "$ref",
-                    };
-                    let target = self.reference_target(*target, active);
+                    let keyword = reference_keyword(source.0);
+                    let reference = self.caches.reference_frame(program, value);
+                    let _guard = self.caches.reference_guard(&reference);
                     let active = scope::Context {
                         active: Some(&frame),
                         ..active
                     };
-                    let result = report.scoped(keyword, None, |r| {
+                    let result = report.scoped(self.caches, keyword, None, |r| {
                         if tracked {
-                            self.collect_kind::<true>(r, target, value, depth + 1, active, kind)
+                            self.collect_kind::<true>(
+                                r,
+                                target,
+                                value,
+                                depth + 1,
+                                active,
+                                kind_state,
+                            )
                         } else {
-                            self.collect_kind::<false>(r, target, value, depth + 1, active, kind)
+                            self.collect_kind::<false>(
+                                r,
+                                target,
+                                value,
+                                depth + 1,
+                                active,
+                                kind_state,
+                            )
                         }
                     })?;
                     if tracked {
-                        prior.merge_diagnostics(result)?;
+                        prior.merge_diagnostics(self, result)?;
                     }
                 }
             }
+            self.caches.apply_report_effects(report);
+            if report.silent
+                && report.failed
+                && matches!(
+                    op,
+                    Op::All(_) | Op::Any(_) | Op::One(_) | Op::Not(_) | Op::Conditional(..)
+                )
+            {
+                break;
+            }
         }
+        self.caches.apply_report_effects(report);
         let failed = report.failed;
         report.failed |= parent_failed;
         // Diagnostic coverage keeps local attempted locations for subsequent
@@ -849,33 +1510,61 @@ impl Execution<'_> {
 
     fn needs_diagnostics(
         &self,
-        node: usize,
+        mut node: usize,
         value: Value,
-        depth: usize,
-        active: scope::Context<'_>,
+        mut depth: usize,
     ) -> Result<bool, Verdict> {
-        if !self.budget.checkpoint() {
-            return Err(Unsupported);
+        loop {
+            if !self.budget.checkpoint() {
+                return Err(Unsupported);
+            }
+            if depth > MAX_EVALUATION_DEPTH {
+                return Ok(true);
+            }
+            let [Op::Ref(reference)] = self.nodes[node].as_slice() else {
+                break;
+            };
+            let Some(target) = reference.static_target() else {
+                break;
+            };
+            node = target;
+            depth += 1;
         }
         let status = match self.nodes[node].as_slice() {
             [Op::Number(required, rules)] if depth <= MAX_EVALUATION_DEPTH => {
-                rules.eval_guarded(*required, value)
+                if self.caches.dynamic_calls()
+                    || self.diagnostic_kind(node, value, &InstanceKind::new(TYPE_UNCHECKED))
+                        == TYPE_UNSUPPORTED
+                {
+                    return Ok(true);
+                }
+                rules.eval_guarded(self.caches, *required, value, &self.budget)
             }
-            [op @ (Op::Type(_) | Op::Boolean(_) | Op::String(..) | Op::Const(_) | Op::Enum(_))]
-                if depth <= MAX_EVALUATION_DEPTH =>
-            {
-                let kind = if value & self.fixnum_flag != 0 {
-                    TYPE_INTEGRAL_NUMBER
-                } else {
-                    unsafe { sn_kind(value) }
-                };
-                if kind == TYPE_UNSUPPORTED {
+            [
+                op @ (Op::Type(..) | Op::Boolean(_) | Op::String(..) | Op::Const(_) | Op::Enum(_)),
+            ] if depth <= MAX_EVALUATION_DEPTH => {
+                let kind = self.diagnostic_kind(node, value, &InstanceKind::new(TYPE_UNCHECKED));
+                if (kind == TYPE_UNSUPPORTED
+                    && matches!(
+                        op,
+                        Op::Type(..) | Op::String(..) | Op::Const(_) | Op::Enum(_)
+                    ))
+                    || (self.caches.dynamic_calls()
+                        && matches!(op, Op::String(..) | Op::Const(_) | Op::Enum(_)))
+                {
+                    // Collection must execute a dynamic predicate once, rather
+                    // than once here and again while recording its failure.
+                    return Ok(true);
+                }
+                if self.unsupported_kind(node, kind) {
                     Unsupported
                 } else {
                     self.leaf(op, kind, value, depth)
                 }
             }
-            _ => self.eval(node, value, depth, active),
+            // A successful validity/trial scan can omit diagnostic-only work
+            // in descendants. Only complete collection proves their success.
+            _ => return Ok(true),
         };
         match status {
             Valid => Ok(false),
@@ -904,8 +1593,8 @@ unsafe extern "C" fn object_diagnostic(context: *mut c_void, key: Value, value:
             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| {
+            if c.engine.needs_diagnostics(child, item, c.depth)? {
+                report.property(c.engine.caches, segment, key, schema_key, |r| {
                     c.engine.collect::<false>(r, child, item, c.depth, c.active)
                 })?;
             }
@@ -934,9 +1623,10 @@ unsafe extern "C" fn object_diagnostic(context: *mut c_void, key: Value, value:
                 c.coverage.property(c.engine, key);
                 return Ok(());
             }
-            let evaluated = c.rules.visit_value_rules::<true>(
+            let evaluated = c.rules.visit_value_rules(
                 c.engine.caches,
                 &c.engine.budget,
+                true,
                 key,
                 None,
                 |segment, name, child| visit(c.report, child, value, segment, name),
@@ -962,10 +1652,20 @@ pub struct Record {
     instance_len: usize,
     schema_path: *const u8,
     schema_len: usize,
+    instance_pointer: Value,
+    schema_pointer: Value,
     opcode: i32,
     operand: Value,
     instance: Value,
     detail: usize,
+    message: Value,
+}
+fn report_outcome(result: std::thread::Result<Result<*mut Report, i32>>) -> (*mut Report, i32) {
+    match result {
+        Ok(Ok(report)) => (report, VERDICT_VALID),
+        Ok(Err(code)) => (std::ptr::null_mut(), code),
+        Err(_) => (std::ptr::null_mut(), STATUS_PANIC),
+    }
 }
 /// # Safety
 /// Engine/status must be live under the GVL; root must be in bounds and
@@ -973,14 +1673,14 @@ pub struct Record {
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn sn_diagnose(
     engine: *const Engine,
-    caches: *const pattern::Caches,
+    caches: *const runtime::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 local = runtime::Caches::default();
         let caches = unsafe { caches.as_ref() }.unwrap_or(&local);
         let execution = Execution {
             engine,
@@ -988,33 +1688,29 @@ pub unsafe extern "C" fn sn_diagnose(
             memo: memo::Memo::default(),
             budget: budget::Budget::default(),
         };
-        let mut report = Report::default();
-        execution.collect::<false>(&mut report, root, instance, 0, scope::Context::default())?;
-        Ok::<_, Verdict>(Box::into_raw(Box::new(report)))
+        caches.admit(engine, root);
+        let inherited = caches.initial_report();
+        let resumed = inherited.is_some();
+        let mut report = inherited.unwrap_or_else(|| Report {
+            render_messages: engine.runtime_messages,
+            ..Report::default()
+        });
+        let result = execution
+            .collect_report(&mut report, root, instance)
+            .map_err(|verdict| execution.budget.status(verdict))?;
+        report.evaluation = if resumed { Some(result) } else { None };
+        Ok::<_, i32>(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()
-        }
-    }
+    let (report, code) = report_outcome(result);
+    unsafe { *status = code };
+    report
 }
 /// # 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,
+    caches: *const runtime::Caches,
     root: usize,
     instance: Value,
     status: *mut i32,
@@ -1022,21 +1718,25 @@ pub unsafe extern "C" fn sn_diagnose_with_limits(
     outcome: *mut budget::Outcome,
 ) -> *mut Report {
     let result = catch_unwind(AssertUnwindSafe(|| {
-        let local = pattern::Caches::default();
+        let local = runtime::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),
+            budget: caches.budget(limits),
         };
-        let mut report = Report {
+        caches.admit(execution.engine, root);
+        let inherited = caches.initial_report();
+        let resumed = inherited.is_some();
+        let mut report = inherited.unwrap_or_else(|| Report {
             limits,
+            render_messages: execution.runtime_messages,
             ..Report::default()
-        };
+        });
         let result = if execution.budget.check_deadline() {
-            execution.collect::<false>(&mut report, root, instance, 0, scope::Context::default())
+            execution.collect_report(&mut report, root, instance)
         } else {
             Err(Unsupported)
         };
@@ -1053,24 +1753,16 @@ pub unsafe extern "C" fn sn_diagnose_with_limits(
         unsafe {
             ((*outcome).kind, (*outcome).attempted) = hit;
         }
-        result.map(|_| Box::into_raw(Box::new(report)))
+        result
+            .map(|evaluation| {
+                report.evaluation = if resumed { Some(evaluation) } else { None };
+                Box::into_raw(Box::new(report))
+            })
+            .map_err(|verdict| execution.budget.status(verdict))
     }));
-    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()
-        }
-    }
+    let (report, code) = report_outcome(result);
+    unsafe { *status = code };
+    report
 }
 /// # Safety
 /// Report must be live under the GVL.
@@ -1082,15 +1774,7 @@ pub unsafe extern "C" fn sn_report_len(report: *const Report) -> usize {
 /// Report must be live under the GVL.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn sn_report_size(report: *const Report) -> usize {
-    let r = unsafe { &*report };
-    std::mem::size_of::<Report>()
-        + r.errors.capacity() * std::mem::size_of::<Error>()
-        + r.instance_path.capacity()
-        + r.schema_path.capacity()
-        + r.errors
-            .iter()
-            .map(|e| e.instance_path.capacity() + e.schema_path.capacity())
-            .sum::<usize>()
+    std::mem::size_of::<Report>() + unsafe { &*report }.memory_usage()
 }
 /// # Safety
 /// Report must be live, index in bounds, and record a writable pointer.
@@ -1105,14 +1789,17 @@ pub unsafe extern "C" fn sn_report_record(
         *record = Record {
             keyword: e.keyword.as_ptr(),
             keyword_len: e.keyword.len(),
-            instance_path: e.instance_path.as_ptr(),
-            instance_len: e.instance_path.len(),
-            schema_path: e.schema_path.as_ptr(),
-            schema_len: e.schema_path.len(),
+            instance_path: e.instance_path.bytes().as_ptr(),
+            instance_len: e.instance_path.bytes().len(),
+            schema_path: e.schema_path.bytes().as_ptr(),
+            schema_len: e.schema_path.bytes().len(),
+            instance_pointer: e.instance_path.value(),
+            schema_pointer: e.schema_path.value(),
             opcode: e.opcode,
             operand: e.operand,
             instance: e.instance,
             detail: e.detail,
+            message: e.message,
         }
     };
 }
@@ -1120,12 +1807,7 @@ pub unsafe extern "C" fn sn_report_record(
 /// Report must be live; call only from its synchronous Ruby GC mark callback.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn sn_report_mark(report: *const Report) {
-    for error in &unsafe { &*report }.errors {
-        unsafe {
-            sn_pin(error.operand);
-            sn_pin(error.instance);
-        }
-    }
+    unsafe { &*report }.mark();
 }
 /// # Safety
 /// Report must be owned, returned by sn_diagnose, and freed exactly once.
@@ -1133,3 +1815,60 @@ pub unsafe extern "C" fn sn_report_mark(report: *const Report) {
 pub unsafe extern "C" fn sn_report_free(report: *mut Report) {
     drop(unsafe { Box::from_raw(report) });
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn report_seeds_and_results_own_error_paths_limits_and_locations() {
+        let mut report = Report {
+            attempts: 2,
+            failed: true,
+            ..Report::default()
+        };
+        report.instance_path.text.push_str("/item");
+        report.schema_path.text.push_str("/allOf/1");
+        report.limits = budget::Limits {
+            enabled: 1,
+            max_errors: 3,
+            ..budget::Limits::default()
+        };
+        report.errors.push(Error {
+            keyword: "type",
+            instance_path: pointer::Rendered::Native("/item".into()),
+            schema_path: pointer::Rendered::Native("/allOf/0/type".into()),
+            opcode: OP_TYPE_INTEGER,
+            operand: 0,
+            instance: 0,
+            detail: 0,
+            message: 0,
+        });
+        let mut locations = Tracked::new(Valid);
+        locations.item(4);
+        locations.item(65);
+        report.evaluation = Some(locations);
+        let mut seed = report.continuation(true);
+        assert!(seed.annotations);
+        assert!(seed.evaluation.is_none());
+        assert_eq!(seed.attempts, 2);
+        assert!(seed.failed);
+        assert_eq!(seed.limits.max_errors, 3);
+        seed.instance_path.text.push_str("/child");
+        seed.errors.clear();
+        assert_eq!(report.instance_path.text, "/item");
+        assert_eq!(report.errors.len(), 1);
+        assert!(report.memory_usage() > 0);
+        let mut adopted = Report::default();
+        let mut completed = report.clone();
+        completed.annotations = true;
+        let mut result = adopted.adopt(completed);
+        result.item(8);
+        assert_eq!(result.item_count(), 3);
+        assert_eq!(report.evaluation.as_ref().unwrap().item_count(), 2);
+        assert!(report.evaluation.as_ref().unwrap().contains_item(65));
+        assert!(adopted.evaluation.is_none());
+        assert!(!adopted.annotations);
+        assert_eq!(adopted.attempts, 2);
+    }
+}