uor-foundation 0.3.5

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

//! `interaction/` namespace — Multi-entity interaction: commutator states, associator triples, negotiation convergence..
//!
//! Space: Bridge

use crate::HostTypes;

/// Two entities sharing sites through composed operations. Properties: entityA, entityB, sharedSiteMask, commutatorNorm.
pub trait InteractionContext<H: HostTypes> {
    /// Associated type for `TermExpression`.
    type TermExpression: crate::kernel::schema::TermExpression<H>;
    /// First entity in the interaction context.
    fn entity_a(&self) -> &Self::TermExpression;
    /// Second entity in the interaction context.
    fn entity_b(&self) -> &Self::TermExpression;
    /// Bitmask identifying which sites are shared between the two entities.
    fn shared_site_mask(&self) -> u64;
    /// The norm of the commutator on shared sites. Zero iff the operators commute.
    fn commutator_norm(&self) -> H::Decimal;
}

/// The norm ‖\[δ_A, ι_B\]‖ on shared sites. Zero iff operators commute on the shared domain.
pub trait CommutatorState<H: HostTypes> {
    /// The computed commutator norm value.
    fn commutator_value(&self) -> H::Decimal;
}

/// The norm of the three-way associator on shared sites.
pub trait AssociatorState<H: HostTypes> {
    /// The norm of the three-way associator on shared sites.
    fn associator_norm(&self) -> H::Decimal;
}

/// Three entities whose interaction exhibits non-associativity due to read-write interleaving.
pub trait AssociatorTriple<H: HostTypes> {
    /// Associated type for `Datum`.
    type Datum: crate::kernel::schema::Datum<H>;
    /// First component datum in the associator triple.
    fn triple_component_a(&self) -> &Self::Datum;
    /// Second component datum in the associator triple.
    fn triple_component_b(&self) -> &Self::Datum;
    /// Third component datum in the associator triple.
    fn triple_component_c(&self) -> &Self::Datum;
    /// Associated type for `Observable`.
    type Observable: crate::bridge::observable::Observable<H>;
    /// Reference to the observable describing the associativity profile.
    fn associator_profile_ref(&self) -> &Self::Observable;
    /// The maximum norm of the associator for this triple.
    fn associator_norm_value(&self) -> H::Decimal;
}

/// A site shared by all three entities in an AssociatorTriple.
pub trait ThreeWaySite<H: HostTypes> {
    /// The position index of the shared site.
    fn site_position(&self) -> u64;
    /// Value under left-associative grouping (AB)C.
    fn left_grouping_value(&self) -> H::Decimal;
    /// Value under right-associative grouping A(BC).
    fn right_grouping_value(&self) -> H::Decimal;
    /// Whether this site is pinned by a lease constraint.
    fn is_pinned(&self) -> bool;
    /// Associated type for `TermExpression`.
    type TermExpression: crate::kernel::schema::TermExpression<H>;
    /// Identifier of the entity pair that pins this site.
    fn pinning_pair(&self) -> &Self::TermExpression;
}

/// Sequence of CommutatorStates across interaction steps.
pub trait NegotiationTrace<H: HostTypes> {
    /// Number of steps in the negotiation trace.
    fn negotiation_steps(&self) -> u64;
    /// Whether the trace converges to zero commutator or zero associator.
    fn is_convergent(&self) -> bool;
    /// The number of steps in a negotiation trace.
    fn trace_length(&self) -> u64;
    /// The rate at which the negotiation trace converges.
    fn convergence_rate(&self) -> H::Decimal;
    /// Associated type for `TermExpression`.
    type TermExpression: crate::kernel::schema::TermExpression<H>;
    /// The terminal value of the negotiation trace.
    fn terminal_value(&self) -> &Self::TermExpression;
}

/// Sequence of AssociatorStates across interaction steps.
pub trait MutualModelTrace<H: HostTypes> {
    /// Whether the mutual model trace converges.
    fn model_convergent(&self) -> bool;
}

/// Simplicial complex of N-entity coupling.
pub trait InteractionNerve<H: HostTypes> {
    /// Maximum dimension of the interaction nerve simplicial complex.
    fn nerve_dimension(&self) -> u64;
    /// Betti number sequence of the interaction nerve.
    fn nerve_betti_numbers(&self) -> u64;
}

/// IC(A,B) = κ(session(A,B)). Combined interaction-composition operator.
pub trait InteractionComposition<H: HostTypes> {
    /// Depth of the interaction composition reification.
    fn reification_depth(&self) -> u64;
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `InteractionContext<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 NullInteractionContext<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullInteractionContext<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullInteractionContext<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullInteractionContext<H> = NullInteractionContext {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> InteractionContext<H> for NullInteractionContext<H> {
    type TermExpression = crate::kernel::schema::NullTermExpression<H>;
    fn entity_a(&self) -> &Self::TermExpression {
        &<crate::kernel::schema::NullTermExpression<H>>::ABSENT
    }
    fn entity_b(&self) -> &Self::TermExpression {
        &<crate::kernel::schema::NullTermExpression<H>>::ABSENT
    }
    fn shared_site_mask(&self) -> u64 {
        0
    }
    fn commutator_norm(&self) -> H::Decimal {
        H::EMPTY_DECIMAL
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `CommutatorState<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 NullCommutatorState<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullCommutatorState<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullCommutatorState<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullCommutatorState<H> = NullCommutatorState {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> CommutatorState<H> for NullCommutatorState<H> {
    fn commutator_value(&self) -> H::Decimal {
        H::EMPTY_DECIMAL
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `AssociatorState<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 NullAssociatorState<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullAssociatorState<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullAssociatorState<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullAssociatorState<H> = NullAssociatorState {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> AssociatorState<H> for NullAssociatorState<H> {
    fn associator_norm(&self) -> H::Decimal {
        H::EMPTY_DECIMAL
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `AssociatorTriple<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 NullAssociatorTriple<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullAssociatorTriple<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullAssociatorTriple<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullAssociatorTriple<H> = NullAssociatorTriple {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> AssociatorTriple<H> for NullAssociatorTriple<H> {
    type Datum = crate::kernel::schema::NullDatum<H>;
    fn triple_component_a(&self) -> &Self::Datum {
        &<crate::kernel::schema::NullDatum<H>>::ABSENT
    }
    fn triple_component_b(&self) -> &Self::Datum {
        &<crate::kernel::schema::NullDatum<H>>::ABSENT
    }
    fn triple_component_c(&self) -> &Self::Datum {
        &<crate::kernel::schema::NullDatum<H>>::ABSENT
    }
    type Observable = crate::bridge::observable::NullObservable<H>;
    fn associator_profile_ref(&self) -> &Self::Observable {
        &<crate::bridge::observable::NullObservable<H>>::ABSENT
    }
    fn associator_norm_value(&self) -> H::Decimal {
        H::EMPTY_DECIMAL
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `ThreeWaySite<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 NullThreeWaySite<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullThreeWaySite<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullThreeWaySite<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullThreeWaySite<H> = NullThreeWaySite {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> ThreeWaySite<H> for NullThreeWaySite<H> {
    fn site_position(&self) -> u64 {
        0
    }
    fn left_grouping_value(&self) -> H::Decimal {
        H::EMPTY_DECIMAL
    }
    fn right_grouping_value(&self) -> H::Decimal {
        H::EMPTY_DECIMAL
    }
    fn is_pinned(&self) -> bool {
        false
    }
    type TermExpression = crate::kernel::schema::NullTermExpression<H>;
    fn pinning_pair(&self) -> &Self::TermExpression {
        &<crate::kernel::schema::NullTermExpression<H>>::ABSENT
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `NegotiationTrace<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 NullNegotiationTrace<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullNegotiationTrace<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullNegotiationTrace<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullNegotiationTrace<H> = NullNegotiationTrace {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> NegotiationTrace<H> for NullNegotiationTrace<H> {
    fn negotiation_steps(&self) -> u64 {
        0
    }
    fn is_convergent(&self) -> bool {
        false
    }
    fn trace_length(&self) -> u64 {
        0
    }
    fn convergence_rate(&self) -> H::Decimal {
        H::EMPTY_DECIMAL
    }
    type TermExpression = crate::kernel::schema::NullTermExpression<H>;
    fn terminal_value(&self) -> &Self::TermExpression {
        &<crate::kernel::schema::NullTermExpression<H>>::ABSENT
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `MutualModelTrace<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 NullMutualModelTrace<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullMutualModelTrace<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullMutualModelTrace<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullMutualModelTrace<H> = NullMutualModelTrace {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> MutualModelTrace<H> for NullMutualModelTrace<H> {
    fn model_convergent(&self) -> bool {
        false
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `InteractionNerve<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 NullInteractionNerve<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullInteractionNerve<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullInteractionNerve<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullInteractionNerve<H> = NullInteractionNerve {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> InteractionNerve<H> for NullInteractionNerve<H> {
    fn nerve_dimension(&self) -> u64 {
        0
    }
    fn nerve_betti_numbers(&self) -> u64 {
        0
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `InteractionComposition<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 NullInteractionComposition<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullInteractionComposition<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullInteractionComposition<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullInteractionComposition<H> = NullInteractionComposition {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> InteractionComposition<H> for NullInteractionComposition<H> {
    fn reification_depth(&self) -> u64 {
        0
    }
}

/// Phase 8 (orphan-closure) — content-addressed handle for `InteractionContext<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 InteractionContextHandle<H: HostTypes> {
    /// Content fingerprint identifying the resolved record.
    pub fingerprint: crate::enforcement::ContentFingerprint,
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Copy for InteractionContextHandle<H> {}
impl<H: HostTypes> Clone for InteractionContextHandle<H> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<H: HostTypes> PartialEq for InteractionContextHandle<H> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.fingerprint == other.fingerprint
    }
}
impl<H: HostTypes> Eq for InteractionContextHandle<H> {}
impl<H: HostTypes> core::hash::Hash for InteractionContextHandle<H> {
    #[inline]
    fn hash<S: core::hash::Hasher>(&self, state: &mut S) {
        self.fingerprint.hash(state);
    }
}
impl<H: HostTypes> InteractionContextHandle<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 `InteractionContext<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 InteractionContextResolver<H: HostTypes> {
    /// Resolve a handle into its record. Returns `None` when the
    /// handle does not correspond to known content.
    fn resolve(&self, handle: InteractionContextHandle<H>) -> Option<InteractionContextRecord<H>>;
}

/// Phase 8 (orphan-closure) — typed record for `InteractionContext<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 InteractionContextRecord<H: HostTypes> {
    pub entity_a_handle: crate::kernel::schema::TermExpressionHandle<H>,
    pub entity_b_handle: crate::kernel::schema::TermExpressionHandle<H>,
    pub shared_site_mask: u64,
    pub commutator_norm: H::Decimal,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `InteractionContext<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 ResolvedInteractionContext<'r, R: InteractionContextResolver<H>, H: HostTypes> {
    handle: InteractionContextHandle<H>,
    resolver: &'r R,
    record: Option<InteractionContextRecord<H>>,
}
impl<'r, R: InteractionContextResolver<H>, H: HostTypes> ResolvedInteractionContext<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: InteractionContextHandle<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) -> InteractionContextHandle<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<&InteractionContextRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: InteractionContextResolver<H>, H: HostTypes> InteractionContext<H>
    for ResolvedInteractionContext<'r, R, H>
{
    type TermExpression = crate::kernel::schema::NullTermExpression<H>;
    fn entity_a(&self) -> &Self::TermExpression {
        &<crate::kernel::schema::NullTermExpression<H>>::ABSENT
    }
    fn entity_b(&self) -> &Self::TermExpression {
        &<crate::kernel::schema::NullTermExpression<H>>::ABSENT
    }
    fn shared_site_mask(&self) -> u64 {
        match &self.record {
            Some(r) => r.shared_site_mask,
            None => 0,
        }
    }
    fn commutator_norm(&self) -> H::Decimal {
        match &self.record {
            Some(r) => r.commutator_norm,
            None => H::EMPTY_DECIMAL,
        }
    }
}
impl<'r, R: InteractionContextResolver<H>, H: HostTypes> ResolvedInteractionContext<'r, R, H> {
    /// Promote the `entity_a` 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_entity_a<'r2, R2: crate::kernel::schema::TermExpressionResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::kernel::schema::ResolvedTermExpression<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::kernel::schema::ResolvedTermExpression::new(
            record.entity_a_handle,
            r,
        ))
    }
    /// Promote the `entity_b` 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_entity_b<'r2, R2: crate::kernel::schema::TermExpressionResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::kernel::schema::ResolvedTermExpression<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::kernel::schema::ResolvedTermExpression::new(
            record.entity_b_handle,
            r,
        ))
    }
}

/// Phase 8 (orphan-closure) — content-addressed handle for `CommutatorState<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 CommutatorStateHandle<H: HostTypes> {
    /// Content fingerprint identifying the resolved record.
    pub fingerprint: crate::enforcement::ContentFingerprint,
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Copy for CommutatorStateHandle<H> {}
impl<H: HostTypes> Clone for CommutatorStateHandle<H> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<H: HostTypes> PartialEq for CommutatorStateHandle<H> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.fingerprint == other.fingerprint
    }
}
impl<H: HostTypes> Eq for CommutatorStateHandle<H> {}
impl<H: HostTypes> core::hash::Hash for CommutatorStateHandle<H> {
    #[inline]
    fn hash<S: core::hash::Hasher>(&self, state: &mut S) {
        self.fingerprint.hash(state);
    }
}
impl<H: HostTypes> CommutatorStateHandle<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 `CommutatorState<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 CommutatorStateResolver<H: HostTypes> {
    /// Resolve a handle into its record. Returns `None` when the
    /// handle does not correspond to known content.
    fn resolve(&self, handle: CommutatorStateHandle<H>) -> Option<CommutatorStateRecord<H>>;
}

/// Phase 8 (orphan-closure) — typed record for `CommutatorState<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 CommutatorStateRecord<H: HostTypes> {
    pub commutator_value: H::Decimal,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `CommutatorState<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 ResolvedCommutatorState<'r, R: CommutatorStateResolver<H>, H: HostTypes> {
    handle: CommutatorStateHandle<H>,
    resolver: &'r R,
    record: Option<CommutatorStateRecord<H>>,
}
impl<'r, R: CommutatorStateResolver<H>, H: HostTypes> ResolvedCommutatorState<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: CommutatorStateHandle<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) -> CommutatorStateHandle<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<&CommutatorStateRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: CommutatorStateResolver<H>, H: HostTypes> CommutatorState<H>
    for ResolvedCommutatorState<'r, R, H>
{
    fn commutator_value(&self) -> H::Decimal {
        match &self.record {
            Some(r) => r.commutator_value,
            None => H::EMPTY_DECIMAL,
        }
    }
}

/// Phase 8 (orphan-closure) — content-addressed handle for `AssociatorState<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 AssociatorStateHandle<H: HostTypes> {
    /// Content fingerprint identifying the resolved record.
    pub fingerprint: crate::enforcement::ContentFingerprint,
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Copy for AssociatorStateHandle<H> {}
impl<H: HostTypes> Clone for AssociatorStateHandle<H> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<H: HostTypes> PartialEq for AssociatorStateHandle<H> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.fingerprint == other.fingerprint
    }
}
impl<H: HostTypes> Eq for AssociatorStateHandle<H> {}
impl<H: HostTypes> core::hash::Hash for AssociatorStateHandle<H> {
    #[inline]
    fn hash<S: core::hash::Hasher>(&self, state: &mut S) {
        self.fingerprint.hash(state);
    }
}
impl<H: HostTypes> AssociatorStateHandle<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 `AssociatorState<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 AssociatorStateResolver<H: HostTypes> {
    /// Resolve a handle into its record. Returns `None` when the
    /// handle does not correspond to known content.
    fn resolve(&self, handle: AssociatorStateHandle<H>) -> Option<AssociatorStateRecord<H>>;
}

/// Phase 8 (orphan-closure) — typed record for `AssociatorState<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 AssociatorStateRecord<H: HostTypes> {
    pub associator_norm: H::Decimal,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `AssociatorState<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 ResolvedAssociatorState<'r, R: AssociatorStateResolver<H>, H: HostTypes> {
    handle: AssociatorStateHandle<H>,
    resolver: &'r R,
    record: Option<AssociatorStateRecord<H>>,
}
impl<'r, R: AssociatorStateResolver<H>, H: HostTypes> ResolvedAssociatorState<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: AssociatorStateHandle<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) -> AssociatorStateHandle<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<&AssociatorStateRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: AssociatorStateResolver<H>, H: HostTypes> AssociatorState<H>
    for ResolvedAssociatorState<'r, R, H>
{
    fn associator_norm(&self) -> H::Decimal {
        match &self.record {
            Some(r) => r.associator_norm,
            None => H::EMPTY_DECIMAL,
        }
    }
}

/// Phase 8 (orphan-closure) — content-addressed handle for `AssociatorTriple<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 AssociatorTripleHandle<H: HostTypes> {
    /// Content fingerprint identifying the resolved record.
    pub fingerprint: crate::enforcement::ContentFingerprint,
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Copy for AssociatorTripleHandle<H> {}
impl<H: HostTypes> Clone for AssociatorTripleHandle<H> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<H: HostTypes> PartialEq for AssociatorTripleHandle<H> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.fingerprint == other.fingerprint
    }
}
impl<H: HostTypes> Eq for AssociatorTripleHandle<H> {}
impl<H: HostTypes> core::hash::Hash for AssociatorTripleHandle<H> {
    #[inline]
    fn hash<S: core::hash::Hasher>(&self, state: &mut S) {
        self.fingerprint.hash(state);
    }
}
impl<H: HostTypes> AssociatorTripleHandle<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 `AssociatorTriple<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 AssociatorTripleResolver<H: HostTypes> {
    /// Resolve a handle into its record. Returns `None` when the
    /// handle does not correspond to known content.
    fn resolve(&self, handle: AssociatorTripleHandle<H>) -> Option<AssociatorTripleRecord<H>>;
}

/// Phase 8 (orphan-closure) — typed record for `AssociatorTriple<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 AssociatorTripleRecord<H: HostTypes> {
    pub triple_component_a_handle: crate::kernel::schema::DatumHandle<H>,
    pub triple_component_b_handle: crate::kernel::schema::DatumHandle<H>,
    pub triple_component_c_handle: crate::kernel::schema::DatumHandle<H>,
    pub associator_profile_ref_handle: crate::bridge::observable::ObservableHandle<H>,
    pub associator_norm_value: H::Decimal,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `AssociatorTriple<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 ResolvedAssociatorTriple<'r, R: AssociatorTripleResolver<H>, H: HostTypes> {
    handle: AssociatorTripleHandle<H>,
    resolver: &'r R,
    record: Option<AssociatorTripleRecord<H>>,
}
impl<'r, R: AssociatorTripleResolver<H>, H: HostTypes> ResolvedAssociatorTriple<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: AssociatorTripleHandle<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) -> AssociatorTripleHandle<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<&AssociatorTripleRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: AssociatorTripleResolver<H>, H: HostTypes> AssociatorTriple<H>
    for ResolvedAssociatorTriple<'r, R, H>
{
    type Datum = crate::kernel::schema::NullDatum<H>;
    fn triple_component_a(&self) -> &Self::Datum {
        &<crate::kernel::schema::NullDatum<H>>::ABSENT
    }
    fn triple_component_b(&self) -> &Self::Datum {
        &<crate::kernel::schema::NullDatum<H>>::ABSENT
    }
    fn triple_component_c(&self) -> &Self::Datum {
        &<crate::kernel::schema::NullDatum<H>>::ABSENT
    }
    type Observable = crate::bridge::observable::NullObservable<H>;
    fn associator_profile_ref(&self) -> &Self::Observable {
        &<crate::bridge::observable::NullObservable<H>>::ABSENT
    }
    fn associator_norm_value(&self) -> H::Decimal {
        match &self.record {
            Some(r) => r.associator_norm_value,
            None => H::EMPTY_DECIMAL,
        }
    }
}
impl<'r, R: AssociatorTripleResolver<H>, H: HostTypes> ResolvedAssociatorTriple<'r, R, H> {
    /// Promote the `triple_component_a` 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_triple_component_a<'r2, R2: crate::kernel::schema::DatumResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::kernel::schema::ResolvedDatum<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::kernel::schema::ResolvedDatum::new(
            record.triple_component_a_handle,
            r,
        ))
    }
    /// Promote the `triple_component_b` 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_triple_component_b<'r2, R2: crate::kernel::schema::DatumResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::kernel::schema::ResolvedDatum<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::kernel::schema::ResolvedDatum::new(
            record.triple_component_b_handle,
            r,
        ))
    }
    /// Promote the `triple_component_c` 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_triple_component_c<'r2, R2: crate::kernel::schema::DatumResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::kernel::schema::ResolvedDatum<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::kernel::schema::ResolvedDatum::new(
            record.triple_component_c_handle,
            r,
        ))
    }
    /// Promote the `associator_profile_ref` 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_associator_profile_ref<
        'r2,
        R2: crate::bridge::observable::ObservableResolver<H>,
    >(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::bridge::observable::ResolvedObservable<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::bridge::observable::ResolvedObservable::new(
            record.associator_profile_ref_handle,
            r,
        ))
    }
}

/// Phase 8 (orphan-closure) — content-addressed handle for `ThreeWaySite<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 ThreeWaySiteHandle<H: HostTypes> {
    /// Content fingerprint identifying the resolved record.
    pub fingerprint: crate::enforcement::ContentFingerprint,
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Copy for ThreeWaySiteHandle<H> {}
impl<H: HostTypes> Clone for ThreeWaySiteHandle<H> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<H: HostTypes> PartialEq for ThreeWaySiteHandle<H> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.fingerprint == other.fingerprint
    }
}
impl<H: HostTypes> Eq for ThreeWaySiteHandle<H> {}
impl<H: HostTypes> core::hash::Hash for ThreeWaySiteHandle<H> {
    #[inline]
    fn hash<S: core::hash::Hasher>(&self, state: &mut S) {
        self.fingerprint.hash(state);
    }
}
impl<H: HostTypes> ThreeWaySiteHandle<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 `ThreeWaySite<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 ThreeWaySiteResolver<H: HostTypes> {
    /// Resolve a handle into its record. Returns `None` when the
    /// handle does not correspond to known content.
    fn resolve(&self, handle: ThreeWaySiteHandle<H>) -> Option<ThreeWaySiteRecord<H>>;
}

/// Phase 8 (orphan-closure) — typed record for `ThreeWaySite<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 ThreeWaySiteRecord<H: HostTypes> {
    pub site_position: u64,
    pub left_grouping_value: H::Decimal,
    pub right_grouping_value: H::Decimal,
    pub is_pinned: bool,
    pub pinning_pair_handle: crate::kernel::schema::TermExpressionHandle<H>,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `ThreeWaySite<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 ResolvedThreeWaySite<'r, R: ThreeWaySiteResolver<H>, H: HostTypes> {
    handle: ThreeWaySiteHandle<H>,
    resolver: &'r R,
    record: Option<ThreeWaySiteRecord<H>>,
}
impl<'r, R: ThreeWaySiteResolver<H>, H: HostTypes> ResolvedThreeWaySite<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: ThreeWaySiteHandle<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) -> ThreeWaySiteHandle<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<&ThreeWaySiteRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: ThreeWaySiteResolver<H>, H: HostTypes> ThreeWaySite<H>
    for ResolvedThreeWaySite<'r, R, H>
{
    fn site_position(&self) -> u64 {
        match &self.record {
            Some(r) => r.site_position,
            None => 0,
        }
    }
    fn left_grouping_value(&self) -> H::Decimal {
        match &self.record {
            Some(r) => r.left_grouping_value,
            None => H::EMPTY_DECIMAL,
        }
    }
    fn right_grouping_value(&self) -> H::Decimal {
        match &self.record {
            Some(r) => r.right_grouping_value,
            None => H::EMPTY_DECIMAL,
        }
    }
    fn is_pinned(&self) -> bool {
        match &self.record {
            Some(r) => r.is_pinned,
            None => false,
        }
    }
    type TermExpression = crate::kernel::schema::NullTermExpression<H>;
    fn pinning_pair(&self) -> &Self::TermExpression {
        &<crate::kernel::schema::NullTermExpression<H>>::ABSENT
    }
}
impl<'r, R: ThreeWaySiteResolver<H>, H: HostTypes> ResolvedThreeWaySite<'r, R, H> {
    /// Promote the `pinning_pair` 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_pinning_pair<'r2, R2: crate::kernel::schema::TermExpressionResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::kernel::schema::ResolvedTermExpression<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::kernel::schema::ResolvedTermExpression::new(
            record.pinning_pair_handle,
            r,
        ))
    }
}

/// Phase 8 (orphan-closure) — content-addressed handle for `NegotiationTrace<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 NegotiationTraceHandle<H: HostTypes> {
    /// Content fingerprint identifying the resolved record.
    pub fingerprint: crate::enforcement::ContentFingerprint,
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Copy for NegotiationTraceHandle<H> {}
impl<H: HostTypes> Clone for NegotiationTraceHandle<H> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<H: HostTypes> PartialEq for NegotiationTraceHandle<H> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.fingerprint == other.fingerprint
    }
}
impl<H: HostTypes> Eq for NegotiationTraceHandle<H> {}
impl<H: HostTypes> core::hash::Hash for NegotiationTraceHandle<H> {
    #[inline]
    fn hash<S: core::hash::Hasher>(&self, state: &mut S) {
        self.fingerprint.hash(state);
    }
}
impl<H: HostTypes> NegotiationTraceHandle<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 `NegotiationTrace<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 NegotiationTraceResolver<H: HostTypes> {
    /// Resolve a handle into its record. Returns `None` when the
    /// handle does not correspond to known content.
    fn resolve(&self, handle: NegotiationTraceHandle<H>) -> Option<NegotiationTraceRecord<H>>;
}

/// Phase 8 (orphan-closure) — typed record for `NegotiationTrace<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 NegotiationTraceRecord<H: HostTypes> {
    pub negotiation_steps: u64,
    pub is_convergent: bool,
    pub trace_length: u64,
    pub convergence_rate: H::Decimal,
    pub terminal_value_handle: crate::kernel::schema::TermExpressionHandle<H>,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `NegotiationTrace<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 ResolvedNegotiationTrace<'r, R: NegotiationTraceResolver<H>, H: HostTypes> {
    handle: NegotiationTraceHandle<H>,
    resolver: &'r R,
    record: Option<NegotiationTraceRecord<H>>,
}
impl<'r, R: NegotiationTraceResolver<H>, H: HostTypes> ResolvedNegotiationTrace<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: NegotiationTraceHandle<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) -> NegotiationTraceHandle<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<&NegotiationTraceRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: NegotiationTraceResolver<H>, H: HostTypes> NegotiationTrace<H>
    for ResolvedNegotiationTrace<'r, R, H>
{
    fn negotiation_steps(&self) -> u64 {
        match &self.record {
            Some(r) => r.negotiation_steps,
            None => 0,
        }
    }
    fn is_convergent(&self) -> bool {
        match &self.record {
            Some(r) => r.is_convergent,
            None => false,
        }
    }
    fn trace_length(&self) -> u64 {
        match &self.record {
            Some(r) => r.trace_length,
            None => 0,
        }
    }
    fn convergence_rate(&self) -> H::Decimal {
        match &self.record {
            Some(r) => r.convergence_rate,
            None => H::EMPTY_DECIMAL,
        }
    }
    type TermExpression = crate::kernel::schema::NullTermExpression<H>;
    fn terminal_value(&self) -> &Self::TermExpression {
        &<crate::kernel::schema::NullTermExpression<H>>::ABSENT
    }
}
impl<'r, R: NegotiationTraceResolver<H>, H: HostTypes> ResolvedNegotiationTrace<'r, R, H> {
    /// Promote the `terminal_value` 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_terminal_value<'r2, R2: crate::kernel::schema::TermExpressionResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::kernel::schema::ResolvedTermExpression<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::kernel::schema::ResolvedTermExpression::new(
            record.terminal_value_handle,
            r,
        ))
    }
}

/// Phase 8 (orphan-closure) — content-addressed handle for `MutualModelTrace<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 MutualModelTraceHandle<H: HostTypes> {
    /// Content fingerprint identifying the resolved record.
    pub fingerprint: crate::enforcement::ContentFingerprint,
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Copy for MutualModelTraceHandle<H> {}
impl<H: HostTypes> Clone for MutualModelTraceHandle<H> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<H: HostTypes> PartialEq for MutualModelTraceHandle<H> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.fingerprint == other.fingerprint
    }
}
impl<H: HostTypes> Eq for MutualModelTraceHandle<H> {}
impl<H: HostTypes> core::hash::Hash for MutualModelTraceHandle<H> {
    #[inline]
    fn hash<S: core::hash::Hasher>(&self, state: &mut S) {
        self.fingerprint.hash(state);
    }
}
impl<H: HostTypes> MutualModelTraceHandle<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 `MutualModelTrace<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 MutualModelTraceResolver<H: HostTypes> {
    /// Resolve a handle into its record. Returns `None` when the
    /// handle does not correspond to known content.
    fn resolve(&self, handle: MutualModelTraceHandle<H>) -> Option<MutualModelTraceRecord<H>>;
}

/// Phase 8 (orphan-closure) — typed record for `MutualModelTrace<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 MutualModelTraceRecord<H: HostTypes> {
    pub model_convergent: bool,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `MutualModelTrace<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 ResolvedMutualModelTrace<'r, R: MutualModelTraceResolver<H>, H: HostTypes> {
    handle: MutualModelTraceHandle<H>,
    resolver: &'r R,
    record: Option<MutualModelTraceRecord<H>>,
}
impl<'r, R: MutualModelTraceResolver<H>, H: HostTypes> ResolvedMutualModelTrace<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: MutualModelTraceHandle<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) -> MutualModelTraceHandle<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<&MutualModelTraceRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: MutualModelTraceResolver<H>, H: HostTypes> MutualModelTrace<H>
    for ResolvedMutualModelTrace<'r, R, H>
{
    fn model_convergent(&self) -> bool {
        match &self.record {
            Some(r) => r.model_convergent,
            None => false,
        }
    }
}

/// Phase 8 (orphan-closure) — content-addressed handle for `InteractionNerve<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 InteractionNerveHandle<H: HostTypes> {
    /// Content fingerprint identifying the resolved record.
    pub fingerprint: crate::enforcement::ContentFingerprint,
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Copy for InteractionNerveHandle<H> {}
impl<H: HostTypes> Clone for InteractionNerveHandle<H> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<H: HostTypes> PartialEq for InteractionNerveHandle<H> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.fingerprint == other.fingerprint
    }
}
impl<H: HostTypes> Eq for InteractionNerveHandle<H> {}
impl<H: HostTypes> core::hash::Hash for InteractionNerveHandle<H> {
    #[inline]
    fn hash<S: core::hash::Hasher>(&self, state: &mut S) {
        self.fingerprint.hash(state);
    }
}
impl<H: HostTypes> InteractionNerveHandle<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 `InteractionNerve<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 InteractionNerveResolver<H: HostTypes> {
    /// Resolve a handle into its record. Returns `None` when the
    /// handle does not correspond to known content.
    fn resolve(&self, handle: InteractionNerveHandle<H>) -> Option<InteractionNerveRecord<H>>;
}

/// Phase 8 (orphan-closure) — typed record for `InteractionNerve<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 InteractionNerveRecord<H: HostTypes> {
    pub nerve_dimension: u64,
    pub nerve_betti_numbers: u64,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `InteractionNerve<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 ResolvedInteractionNerve<'r, R: InteractionNerveResolver<H>, H: HostTypes> {
    handle: InteractionNerveHandle<H>,
    resolver: &'r R,
    record: Option<InteractionNerveRecord<H>>,
}
impl<'r, R: InteractionNerveResolver<H>, H: HostTypes> ResolvedInteractionNerve<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: InteractionNerveHandle<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) -> InteractionNerveHandle<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<&InteractionNerveRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: InteractionNerveResolver<H>, H: HostTypes> InteractionNerve<H>
    for ResolvedInteractionNerve<'r, R, H>
{
    fn nerve_dimension(&self) -> u64 {
        match &self.record {
            Some(r) => r.nerve_dimension,
            None => 0,
        }
    }
    fn nerve_betti_numbers(&self) -> u64 {
        match &self.record {
            Some(r) => r.nerve_betti_numbers,
            None => 0,
        }
    }
}

/// Phase 8 (orphan-closure) — content-addressed handle for `InteractionComposition<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 InteractionCompositionHandle<H: HostTypes> {
    /// Content fingerprint identifying the resolved record.
    pub fingerprint: crate::enforcement::ContentFingerprint,
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Copy for InteractionCompositionHandle<H> {}
impl<H: HostTypes> Clone for InteractionCompositionHandle<H> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<H: HostTypes> PartialEq for InteractionCompositionHandle<H> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.fingerprint == other.fingerprint
    }
}
impl<H: HostTypes> Eq for InteractionCompositionHandle<H> {}
impl<H: HostTypes> core::hash::Hash for InteractionCompositionHandle<H> {
    #[inline]
    fn hash<S: core::hash::Hasher>(&self, state: &mut S) {
        self.fingerprint.hash(state);
    }
}
impl<H: HostTypes> InteractionCompositionHandle<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 `InteractionComposition<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 InteractionCompositionResolver<H: HostTypes> {
    /// Resolve a handle into its record. Returns `None` when the
    /// handle does not correspond to known content.
    fn resolve(
        &self,
        handle: InteractionCompositionHandle<H>,
    ) -> Option<InteractionCompositionRecord<H>>;
}

/// Phase 8 (orphan-closure) — typed record for `InteractionComposition<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 InteractionCompositionRecord<H: HostTypes> {
    pub reification_depth: u64,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `InteractionComposition<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 ResolvedInteractionComposition<'r, R: InteractionCompositionResolver<H>, H: HostTypes> {
    handle: InteractionCompositionHandle<H>,
    resolver: &'r R,
    record: Option<InteractionCompositionRecord<H>>,
}
impl<'r, R: InteractionCompositionResolver<H>, H: HostTypes>
    ResolvedInteractionComposition<'r, R, H>
{
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: InteractionCompositionHandle<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) -> InteractionCompositionHandle<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<&InteractionCompositionRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: InteractionCompositionResolver<H>, H: HostTypes> InteractionComposition<H>
    for ResolvedInteractionComposition<'r, R, H>
{
    fn reification_depth(&self) -> u64 {
        match &self.record {
            Some(r) => r.reification_depth,
            None => 0,
        }
    }
}