uor-foundation 0.3.5

// @generated by uor-crate from uor-ontology — do not edit manually

//! `predicate/` namespace — Boolean-valued functions on kernel objects. Formalizes resolver dispatch, reduction guard evaluation, and conditional resolution paths..
//!
//! Space: Kernel

use crate::HostTypes;

/// A total, pure, boolean-valued function on a kernel object. Evaluation terminates for all inputs and produces no side effects.
pub trait Predicate<H: HostTypes> {
    /// The OWL class of objects this predicate accepts as input.
    fn evaluates_over(&self) -> &H::HostString;
    /// Associated type for `Term`.
    type Term: crate::kernel::schema::Term<H>;
    /// The evaluator term that must reduce to a boolean-shaped datum on every input of the declared input type.
    fn evaluator_term(&self) -> &Self::Term;
    /// An IRI or identifier of the proof:Proof / proof:ComputationCertificate attesting that the evaluator halts on all inputs.
    fn termination_witness(&self) -> &H::HostString;
    /// Associated type for `DescentMeasure`.
    type DescentMeasure: crate::kernel::recursion::DescentMeasure<H>;
    /// A termination witness for user-declared predicates. Kernel predicates are total by construction; user-declared predicates must carry a descent measure certifying termination.
    fn bounded_evaluator(&self) -> &[Self::DescentMeasure];
}

/// A predicate over type:TypeDefinition. Used for resolver dispatch.
pub trait TypePredicate<H: HostTypes>: Predicate<H> {}

/// A predicate over state:Context or reduction:ReductionState. Used for reduction step guards.
pub trait StatePredicate<H: HostTypes>: Predicate<H> {}

/// A predicate over partition:SiteIndex. Used for site-level selection in geodesic resolution.
pub trait SitePredicate<H: HostTypes>: Predicate<H> {}

/// A pair (Predicate, Target) where Target is a resolver:Resolver class. The kernel evaluates the predicate; if true, the target resolver is selected.
pub trait DispatchRule<H: HostTypes> {
    /// Associated type for `Predicate`.
    type Predicate: Predicate<H>;
    /// The predicate that triggers this dispatch rule.
    fn dispatch_predicate(&self) -> &Self::Predicate;
    /// The resolver class selected when the predicate is satisfied. Range is the OWL class IRI of a resolver:Resolver subclass; v0.2.1 uses class IRIs so the codegen can construct façade structs.
    fn dispatch_target(&self) -> &H::HostString;
    /// Non-negative integer priority. Lower priority values are evaluated first; ties within a DispatchTable are resolved by declaration order.
    fn dispatch_priority(&self) -> u64;
    /// Position in the dispatch table (evaluation order).
    fn dispatch_index(&self) -> u64;
}

/// An ordered set of DispatchRules for a single dispatch point. Must satisfy exhaustiveness and mutual exclusion.
pub trait DispatchTable<H: HostTypes> {
    /// Associated type for `DispatchRule`.
    type DispatchRule: DispatchRule<H>;
    /// The ordered set of rules in this table.
    fn dispatch_rules(&self) -> &[Self::DispatchRule];
    /// True iff the disjunction of all dispatch predicates is a tautology over the input class.
    fn is_exhaustive(&self) -> bool;
    /// True iff no two dispatch predicates can be simultaneously true for any input.
    fn is_mutually_exclusive(&self) -> bool;
}

/// A triple (StatePredicate, effect:Effect, reduction:ReductionStep). The guard is a StatePredicate; if true, the effect is applied and the reduction advances to the target step.
pub trait GuardedTransition<H: HostTypes> {
    /// Associated type for `StatePredicate`.
    type StatePredicate: StatePredicate<H>;
    /// The guard predicate for this transition.
    fn guard_predicate(&self) -> &Self::StatePredicate;
    /// Associated type for `Effect`.
    type Effect: crate::kernel::effect::Effect<H>;
    /// The effect applied when the guard is satisfied.
    fn guard_effect(&self) -> &Self::Effect;
    /// Associated type for `ReductionStep`.
    type ReductionStep: crate::kernel::reduction::ReductionStep<H>;
    /// The reduction step to advance to.
    fn guard_target(&self) -> &Self::ReductionStep;
}

/// A single case in a pattern match: a Predicate and a result Term. The match evaluates predicates in order and returns the result of the first matching arm.
pub trait MatchArm<H: HostTypes> {
    /// Associated type for `Predicate`.
    type Predicate: Predicate<H>;
    /// The predicate guarding this arm.
    fn arm_predicate(&self) -> &Self::Predicate;
    /// Associated type for `Term`.
    type Term: crate::kernel::schema::Term<H>;
    /// The result term if this arm matches.
    fn arm_result(&self) -> &Self::Term;
    /// Position in the match expression (evaluation order).
    fn arm_index(&self) -> u64;
}

/// A term formed by evaluating a sequence of MatchArms. Extends the term language with deterministic conditional evaluation.
pub trait MatchExpression<H: HostTypes>: crate::kernel::schema::Term<H> {
    /// Associated type for `MatchArm`.
    type MatchArm: MatchArm<H>;
    /// The ordered arms of this match expression.
    fn match_arms(&self) -> &[Self::MatchArm];
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `Predicate<H>`.
/// Every accessor returns `H::EMPTY_*` sentinels (for scalar / host-typed
/// returns) or a `'static`-lifetime reference to a sibling `Null*`'s `ABSENT`
/// const (for trait-typed returns).  Downstream provides concrete impls;
/// this stub closes the ontology-derived trait orphan.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct NullPredicate<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullPredicate<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullPredicate<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullPredicate<H> = NullPredicate {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> Predicate<H> for NullPredicate<H> {
    fn evaluates_over(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type Term = crate::kernel::schema::NullTerm<H>;
    fn evaluator_term(&self) -> &Self::Term {
        &<crate::kernel::schema::NullTerm<H>>::ABSENT
    }
    fn termination_witness(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type DescentMeasure = crate::kernel::recursion::NullDescentMeasure<H>;
    fn bounded_evaluator(&self) -> &[Self::DescentMeasure] {
        &[]
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `TypePredicate<H>`.
/// Every accessor returns `H::EMPTY_*` sentinels (for scalar / host-typed
/// returns) or a `'static`-lifetime reference to a sibling `Null*`'s `ABSENT`
/// const (for trait-typed returns).  Downstream provides concrete impls;
/// this stub closes the ontology-derived trait orphan.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct NullTypePredicate<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullTypePredicate<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullTypePredicate<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullTypePredicate<H> = NullTypePredicate {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> Predicate<H> for NullTypePredicate<H> {
    fn evaluates_over(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type Term = crate::kernel::schema::NullTerm<H>;
    fn evaluator_term(&self) -> &Self::Term {
        &<crate::kernel::schema::NullTerm<H>>::ABSENT
    }
    fn termination_witness(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type DescentMeasure = crate::kernel::recursion::NullDescentMeasure<H>;
    fn bounded_evaluator(&self) -> &[Self::DescentMeasure] {
        &[]
    }
}
impl<H: HostTypes> TypePredicate<H> for NullTypePredicate<H> {}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `StatePredicate<H>`.
/// Every accessor returns `H::EMPTY_*` sentinels (for scalar / host-typed
/// returns) or a `'static`-lifetime reference to a sibling `Null*`'s `ABSENT`
/// const (for trait-typed returns).  Downstream provides concrete impls;
/// this stub closes the ontology-derived trait orphan.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct NullStatePredicate<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullStatePredicate<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullStatePredicate<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullStatePredicate<H> = NullStatePredicate {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> Predicate<H> for NullStatePredicate<H> {
    fn evaluates_over(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type Term = crate::kernel::schema::NullTerm<H>;
    fn evaluator_term(&self) -> &Self::Term {
        &<crate::kernel::schema::NullTerm<H>>::ABSENT
    }
    fn termination_witness(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type DescentMeasure = crate::kernel::recursion::NullDescentMeasure<H>;
    fn bounded_evaluator(&self) -> &[Self::DescentMeasure] {
        &[]
    }
}
impl<H: HostTypes> StatePredicate<H> for NullStatePredicate<H> {}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `SitePredicate<H>`.
/// Every accessor returns `H::EMPTY_*` sentinels (for scalar / host-typed
/// returns) or a `'static`-lifetime reference to a sibling `Null*`'s `ABSENT`
/// const (for trait-typed returns).  Downstream provides concrete impls;
/// this stub closes the ontology-derived trait orphan.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct NullSitePredicate<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullSitePredicate<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullSitePredicate<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullSitePredicate<H> = NullSitePredicate {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> Predicate<H> for NullSitePredicate<H> {
    fn evaluates_over(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type Term = crate::kernel::schema::NullTerm<H>;
    fn evaluator_term(&self) -> &Self::Term {
        &<crate::kernel::schema::NullTerm<H>>::ABSENT
    }
    fn termination_witness(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type DescentMeasure = crate::kernel::recursion::NullDescentMeasure<H>;
    fn bounded_evaluator(&self) -> &[Self::DescentMeasure] {
        &[]
    }
}
impl<H: HostTypes> SitePredicate<H> for NullSitePredicate<H> {}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `DispatchRule<H>`.
/// Every accessor returns `H::EMPTY_*` sentinels (for scalar / host-typed
/// returns) or a `'static`-lifetime reference to a sibling `Null*`'s `ABSENT`
/// const (for trait-typed returns).  Downstream provides concrete impls;
/// this stub closes the ontology-derived trait orphan.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct NullDispatchRule<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullDispatchRule<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullDispatchRule<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullDispatchRule<H> = NullDispatchRule {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> DispatchRule<H> for NullDispatchRule<H> {
    type Predicate = NullPredicate<H>;
    fn dispatch_predicate(&self) -> &Self::Predicate {
        &<NullPredicate<H>>::ABSENT
    }
    fn dispatch_target(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn dispatch_priority(&self) -> u64 {
        0
    }
    fn dispatch_index(&self) -> u64 {
        0
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `DispatchTable<H>`.
/// Every accessor returns `H::EMPTY_*` sentinels (for scalar / host-typed
/// returns) or a `'static`-lifetime reference to a sibling `Null*`'s `ABSENT`
/// const (for trait-typed returns).  Downstream provides concrete impls;
/// this stub closes the ontology-derived trait orphan.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct NullDispatchTable<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullDispatchTable<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullDispatchTable<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullDispatchTable<H> = NullDispatchTable {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> DispatchTable<H> for NullDispatchTable<H> {
    type DispatchRule = NullDispatchRule<H>;
    fn dispatch_rules(&self) -> &[Self::DispatchRule] {
        &[]
    }
    fn is_exhaustive(&self) -> bool {
        false
    }
    fn is_mutually_exclusive(&self) -> bool {
        false
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `GuardedTransition<H>`.
/// Every accessor returns `H::EMPTY_*` sentinels (for scalar / host-typed
/// returns) or a `'static`-lifetime reference to a sibling `Null*`'s `ABSENT`
/// const (for trait-typed returns).  Downstream provides concrete impls;
/// this stub closes the ontology-derived trait orphan.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct NullGuardedTransition<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullGuardedTransition<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullGuardedTransition<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullGuardedTransition<H> = NullGuardedTransition {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> GuardedTransition<H> for NullGuardedTransition<H> {
    type StatePredicate = NullStatePredicate<H>;
    fn guard_predicate(&self) -> &Self::StatePredicate {
        &<NullStatePredicate<H>>::ABSENT
    }
    type Effect = crate::kernel::effect::NullEffect<H>;
    fn guard_effect(&self) -> &Self::Effect {
        &<crate::kernel::effect::NullEffect<H>>::ABSENT
    }
    type ReductionStep = crate::kernel::reduction::NullReductionStep<H>;
    fn guard_target(&self) -> &Self::ReductionStep {
        &<crate::kernel::reduction::NullReductionStep<H>>::ABSENT
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `MatchArm<H>`.
/// Every accessor returns `H::EMPTY_*` sentinels (for scalar / host-typed
/// returns) or a `'static`-lifetime reference to a sibling `Null*`'s `ABSENT`
/// const (for trait-typed returns).  Downstream provides concrete impls;
/// this stub closes the ontology-derived trait orphan.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct NullMatchArm<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullMatchArm<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullMatchArm<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullMatchArm<H> = NullMatchArm {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> MatchArm<H> for NullMatchArm<H> {
    type Predicate = NullPredicate<H>;
    fn arm_predicate(&self) -> &Self::Predicate {
        &<NullPredicate<H>>::ABSENT
    }
    type Term = crate::kernel::schema::NullTerm<H>;
    fn arm_result(&self) -> &Self::Term {
        &<crate::kernel::schema::NullTerm<H>>::ABSENT
    }
    fn arm_index(&self) -> u64 {
        0
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `MatchExpression<H>`.
/// Every accessor returns `H::EMPTY_*` sentinels (for scalar / host-typed
/// returns) or a `'static`-lifetime reference to a sibling `Null*`'s `ABSENT`
/// const (for trait-typed returns).  Downstream provides concrete impls;
/// this stub closes the ontology-derived trait orphan.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct NullMatchExpression<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullMatchExpression<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullMatchExpression<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullMatchExpression<H> = NullMatchExpression {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> crate::kernel::schema::Term<H> for NullMatchExpression<H> {}
impl<H: HostTypes> MatchExpression<H> for NullMatchExpression<H> {
    type MatchArm = NullMatchArm<H>;
    fn match_arms(&self) -> &[Self::MatchArm] {
        &[]
    }
}

/// Phase 8 (orphan-closure) — content-addressed handle for `Predicate<H>`.
///
/// Pairs a [`crate::enforcement::ContentFingerprint`] with a phantom
/// `H` so type-state checks can't mix handles across `HostTypes` impls.
#[derive(Debug)]
pub struct PredicateHandle<H: HostTypes> {
    /// Content fingerprint identifying the resolved record.
    pub fingerprint: crate::enforcement::ContentFingerprint,
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Copy for PredicateHandle<H> {}
impl<H: HostTypes> Clone for PredicateHandle<H> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<H: HostTypes> PartialEq for PredicateHandle<H> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.fingerprint == other.fingerprint
    }
}
impl<H: HostTypes> Eq for PredicateHandle<H> {}
impl<H: HostTypes> core::hash::Hash for PredicateHandle<H> {
    #[inline]
    fn hash<S: core::hash::Hasher>(&self, state: &mut S) {
        self.fingerprint.hash(state);
    }
}
impl<H: HostTypes> PredicateHandle<H> {
    /// Construct a handle from its content fingerprint.
    #[inline]
    #[must_use]
    pub const fn new(fingerprint: crate::enforcement::ContentFingerprint) -> Self {
        Self {
            fingerprint,
            _phantom: core::marker::PhantomData,
        }
    }
}

/// Phase 8 (orphan-closure) — resolver trait for `Predicate<H>`.
///
/// Hosts implement this trait to map a handle into a typed record.
/// The default Null stub does not implement this trait — it carries
/// no record. Resolution is the responsibility of the host pipeline.
pub trait PredicateResolver<H: HostTypes> {
    /// Resolve a handle into its record. Returns `None` when the
    /// handle does not correspond to known content.
    fn resolve(&self, handle: PredicateHandle<H>) -> Option<PredicateRecord<H>>;
}

/// Phase 8 (orphan-closure) — typed record for `Predicate<H>`.
///
/// Carries a field per functional accessor of the trait. Object
/// fields hold `{Range}Handle<H>`; iterate via the Resolved wrapper
/// chain-resolver methods.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct PredicateRecord<H: HostTypes> {
    pub evaluates_over: &'static H::HostString,
    pub evaluator_term_handle: crate::kernel::schema::TermHandle<H>,
    pub termination_witness: &'static H::HostString,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `Predicate<H>`.
///
/// Caches the resolver's lookup at construction. Accessors return
/// the cached record's fields when present, falling back to the
/// `Null{Class}<H>` absent sentinels when the resolver returned
/// `None`. Object accessors always return absent sentinels — use
/// the `resolve_{m}` chain methods to descend into sub-records.
pub struct ResolvedPredicate<'r, R: PredicateResolver<H>, H: HostTypes> {
    handle: PredicateHandle<H>,
    resolver: &'r R,
    record: Option<PredicateRecord<H>>,
}
impl<'r, R: PredicateResolver<H>, H: HostTypes> ResolvedPredicate<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: PredicateHandle<H>, resolver: &'r R) -> Self {
        let record = resolver.resolve(handle);
        Self {
            handle,
            resolver,
            record,
        }
    }
    /// The handle this wrapper resolves.
    #[inline]
    #[must_use]
    pub const fn handle(&self) -> PredicateHandle<H> {
        self.handle
    }
    /// The resolver supplied at construction.
    #[inline]
    #[must_use]
    pub const fn resolver(&self) -> &'r R {
        self.resolver
    }
    /// The cached record, or `None` when the resolver returned `None`.
    #[inline]
    #[must_use]
    pub const fn record(&self) -> Option<&PredicateRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: PredicateResolver<H>, H: HostTypes> Predicate<H> for ResolvedPredicate<'r, R, H> {
    fn evaluates_over(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type Term = crate::kernel::schema::NullTerm<H>;
    fn evaluator_term(&self) -> &Self::Term {
        &<crate::kernel::schema::NullTerm<H>>::ABSENT
    }
    fn termination_witness(&self) -> &H::HostString {
        match &self.record {
            Some(r) => r.termination_witness,
            None => H::EMPTY_HOST_STRING,
        }
    }
    type DescentMeasure = crate::kernel::recursion::NullDescentMeasure<H>;
    fn bounded_evaluator(&self) -> &[Self::DescentMeasure] {
        &[]
    }
}
impl<'r, R: PredicateResolver<H>, H: HostTypes> ResolvedPredicate<'r, R, H> {
    /// Promote the `evaluator_term` handle on the cached record into a
    /// resolved wrapper, given a resolver for the range class.
    /// Returns `None` if no record was resolved at construction.
    #[inline]
    pub fn resolve_evaluator_term<'r2, R2: crate::kernel::schema::TermResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::kernel::schema::ResolvedTerm<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::kernel::schema::ResolvedTerm::new(
            record.evaluator_term_handle,
            r,
        ))
    }
}

/// Phase 8 (orphan-closure) — content-addressed handle for `TypePredicate<H>`.
///
/// Pairs a [`crate::enforcement::ContentFingerprint`] with a phantom
/// `H` so type-state checks can't mix handles across `HostTypes` impls.
#[derive(Debug)]
pub struct TypePredicateHandle<H: HostTypes> {
    /// Content fingerprint identifying the resolved record.
    pub fingerprint: crate::enforcement::ContentFingerprint,
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Copy for TypePredicateHandle<H> {}
impl<H: HostTypes> Clone for TypePredicateHandle<H> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<H: HostTypes> PartialEq for TypePredicateHandle<H> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.fingerprint == other.fingerprint
    }
}
impl<H: HostTypes> Eq for TypePredicateHandle<H> {}
impl<H: HostTypes> core::hash::Hash for TypePredicateHandle<H> {
    #[inline]
    fn hash<S: core::hash::Hasher>(&self, state: &mut S) {
        self.fingerprint.hash(state);
    }
}
impl<H: HostTypes> TypePredicateHandle<H> {
    /// Construct a handle from its content fingerprint.
    #[inline]
    #[must_use]
    pub const fn new(fingerprint: crate::enforcement::ContentFingerprint) -> Self {
        Self {
            fingerprint,
            _phantom: core::marker::PhantomData,
        }
    }
}

/// Phase 8 (orphan-closure) — resolver trait for `TypePredicate<H>`.
///
/// Hosts implement this trait to map a handle into a typed record.
/// The default Null stub does not implement this trait — it carries
/// no record. Resolution is the responsibility of the host pipeline.
pub trait TypePredicateResolver<H: HostTypes> {
    /// Resolve a handle into its record. Returns `None` when the
    /// handle does not correspond to known content.
    fn resolve(&self, handle: TypePredicateHandle<H>) -> Option<TypePredicateRecord<H>>;
}

/// Phase 8 (orphan-closure) — typed record for `TypePredicate<H>`.
///
/// Carries a field per functional accessor of the trait. Object
/// fields hold `{Range}Handle<H>`; iterate via the Resolved wrapper
/// chain-resolver methods.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct TypePredicateRecord<H: HostTypes> {
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `TypePredicate<H>`.
///
/// Caches the resolver's lookup at construction. Accessors return
/// the cached record's fields when present, falling back to the
/// `Null{Class}<H>` absent sentinels when the resolver returned
/// `None`. Object accessors always return absent sentinels — use
/// the `resolve_{m}` chain methods to descend into sub-records.
pub struct ResolvedTypePredicate<'r, R: TypePredicateResolver<H>, H: HostTypes> {
    handle: TypePredicateHandle<H>,
    resolver: &'r R,
    record: Option<TypePredicateRecord<H>>,
}
impl<'r, R: TypePredicateResolver<H>, H: HostTypes> ResolvedTypePredicate<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: TypePredicateHandle<H>, resolver: &'r R) -> Self {
        let record = resolver.resolve(handle);
        Self {
            handle,
            resolver,
            record,
        }
    }
    /// The handle this wrapper resolves.
    #[inline]
    #[must_use]
    pub const fn handle(&self) -> TypePredicateHandle<H> {
        self.handle
    }
    /// The resolver supplied at construction.
    #[inline]
    #[must_use]
    pub const fn resolver(&self) -> &'r R {
        self.resolver
    }
    /// The cached record, or `None` when the resolver returned `None`.
    #[inline]
    #[must_use]
    pub const fn record(&self) -> Option<&TypePredicateRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: TypePredicateResolver<H>, H: HostTypes> Predicate<H>
    for ResolvedTypePredicate<'r, R, H>
{
    fn evaluates_over(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type Term = crate::kernel::schema::NullTerm<H>;
    fn evaluator_term(&self) -> &Self::Term {
        &<crate::kernel::schema::NullTerm<H>>::ABSENT
    }
    fn termination_witness(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type DescentMeasure = crate::kernel::recursion::NullDescentMeasure<H>;
    fn bounded_evaluator(&self) -> &[Self::DescentMeasure] {
        &[]
    }
}
impl<'r, R: TypePredicateResolver<H>, H: HostTypes> TypePredicate<H>
    for ResolvedTypePredicate<'r, R, H>
{
}

/// Phase 8 (orphan-closure) — content-addressed handle for `StatePredicate<H>`.
///
/// Pairs a [`crate::enforcement::ContentFingerprint`] with a phantom
/// `H` so type-state checks can't mix handles across `HostTypes` impls.
#[derive(Debug)]
pub struct StatePredicateHandle<H: HostTypes> {
    /// Content fingerprint identifying the resolved record.
    pub fingerprint: crate::enforcement::ContentFingerprint,
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Copy for StatePredicateHandle<H> {}
impl<H: HostTypes> Clone for StatePredicateHandle<H> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<H: HostTypes> PartialEq for StatePredicateHandle<H> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.fingerprint == other.fingerprint
    }
}
impl<H: HostTypes> Eq for StatePredicateHandle<H> {}
impl<H: HostTypes> core::hash::Hash for StatePredicateHandle<H> {
    #[inline]
    fn hash<S: core::hash::Hasher>(&self, state: &mut S) {
        self.fingerprint.hash(state);
    }
}
impl<H: HostTypes> StatePredicateHandle<H> {
    /// Construct a handle from its content fingerprint.
    #[inline]
    #[must_use]
    pub const fn new(fingerprint: crate::enforcement::ContentFingerprint) -> Self {
        Self {
            fingerprint,
            _phantom: core::marker::PhantomData,
        }
    }
}

/// Phase 8 (orphan-closure) — resolver trait for `StatePredicate<H>`.
///
/// Hosts implement this trait to map a handle into a typed record.
/// The default Null stub does not implement this trait — it carries
/// no record. Resolution is the responsibility of the host pipeline.
pub trait StatePredicateResolver<H: HostTypes> {
    /// Resolve a handle into its record. Returns `None` when the
    /// handle does not correspond to known content.
    fn resolve(&self, handle: StatePredicateHandle<H>) -> Option<StatePredicateRecord<H>>;
}

/// Phase 8 (orphan-closure) — typed record for `StatePredicate<H>`.
///
/// Carries a field per functional accessor of the trait. Object
/// fields hold `{Range}Handle<H>`; iterate via the Resolved wrapper
/// chain-resolver methods.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct StatePredicateRecord<H: HostTypes> {
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `StatePredicate<H>`.
///
/// Caches the resolver's lookup at construction. Accessors return
/// the cached record's fields when present, falling back to the
/// `Null{Class}<H>` absent sentinels when the resolver returned
/// `None`. Object accessors always return absent sentinels — use
/// the `resolve_{m}` chain methods to descend into sub-records.
pub struct ResolvedStatePredicate<'r, R: StatePredicateResolver<H>, H: HostTypes> {
    handle: StatePredicateHandle<H>,
    resolver: &'r R,
    record: Option<StatePredicateRecord<H>>,
}
impl<'r, R: StatePredicateResolver<H>, H: HostTypes> ResolvedStatePredicate<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: StatePredicateHandle<H>, resolver: &'r R) -> Self {
        let record = resolver.resolve(handle);
        Self {
            handle,
            resolver,
            record,
        }
    }
    /// The handle this wrapper resolves.
    #[inline]
    #[must_use]
    pub const fn handle(&self) -> StatePredicateHandle<H> {
        self.handle
    }
    /// The resolver supplied at construction.
    #[inline]
    #[must_use]
    pub const fn resolver(&self) -> &'r R {
        self.resolver
    }
    /// The cached record, or `None` when the resolver returned `None`.
    #[inline]
    #[must_use]
    pub const fn record(&self) -> Option<&StatePredicateRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: StatePredicateResolver<H>, H: HostTypes> Predicate<H>
    for ResolvedStatePredicate<'r, R, H>
{
    fn evaluates_over(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type Term = crate::kernel::schema::NullTerm<H>;
    fn evaluator_term(&self) -> &Self::Term {
        &<crate::kernel::schema::NullTerm<H>>::ABSENT
    }
    fn termination_witness(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type DescentMeasure = crate::kernel::recursion::NullDescentMeasure<H>;
    fn bounded_evaluator(&self) -> &[Self::DescentMeasure] {
        &[]
    }
}
impl<'r, R: StatePredicateResolver<H>, H: HostTypes> StatePredicate<H>
    for ResolvedStatePredicate<'r, R, H>
{
}

/// Phase 8 (orphan-closure) — content-addressed handle for `SitePredicate<H>`.
///
/// Pairs a [`crate::enforcement::ContentFingerprint`] with a phantom
/// `H` so type-state checks can't mix handles across `HostTypes` impls.
#[derive(Debug)]
pub struct SitePredicateHandle<H: HostTypes> {
    /// Content fingerprint identifying the resolved record.
    pub fingerprint: crate::enforcement::ContentFingerprint,
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Copy for SitePredicateHandle<H> {}
impl<H: HostTypes> Clone for SitePredicateHandle<H> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<H: HostTypes> PartialEq for SitePredicateHandle<H> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.fingerprint == other.fingerprint
    }
}
impl<H: HostTypes> Eq for SitePredicateHandle<H> {}
impl<H: HostTypes> core::hash::Hash for SitePredicateHandle<H> {
    #[inline]
    fn hash<S: core::hash::Hasher>(&self, state: &mut S) {
        self.fingerprint.hash(state);
    }
}
impl<H: HostTypes> SitePredicateHandle<H> {
    /// Construct a handle from its content fingerprint.
    #[inline]
    #[must_use]
    pub const fn new(fingerprint: crate::enforcement::ContentFingerprint) -> Self {
        Self {
            fingerprint,
            _phantom: core::marker::PhantomData,
        }
    }
}

/// Phase 8 (orphan-closure) — resolver trait for `SitePredicate<H>`.
///
/// Hosts implement this trait to map a handle into a typed record.
/// The default Null stub does not implement this trait — it carries
/// no record. Resolution is the responsibility of the host pipeline.
pub trait SitePredicateResolver<H: HostTypes> {
    /// Resolve a handle into its record. Returns `None` when the
    /// handle does not correspond to known content.
    fn resolve(&self, handle: SitePredicateHandle<H>) -> Option<SitePredicateRecord<H>>;
}

/// Phase 8 (orphan-closure) — typed record for `SitePredicate<H>`.
///
/// Carries a field per functional accessor of the trait. Object
/// fields hold `{Range}Handle<H>`; iterate via the Resolved wrapper
/// chain-resolver methods.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct SitePredicateRecord<H: HostTypes> {
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `SitePredicate<H>`.
///
/// Caches the resolver's lookup at construction. Accessors return
/// the cached record's fields when present, falling back to the
/// `Null{Class}<H>` absent sentinels when the resolver returned
/// `None`. Object accessors always return absent sentinels — use
/// the `resolve_{m}` chain methods to descend into sub-records.
pub struct ResolvedSitePredicate<'r, R: SitePredicateResolver<H>, H: HostTypes> {
    handle: SitePredicateHandle<H>,
    resolver: &'r R,
    record: Option<SitePredicateRecord<H>>,
}
impl<'r, R: SitePredicateResolver<H>, H: HostTypes> ResolvedSitePredicate<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: SitePredicateHandle<H>, resolver: &'r R) -> Self {
        let record = resolver.resolve(handle);
        Self {
            handle,
            resolver,
            record,
        }
    }
    /// The handle this wrapper resolves.
    #[inline]
    #[must_use]
    pub const fn handle(&self) -> SitePredicateHandle<H> {
        self.handle
    }
    /// The resolver supplied at construction.
    #[inline]
    #[must_use]
    pub const fn resolver(&self) -> &'r R {
        self.resolver
    }
    /// The cached record, or `None` when the resolver returned `None`.
    #[inline]
    #[must_use]
    pub const fn record(&self) -> Option<&SitePredicateRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: SitePredicateResolver<H>, H: HostTypes> Predicate<H>
    for ResolvedSitePredicate<'r, R, H>
{
    fn evaluates_over(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type Term = crate::kernel::schema::NullTerm<H>;
    fn evaluator_term(&self) -> &Self::Term {
        &<crate::kernel::schema::NullTerm<H>>::ABSENT
    }
    fn termination_witness(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type DescentMeasure = crate::kernel::recursion::NullDescentMeasure<H>;
    fn bounded_evaluator(&self) -> &[Self::DescentMeasure] {
        &[]
    }
}
impl<'r, R: SitePredicateResolver<H>, H: HostTypes> SitePredicate<H>
    for ResolvedSitePredicate<'r, R, H>
{
}

/// Phase 8 (orphan-closure) — content-addressed handle for `DispatchRule<H>`.
///
/// Pairs a [`crate::enforcement::ContentFingerprint`] with a phantom
/// `H` so type-state checks can't mix handles across `HostTypes` impls.
#[derive(Debug)]
pub struct DispatchRuleHandle<H: HostTypes> {
    /// Content fingerprint identifying the resolved record.
    pub fingerprint: crate::enforcement::ContentFingerprint,
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Copy for DispatchRuleHandle<H> {}
impl<H: HostTypes> Clone for DispatchRuleHandle<H> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<H: HostTypes> PartialEq for DispatchRuleHandle<H> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.fingerprint == other.fingerprint
    }
}
impl<H: HostTypes> Eq for DispatchRuleHandle<H> {}
impl<H: HostTypes> core::hash::Hash for DispatchRuleHandle<H> {
    #[inline]
    fn hash<S: core::hash::Hasher>(&self, state: &mut S) {
        self.fingerprint.hash(state);
    }
}
impl<H: HostTypes> DispatchRuleHandle<H> {
    /// Construct a handle from its content fingerprint.
    #[inline]
    #[must_use]
    pub const fn new(fingerprint: crate::enforcement::ContentFingerprint) -> Self {
        Self {
            fingerprint,
            _phantom: core::marker::PhantomData,
        }
    }
}

/// Phase 8 (orphan-closure) — resolver trait for `DispatchRule<H>`.
///
/// Hosts implement this trait to map a handle into a typed record.
/// The default Null stub does not implement this trait — it carries
/// no record. Resolution is the responsibility of the host pipeline.
pub trait DispatchRuleResolver<H: HostTypes> {
    /// Resolve a handle into its record. Returns `None` when the
    /// handle does not correspond to known content.
    fn resolve(&self, handle: DispatchRuleHandle<H>) -> Option<DispatchRuleRecord<H>>;
}

/// Phase 8 (orphan-closure) — typed record for `DispatchRule<H>`.
///
/// Carries a field per functional accessor of the trait. Object
/// fields hold `{Range}Handle<H>`; iterate via the Resolved wrapper
/// chain-resolver methods.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct DispatchRuleRecord<H: HostTypes> {
    pub dispatch_predicate_handle: PredicateHandle<H>,
    pub dispatch_target: &'static H::HostString,
    pub dispatch_priority: u64,
    pub dispatch_index: u64,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `DispatchRule<H>`.
///
/// Caches the resolver's lookup at construction. Accessors return
/// the cached record's fields when present, falling back to the
/// `Null{Class}<H>` absent sentinels when the resolver returned
/// `None`. Object accessors always return absent sentinels — use
/// the `resolve_{m}` chain methods to descend into sub-records.
pub struct ResolvedDispatchRule<'r, R: DispatchRuleResolver<H>, H: HostTypes> {
    handle: DispatchRuleHandle<H>,
    resolver: &'r R,
    record: Option<DispatchRuleRecord<H>>,
}
impl<'r, R: DispatchRuleResolver<H>, H: HostTypes> ResolvedDispatchRule<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: DispatchRuleHandle<H>, resolver: &'r R) -> Self {
        let record = resolver.resolve(handle);
        Self {
            handle,
            resolver,
            record,
        }
    }
    /// The handle this wrapper resolves.
    #[inline]
    #[must_use]
    pub const fn handle(&self) -> DispatchRuleHandle<H> {
        self.handle
    }
    /// The resolver supplied at construction.
    #[inline]
    #[must_use]
    pub const fn resolver(&self) -> &'r R {
        self.resolver
    }
    /// The cached record, or `None` when the resolver returned `None`.
    #[inline]
    #[must_use]
    pub const fn record(&self) -> Option<&DispatchRuleRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: DispatchRuleResolver<H>, H: HostTypes> DispatchRule<H>
    for ResolvedDispatchRule<'r, R, H>
{
    type Predicate = NullPredicate<H>;
    fn dispatch_predicate(&self) -> &Self::Predicate {
        &<NullPredicate<H>>::ABSENT
    }
    fn dispatch_target(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn dispatch_priority(&self) -> u64 {
        match &self.record {
            Some(r) => r.dispatch_priority,
            None => 0,
        }
    }
    fn dispatch_index(&self) -> u64 {
        match &self.record {
            Some(r) => r.dispatch_index,
            None => 0,
        }
    }
}
impl<'r, R: DispatchRuleResolver<H>, H: HostTypes> ResolvedDispatchRule<'r, R, H> {
    /// Promote the `dispatch_predicate` handle on the cached record into a
    /// resolved wrapper, given a resolver for the range class.
    /// Returns `None` if no record was resolved at construction.
    #[inline]
    pub fn resolve_dispatch_predicate<'r2, R2: PredicateResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedPredicate<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedPredicate::new(record.dispatch_predicate_handle, r))
    }
}

/// Phase 8 (orphan-closure) — content-addressed handle for `DispatchTable<H>`.
///
/// Pairs a [`crate::enforcement::ContentFingerprint`] with a phantom
/// `H` so type-state checks can't mix handles across `HostTypes` impls.
#[derive(Debug)]
pub struct DispatchTableHandle<H: HostTypes> {
    /// Content fingerprint identifying the resolved record.
    pub fingerprint: crate::enforcement::ContentFingerprint,
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Copy for DispatchTableHandle<H> {}
impl<H: HostTypes> Clone for DispatchTableHandle<H> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<H: HostTypes> PartialEq for DispatchTableHandle<H> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.fingerprint == other.fingerprint
    }
}
impl<H: HostTypes> Eq for DispatchTableHandle<H> {}
impl<H: HostTypes> core::hash::Hash for DispatchTableHandle<H> {
    #[inline]
    fn hash<S: core::hash::Hasher>(&self, state: &mut S) {
        self.fingerprint.hash(state);
    }
}
impl<H: HostTypes> DispatchTableHandle<H> {
    /// Construct a handle from its content fingerprint.
    #[inline]
    #[must_use]
    pub const fn new(fingerprint: crate::enforcement::ContentFingerprint) -> Self {
        Self {
            fingerprint,
            _phantom: core::marker::PhantomData,
        }
    }
}

/// Phase 8 (orphan-closure) — resolver trait for `DispatchTable<H>`.
///
/// Hosts implement this trait to map a handle into a typed record.
/// The default Null stub does not implement this trait — it carries
/// no record. Resolution is the responsibility of the host pipeline.
pub trait DispatchTableResolver<H: HostTypes> {
    /// Resolve a handle into its record. Returns `None` when the
    /// handle does not correspond to known content.
    fn resolve(&self, handle: DispatchTableHandle<H>) -> Option<DispatchTableRecord<H>>;
}

/// Phase 8 (orphan-closure) — typed record for `DispatchTable<H>`.
///
/// Carries a field per functional accessor of the trait. Object
/// fields hold `{Range}Handle<H>`; iterate via the Resolved wrapper
/// chain-resolver methods.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct DispatchTableRecord<H: HostTypes> {
    pub is_exhaustive: bool,
    pub is_mutually_exclusive: bool,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `DispatchTable<H>`.
///
/// Caches the resolver's lookup at construction. Accessors return
/// the cached record's fields when present, falling back to the
/// `Null{Class}<H>` absent sentinels when the resolver returned
/// `None`. Object accessors always return absent sentinels — use
/// the `resolve_{m}` chain methods to descend into sub-records.
pub struct ResolvedDispatchTable<'r, R: DispatchTableResolver<H>, H: HostTypes> {
    handle: DispatchTableHandle<H>,
    resolver: &'r R,
    record: Option<DispatchTableRecord<H>>,
}
impl<'r, R: DispatchTableResolver<H>, H: HostTypes> ResolvedDispatchTable<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: DispatchTableHandle<H>, resolver: &'r R) -> Self {
        let record = resolver.resolve(handle);
        Self {
            handle,
            resolver,
            record,
        }
    }
    /// The handle this wrapper resolves.
    #[inline]
    #[must_use]
    pub const fn handle(&self) -> DispatchTableHandle<H> {
        self.handle
    }
    /// The resolver supplied at construction.
    #[inline]
    #[must_use]
    pub const fn resolver(&self) -> &'r R {
        self.resolver
    }
    /// The cached record, or `None` when the resolver returned `None`.
    #[inline]
    #[must_use]
    pub const fn record(&self) -> Option<&DispatchTableRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: DispatchTableResolver<H>, H: HostTypes> DispatchTable<H>
    for ResolvedDispatchTable<'r, R, H>
{
    type DispatchRule = NullDispatchRule<H>;
    fn dispatch_rules(&self) -> &[Self::DispatchRule] {
        &[]
    }
    fn is_exhaustive(&self) -> bool {
        match &self.record {
            Some(r) => r.is_exhaustive,
            None => false,
        }
    }
    fn is_mutually_exclusive(&self) -> bool {
        match &self.record {
            Some(r) => r.is_mutually_exclusive,
            None => false,
        }
    }
}

/// Phase 8 (orphan-closure) — content-addressed handle for `GuardedTransition<H>`.
///
/// Pairs a [`crate::enforcement::ContentFingerprint`] with a phantom
/// `H` so type-state checks can't mix handles across `HostTypes` impls.
#[derive(Debug)]
pub struct GuardedTransitionHandle<H: HostTypes> {
    /// Content fingerprint identifying the resolved record.
    pub fingerprint: crate::enforcement::ContentFingerprint,
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Copy for GuardedTransitionHandle<H> {}
impl<H: HostTypes> Clone for GuardedTransitionHandle<H> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<H: HostTypes> PartialEq for GuardedTransitionHandle<H> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.fingerprint == other.fingerprint
    }
}
impl<H: HostTypes> Eq for GuardedTransitionHandle<H> {}
impl<H: HostTypes> core::hash::Hash for GuardedTransitionHandle<H> {
    #[inline]
    fn hash<S: core::hash::Hasher>(&self, state: &mut S) {
        self.fingerprint.hash(state);
    }
}
impl<H: HostTypes> GuardedTransitionHandle<H> {
    /// Construct a handle from its content fingerprint.
    #[inline]
    #[must_use]
    pub const fn new(fingerprint: crate::enforcement::ContentFingerprint) -> Self {
        Self {
            fingerprint,
            _phantom: core::marker::PhantomData,
        }
    }
}

/// Phase 8 (orphan-closure) — resolver trait for `GuardedTransition<H>`.
///
/// Hosts implement this trait to map a handle into a typed record.
/// The default Null stub does not implement this trait — it carries
/// no record. Resolution is the responsibility of the host pipeline.
pub trait GuardedTransitionResolver<H: HostTypes> {
    /// Resolve a handle into its record. Returns `None` when the
    /// handle does not correspond to known content.
    fn resolve(&self, handle: GuardedTransitionHandle<H>) -> Option<GuardedTransitionRecord<H>>;
}

/// Phase 8 (orphan-closure) — typed record for `GuardedTransition<H>`.
///
/// Carries a field per functional accessor of the trait. Object
/// fields hold `{Range}Handle<H>`; iterate via the Resolved wrapper
/// chain-resolver methods.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct GuardedTransitionRecord<H: HostTypes> {
    pub guard_predicate_handle: StatePredicateHandle<H>,
    pub guard_effect_handle: crate::kernel::effect::EffectHandle<H>,
    pub guard_target_handle: crate::kernel::reduction::ReductionStepHandle<H>,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `GuardedTransition<H>`.
///
/// Caches the resolver's lookup at construction. Accessors return
/// the cached record's fields when present, falling back to the
/// `Null{Class}<H>` absent sentinels when the resolver returned
/// `None`. Object accessors always return absent sentinels — use
/// the `resolve_{m}` chain methods to descend into sub-records.
pub struct ResolvedGuardedTransition<'r, R: GuardedTransitionResolver<H>, H: HostTypes> {
    handle: GuardedTransitionHandle<H>,
    resolver: &'r R,
    record: Option<GuardedTransitionRecord<H>>,
}
impl<'r, R: GuardedTransitionResolver<H>, H: HostTypes> ResolvedGuardedTransition<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: GuardedTransitionHandle<H>, resolver: &'r R) -> Self {
        let record = resolver.resolve(handle);
        Self {
            handle,
            resolver,
            record,
        }
    }
    /// The handle this wrapper resolves.
    #[inline]
    #[must_use]
    pub const fn handle(&self) -> GuardedTransitionHandle<H> {
        self.handle
    }
    /// The resolver supplied at construction.
    #[inline]
    #[must_use]
    pub const fn resolver(&self) -> &'r R {
        self.resolver
    }
    /// The cached record, or `None` when the resolver returned `None`.
    #[inline]
    #[must_use]
    pub const fn record(&self) -> Option<&GuardedTransitionRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: GuardedTransitionResolver<H>, H: HostTypes> GuardedTransition<H>
    for ResolvedGuardedTransition<'r, R, H>
{
    type StatePredicate = NullStatePredicate<H>;
    fn guard_predicate(&self) -> &Self::StatePredicate {
        &<NullStatePredicate<H>>::ABSENT
    }
    type Effect = crate::kernel::effect::NullEffect<H>;
    fn guard_effect(&self) -> &Self::Effect {
        &<crate::kernel::effect::NullEffect<H>>::ABSENT
    }
    type ReductionStep = crate::kernel::reduction::NullReductionStep<H>;
    fn guard_target(&self) -> &Self::ReductionStep {
        &<crate::kernel::reduction::NullReductionStep<H>>::ABSENT
    }
}
impl<'r, R: GuardedTransitionResolver<H>, H: HostTypes> ResolvedGuardedTransition<'r, R, H> {
    /// Promote the `guard_predicate` handle on the cached record into a
    /// resolved wrapper, given a resolver for the range class.
    /// Returns `None` if no record was resolved at construction.
    #[inline]
    pub fn resolve_guard_predicate<'r2, R2: StatePredicateResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedStatePredicate<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedStatePredicate::new(
            record.guard_predicate_handle,
            r,
        ))
    }
    /// Promote the `guard_effect` handle on the cached record into a
    /// resolved wrapper, given a resolver for the range class.
    /// Returns `None` if no record was resolved at construction.
    #[inline]
    pub fn resolve_guard_effect<'r2, R2: crate::kernel::effect::EffectResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::kernel::effect::ResolvedEffect<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::kernel::effect::ResolvedEffect::new(
            record.guard_effect_handle,
            r,
        ))
    }
    /// Promote the `guard_target` handle on the cached record into a
    /// resolved wrapper, given a resolver for the range class.
    /// Returns `None` if no record was resolved at construction.
    #[inline]
    pub fn resolve_guard_target<'r2, R2: crate::kernel::reduction::ReductionStepResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::kernel::reduction::ResolvedReductionStep<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::kernel::reduction::ResolvedReductionStep::new(
            record.guard_target_handle,
            r,
        ))
    }
}

/// Phase 8 (orphan-closure) — content-addressed handle for `MatchArm<H>`.
///
/// Pairs a [`crate::enforcement::ContentFingerprint`] with a phantom
/// `H` so type-state checks can't mix handles across `HostTypes` impls.
#[derive(Debug)]
pub struct MatchArmHandle<H: HostTypes> {
    /// Content fingerprint identifying the resolved record.
    pub fingerprint: crate::enforcement::ContentFingerprint,
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Copy for MatchArmHandle<H> {}
impl<H: HostTypes> Clone for MatchArmHandle<H> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<H: HostTypes> PartialEq for MatchArmHandle<H> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.fingerprint == other.fingerprint
    }
}
impl<H: HostTypes> Eq for MatchArmHandle<H> {}
impl<H: HostTypes> core::hash::Hash for MatchArmHandle<H> {
    #[inline]
    fn hash<S: core::hash::Hasher>(&self, state: &mut S) {
        self.fingerprint.hash(state);
    }
}
impl<H: HostTypes> MatchArmHandle<H> {
    /// Construct a handle from its content fingerprint.
    #[inline]
    #[must_use]
    pub const fn new(fingerprint: crate::enforcement::ContentFingerprint) -> Self {
        Self {
            fingerprint,
            _phantom: core::marker::PhantomData,
        }
    }
}

/// Phase 8 (orphan-closure) — resolver trait for `MatchArm<H>`.
///
/// Hosts implement this trait to map a handle into a typed record.
/// The default Null stub does not implement this trait — it carries
/// no record. Resolution is the responsibility of the host pipeline.
pub trait MatchArmResolver<H: HostTypes> {
    /// Resolve a handle into its record. Returns `None` when the
    /// handle does not correspond to known content.
    fn resolve(&self, handle: MatchArmHandle<H>) -> Option<MatchArmRecord<H>>;
}

/// Phase 8 (orphan-closure) — typed record for `MatchArm<H>`.
///
/// Carries a field per functional accessor of the trait. Object
/// fields hold `{Range}Handle<H>`; iterate via the Resolved wrapper
/// chain-resolver methods.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct MatchArmRecord<H: HostTypes> {
    pub arm_predicate_handle: PredicateHandle<H>,
    pub arm_result_handle: crate::kernel::schema::TermHandle<H>,
    pub arm_index: u64,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `MatchArm<H>`.
///
/// Caches the resolver's lookup at construction. Accessors return
/// the cached record's fields when present, falling back to the
/// `Null{Class}<H>` absent sentinels when the resolver returned
/// `None`. Object accessors always return absent sentinels — use
/// the `resolve_{m}` chain methods to descend into sub-records.
pub struct ResolvedMatchArm<'r, R: MatchArmResolver<H>, H: HostTypes> {
    handle: MatchArmHandle<H>,
    resolver: &'r R,
    record: Option<MatchArmRecord<H>>,
}
impl<'r, R: MatchArmResolver<H>, H: HostTypes> ResolvedMatchArm<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: MatchArmHandle<H>, resolver: &'r R) -> Self {
        let record = resolver.resolve(handle);
        Self {
            handle,
            resolver,
            record,
        }
    }
    /// The handle this wrapper resolves.
    #[inline]
    #[must_use]
    pub const fn handle(&self) -> MatchArmHandle<H> {
        self.handle
    }
    /// The resolver supplied at construction.
    #[inline]
    #[must_use]
    pub const fn resolver(&self) -> &'r R {
        self.resolver
    }
    /// The cached record, or `None` when the resolver returned `None`.
    #[inline]
    #[must_use]
    pub const fn record(&self) -> Option<&MatchArmRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: MatchArmResolver<H>, H: HostTypes> MatchArm<H> for ResolvedMatchArm<'r, R, H> {
    type Predicate = NullPredicate<H>;
    fn arm_predicate(&self) -> &Self::Predicate {
        &<NullPredicate<H>>::ABSENT
    }
    type Term = crate::kernel::schema::NullTerm<H>;
    fn arm_result(&self) -> &Self::Term {
        &<crate::kernel::schema::NullTerm<H>>::ABSENT
    }
    fn arm_index(&self) -> u64 {
        match &self.record {
            Some(r) => r.arm_index,
            None => 0,
        }
    }
}
impl<'r, R: MatchArmResolver<H>, H: HostTypes> ResolvedMatchArm<'r, R, H> {
    /// Promote the `arm_predicate` handle on the cached record into a
    /// resolved wrapper, given a resolver for the range class.
    /// Returns `None` if no record was resolved at construction.
    #[inline]
    pub fn resolve_arm_predicate<'r2, R2: PredicateResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedPredicate<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedPredicate::new(record.arm_predicate_handle, r))
    }
    /// Promote the `arm_result` handle on the cached record into a
    /// resolved wrapper, given a resolver for the range class.
    /// Returns `None` if no record was resolved at construction.
    #[inline]
    pub fn resolve_arm_result<'r2, R2: crate::kernel::schema::TermResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::kernel::schema::ResolvedTerm<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::kernel::schema::ResolvedTerm::new(
            record.arm_result_handle,
            r,
        ))
    }
}

/// Phase 8 (orphan-closure) — content-addressed handle for `MatchExpression<H>`.
///
/// Pairs a [`crate::enforcement::ContentFingerprint`] with a phantom
/// `H` so type-state checks can't mix handles across `HostTypes` impls.
#[derive(Debug)]
pub struct MatchExpressionHandle<H: HostTypes> {
    /// Content fingerprint identifying the resolved record.
    pub fingerprint: crate::enforcement::ContentFingerprint,
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Copy for MatchExpressionHandle<H> {}
impl<H: HostTypes> Clone for MatchExpressionHandle<H> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<H: HostTypes> PartialEq for MatchExpressionHandle<H> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.fingerprint == other.fingerprint
    }
}
impl<H: HostTypes> Eq for MatchExpressionHandle<H> {}
impl<H: HostTypes> core::hash::Hash for MatchExpressionHandle<H> {
    #[inline]
    fn hash<S: core::hash::Hasher>(&self, state: &mut S) {
        self.fingerprint.hash(state);
    }
}
impl<H: HostTypes> MatchExpressionHandle<H> {
    /// Construct a handle from its content fingerprint.
    #[inline]
    #[must_use]
    pub const fn new(fingerprint: crate::enforcement::ContentFingerprint) -> Self {
        Self {
            fingerprint,
            _phantom: core::marker::PhantomData,
        }
    }
}

/// Phase 8 (orphan-closure) — resolver trait for `MatchExpression<H>`.
///
/// Hosts implement this trait to map a handle into a typed record.
/// The default Null stub does not implement this trait — it carries
/// no record. Resolution is the responsibility of the host pipeline.
pub trait MatchExpressionResolver<H: HostTypes> {
    /// Resolve a handle into its record. Returns `None` when the
    /// handle does not correspond to known content.
    fn resolve(&self, handle: MatchExpressionHandle<H>) -> Option<MatchExpressionRecord<H>>;
}

/// Phase 8 (orphan-closure) — typed record for `MatchExpression<H>`.
///
/// Carries a field per functional accessor of the trait. Object
/// fields hold `{Range}Handle<H>`; iterate via the Resolved wrapper
/// chain-resolver methods.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct MatchExpressionRecord<H: HostTypes> {
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `MatchExpression<H>`.
///
/// Caches the resolver's lookup at construction. Accessors return
/// the cached record's fields when present, falling back to the
/// `Null{Class}<H>` absent sentinels when the resolver returned
/// `None`. Object accessors always return absent sentinels — use
/// the `resolve_{m}` chain methods to descend into sub-records.
pub struct ResolvedMatchExpression<'r, R: MatchExpressionResolver<H>, H: HostTypes> {
    handle: MatchExpressionHandle<H>,
    resolver: &'r R,
    record: Option<MatchExpressionRecord<H>>,
}
impl<'r, R: MatchExpressionResolver<H>, H: HostTypes> ResolvedMatchExpression<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: MatchExpressionHandle<H>, resolver: &'r R) -> Self {
        let record = resolver.resolve(handle);
        Self {
            handle,
            resolver,
            record,
        }
    }
    /// The handle this wrapper resolves.
    #[inline]
    #[must_use]
    pub const fn handle(&self) -> MatchExpressionHandle<H> {
        self.handle
    }
    /// The resolver supplied at construction.
    #[inline]
    #[must_use]
    pub const fn resolver(&self) -> &'r R {
        self.resolver
    }
    /// The cached record, or `None` when the resolver returned `None`.
    #[inline]
    #[must_use]
    pub const fn record(&self) -> Option<&MatchExpressionRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: MatchExpressionResolver<H>, H: HostTypes> crate::kernel::schema::Term<H>
    for ResolvedMatchExpression<'r, R, H>
{
}
impl<'r, R: MatchExpressionResolver<H>, H: HostTypes> MatchExpression<H>
    for ResolvedMatchExpression<'r, R, H>
{
    type MatchArm = NullMatchArm<H>;
    fn match_arms(&self) -> &[Self::MatchArm] {
        &[]
    }
}

/// True on every Datum. Match-arm default catch-all.
pub mod always {
    /// `evaluatesOver` -> `Datum`
    pub const EVALUATES_OVER: &str = "https://uor.foundation/schema/Datum";
}

/// False on every Datum. Disabled-arm marker.
pub mod never {
    /// `evaluatesOver` -> `Datum`
    pub const EVALUATES_OVER: &str = "https://uor.foundation/schema/Datum";
}

/// True iff the Datum is the additive identity of its ring.
pub mod is_zero {
    /// `evaluatesOver` -> `Datum`
    pub const EVALUATES_OVER: &str = "https://uor.foundation/schema/Datum";
}

/// True iff the Datum is the multiplicative identity.
pub mod is_unit {
    /// `evaluatesOver` -> `Datum`
    pub const EVALUATES_OVER: &str = "https://uor.foundation/schema/Datum";
}

/// True iff the Datum parity bit is 1.
pub mod is_odd {
    /// `evaluatesOver` -> `Datum`
    pub const EVALUATES_OVER: &str = "https://uor.foundation/schema/Datum";
}

/// True iff the Datum parity bit is 0.
pub mod is_even {
    /// `evaluatesOver` -> `Datum`
    pub const EVALUATES_OVER: &str = "https://uor.foundation/schema/Datum";
}

/// True iff op(op(x)) = x for the bound op.
pub mod is_involution {
    /// `evaluatesOver` -> `Datum`
    pub const EVALUATES_OVER: &str = "https://uor.foundation/schema/Datum";
}

/// True iff the named site coordinate is currently pinned.
pub mod site_pinned {
    /// `evaluatesOver` -> `SiteIndex`
    pub const EVALUATES_OVER: &str = "https://uor.foundation/partition/SiteIndex";
}

/// True iff the named site coordinate is currently free.
pub mod site_free {
    /// `evaluatesOver` -> `SiteIndex`
    pub const EVALUATES_OVER: &str = "https://uor.foundation/partition/SiteIndex";
}

/// True iff the resolver has entered a ContradictionBoundary.
pub mod contradiction_reached {
    /// `evaluatesOver` -> `ContradictionBoundary`
    pub const EVALUATES_OVER: &str = "https://uor.foundation/state/ContradictionBoundary";
}

/// True iff the FreeRank deficit is zero.
pub mod budget_exhausted {
    /// `evaluatesOver` -> `FreeRank`
    pub const EVALUATES_OVER: &str = "https://uor.foundation/partition/FreeRank";
}

/// True iff the reduction fixpoint has been reached.
pub mod reduction_converged {
    /// `evaluatesOver` -> `ReductionState`
    pub const EVALUATES_OVER: &str = "https://uor.foundation/reduction/ReductionState";
}

/// True on ConstrainedType instances whose constraint nerve contains only disjunctions of width ≤ 2.
pub mod is2_sat_shape {
    /// `evaluatesOver` -> `ConstrainedType`
    pub const EVALUATES_OVER: &str = "https://uor.foundation/type/ConstrainedType";
}

/// True on ConstrainedType instances whose disjunctions each contain at most one positive literal.
pub mod is_horn_shape {
    /// `evaluatesOver` -> `ConstrainedType`
    pub const EVALUATES_OVER: &str = "https://uor.foundation/type/ConstrainedType";
}

/// Default (catch-all) predicate. True on ConstrainedType instances not classified by Is2SatShape or IsHornShape.
pub mod is_residual_fragment {
    /// `evaluatesOver` -> `ConstrainedType`
    pub const EVALUATES_OVER: &str = "https://uor.foundation/type/ConstrainedType";
}

/// The predicate:DispatchTable governing resolver:InhabitanceResolver. Three rules form a partition of type:ConstrainedType: Is2SatShape → TwoSatDecider (priority 0), IsHornShape → HornSatDecider (priority 1), IsResidualFragment → ResidualVerdictResolver (priority 2, catch-all). Total coverage is enforced by reduction:DispatchCoverageCheck; DispatchMiss is unreachable for this table.
pub mod inhabitance_dispatch_table {
    /// `isExhaustive`
    pub const IS_EXHAUSTIVE: bool = true;
    /// `isMutuallyExclusive`
    pub const IS_MUTUALLY_EXCLUSIVE: bool = true;
}

/// Dispatch rule 1 of InhabitanceDispatchTable: Is2SatShape → TwoSatDecider at priority 0.
pub mod inhabitance_rule_2sat {
    /// `dispatchPredicate` -> `Is2SatShape`
    pub const DISPATCH_PREDICATE: &str = "https://uor.foundation/predicate/Is2SatShape";
    /// `dispatchPriority`
    pub const DISPATCH_PRIORITY: i64 = 0;
    /// `dispatchTarget` -> `TwoSatDecider`
    pub const DISPATCH_TARGET: &str = "https://uor.foundation/resolver/TwoSatDecider";
}

/// Dispatch rule 2 of InhabitanceDispatchTable: IsHornShape → HornSatDecider at priority 1.
pub mod inhabitance_rule_horn {
    /// `dispatchPredicate` -> `IsHornShape`
    pub const DISPATCH_PREDICATE: &str = "https://uor.foundation/predicate/IsHornShape";
    /// `dispatchPriority`
    pub const DISPATCH_PRIORITY: i64 = 1;
    /// `dispatchTarget` -> `HornSatDecider`
    pub const DISPATCH_TARGET: &str = "https://uor.foundation/resolver/HornSatDecider";
}

/// Dispatch rule 3 (catch-all) of InhabitanceDispatchTable: IsResidualFragment → ResidualVerdictResolver at priority 2. Ensures total coverage.
pub mod inhabitance_rule_residual {
    /// `dispatchPredicate` -> `IsResidualFragment`
    pub const DISPATCH_PREDICATE: &str = "https://uor.foundation/predicate/IsResidualFragment";
    /// `dispatchPriority`
    pub const DISPATCH_PRIORITY: i64 = 2;
    /// `dispatchTarget` -> `ResidualVerdictResolver`
    pub const DISPATCH_TARGET: &str = "https://uor.foundation/resolver/ResidualVerdictResolver";
}