schemurai 3.0.1 → 3.0.2

data/ext/schemurai_native/src/lib.rs

@@ -6,6 +6,7 @@ use std::ffi::{c_char, c_void};
 use std::hash::{BuildHasherDefault, Hasher};
 use std::panic::{AssertUnwindSafe, catch_unwind};
 mod budget;
+mod container;
 mod content;
 mod diagnostics;
 mod enumeration;
@@ -18,6 +19,9 @@ mod memo;
 mod memo_scope;
 mod number;
 mod pattern;
+mod pointer;
+mod runtime;
+mod string;
 // Some shared constants are consumed only by C or Ruby.
 #[allow(dead_code)]
 mod protocol {
@@ -42,6 +46,7 @@ unsafe extern "C" {
     ) -> i32;
     fn sn_small_hash(value: Value, entries: *mut Value) -> i32;
     fn sn_true(value: Value) -> i32;
+    fn sn_truthy(value: Value) -> i32;
     fn sn_fixnum(value: Value) -> i32;
     fn sn_fixnum_flag() -> Value;
     fn sn_array_data(value: Value) -> *const Value;
@@ -56,6 +61,8 @@ unsafe extern "C" {
         required: i32,
     ) -> i32;
     fn sn_integer1024(value: Value, words: *mut u64) -> i32;
+    fn sn_integer_word_count(value: Value) -> usize;
+    fn sn_integer_words(value: Value, words: *mut u64, count: usize) -> i32;
     fn sn_is_bignum(value: Value) -> i32;
     fn sn_big256(value: Value, words: *mut u64) -> i32;
     fn sn_big_hash(value: Value, hash: *mut u64) -> i32;
@@ -116,13 +123,24 @@ enum Verdict {
 }
 use Verdict::*;
 const MAX_EVALUATION_DEPTH: usize = 256;
+// Control-flow instructions can forward an instance without examining its kind.
+// No real classified Ruby value has this kind.
+const TYPE_UNCHECKED: i32 = 0;
+type InstanceKind = std::cell::Cell<i32>;
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+enum KindDemand {
+    None,
+    Predicate,
+    Data,
+}
 const MAX_UNIQUE_INDEX_BYTES: usize = 64 * 1024 * 1024;
 #[derive(Debug)]
 enum Op {
     Unsupported,
+    UnresolvedRef(Value),
     Boolean(bool),
     Ref(scope::Reference),
-    Type(i32),
+    Type(i32, bool),
     Const(Value),
     Enum(Box<enumeration::Enumeration>),
     All(Vec<usize>),
@@ -137,6 +155,7 @@ enum Op {
 }
 #[derive(Debug)]
 struct Array {
+    header: container::Header,
     min: Option<usize>,
     max: Option<usize>,
     unique: bool,
@@ -147,10 +166,14 @@ struct Array {
     contains: Option<usize>,
     min_contains: usize,
     max_contains: Option<usize>,
+    count_contains: bool,
     unevaluated: Option<usize>,
 }
 #[derive(Debug)]
 struct StringRules {
+    source: Value,
+    runtime_flags: i32,
+    runtime_format: bool,
     min: Option<usize>,
     max: Option<usize>,
     pattern: Option<pattern::Pattern>,
@@ -197,15 +220,31 @@ impl StringRules {
             && self.format.is_none()
             && self.content.is_none()
     }
-    fn eval_length_guarded(&self, required: i32, value: Value) -> Verdict {
-        length_guarded(value, required, self.min, self.max)
+    fn eval_length_guarded(
+        &self,
+        caches: &runtime::Caches,
+        required: i32,
+        value: Value,
+    ) -> Verdict {
+        if caches.dynamic_calls() {
+            return self.runtime_valid(caches, required, value);
+        }
+        let result = length_guarded(value, required, self.min, self.max);
+        if result == Unsupported {
+            self.runtime_valid(caches, required, value)
+        } else {
+            result
+        }
     }
-    fn eval_guarded(&self, caches: &pattern::Caches, required: i32, value: Value) -> Verdict {
+    fn eval_guarded(&self, caches: &runtime::Caches, required: i32, value: Value) -> Verdict {
+        if caches.dynamic_calls() {
+            return self.runtime_valid(caches, required, value);
+        }
         let mut data = std::ptr::null();
         let mut len = 0;
         let encoding = unsafe { sn_pattern_item_view(value, &mut data, &mut len) };
         if encoding == -TYPE_UNSUPPORTED {
-            Unsupported
+            self.runtime_valid(caches, required, value)
         } else if encoding < 0 {
             verdict(required == 0)
         } else {
@@ -213,12 +252,12 @@ impl StringRules {
             self.eval_with_view::<true>(caches, value, Some((bytes, encoding)))
         }
     }
-    fn eval(&self, caches: &pattern::Caches, value: Value) -> Verdict {
+    fn eval(&self, caches: &runtime::Caches, value: Value) -> Verdict {
         self.eval_with_view::<false>(caches, value, None)
     }
     fn eval_with_view<const BORROWED: bool>(
         &self,
-        caches: &pattern::Caches,
+        caches: &runtime::Caches,
         value: Value,
         view: Option<(&[u8], i32)>,
     ) -> Verdict {
@@ -232,8 +271,8 @@ impl StringRules {
         }
         if let Some(pattern) = &self.pattern {
             let result = match view {
-                Some((bytes, encoding)) => pattern.eval_bytes(caches, bytes, encoding),
-                None => pattern.eval(caches, value),
+                Some((bytes, encoding)) => pattern.eval_bytes(caches, value, bytes, encoding),
+                None => pattern.assertion(caches, value),
             };
             if result != Valid {
                 return result;
@@ -249,16 +288,41 @@ impl StringRules {
             }
         }
         self.content.as_ref().map_or(Valid, |content| match view {
-            Some((bytes, encoding)) => content.eval_borrowed(value, bytes, encoding),
-            None => content.eval(value),
+            Some((bytes, encoding)) => content.eval_borrowed(caches, value, bytes, encoding),
+            None => content.eval(caches, value),
         })
     }
 }
 #[derive(Debug)]
 enum DiagnosticDependency {
-    Required(Value, Vec<Value>, &'static str),
+    Required(Value, Vec<RequiredKey>, &'static str),
     Schema(Value, usize, &'static str),
 }
+// Keep ordinary String lookups native; other operands may dispatch Ruby hash
+// methods. Retain the original value for runtime lookup and ordered rendering.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+struct RequiredKey {
+    name: Value,
+    ordinary_string: bool,
+}
+impl RequiredKey {
+    fn missing(
+        self,
+        caches: &runtime::Caches,
+        value: Value,
+        undefined: Value,
+    ) -> Result<bool, Verdict> {
+        if self.ordinary_string {
+            Ok(missing(value, self.name, undefined))
+        } else {
+            match caches.required_missing(self.name, value) {
+                Valid => Ok(true),
+                Invalid => Ok(false),
+                Unsupported => Err(Unsupported),
+            }
+        }
+    }
+}
 #[derive(Clone, Copy, Debug)]
 struct PropertyTarget {
     name: Value,
@@ -267,11 +331,13 @@ struct PropertyTarget {
 }
 #[derive(Debug)]
 struct Object {
+    header: container::Header,
+    inspect_required: bool,
     record: Option<RecordObject>,
     min: Option<usize>,
     max: Option<usize>,
-    required: Vec<Value>,
-    required_order: Vec<Value>,
+    required: Vec<RequiredKey>,
+    required_order: Vec<RequiredKey>,
     properties: Vec<(Value, usize)>,
     property_targets: HashMap<tracking::JsonKey, PropertyTarget, BuildHasherDefault<BucketHasher>>,
     patterns: Vec<(pattern::Pattern, usize)>,
@@ -283,7 +349,7 @@ struct Object {
     property_indices: Vec<usize>,
     additional: Option<usize>,
     names: Option<usize>,
-    dependent_required: Vec<(Value, Vec<Value>)>,
+    dependent_required: Vec<(Value, Vec<RequiredKey>)>,
     dependent_schemas: Vec<(Value, usize)>,
     diagnostic_dependencies: Vec<DiagnosticDependency>,
     unevaluated: Option<usize>,
@@ -352,13 +418,18 @@ impl RecordShortIndex {
 impl Object {
     // Keep these calls at their original evaluation positions: property
     // failures and unsupported children must retain their ordering.
-    #[inline]
-    fn check_required(&self, value: Value, undefined: Value, budget: &budget::Budget) -> Verdict {
-        Self::check_keys(&self.required, value, undefined, budget)
+    fn check_required(
+        &self,
+        caches: &runtime::Caches,
+        value: Value,
+        undefined: Value,
+        budget: &budget::Budget,
+    ) -> Verdict {
+        Self::check_keys(&self.required, caches, value, undefined, budget)
     }
-    #[inline]
     fn check_keys(
-        keys: &[Value],
+        keys: &[RequiredKey],
+        caches: &runtime::Caches,
         value: Value,
         undefined: Value,
         budget: &budget::Budget,
@@ -367,15 +438,17 @@ impl Object {
             if !budget.checkpoint() {
                 return Unsupported;
             }
-            if missing(value, key, undefined) {
-                return Invalid;
+            match key.missing(caches, value, undefined) {
+                Ok(false) => {}
+                Ok(true) => return Invalid,
+                Err(status) => return status,
             }
         }
         Valid
     }
-    #[inline]
     fn check_dependent_required(
         &self,
+        caches: &runtime::Caches,
         value: Value,
         undefined: Value,
         budget: &budget::Budget,
@@ -385,7 +458,7 @@ impl Object {
                 return Unsupported;
             }
             if !missing(value, *name, undefined) {
-                let status = Self::check_keys(required, value, undefined, budget);
+                let status = Self::check_keys(required, caches, value, undefined, budget);
                 if status != Valid {
                     return status;
                 }
@@ -482,10 +555,11 @@ impl Object {
     // All execution policies use the same property/pattern/additional routing.
     // Schema-order validity scans have already visited declared properties;
     // input-order diagnostic scans visit them here as well.
-    fn visit_value_rules<const PROPERTIES: bool>(
+    fn visit_value_rules(
         &self,
-        caches: &pattern::Caches,
+        caches: &runtime::Caches,
         budget: &budget::Budget,
+        properties: bool,
         key: Value,
         location: Option<tracking::JsonKey>,
         mut visit: impl FnMut(&'static str, Option<Value>, usize) -> Result<(), Verdict>,
@@ -494,7 +568,7 @@ impl Object {
         // Reuse that result, and skip hashing for pattern-only object rules.
         let mut matched = if self.properties.is_empty() {
             false
-        } else if PROPERTIES {
+        } else if properties {
             if let Some(target) = self
                 .property_targets
                 .get(&location.unwrap_or_else(|| tracking::JsonKey::new(key)))
@@ -549,6 +623,7 @@ impl Object {
 
     fn with_record(mut self) -> Self {
         if self.required_order.len() > 64
+            || self.required_order.iter().any(|key| !key.ordinary_string)
             || !self.patterns.is_empty()
             || self.names.is_some()
             || !self.diagnostic_dependencies.is_empty()
@@ -573,7 +648,8 @@ impl Object {
                 )
             })
             .collect();
-        for &name in &self.required_order {
+        for key in &self.required_order {
+            let name = key.name;
             fields
                 .entry(tracking::JsonKey::new(name))
                 .or_insert(RecordField {
@@ -593,8 +669,8 @@ impl Object {
         }
         // Required names share the field bits already used for duplicate-key
         // detection. Repeated required names therefore need no extra state.
-        let required = self.required_order.iter().fold(0, |bits, &name| {
-            bits | fields[&tracking::JsonKey::new(name)].bit
+        let required = self.required_order.iter().fold(0, |bits, key| {
+            bits | fields[&tracking::JsonKey::new(key.name)].bit
         });
         let fields: Vec<_> = fields.into_values().collect();
         let short_index = RecordShortIndex::compile(&fields);
@@ -615,9 +691,15 @@ pub struct Roots {
 #[derive(Default)]
 pub struct Engine {
     nodes: Vec<Vec<Op>>,
+    programs: Vec<Value>,
     pattern_cache_count: usize,
     error_operands: Vec<Vec<(i32, Value)>>,
     tracks: Vec<bool>,
+    kind_demand: Vec<KindDemand>,
+    callback_roots: Vec<bool>,
+    validity_supported: Vec<bool>,
+    report_supported: Vec<bool>,
+    has_references: bool,
     memoizable: Vec<bool>,
     memo_contextual: Vec<bool>,
     memo_guarded: Vec<bool>,
@@ -638,6 +720,7 @@ pub struct Engine {
     root: usize,
     fixnum_flag: Value,
     compiler: Value,
+    runtime_messages: bool,
     validate_format: bool,
     validate_content: bool,
     undefined: Value,
@@ -657,6 +740,24 @@ impl Engine {
         }
         Ok(self.retain(result))
     }
+    fn required_keys(&mut self, value: Value) -> Vec<RequiredKey> {
+        // Non-array operands retain their Ruby iteration/error behavior in a
+        // runtime frame; they cannot authorize borrowed Array storage.
+        if unsafe { sn_kind(value) } != TYPE_ARRAY {
+            return vec![];
+        }
+        self.values(value)
+            .into_iter()
+            .map(|name| {
+                let ordinary_string = unsafe { sn_kind(name) } == TYPE_STRING;
+                self.runtime_messages |= !ordinary_string;
+                RequiredKey {
+                    name,
+                    ordinary_string,
+                }
+            })
+            .collect()
+    }
     fn values(&mut self, value: Value) -> Vec<Value> {
         if unsafe { sn_same(value, sn_nil()) } != 0 {
             return vec![];
@@ -760,7 +861,7 @@ impl Engine {
                     // shape-independent leaves can ignore resource/path metadata.
                     ka == kb
                         && match (self.nodes[ca].as_slice(), self.nodes[cb].as_slice()) {
-                            ([Op::Type(a)], [Op::Type(b)]) => a == b,
+                            ([Op::Type(a, ua)], [Op::Type(b, ub)]) => a == b && ua == ub,
                             ([Op::Boolean(a)], [Op::Boolean(b)]) => a == b,
                             _ => false,
                         }
@@ -780,8 +881,10 @@ impl Engine {
         let index = self.nodes.len();
         self.indices.insert(program, index);
         self.nodes.push(vec![]);
+        self.programs.push(program);
         self.error_operands.push(vec![]);
         self.tracks.push(false);
+        self.kind_demand.push(KindDemand::None);
         self.metadata.push(scope::Metadata::default());
         let code = self.field(program, b"code\0")?;
         let flags = unsafe { sn_integer(sn_entry(code, 0)) };
@@ -795,19 +898,20 @@ impl Engine {
             error_operands.push((opcode, operand));
             let op = match opcode {
                 OP_BOOLEAN => Op::Boolean(unsafe { sn_true(operand) } != 0),
-                OP_TYPE_NULL => Op::Type(TYPE_NULL),
-                OP_TYPE_BOOLEAN => Op::Type(TYPE_BOOLEAN),
-                OP_TYPE_OBJECT => Op::Type(TYPE_OBJECT),
-                OP_TYPE_ARRAY => Op::Type(TYPE_ARRAY),
-                OP_TYPE_NUMBER => Op::Type(TYPE_NUMBER),
-                OP_TYPE_INTEGER => Op::Type(TYPE_INTEGER),
-                OP_TYPE_STRING => Op::Type(TYPE_STRING),
+                OP_TYPE_NULL => Op::Type(TYPE_NULL, false),
+                OP_TYPE_BOOLEAN => Op::Type(TYPE_BOOLEAN, false),
+                OP_TYPE_OBJECT => Op::Type(TYPE_OBJECT, false),
+                OP_TYPE_ARRAY => Op::Type(TYPE_ARRAY, false),
+                OP_TYPE_NUMBER => Op::Type(TYPE_NUMBER, false),
+                OP_TYPE_INTEGER => Op::Type(TYPE_INTEGER, false),
+                OP_TYPE_STRING => Op::Type(TYPE_STRING, false),
                 OP_TYPES => {
                     let mask = self.field(operand, b"mask\0")?;
-                    Op::Type(unsafe { sn_integer(mask) } as i32)
+                    Op::Type(unsafe { sn_integer(mask) } as i32, true)
                 }
                 OP_CONST => Op::Const(operand),
                 OP_ENUM => Op::Enum(Box::new(enumeration::Enumeration::compile(
+                    operand,
                     self.values(operand),
                     self.fixnum_flag,
                 ))),
@@ -856,9 +960,10 @@ impl Engine {
                             None
                         };
                         let assertion = self.field(operand, b"format_assertion\0")?;
-                        let format = if (self.validate_format || unsafe { sn_true(assertion) } != 0)
-                            && unsafe { sn_same(format, sn_nil()) } == 0
-                        {
+                        let runtime_format = (self.validate_format
+                            || unsafe { sn_true(assertion) } != 0)
+                            && unsafe { sn_same(format, sn_nil()) } == 0;
+                        let format = if runtime_format {
                             let name = self.field(format, b"name\0")?;
                             if unsafe { sn_same(name, sn_nil()) } != 0 {
                                 None
@@ -868,6 +973,10 @@ impl Engine {
                         } else {
                             None
                         };
+                        let max_length = self.field(operand, b"max_length\0")?;
+                        let min_length = self.field(operand, b"min_length\0")?;
+                        let length_flags = (unsafe { sn_truthy(max_length) } << 2)
+                            | (unsafe { sn_truthy(min_length) } << 3);
                         Op::String(
                             if opcode == OP_TYPED_STRING {
                                 TYPE_STRING
@@ -875,11 +984,16 @@ impl Engine {
                                 0
                             },
                             Box::new(StringRules {
+                                source: operand,
+                                runtime_flags: i32::from(self.validate_format)
+                                    | (i32::from(self.validate_content) << 1)
+                                    | length_flags,
+                                runtime_format,
                                 format,
                                 content,
                                 min: self.size_field(operand, b"min_length\0")?,
                                 max: self.size_field(operand, b"max_length\0")?,
-                                pattern: if unsafe { sn_same(pattern, sn_nil()) } != 0 {
+                                pattern: if unsafe { sn_truthy(pattern) } == 0 {
                                     None
                                 } else {
                                     Some(pattern::Pattern::compile(
@@ -912,7 +1026,18 @@ impl Engine {
                             0
                         },
                         Box::new(Array {
-                            unique: unsafe { sn_true(unique) } != 0,
+                            header: self.container_header(
+                                operand,
+                                b"max_items\0",
+                                b"min_items\0",
+                                false,
+                                (if unsafe { sn_truthy(unique) } != 0 {
+                                    4
+                                } else {
+                                    0
+                                }) | (if list { 8 } else { 0 }),
+                            )?,
+                            unique: unsafe { sn_truthy(unique) } != 0,
                             min: self.size_field(operand, b"min_items\0")?,
                             max: self.size_field(operand, b"max_items\0")?,
                             prefix,
@@ -922,6 +1047,9 @@ impl Engine {
                             contains: self.child(operand, b"contains\0")?,
                             min_contains: self.size_field(operand, b"min_contains\0")?.unwrap_or(1),
                             max_contains: self.size_field(operand, b"max_contains\0")?,
+                            count_contains: unsafe {
+                                sn_true(self.field(operand, b"count_contains\0")?)
+                            } != 0,
                             unevaluated: self.child(operand, b"unevaluated\0")?,
                         }),
                     )
@@ -944,14 +1072,21 @@ impl Engine {
                         let pattern_group =
                             pattern::PatternGroup::compile(&pattern_names, &patterns);
                         let required = self.field(operand, b"required\0")?;
-                        let required = self.values(required);
+                        let inspect_required = unsafe { sn_truthy(required) } != 0
+                            && !(unsafe { sn_kind(required) } == TYPE_ARRAY
+                                && unsafe { sn_len(required) } == 0);
+                        let required = self.required_keys(required);
                         let required_order = required.clone();
+                        let required_strings: Vec<_> = required
+                            .iter()
+                            .filter(|key| key.ordinary_string)
+                            .map(|key| key.name)
+                            .collect();
                         let properties = self.field(operand, b"properties\0")?;
                         let properties = self.compile_map(properties)?;
-                        if required
+                        if properties
                             .iter()
-                            .chain(properties.iter().map(|(key, _)| key))
-                            .any(|&key| unsafe { sn_kind(key) } != TYPE_STRING)
+                            .any(|&(key, _)| unsafe { sn_kind(key) } != TYPE_STRING)
                         {
                             ops.push(Op::Unsupported);
                             continue;
@@ -983,7 +1118,7 @@ impl Engine {
                         // content-keyed sets and the already compiled property index.
                         let indexed_required = properties.len().saturating_mul(required.len()) > 64;
                         let required_keys: Option<tracking::KeySet> = indexed_required.then(|| {
-                            required
+                            required_strings
                                 .iter()
                                 .map(|&name| tracking::JsonKey::new(name))
                                 .collect()
@@ -993,7 +1128,7 @@ impl Engine {
                             .map(|key| {
                                 required_keys.as_ref().map_or_else(
                                     || {
-                                        required.iter().any(
+                                        required_strings.iter().any(
                                             |&name| unsafe { sn_string_equal(key.0, name) } != 0,
                                         )
                                     },
@@ -1008,7 +1143,11 @@ impl Engine {
                             .collect();
                         let required = required
                             .into_iter()
-                            .filter(|&name| {
+                            .filter(|key| {
+                                if !key.ordinary_string {
+                                    return true;
+                                }
+                                let name = key.name;
                                 if indexed_required {
                                     !property_targets.contains_key(&tracking::JsonKey::new(name))
                                 } else {
@@ -1026,7 +1165,7 @@ impl Engine {
                             let name = self.retain(unsafe { sn_entry(pair, 0) });
                             let dependency = self.retain(unsafe { sn_entry(pair, 1) });
                             if unsafe { sn_kind(dependency) } == TYPE_ARRAY {
-                                let names = self.values(dependency);
+                                let names = self.required_keys(dependency);
                                 diagnostic_dependencies.push(DiagnosticDependency::Required(
                                     name,
                                     names.clone(),
@@ -1045,7 +1184,7 @@ impl Engine {
                         }
                         for pair in self.values(dependent) {
                             let name = self.retain(unsafe { sn_entry(pair, 0) });
-                            let names = self.values(unsafe { sn_entry(pair, 1) });
+                            let names = self.required_keys(unsafe { sn_entry(pair, 1) });
                             diagnostic_dependencies.push(DiagnosticDependency::Required(
                                 name,
                                 names.clone(),
@@ -1059,19 +1198,25 @@ impl Engine {
                             DiagnosticDependency::Schema(name, child, "dependentSchemas")
                         }));
                         dependent_schemas.extend(schemas);
-                        if dependent_required.iter().any(|(name, keys)| {
-                            (unsafe { sn_kind(*name) }) != TYPE_STRING
-                                || keys
-                                    .iter()
-                                    .any(|&key| unsafe { sn_kind(key) } != TYPE_STRING)
-                        }) || dependent_schemas
+                        if dependent_required
                             .iter()
-                            .any(|&(key, _)| unsafe { sn_kind(key) } != TYPE_STRING)
+                            .any(|(name, _)| unsafe { sn_kind(*name) } != TYPE_STRING)
+                            || dependent_schemas
+                                .iter()
+                                .any(|&(key, _)| unsafe { sn_kind(key) } != TYPE_STRING)
                         {
                             ops.push(Op::Unsupported);
                             continue;
                         }
                         let mut object = Object {
+                            header: self.container_header(
+                                operand,
+                                b"max_properties\0",
+                                b"min_properties\0",
+                                true,
+                                0,
+                            )?,
+                            inspect_required,
                             record: None,
                             min: self.size_field(operand, b"min_properties\0")?,
                             max: self.size_field(operand, b"max_properties\0")?,
@@ -1148,7 +1293,8 @@ impl Engine {
                     let mut target = 0;
                     if unsafe { sn_resolve(self.compiler, program, reference, &mut target) } != 0 {
                         if unsafe { sn_resolution_error(target) } != 0 {
-                            Op::Unsupported
+                            let message = self.field(target, b"message\0")?;
+                            Op::UnresolvedRef(message)
                         } else {
                             return Err(target);
                         }
@@ -1166,12 +1312,53 @@ impl Engine {
         self.error_operands[index] = error_operands;
         Ok(index)
     }
+    fn compile_kind_demands(&mut self) {
+        self.kind_demand = self
+            .nodes
+            .iter()
+            .map(|ops| self.kind_demand_for(ops))
+            .collect();
+    }
+    fn kind_demand_for(&self, ops: &[Op]) -> KindDemand {
+        ops.iter()
+            .map(|op| match op {
+                Op::Type(..) | Op::Number(..) | Op::String(..) | Op::Const(_) | Op::Enum(_) => {
+                    KindDemand::Predicate
+                }
+                Op::Array(_, rules)
+                    if rules.header_only()
+                        || self.array_callbacks(rules)
+                        || self.array_report_callbacks(rules) =>
+                {
+                    KindDemand::Predicate
+                }
+                Op::Object(_, rules)
+                    if rules.header_only()
+                        || self.object_callbacks(rules)
+                        || self.object_report_callbacks(rules) =>
+                {
+                    KindDemand::Predicate
+                }
+                Op::Array(..) | Op::Object(..) => KindDemand::Data,
+                Op::Unsupported
+                | Op::Boolean(_)
+                | Op::UnresolvedRef(_)
+                | Op::Ref(_)
+                | Op::All(_)
+                | Op::Any(_)
+                | Op::One(_)
+                | Op::Not(_)
+                | Op::Conditional(..) => KindDemand::None,
+            })
+            .max()
+            .unwrap_or(KindDemand::None)
+    }
 }
 
-// A view of immutable compiled data and validator-owned regex search caches.
+// A view of immutable compiled data and validator-owned runtime caches.
 struct Execution<'a> {
     engine: &'a Engine,
-    caches: &'a pattern::Caches,
+    caches: &'a runtime::Caches,
     memo: memo::Memo,
     budget: budget::Budget,
 }
@@ -1193,9 +1380,14 @@ impl Execution<'_> {
         value: Value,
         depth: usize,
         active: scope::Context<'_>,
-        known_kind: Option<i32>,
+        known_kind: Option<&InstanceKind>,
     ) -> Verdict {
-        if !self.budget.checkpoint() {
+        // Suspend before entering the next node. C runs a fresh native stack
+        // only after these frames and their borrowed views have unwound.
+        if depth >= MAX_EVALUATION_DEPTH && self.caches.continuations_allowed() {
+            return self.caches.native_child(node, value);
+        }
+        if self.caches.callback_checkpoint(value) != Valid || !self.budget.checkpoint() {
             return Unsupported;
         }
         let Some(key) = self
@@ -1223,7 +1415,7 @@ impl Execution<'_> {
         value: Value,
         depth: usize,
         active: scope::Context<'_>,
-        known_kind: Option<i32>,
+        known_kind: Option<&InstanceKind>,
     ) -> Verdict {
         let frame = scope::ScopeFrame {
             resource: self.metadata[node].resource,
@@ -1234,7 +1426,13 @@ 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);
         if self.tracks[node] {
+            if let Some(result) = self.caches.callback_tracked(node, value) {
+                return result;
+            }
             return match known_kind {
                 Some(kind) => {
                     self.eval_tracked_kind(node, value, depth, active, kind)
@@ -1248,26 +1446,42 @@ impl Execution<'_> {
         }
         if let [Op::String(required, rules)] = self.nodes[node].as_slice()
             && rules.pattern.is_some()
+            && !self.caches.scalar_callback()
         {
             return rules.eval_guarded(self.caches, *required, value);
         }
-        let kind = known_kind.unwrap_or_else(|| {
-            if value & self.fixnum_flag != 0 {
-                TYPE_INTEGRAL_NUMBER
-            } else {
-                self.instance_kind(node, value)
-            }
-        });
-        if kind == TYPE_UNSUPPORTED {
+        let local_kind = InstanceKind::new(TYPE_UNCHECKED);
+        let kind_state = known_kind.unwrap_or(&local_kind);
+        let kind = if known_kind.is_some() {
+            // A proof shared with sibling branches must guard every Hash key.
+            self.diagnostic_kind(node, value, kind_state)
+        } else {
+            let kind = self.instance_kind(node, value);
+            kind_state.set(kind);
+            kind
+        };
+        if self.unsupported_kind(node, kind) {
             return Unsupported;
         }
         for op in &self.nodes[node] {
+            // Runtime observations checkpoint each reached opcode once, after
+            // earlier assertions and descendant calls have completed.
+            if self.caches.callback_checkpoint(value) != Valid {
+                return Unsupported;
+            }
             if !self.budget.checkpoint() {
                 return Unsupported;
             }
             let outcome = match op {
                 Op::Ref(target) => {
-                    if RefFrame::contains(active.active, node, value) {
+                    let target = match self.resolve_reference(*target, value, active) {
+                        Ok(target) => target,
+                        Err(status) => return status,
+                    };
+                    let program = self.programs[node];
+                    if RefFrame::contains(active.active, node, value)
+                        || self.caches.reference_active(program, value)
+                    {
                         Valid
                     } else {
                         let frame = RefFrame {
@@ -1275,15 +1489,17 @@ impl Execution<'_> {
                             value,
                             parent: active.active,
                         };
+                        let reference = self.caches.reference_frame(program, value);
+                        let _guard = self.caches.reference_guard(&reference);
                         self.eval_with_kind(
-                            self.reference_target(*target, active),
+                            target,
                             value,
                             depth + 1,
                             scope::Context {
                                 active: Some(&frame),
                                 ..active
                             },
-                            Some(kind),
+                            Some(kind_state),
                         )
                     }
                 }
@@ -1293,7 +1509,8 @@ impl Execution<'_> {
                         if !self.budget.checkpoint() {
                             return Unsupported;
                         }
-                        outcome = self.eval_with_kind(n, value, depth + 1, active, Some(kind));
+                        outcome =
+                            self.eval_with_kind(n, value, depth + 1, active, Some(kind_state));
                         if outcome != Valid {
                             break;
                         }
@@ -1309,30 +1526,61 @@ impl Execution<'_> {
                     match evaluation::scan_branches(
                         nodes,
                         evaluation::BranchPolicy::Validity(branch_kind),
-                        |child| self.eval_with_kind(child, value, depth + 1, active, Some(kind)),
+                        self.caches.dynamic_calls(),
+                        |child| {
+                            if matches!(op, Op::One(_))
+                                && self.caches.callback_checkpoint(value) != Valid
+                            {
+                                return Unsupported;
+                            }
+                            self.eval_with_kind(child, value, depth + 1, active, Some(kind_state))
+                        },
+                        |_, _| Ok(()),
                     ) {
                         Ok(result) => verdict(branch_kind.accepts(result.matches)),
                         Err(status) => status,
                     }
                 }
-                Op::Not(n) => match self.eval_with_kind(*n, value, depth + 1, active, Some(kind)) {
-                    Valid => Invalid,
-                    Invalid => Valid,
-                    Unsupported => Unsupported,
-                },
+                Op::Not(n) => {
+                    match self.eval_with_kind(*n, value, depth + 1, active, Some(kind_state)) {
+                        Valid => Invalid,
+                        Invalid => Valid,
+                        Unsupported => Unsupported,
+                    }
+                }
                 Op::Conditional(c, yes, no) => {
-                    match self.eval_with_kind(*c, value, depth + 1, active, Some(kind)) {
+                    match self.eval_with_kind(*c, value, depth + 1, active, Some(kind_state)) {
                         Unsupported => Unsupported,
                         result => match if result == Valid { yes } else { no } {
                             Some(n) => {
-                                self.eval_with_kind(*n, value, depth + 1, active, Some(kind))
+                                self.eval_with_kind(*n, value, depth + 1, active, Some(kind_state))
                             }
                             None => Valid,
                         },
                     }
                 }
                 Op::Array(required, rules) => {
-                    if *required != 0 && kind != TYPE_ARRAY {
+                    if rules.header_only() && rules.header.runtime_required(self.caches, kind) {
+                        rules.header.valid(self.caches, *required, value)
+                    } else if self.caches.callbacks_allowed()
+                        && rules.header.runtime_required(self.caches, kind)
+                        && self.scalar_contains(rules)
+                    {
+                        rules.header.contains(
+                            self.caches,
+                            *required,
+                            value,
+                            rules.contains.expect("scalar contains child"),
+                            self.scalar_callback_kind(
+                                rules.contains.expect("scalar contains child"),
+                            ),
+                        )
+                    } else if self.caches.callbacks_allowed()
+                        && rules.header.runtime_required(self.caches, kind)
+                        && self.array_callbacks(rules)
+                    {
+                        rules.header.children(self.caches, *required, value, node)
+                    } else if *required != 0 && kind != TYPE_ARRAY {
                         Invalid
                     } else if kind != TYPE_ARRAY {
                         Valid
@@ -1341,12 +1589,29 @@ impl Execution<'_> {
                     }
                 }
                 Op::Object(required, rules) => {
-                    if *required != 0 && kind != TYPE_OBJECT {
+                    if rules.header_only() && rules.header.runtime_required(self.caches, kind) {
+                        rules.header.valid(self.caches, *required, value)
+                    } else if self.caches.callbacks_allowed()
+                        && rules.header.runtime_required(self.caches, kind)
+                        && self.object_callbacks(rules)
+                    {
+                        rules.header.children(self.caches, *required, value, node)
+                    } else if *required != 0 && kind != TYPE_OBJECT {
                         Invalid
                     } else if kind != TYPE_OBJECT {
                         Valid
+                    } else if rules.header_only() {
+                        rules.valid_header(self.caches, value, self.undefined, &self.budget)
                     } else {
-                        self.object(rules, value, depth + 1, active)
+                        let result = self.object(rules, value, depth + 1, active);
+                        if self.can_call_runtime(result)
+                            && self.caches.callbacks_allowed()
+                            && self.object_callbacks(rules)
+                        {
+                            rules.header.children(self.caches, *required, value, node)
+                        } else {
+                            result
+                        }
                     }
                 }
                 _ => self.leaf(op, kind, value, depth),
@@ -1360,20 +1625,49 @@ impl Execution<'_> {
     fn leaf(&self, op: &Op, kind: i32, value: Value, depth: usize) -> Verdict {
         match op {
             Op::Unsupported => Unsupported,
+            Op::UnresolvedRef(_) => Invalid,
             Op::Boolean(v) => verdict(*v),
-            Op::Type(mask) => verdict(kind & mask != 0),
-            Op::Const(v) => equal_budgeted(*v, value, depth, &self.budget),
-            Op::Enum(values) => values.eval(value, kind, depth, self.fixnum_flag, &self.budget),
+            Op::Type(mask, union) => self.type_verdict(*mask, *union, kind, value),
+            Op::Const(v) => {
+                let result = if kind == TYPE_UNSUPPORTED || self.caches.dynamic_calls() {
+                    Unsupported
+                } else {
+                    equal_budgeted(*v, value, depth, &self.budget)
+                };
+                if self.can_call_runtime(result) {
+                    self.caches.equality(*v, value, RUNTIME_EQUAL)
+                } else {
+                    result
+                }
+            }
+            Op::Enum(values) => {
+                let result = if kind == TYPE_UNSUPPORTED || self.caches.dynamic_calls() {
+                    Unsupported
+                } else {
+                    values.eval(value, kind, depth, self.fixnum_flag, &self.budget)
+                };
+                if self.can_call_runtime(result) {
+                    values.runtime(self.caches, value)
+                } else {
+                    result
+                }
+            }
             Op::Number(required, rules) => {
+                if kind == TYPE_UNSUPPORTED || self.caches.dynamic_calls() {
+                    return rules.runtime_valid(self.caches, *required, value);
+                }
                 if *required != 0 && kind & required == 0 {
                     Invalid
                 } else if kind & TYPE_NUMBER == 0 {
                     Valid
                 } else {
-                    rules.eval(value)
+                    rules.eval(self.caches, value, &self.budget)
                 }
             }
             Op::String(required, rules) => {
+                if kind == TYPE_UNSUPPORTED || self.caches.dynamic_calls() {
+                    return rules.runtime_valid(self.caches, *required, value);
+                }
                 if *required != 0 && kind != TYPE_STRING {
                     Invalid
                 } else if kind != TYPE_STRING {
@@ -1385,6 +1679,22 @@ impl Execution<'_> {
             _ => unreachable!("applicators must be evaluated with their context"),
         }
     }
+    fn can_call_runtime(&self, result: Verdict) -> bool {
+        result == Unsupported && self.budget.failure.get() == 0 && self.budget.hit.get().0 == 0
+    }
+    fn unique_values(&self, value: Value, depth: usize) -> Verdict {
+        let result = if self.caches.dynamic_calls() {
+            Unsupported
+        } else {
+            unique(value, depth, self.fixnum_flag, &self.budget)
+        };
+        if self.can_call_runtime(result) {
+            self.caches
+                .equality(unsafe { sn_nil() }, value, RUNTIME_UNIQUE)
+        } else {
+            result
+        }
+    }
     fn array(&self, r: &Array, value: Value, depth: usize, active: scope::Context<'_>) -> Verdict {
         if !self.budget.checkpoint() {
             return Unsupported;
@@ -1394,7 +1704,7 @@ impl Execution<'_> {
             return Invalid;
         }
         if r.unique {
-            let result = unique(value, depth, self.fixnum_flag, &self.budget);
+            let result = self.unique_values(value, depth);
             if result != Valid {
                 return result;
             }
@@ -1438,15 +1748,18 @@ impl Execution<'_> {
                 unsafe { std::slice::from_raw_parts(sn_array_data(value), len) }
             };
             let primitive = match self.nodes[child].as_slice() {
-                [Op::Type(mask)] if mask & TYPE_NUMBER != 0 || mask & TYPE_INTEGER != 0 => {
+                [Op::Type(mask, _)] if mask & TYPE_NUMBER != 0 || mask & TYPE_INTEGER != 0 => {
                     Some(&[][..])
                 }
                 [Op::Number(_, rules)] => rules.fast_limits.as_deref(),
                 _ => None,
             };
+            let primitive = primitive.filter(|_| !self.caches.dynamic_calls());
             let number = match self.nodes[child].as_slice() {
                 [Op::Number(required, rules)]
-                    if depth <= MAX_EVALUATION_DEPTH && !self.tracks[child] =>
+                    if depth <= MAX_EVALUATION_DEPTH
+                        && !self.tracks[child]
+                        && !self.caches.dynamic_calls() =>
                 {
                     Some((*required, rules))
                 }
@@ -1479,47 +1792,60 @@ impl Execution<'_> {
                     .or(self.metadata[child].primary_binding),
             };
             let object_active = self.enter_scope(child, active, &frame);
+            let _scope = self.caches.scope_guard(
+                frame.resource,
+                object.is_some() && self.metadata[child].enters_scope,
+            );
             let pattern = string.and_then(|(required, rules)| {
                 rules
                     .pattern_only()
                     .map(|pattern| (required, pattern))
-                    .filter(|_| !self.budget.timed())
+                    .filter(|_| !self.budget.timed() && !self.caches.dynamic_calls())
             });
             let format = string.and_then(|(required, rules)| {
                 rules
                     .format_only()
                     .map(|format| (required, format))
-                    .filter(|_| !self.budget.timed())
+                    .filter(|_| !self.budget.timed() && !self.caches.dynamic_calls())
             });
             let content = string.and_then(|(required, rules)| {
                 rules
                     .content_only()
                     .map(|content| (required, content))
-                    .filter(|_| !self.budget.timed())
+                    .filter(|_| !self.budget.timed() && !self.caches.dynamic_calls())
             });
             if let Some((required, pattern)) = pattern {
-                let result = pattern.eval_items(
+                let result = pattern.visit_invalid_items(
                     self.caches,
                     required,
                     values.get(r.prefix.len()..).unwrap_or(&[]),
+                    |_, item| self.eval(child, item, depth, active),
                 );
                 if result != Valid {
                     return result;
                 }
             } else if let Some((required, format)) = format {
-                let result =
-                    format.eval_items(required, values.get(r.prefix.len()..).unwrap_or(&[]));
+                let result = format.visit_invalid_items(
+                    required,
+                    values.get(r.prefix.len()..).unwrap_or(&[]),
+                    |_, item| self.eval(child, item, depth, active),
+                );
                 if result != Valid {
                     return result;
                 }
             } else if let Some((required, content)) = content {
-                let result =
-                    content.eval_items(required, values.get(r.prefix.len()..).unwrap_or(&[]));
+                let result = content.visit_invalid_items(
+                    self.caches,
+                    required,
+                    values.get(r.prefix.len()..).unwrap_or(&[]),
+                    |_, item| self.eval(child, item, depth, active),
+                );
                 if result != Valid {
                     return result;
                 }
             } else if let Some((required, rules)) = object {
                 let result = self.record_items(
+                    child,
                     rules,
                     required,
                     values.get(r.prefix.len()..).unwrap_or(&[]),
@@ -1546,16 +1872,21 @@ impl Execution<'_> {
                         return Unsupported;
                     }
                     let result = if let Some((required, rules)) = number {
-                        rules.eval_guarded(required, item)
+                        let status = rules.eval_guarded(self.caches, required, item, &self.budget);
+                        if status == Unsupported {
+                            self.eval(child, item, depth, active)
+                        } else {
+                            status
+                        }
                     } else if let Some((required, rules)) = string {
                         if rules.pattern.is_some() {
                             rules.eval_guarded(self.caches, required, item)
                         } else if rules.length_only() {
-                            rules.eval_length_guarded(required, item)
+                            rules.eval_length_guarded(self.caches, required, item)
                         } else {
                             let kind = unsafe { sn_kind(item) };
-                            if kind == TYPE_UNSUPPORTED {
-                                Unsupported
+                            if kind == TYPE_UNSUPPORTED || self.caches.dynamic_calls() {
+                                rules.runtime_valid(self.caches, required, item)
                             } else if kind != TYPE_STRING {
                                 verdict(required == 0)
                             } else {
@@ -1572,18 +1903,30 @@ impl Execution<'_> {
             }
         }
         if let Some(child) = r.contains {
-            if let Some(status) = self.fixnum_contains(r, child, value, len, depth) {
+            if r.count_contains
+                && let Some(status) = self.fixnum_contains(r, child, value, len, depth)
+            {
                 return status;
             }
             let matches = match evaluation::scan_contains(
                 len,
+                if r.count_contains {
+                    evaluation::ContainsPolicy::AllMatches
+                } else {
+                    evaluation::ContainsPolicy::FirstMatch
+                },
                 |index| self.eval(child, unsafe { sn_entry(value, index) }, depth, active),
                 |_| {},
             ) {
                 Ok(matches) => matches,
                 Err(status) => return status,
             };
-            if bounds(matches, Some(r.min_contains), r.max_contains) == Invalid {
+            let (min, max) = if r.count_contains {
+                (r.min_contains, r.max_contains)
+            } else {
+                (1, None)
+            };
+            if bounds(matches, Some(min), max) == Invalid {
                 return Invalid;
             }
         }
@@ -1604,7 +1947,7 @@ impl Execution<'_> {
             return None;
         };
         let total = match op {
-            Op::Type(_) | Op::Boolean(_) => true,
+            Op::Type(..) | Op::Boolean(_) => true,
             Op::Const(expected) => expected & self.fixnum_flag != 0,
             Op::Number(_, rules) => rules.fast_limits.is_some(),
             _ => false,
@@ -1630,7 +1973,6 @@ impl Execution<'_> {
             |index| self.leaf(op, TYPE_INTEGRAL_NUMBER, values[index], depth) == Valid,
         ))
     }
-    #[inline(never)]
     fn integer_items(
         &self,
         limits: &[(i32, i64)],
@@ -1653,7 +1995,9 @@ impl Execution<'_> {
             );
         let number = match self.nodes[child].as_slice() {
             [Op::Number(required, rules)]
-                if depth <= MAX_EVALUATION_DEPTH && !self.tracks[child] =>
+                if depth <= MAX_EVALUATION_DEPTH
+                    && !self.tracks[child]
+                    && !self.caches.dynamic_calls() =>
             {
                 Some((*required, rules))
             }
@@ -1672,7 +2016,12 @@ impl Execution<'_> {
                 let n = immediate_integer(value);
                 verdict(n >= min && n <= max)
             } else if let Some((required, rules)) = number {
-                rules.eval_guarded(required, value)
+                let status = rules.eval_guarded(self.caches, required, value, &self.budget);
+                if status == Unsupported {
+                    self.eval(child, value, depth, active)
+                } else {
+                    status
+                }
             } else {
                 self.eval(child, value, depth, active)
             };
@@ -1682,15 +2031,16 @@ impl Execution<'_> {
         }
         Valid
     }
-    #[inline(never)]
     fn record_items(
         &self,
+        node: usize,
         rules: &Object,
         required: i32,
         values: &[Value],
         depth: usize,
         active: scope::Context<'_>,
     ) -> Verdict {
+        let header_only = rules.header_only();
         for &value in values {
             if !self.budget.checkpoint() {
                 return Unsupported;
@@ -1700,13 +2050,29 @@ impl Execution<'_> {
             } else {
                 unsafe { sn_shallow_kind(value) }
             };
-            let result = if kind == TYPE_UNSUPPORTED {
+            let runtime = header_only && rules.header.runtime_required(self.caches, kind);
+            let result = if runtime {
+                rules.header.valid(self.caches, required, value)
+            } else if kind == TYPE_UNSUPPORTED {
                 Unsupported
             } else if kind != TYPE_OBJECT {
                 verdict(required == 0)
             } else {
                 self.object(rules, value, depth, active)
             };
+            let result = if self.can_call_runtime(result)
+                && self.caches.callbacks_allowed()
+                && self.object_callbacks(rules)
+            {
+                rules.header.children(self.caches, required, value, node)
+            } else if header_only && !runtime && self.can_call_runtime(result) {
+                // A declined record guard has not invoked instance methods.
+                // Preserve the fast record walk while handing special values
+                // to the same runtime frame as general header evaluation.
+                rules.header.valid(self.caches, required, value)
+            } else {
+                result
+            };
             if result != Valid {
                 return result;
             }
@@ -1723,7 +2089,9 @@ impl Execution<'_> {
         if !self.budget.checkpoint() {
             return Unsupported;
         }
-        if let Some(record) = &r.record {
+        if !self.caches.runtime_order()
+            && let Some(record) = &r.record
+        {
             // C initializes only the written key/value pairs. The untouched
             // tail is never read, including empty and unsupported records.
             let mut buffer = std::mem::MaybeUninit::<[Value; 16]>::uninit();
@@ -1805,26 +2173,36 @@ impl Execution<'_> {
         if bounds(len, r.min, r.max) == Invalid {
             return Invalid;
         }
-        let status = r.check_required(value, self.undefined, &self.budget);
+        let status = r.check_required(self.caches, value, self.undefined, &self.budget);
         if status != Valid {
             return status;
         }
-        let found = match r.visit_properties(
-            value,
-            len,
-            self.undefined,
-            &self.budget,
-            |_, child, item| self.eval(child, item, depth, active),
-        ) {
-            Ok(found) => found,
-            Err(status) => return status,
+        let ordered = self.caches.runtime_order();
+        let found = if ordered {
+            0
+        } else {
+            match r.visit_properties(
+                value,
+                len,
+                self.undefined,
+                &self.budget,
+                |_, child, item| self.eval(child, item, depth, active),
+            ) {
+                Ok(found) => found,
+                Err(status) => return status,
+            }
         };
-        if r.names.is_some() || !r.patterns.is_empty() || (r.additional.is_some() && found < len) {
+        if ordered
+            || r.names.is_some()
+            || !r.patterns.is_empty()
+            || (r.additional.is_some() && found < len)
+        {
             let mut context = ObjectContext {
                 engine: self,
                 rules: r,
                 depth,
                 active,
+                names_only: false,
             };
             let result =
                 unsafe { sn_object_each(value, (&mut context as *mut ObjectContext).cast()) };
@@ -1832,7 +2210,13 @@ impl Execution<'_> {
                 return if result == 0 { Invalid } else { Unsupported };
             }
         }
-        let status = r.check_dependent_required(value, self.undefined, &self.budget);
+        if ordered && r.names.is_some() {
+            let status = self.object_names(r, value, depth, active);
+            if status != Valid {
+                return status;
+            }
+        }
+        let status = r.check_dependent_required(self.caches, value, self.undefined, &self.budget);
         if status != Valid {
             return status;
         }
@@ -1849,13 +2233,76 @@ impl Execution<'_> {
         }
         Valid
     }
+    fn object_names(
+        &self,
+        rules: &Object,
+        value: Value,
+        depth: usize,
+        active: scope::Context<'_>,
+    ) -> Verdict {
+        let mut context = ObjectContext {
+            engine: self,
+            rules,
+            depth,
+            active,
+            names_only: true,
+        };
+        decode(unsafe { sn_object_each(value, (&mut context as *mut ObjectContext).cast()) })
+    }
+    fn unsupported_kind(&self, node: usize, kind: i32) -> bool {
+        kind == TYPE_UNSUPPORTED
+            && (self.kind_demand[node] == KindDemand::Data
+                || (!self.caches.callbacks_allowed()
+                    && !self.caches.report_continuations_allowed()
+                    && self.callback_container_node(node)))
+    }
+    fn type_verdict(&self, mask: i32, union: bool, kind: i32, value: Value) -> Verdict {
+        if kind == TYPE_UNSUPPORTED
+            || self.caches.scalar_callback()
+            || (self.caches.callbacks_allowed() && self.caches.dynamic_calls())
+        {
+            self.caches.type_predicate(value, mask, union)
+        } else {
+            verdict(kind & mask != 0)
+        }
+    }
     fn instance_kind(&self, node: usize, value: Value) -> i32 {
-        if matches!(self.nodes[node].as_slice(), [Op::Object(_, rules)] if rules.record.is_some()) {
+        if self.caches.scalar_callback() && self.kind_demand[node] == KindDemand::Predicate {
+            return TYPE_UNSUPPORTED;
+        }
+        if value & self.fixnum_flag != 0 {
+            return TYPE_INTEGRAL_NUMBER;
+        }
+        if self.kind_demand[node] == KindDemand::None {
+            return TYPE_UNCHECKED;
+        }
+        if matches!(self.nodes[node].as_slice(), [Op::Object(_, rules)]
+            if rules.record.is_some() && (!rules.header_only() || (!rules.inspect_required && rules.dependent_required.is_empty())))
+        {
             unsafe { sn_shallow_kind(value) }
         } else {
             unsafe { sn_kind(value) }
         }
     }
+    // Diagnostic/trial paths require a full Hash-key guard. A known parent kind
+    // remains reusable, while control-flow-only children need no classification.
+    fn diagnostic_kind(&self, node: usize, value: Value, known: &InstanceKind) -> i32 {
+        if self.caches.scalar_callback() && self.kind_demand[node] == KindDemand::Predicate {
+            return TYPE_UNSUPPORTED;
+        }
+        if known.get() != TYPE_UNCHECKED {
+            return known.get();
+        }
+        let kind = if value & self.fixnum_flag != 0 {
+            TYPE_INTEGRAL_NUMBER
+        } else if self.kind_demand[node] == KindDemand::None {
+            TYPE_UNCHECKED
+        } else {
+            unsafe { sn_kind(value) }
+        };
+        known.set(kind);
+        kind
+    }
     fn record_value(
         &self,
         node: usize,
@@ -1870,7 +2317,7 @@ impl Execution<'_> {
             [Op::String(required, rules)]
                 if depth <= MAX_EVALUATION_DEPTH && rules.length_only() =>
             {
-                rules.eval_length_guarded(*required, value)
+                rules.eval_length_guarded(self.caches, *required, value)
             }
             [Op::String(required, rules)]
                 if depth <= MAX_EVALUATION_DEPTH && rules.pattern.is_some() =>
@@ -1878,19 +2325,15 @@ impl Execution<'_> {
                 rules.eval_guarded(self.caches, *required, value)
             }
             [
-                op @ (Op::Type(_)
+                op @ (Op::Type(..)
                 | Op::Boolean(_)
                 | Op::Number(..)
                 | 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 {
+                let kind = self.diagnostic_kind(node, value, &InstanceKind::new(TYPE_UNCHECKED));
+                if self.unsupported_kind(node, kind) {
                     Unsupported
                 } else {
                     self.leaf(op, kind, value, depth)
@@ -1969,12 +2412,21 @@ fn record_entry(c: &mut RecordContext<'_, '_>, key: Value, value: Value) -> Verd
     {
         c.status = if c.depth <= MAX_EVALUATION_DEPTH {
             match field.and_then(|field| field.check) {
-                Some(RecordCheck::IntegerBounds(min, max)) if value & c.engine.fixnum_flag != 0 => {
+                Some(RecordCheck::IntegerBounds(min, max))
+                    if value & c.engine.fixnum_flag != 0 && !c.engine.caches.dynamic_calls() =>
+                {
                     let n = immediate_integer(value);
                     verdict(n >= min && n <= max)
                 }
-                Some(RecordCheck::StringLength(required, min, max)) => {
-                    length_guarded(value, required, min, max)
+                Some(RecordCheck::StringLength(required, min, max))
+                    if !c.engine.caches.dynamic_calls() =>
+                {
+                    let status = length_guarded(value, required, min, max);
+                    if status == Unsupported {
+                        c.engine.record_value(child, value, c.depth, c.active)
+                    } else {
+                        status
+                    }
                 }
                 _ => c.engine.record_value(child, value, c.depth, c.active),
             }
@@ -2038,20 +2490,79 @@ fn equal_cached(
         return Unsupported;
     }
     if depth > MAX_EVALUATION_DEPTH {
-        return Unsupported;
+        return equal_iterative(a, b, depth, memo, budget);
+    }
+    let ka = match equality_kind(a, b) {
+        Ok(kind) => kind,
+        Err(result) => return result,
+    };
+    let key = (a, b, depth);
+    if memo.eligible(depth)
+        && let Some(result) = memo.get(key)
+    {
+        return result;
+    }
+    let result = match ka {
+        TYPE_ARRAY => {
+            let len = unsafe { sn_len(a) };
+            if len != unsafe { sn_len(b) } {
+                return Invalid;
+            }
+            for i in 0..len {
+                let result = equal_cached(
+                    unsafe { sn_entry(a, i) },
+                    unsafe { sn_entry(b, i) },
+                    depth + 1,
+                    memo,
+                    budget,
+                );
+                if result != Valid {
+                    return result;
+                }
+            }
+            Valid
+        }
+        TYPE_OBJECT => {
+            if unsafe { sn_len(a) != sn_len(b) } {
+                return Invalid;
+            }
+            let mut context = EqualityContext {
+                other: b,
+                depth: depth + 1,
+                memo,
+                budget,
+            };
+            decode(unsafe {
+                sn_hash_each(
+                    a,
+                    (&mut context as *mut EqualityContext<'_>).cast(),
+                    equal_entry,
+                )
+            })
+        }
+        _ => unreachable!("equality_kind returns only container kinds"),
+    };
+    if memo.eligible(depth) {
+        memo.record(key, result);
     }
+    result
+}
+
+// Resolve scalar equality once for both recursive and explicit-stack traversal.
+// Only ordinary equal-class containers require child traversal.
+fn equality_kind(a: Value, b: Value) -> Result<i32, Verdict> {
     let (ka, kb) = unsafe { (sn_kind(a), sn_kind(b)) };
     if ka == TYPE_UNSUPPORTED || kb == TYPE_UNSUPPORTED {
-        return Unsupported;
+        return Err(Unsupported);
     }
     if ka & TYPE_NUMBER != 0 && kb & TYPE_NUMBER != 0 {
         let (ia, ib) = unsafe { (sn_fixnum(a) != 0, sn_fixnum(b) != 0) };
         let (fa, fb) = unsafe { (sn_is_float(a) != 0, sn_is_float(b) != 0) };
         if ia && ib {
-            return verdict(unsafe { sn_integer(a) == sn_integer(b) });
+            return Err(verdict(unsafe { sn_integer(a) == sn_integer(b) }));
         }
         if fa && fb {
-            return verdict(unsafe { sn_float(a) == sn_float(b) });
+            return Err(verdict(unsafe { sn_float(a) == sn_float(b) }));
         }
         if (ia && fb) || (fa && ib) {
             let (n, f) = unsafe {
@@ -2063,16 +2574,16 @@ fn equal_cached(
             };
             // Convert the float to an integer, never the integer to a rounded float.
             // Fixnums are strictly inside i64's bounds on supported CRuby targets.
-            return verdict(
+            return Err(verdict(
                 f.is_finite()
                     && f.trunc() == f
                     && f >= i64::MIN as f64
                     && f < i64::MAX as f64
                     && f as i64 == n,
-            );
+            ));
         }
         if !fa && !fb {
-            return verdict(
+            return Err(verdict(
                 unsafe {
                     if ia {
                         sn_big_equal(b, a)
@@ -2080,80 +2591,150 @@ fn equal_cached(
                         sn_big_equal(a, b)
                     }
                 } != 0,
-            );
+            ));
         }
-        return if fa {
+        return Err(if fa {
             number::integer_float_equal(b, unsafe { sn_float(a) })
         } else {
             number::integer_float_equal(a, unsafe { sn_float(b) })
-        };
+        });
     }
     // JSON container equality visits every value, even for the same object:
     // nested NaN values are unequal and unsupported values need VM evaluation.
     if ka != TYPE_ARRAY && ka != TYPE_OBJECT && unsafe { sn_same(a, b) } != 0 {
-        return Valid;
+        return Err(Valid);
     }
     if ka != kb {
-        return Invalid;
+        return Err(Invalid);
     }
     if unsafe { sn_same_class(a, b) } == 0 {
-        return Invalid;
+        return Err(Invalid);
     }
-    let container = ka == TYPE_ARRAY || ka == TYPE_OBJECT;
-    let key = (a, b, depth);
-    if container
-        && memo.eligible(depth)
-        && let Some(result) = memo.get(key)
-    {
-        return result;
+    match ka {
+        TYPE_ARRAY | TYPE_OBJECT => Ok(ka),
+        TYPE_STRING => Err(verdict(unsafe { sn_string_equal(a, b) } != 0)),
+        _ => Err(Invalid),
     }
-    let result = match ka {
-        TYPE_STRING => verdict(unsafe { sn_string_equal(a, b) } != 0),
-        TYPE_ARRAY => {
-            let len = unsafe { sn_len(a) };
-            if len != unsafe { sn_len(b) } {
-                return Invalid;
+}
+
+enum EqualityWork {
+    Compare(Value, Value, usize),
+    Array(Value, Value, usize, usize, usize),
+    Object(Value, Vec<(Value, Value)>, usize, usize),
+    Finish(Value, Value, usize),
+}
+
+// Keep shallow comparisons on their allocation-free recursive path. Beyond
+// that bounded prefix, explicit continuations preserve depth-first order
+// without growing the native call stack. Scalar rules remain shared above.
+fn equal_iterative(
+    a: Value,
+    b: Value,
+    depth: usize,
+    memo: &mut structural::Cache<(Value, Value, usize), Verdict>,
+    budget: &budget::Budget,
+) -> Verdict {
+    let mut work = vec![EqualityWork::Compare(a, b, depth)];
+    let mut active = std::collections::HashSet::new();
+    while let Some(task) = work.pop() {
+        if !budget.checkpoint() {
+            return Unsupported;
+        }
+        match task {
+            EqualityWork::Compare(a, b, depth) => {
+                let kind = match equality_kind(a, b) {
+                    Ok(kind) => kind,
+                    Err(Valid) => continue,
+                    Err(result) => return result,
+                };
+                let key = (a, b, depth);
+                if memo.eligible(depth)
+                    && let Some(result) = memo.get(key)
+                {
+                    if result != Valid {
+                        return result;
+                    }
+                    continue;
+                }
+                let len = unsafe { sn_len(a) };
+                if len != unsafe { sn_len(b) } {
+                    return Invalid;
+                }
+                // Report Ruby's recursive-comparison error after unwinding;
+                // an active pair is not proof of JSON equality.
+                if !active.insert((a, b)) {
+                    budget.failure.set(STATUS_STACK_ERROR);
+                    return Unsupported;
+                }
+                work.push(EqualityWork::Finish(a, b, depth));
+                if len == 0 {
+                    continue;
+                }
+                if kind == TYPE_ARRAY {
+                    work.push(EqualityWork::Array(a, b, 0, len, depth + 1));
+                } else {
+                    let mut entries = EqualityEntries {
+                        values: Vec::with_capacity(len),
+                        budget,
+                    };
+                    let status = decode(unsafe {
+                        sn_hash_each(
+                            a,
+                            (&mut entries as *mut EqualityEntries<'_>).cast(),
+                            equality_entry,
+                        )
+                    });
+                    if status != Valid {
+                        return status;
+                    }
+                    work.push(EqualityWork::Object(b, entries.values, 0, depth + 1));
+                }
             }
-            for i in 0..len {
-                let result = equal_cached(
-                    unsafe { sn_entry(a, i) },
-                    unsafe { sn_entry(b, i) },
-                    depth + 1,
-                    memo,
-                    budget,
-                );
-                if result != Valid {
-                    return result;
+            EqualityWork::Array(a, b, index, len, depth) => {
+                let pair = unsafe { (sn_entry(a, index), sn_entry(b, index)) };
+                if index + 1 < len {
+                    work.push(EqualityWork::Array(a, b, index + 1, len, depth));
                 }
+                work.push(EqualityWork::Compare(pair.0, pair.1, depth));
             }
-            Valid
-        }
-        TYPE_OBJECT => {
-            if unsafe { sn_len(a) != sn_len(b) } {
-                return Invalid;
+            EqualityWork::Object(b, entries, index, depth) => {
+                let (key, value) = entries[index];
+                let other = unsafe { sn_lookup(b, key) };
+                if unsafe { sn_missing(other) } != 0 {
+                    return Invalid;
+                }
+                if index + 1 < entries.len() {
+                    work.push(EqualityWork::Object(b, entries, index + 1, depth));
+                }
+                work.push(EqualityWork::Compare(value, other, depth));
+            }
+            EqualityWork::Finish(a, b, depth) => {
+                active.remove(&(a, b));
+                if memo.eligible(depth) {
+                    memo.record((a, b, depth), Valid);
+                }
             }
-            let mut context = EqualityContext {
-                other: b,
-                depth: depth + 1,
-                memo,
-                budget,
-            };
-            decode(unsafe {
-                sn_hash_each(
-                    a,
-                    (&mut context as *mut EqualityContext<'_>).cast(),
-                    equal_entry,
-                )
-            })
         }
-        TYPE_UNSUPPORTED => Unsupported,
-        _ => Invalid,
-    };
-    if container && memo.eligible(depth) {
-        memo.record(key, result);
     }
-    result
+    Valid
+}
+
+struct EqualityEntries<'a> {
+    values: Vec<(Value, Value)>,
+    budget: &'a budget::Budget,
 }
+unsafe extern "C" fn equality_entry(context: *mut c_void, key: Value, value: Value) -> i32 {
+    catch_unwind(AssertUnwindSafe(|| {
+        let entries = unsafe { &mut *context.cast::<EqualityEntries<'_>>() };
+        if !entries.budget.checkpoint() {
+            return Unsupported as i32;
+        }
+        entries.values.push((key, value));
+        Valid as i32
+    }))
+    .unwrap_or(Unsupported as i32)
+}
+
 fn decode(result: i32) -> Verdict {
     match result {
         VERDICT_INVALID => Invalid,
@@ -2321,13 +2902,12 @@ fn fingerprint_cached(
     // before the depth-based cache handles deeper shared graphs.
     let cacheable = container && memo.eligible_container(depth, unsafe { len.assume_init() });
     let key = (value, depth);
-    if cacheable
-        && let Some(result) = memo.get(key)
-    {
+    if cacheable && let Some(result) = memo.get(key) {
         return result;
     }
     let result = match kind {
         TYPE_INTEGRAL_NUMBER => Some(number::integer_fingerprint(value)),
+        TYPE_IDENTITY_SCALAR => Some(mix(value as u64 ^ TYPE_IDENTITY_SCALAR as u64)),
         TYPE_NULL => Some(mix(TYPE_NULL as u64)),
         TYPE_BOOLEAN => Some(mix(if unsafe { len.assume_init() } != 0 {
             2
@@ -2429,21 +3009,7 @@ fn unique(value: Value, depth: usize, fixnum_flag: Value, budget: &budget::Budge
         return Unsupported;
     }
     if len <= 16 {
-        for i in 0..len {
-            for previous in 0..i {
-                match equal_budgeted(
-                    unsafe { sn_entry(value, previous) },
-                    unsafe { sn_entry(value, i) },
-                    depth,
-                    budget,
-                ) {
-                    Valid => return Invalid,
-                    Unsupported => return Unsupported,
-                    Invalid => {}
-                }
-            }
-        }
-        return Valid;
+        return unique_linear(value, depth, budget, false);
     }
     let values = unsafe { std::slice::from_raw_parts(sn_array_data(value), len) };
     // This is a checked optimization hint, not an instance shape assumption.
@@ -2462,11 +3028,54 @@ fn unique(value: Value, depth: usize, fixnum_flag: Value, budget: &budget::Budge
         }
     }
     let mut fingerprints = structural::Cache::batch(depth);
-    indexed_unique(
+    let result = indexed_unique(
         values,
-        |item| fingerprint_cached(item, depth, fixnum_flag, big_hint, &mut fingerprints, budget),
+        |item| {
+            fingerprint_cached(
+                item,
+                depth,
+                fixnum_flag,
+                big_hint,
+                &mut fingerprints,
+                budget,
+            )
+        },
         |a, b| equal_budgeted(a, b, depth, budget),
-    )
+    );
+    if result == Unsupported && budget.failure.get() == 0 && budget.checkpoint() {
+        unique_linear(value, depth, budget, true)
+    } else {
+        result
+    }
+}
+// Index availability is an optimization decision. Exact ordered comparisons
+// can still decide uniqueness when a depth or memory bound declines hashing.
+fn unique_linear(value: Value, depth: usize, budget: &budget::Budget, check_hash: bool) -> Verdict {
+    for i in 0..unsafe { sn_len(value) } {
+        if check_hash {
+            match instance_graph::ordinary_graph(unsafe { sn_entry(value, i) }, budget) {
+                instance_graph::Safety::Ordinary => {}
+                instance_graph::Safety::Cyclic => {
+                    budget.failure.set(STATUS_STACK_ERROR);
+                    return Unsupported;
+                }
+                instance_graph::Safety::Unsupported => return Unsupported,
+            }
+        }
+        for previous in 0..i {
+            match equal_budgeted(
+                unsafe { sn_entry(value, previous) },
+                unsafe { sn_entry(value, i) },
+                depth,
+                budget,
+            ) {
+                Valid => return Invalid,
+                Unsupported => return Unsupported,
+                Invalid => {}
+            }
+        }
+    }
+    Valid
 }
 // Keep Big-only sampling and retry state out of the common scalar path.
 #[inline(never)]
@@ -2806,6 +3415,7 @@ struct ObjectContext<'a> {
     rules: &'a Object,
     depth: usize,
     active: scope::Context<'a>,
+    names_only: bool,
 }
 /// Called synchronously by the C hash iterator. This never calls allocating Ruby APIs.
 /// # Safety
@@ -2820,15 +3430,21 @@ pub unsafe extern "C" fn sn_object_entry(context: *const c_void, key: Value, val
         if unsafe { sn_kind(key) } != TYPE_STRING {
             return Unsupported as i32;
         }
-        if let Some(child) = c.rules.names {
+        if (c.names_only || !c.engine.caches.runtime_order())
+            && let Some(child) = c.rules.names
+        {
             let result = c.engine.eval(child, key, c.depth, c.active);
             if result != Valid {
                 return result as i32;
             }
         }
-        match c.rules.visit_value_rules::<false>(
+        if c.names_only {
+            return Valid as i32;
+        }
+        match c.rules.visit_value_rules(
             c.engine.caches,
             &c.engine.budget,
+            c.engine.caches.runtime_order(),
             key,
             None,
             |_, _, child| match c.engine.eval(child, value, c.depth, c.active) {
@@ -2879,9 +3495,17 @@ pub unsafe extern "C" fn sn_compile(
         e.bind_dynamic_anchors()?;
         e.simplify_dynamic_references();
         e.compile_memoization();
-        Ok::<_, Value>(())
+        e.compile_native_validity_support();
+        e.compile_kind_demands();
+        Ok::<_, Value>(
+            !e.nodes
+                .iter()
+                .flatten()
+                .any(|op| matches!(op, Op::Unsupported)),
+        )
     })) {
-        Ok(Ok(())) => VERDICT_VALID,
+        Ok(Ok(true)) => VERDICT_VALID,
+        Ok(Ok(false)) => VERDICT_UNSUPPORTED,
         Ok(Err(value)) => {
             unsafe { *error = value };
             STATUS_EXCEPTION
@@ -2900,12 +3524,44 @@ pub unsafe extern "C" fn sn_node_index(engine: *const Engine, program: Value) ->
         .unwrap_or(usize::MAX)
 }
 /// # Safety
+/// Engine must be initialized, node compiled, and flags writable.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_callback_kind(
+    engine: *const Engine,
+    node: usize,
+    flags: *mut i32,
+) -> i32 {
+    let (kind, value) = unsafe { &*engine }.scalar_callback_kind(node);
+    unsafe { *flags = value };
+    kind
+}
+/// # Safety
+/// Engine must be initialized and root compiled.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_reference_context(engine: *const Engine) -> i32 {
+    // Any scalar Ruby primitive can reenter a schema block, including from
+    // tracked/diagnostic traversals that cannot admit container callbacks.
+    i32::from(unsafe { &*engine }.has_references)
+}
+/// # Safety
 /// Engine must be initialized.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn sn_root_index(engine: *const Engine) -> usize {
     unsafe { &*engine }.root
 }
 /// # Safety
+/// Engine must be live and compilation must have finished.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sn_has_unresolved_references(engine: *const Engine) -> i32 {
+    i32::from(
+        unsafe { &*engine }
+            .nodes
+            .iter()
+            .flatten()
+            .any(|op| matches!(op, Op::UnresolvedRef(_))),
+    )
+}
+/// # Safety
 /// Roots must be live and compilation must have finished.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn sn_root_count(roots: *const Roots) -> usize {
@@ -2923,21 +3579,25 @@ pub unsafe extern "C" fn sn_root_at(roots: *const Roots, index: usize) -> Value
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn sn_valid(
     engine: *const Engine,
-    caches: *const pattern::Caches,
+    caches: *const runtime::Caches,
     root: usize,
     value: Value,
+    depth: usize,
 ) -> i32 {
     catch_unwind(AssertUnwindSafe(|| {
         let e = unsafe { &*engine };
-        let local = pattern::Caches::default();
+        let local = runtime::Caches::default();
         let caches = unsafe { caches.as_ref() }.unwrap_or(&local);
-        Execution {
+        caches.admit(e, root);
+        let execution = Execution {
             engine: e,
             caches,
             memo: memo::Memo::default(),
             budget: budget::Budget::default(),
-        }
-        .eval(root, value, 0, scope::Context::default()) as i32
+        };
+        let result = execution.eval(root, value, depth, scope::Context::default());
+        caches.finish_callback_report(result);
+        execution.budget.status(result)
     }))
     .unwrap_or(STATUS_PANIC)
 }
@@ -2946,24 +3606,26 @@ pub unsafe extern "C" fn sn_valid(
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn sn_valid_with_limits(
     engine: *const Engine,
-    caches: *const pattern::Caches,
+    caches: *const runtime::Caches,
     root: usize,
     value: Value,
+    depth: usize,
     limits: *const budget::Limits,
     outcome: *mut budget::Outcome,
 ) -> i32 {
-    let budget = budget::Budget::new(unsafe { *limits });
     let result = catch_unwind(AssertUnwindSafe(|| {
-        let local = pattern::Caches::default();
+        let local = runtime::Caches::default();
         let caches = unsafe { caches.as_ref() }.unwrap_or(&local);
+        let e = unsafe { &*engine };
+        caches.admit(e, root);
         let execution = Execution {
             engine: unsafe { &*engine },
             caches,
             memo: memo::Memo::default(),
-            budget,
+            budget: caches.budget(unsafe { *limits }),
         };
         let result = if execution.budget.check_deadline() {
-            execution.eval(root, value, 0, scope::Context::default())
+            execution.eval(root, value, depth, scope::Context::default())
         } else {
             Unsupported
         };
@@ -2975,7 +3637,8 @@ pub unsafe extern "C" fn sn_valid_with_limits(
         unsafe {
             ((*outcome).kind, (*outcome).attempted) = execution.budget.hit.get();
         }
-        result as i32
+        caches.finish_callback_report(result);
+        execution.budget.status(result)
     }));
     result.unwrap_or(STATUS_PANIC)
 }
@@ -3024,7 +3687,12 @@ pub extern "C" fn sn_engine_header_size() -> usize {
 pub unsafe extern "C" fn sn_size(engine: *const Engine) -> usize {
     let nodes = unsafe { &*std::ptr::addr_of!((*engine).nodes) };
     let operands = unsafe { &*std::ptr::addr_of!((*engine).error_operands) };
+    let programs = unsafe { &*std::ptr::addr_of!((*engine).programs) };
     let contextual = unsafe { &*std::ptr::addr_of!((*engine).memo_contextual) };
+    let kinds = unsafe { &*std::ptr::addr_of!((*engine).kind_demand) };
+    let callback_roots = unsafe { &*std::ptr::addr_of!((*engine).callback_roots) };
+    let validity_supported = unsafe { &*std::ptr::addr_of!((*engine).validity_supported) };
+    let report_supported = unsafe { &*std::ptr::addr_of!((*engine).report_supported) };
     let guarded = unsafe { &*std::ptr::addr_of!((*engine).memo_guarded) };
     let sources = unsafe { &*std::ptr::addr_of!((*engine).memo_guard_sources) };
     let same = unsafe { &*std::ptr::addr_of!((*engine).memo_guard_same_sources) };
@@ -3033,6 +3701,9 @@ pub unsafe extern "C" fn sn_size(engine: *const Engine) -> usize {
     let projection = unsafe { &*std::ptr::addr_of!((*engine).memo_scope_projection) };
     std::mem::size_of::<Engine>()
         + projection.memory_usage()
+        + kinds.capacity() * std::mem::size_of::<KindDemand>()
+        + (callback_roots.capacity() + validity_supported.capacity() + report_supported.capacity())
+            * std::mem::size_of::<bool>()
         + (contextual.capacity()
             + guarded.capacity()
             + sources.capacity()
@@ -3040,6 +3711,7 @@ pub unsafe extern "C" fn sn_size(engine: *const Engine) -> usize {
             + scalar.capacity()
             + amplification.capacity())
             * std::mem::size_of::<bool>()
+        + programs.capacity() * std::mem::size_of::<Value>()
         + nodes.capacity() * std::mem::size_of::<Vec<Op>>()
         + operands.capacity() * std::mem::size_of::<Vec<(i32, Value)>>()
         + operands
@@ -3054,6 +3726,7 @@ pub unsafe extern "C" fn sn_size(engine: *const Engine) -> usize {
             .iter()
             .flatten()
             .map(|op| match op {
+                Op::Number(_, rules) => rules.memory_usage(),
                 Op::Enum(values) => values.memory_usage(),
                 Op::String(_, rules) => {
                     std::mem::size_of::<StringRules>()