uor-foundation 0.3.5

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

//! `linear/` namespace — Linear discipline on site consumption. Formalizes that each site in a complete resolution path is targeted by exactly one effect..
//!
//! Space: Kernel

use crate::HostTypes;

/// A site index annotated with a linearity constraint: must be pinned exactly once in any complete resolution path.
pub trait LinearSite<H: HostTypes>: crate::bridge::partition::SiteIndex<H> {}

/// A PinningEffect that consumes its target LinearSite. After application, the site is no longer available for pinning by any subsequent effect.
pub trait LinearEffect<H: HostTypes>: crate::kernel::effect::PinningEffect<H> {
    /// Associated type for `LinearSite`.
    type LinearSite: LinearSite<H>;
    /// The single site consumed by this effect.
    fn linear_target(&self) -> &Self::LinearSite;
}

/// A computation trace where every site in the budget is targeted by exactly one LinearEffect.
pub trait LinearTrace<H: HostTypes>: crate::bridge::trace::ComputationTrace<H> {}

/// The multiset of LinearSites available at a given point in resolution. Starts as the full site budget; each LinearEffect removes exactly one element.
pub trait LinearBudget<H: HostTypes> {
    /// Associated type for `LinearSite`.
    type LinearSite: LinearSite<H>;
    /// The sites remaining in the budget.
    fn budget_sites(&self) -> &[Self::LinearSite];
    /// Associated type for `Context`.
    type Context: crate::user::state::Context<H>;
    /// The context associated with this budget state.
    fn budget_context(&self) -> &Self::Context;
    /// Number of unconsumed sites. Equals freeRank on the associated context.
    fn remaining_count(&self) -> u64;
    /// The stack budget available at the call site in bytes. On embedded targets this is compile-time-known; on std targets it is computed from the thread-local stack frame. Consumed by the MultiplicationResolver to bound the admissible Toom-Cook splitting factor R: deeper recursion requires more stack, so R is capped where stack would overflow.
    fn stack_budget_bytes(&self) -> u64;
}

/// A binding between a state:ContextLease and a subset of LinearSites. Formalizes what resources a lease claims.
pub trait LeaseAllocation<H: HostTypes> {
    /// Associated type for `LinearSite`.
    type LinearSite: LinearSite<H>;
    /// The sites claimed by this lease.
    fn lease_target(&self) -> &[Self::LinearSite];
    /// Associated type for `ContextLease`.
    type ContextLease: crate::user::state::ContextLease<H>;
    /// The ContextLease individual that owns this allocation.
    fn lease_source(&self) -> &Self::ContextLease;
    /// Number of sites claimed by this lease.
    fn lease_cardinality(&self) -> u64;
}

/// A site that may be pinned at most once (but need not be pinned). Relaxation of LinearSite for incomplete resolution paths.
pub trait AffineSite<H: HostTypes>: crate::bridge::partition::SiteIndex<H> {}

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

/// Phase 2 (orphan-closure) — resolver-absent default impl of `LinearEffect<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 NullLinearEffect<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullLinearEffect<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullLinearEffect<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullLinearEffect<H> = NullLinearEffect {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> crate::kernel::effect::Effect<H> for NullLinearEffect<H> {
    type EffectTarget = crate::kernel::effect::NullEffectTarget<H>;
    fn effect_target(&self) -> &Self::EffectTarget {
        &<crate::kernel::effect::NullEffectTarget<H>>::ABSENT
    }
    type Context = crate::user::state::NullContext<H>;
    fn pre_context(&self) -> &Self::Context {
        &<crate::user::state::NullContext<H>>::ABSENT
    }
    fn post_context(&self) -> &Self::Context {
        &<crate::user::state::NullContext<H>>::ABSENT
    }
    fn free_rank_delta(&self) -> i64 {
        0
    }
    fn composite_index(&self) -> u64 {
        0
    }
    fn is_commutative_with(&self) -> bool {
        false
    }
}
impl<H: HostTypes> crate::kernel::effect::ReversibleEffect<H> for NullLinearEffect<H> {}
impl<H: HostTypes> crate::kernel::effect::PinningEffect<H> for NullLinearEffect<H> {}
impl<H: HostTypes> LinearEffect<H> for NullLinearEffect<H> {
    type LinearSite = NullLinearSite<H>;
    fn linear_target(&self) -> &Self::LinearSite {
        &<NullLinearSite<H>>::ABSENT
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `LinearTrace<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 NullLinearTrace<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullLinearTrace<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullLinearTrace<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullLinearTrace<H> = NullLinearTrace {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> crate::bridge::trace::ComputationTrace<H> for NullLinearTrace<H> {
    type Datum = crate::kernel::schema::NullDatum<H>;
    fn input(&self) -> &Self::Datum {
        &<crate::kernel::schema::NullDatum<H>>::ABSENT
    }
    fn output(&self) -> &Self::Datum {
        &<crate::kernel::schema::NullDatum<H>>::ABSENT
    }
    type ComputationStep = crate::bridge::trace::NullComputationStep<H>;
    fn step(&self) -> &[Self::ComputationStep] {
        &[]
    }
    type DihedralElement = crate::bridge::observable::NullDihedralElement<H>;
    fn monodromy(&self) -> &Self::DihedralElement {
        &<crate::bridge::observable::NullDihedralElement<H>>::ABSENT
    }
    type Certificate = crate::bridge::cert::NullCertificate<H>;
    fn certified_by(&self) -> &Self::Certificate {
        &<crate::bridge::cert::NullCertificate<H>>::ABSENT
    }
    type ResidualEntropy = crate::bridge::observable::NullResidualEntropy<H>;
    fn residual_entropy(&self) -> &Self::ResidualEntropy {
        &<crate::bridge::observable::NullResidualEntropy<H>>::ABSENT
    }
    fn is_geodesic(&self) -> bool {
        false
    }
    type GeodesicViolation = crate::bridge::trace::NullGeodesicViolation<H>;
    fn geodesic_violation(&self) -> &[Self::GeodesicViolation] {
        &[]
    }
    fn cumulative_entropy_cost(&self) -> H::Decimal {
        H::EMPTY_DECIMAL
    }
    fn adiabatically_ordered(&self) -> bool {
        false
    }
    type MeasurementEvent = crate::bridge::trace::NullMeasurementEvent<H>;
    fn measurement_event(&self) -> &[Self::MeasurementEvent] {
        &[]
    }
    fn is_ar1_ordered(&self) -> bool {
        false
    }
    fn is_dc10_selected(&self) -> bool {
        false
    }
}
impl<H: HostTypes> LinearTrace<H> for NullLinearTrace<H> {}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `LinearBudget<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 NullLinearBudget<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullLinearBudget<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullLinearBudget<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullLinearBudget<H> = NullLinearBudget {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> LinearBudget<H> for NullLinearBudget<H> {
    type LinearSite = NullLinearSite<H>;
    fn budget_sites(&self) -> &[Self::LinearSite] {
        &[]
    }
    type Context = crate::user::state::NullContext<H>;
    fn budget_context(&self) -> &Self::Context {
        &<crate::user::state::NullContext<H>>::ABSENT
    }
    fn remaining_count(&self) -> u64 {
        0
    }
    fn stack_budget_bytes(&self) -> u64 {
        0
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `LeaseAllocation<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 NullLeaseAllocation<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullLeaseAllocation<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullLeaseAllocation<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullLeaseAllocation<H> = NullLeaseAllocation {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> LeaseAllocation<H> for NullLeaseAllocation<H> {
    type LinearSite = NullLinearSite<H>;
    fn lease_target(&self) -> &[Self::LinearSite] {
        &[]
    }
    type ContextLease = crate::user::state::NullContextLease<H>;
    fn lease_source(&self) -> &Self::ContextLease {
        &<crate::user::state::NullContextLease<H>>::ABSENT
    }
    fn lease_cardinality(&self) -> u64 {
        0
    }
}

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

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `LinearSite<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 ResolvedLinearSite<'r, R: LinearSiteResolver<H>, H: HostTypes> {
    handle: LinearSiteHandle<H>,
    resolver: &'r R,
    record: Option<LinearSiteRecord<H>>,
}
impl<'r, R: LinearSiteResolver<H>, H: HostTypes> ResolvedLinearSite<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: LinearSiteHandle<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) -> LinearSiteHandle<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<&LinearSiteRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: LinearSiteResolver<H>, H: HostTypes> crate::bridge::partition::SiteIndex<H>
    for ResolvedLinearSite<'r, R, H>
{
    fn site_position(&self) -> u64 {
        0
    }
    fn site_state(&self) -> u64 {
        0
    }
    type SiteIndexTarget = crate::bridge::partition::NullSiteIndex<H>;
    fn ancilla_site(&self) -> &Self::SiteIndexTarget {
        &<crate::bridge::partition::NullSiteIndex<H>>::ABSENT
    }
}
impl<'r, R: LinearSiteResolver<H>, H: HostTypes> LinearSite<H> for ResolvedLinearSite<'r, R, H> {}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `LinearEffect<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 ResolvedLinearEffect<'r, R: LinearEffectResolver<H>, H: HostTypes> {
    handle: LinearEffectHandle<H>,
    resolver: &'r R,
    record: Option<LinearEffectRecord<H>>,
}
impl<'r, R: LinearEffectResolver<H>, H: HostTypes> ResolvedLinearEffect<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: LinearEffectHandle<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) -> LinearEffectHandle<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<&LinearEffectRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: LinearEffectResolver<H>, H: HostTypes> crate::kernel::effect::Effect<H>
    for ResolvedLinearEffect<'r, R, H>
{
    type EffectTarget = crate::kernel::effect::NullEffectTarget<H>;
    fn effect_target(&self) -> &Self::EffectTarget {
        &<crate::kernel::effect::NullEffectTarget<H>>::ABSENT
    }
    type Context = crate::user::state::NullContext<H>;
    fn pre_context(&self) -> &Self::Context {
        &<crate::user::state::NullContext<H>>::ABSENT
    }
    fn post_context(&self) -> &Self::Context {
        &<crate::user::state::NullContext<H>>::ABSENT
    }
    fn free_rank_delta(&self) -> i64 {
        0
    }
    fn composite_index(&self) -> u64 {
        0
    }
    fn is_commutative_with(&self) -> bool {
        false
    }
}
impl<'r, R: LinearEffectResolver<H>, H: HostTypes> crate::kernel::effect::ReversibleEffect<H>
    for ResolvedLinearEffect<'r, R, H>
{
}
impl<'r, R: LinearEffectResolver<H>, H: HostTypes> crate::kernel::effect::PinningEffect<H>
    for ResolvedLinearEffect<'r, R, H>
{
}
impl<'r, R: LinearEffectResolver<H>, H: HostTypes> LinearEffect<H>
    for ResolvedLinearEffect<'r, R, H>
{
    type LinearSite = NullLinearSite<H>;
    fn linear_target(&self) -> &Self::LinearSite {
        &<NullLinearSite<H>>::ABSENT
    }
}
impl<'r, R: LinearEffectResolver<H>, H: HostTypes> ResolvedLinearEffect<'r, R, H> {
    /// Promote the `linear_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_linear_target<'r2, R2: LinearSiteResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedLinearSite<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedLinearSite::new(record.linear_target_handle, r))
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `LinearTrace<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 ResolvedLinearTrace<'r, R: LinearTraceResolver<H>, H: HostTypes> {
    handle: LinearTraceHandle<H>,
    resolver: &'r R,
    record: Option<LinearTraceRecord<H>>,
}
impl<'r, R: LinearTraceResolver<H>, H: HostTypes> ResolvedLinearTrace<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: LinearTraceHandle<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) -> LinearTraceHandle<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<&LinearTraceRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: LinearTraceResolver<H>, H: HostTypes> crate::bridge::trace::ComputationTrace<H>
    for ResolvedLinearTrace<'r, R, H>
{
    type Datum = crate::kernel::schema::NullDatum<H>;
    fn input(&self) -> &Self::Datum {
        &<crate::kernel::schema::NullDatum<H>>::ABSENT
    }
    fn output(&self) -> &Self::Datum {
        &<crate::kernel::schema::NullDatum<H>>::ABSENT
    }
    type ComputationStep = crate::bridge::trace::NullComputationStep<H>;
    fn step(&self) -> &[Self::ComputationStep] {
        &[]
    }
    type DihedralElement = crate::bridge::observable::NullDihedralElement<H>;
    fn monodromy(&self) -> &Self::DihedralElement {
        &<crate::bridge::observable::NullDihedralElement<H>>::ABSENT
    }
    type Certificate = crate::bridge::cert::NullCertificate<H>;
    fn certified_by(&self) -> &Self::Certificate {
        &<crate::bridge::cert::NullCertificate<H>>::ABSENT
    }
    type ResidualEntropy = crate::bridge::observable::NullResidualEntropy<H>;
    fn residual_entropy(&self) -> &Self::ResidualEntropy {
        &<crate::bridge::observable::NullResidualEntropy<H>>::ABSENT
    }
    fn is_geodesic(&self) -> bool {
        false
    }
    type GeodesicViolation = crate::bridge::trace::NullGeodesicViolation<H>;
    fn geodesic_violation(&self) -> &[Self::GeodesicViolation] {
        &[]
    }
    fn cumulative_entropy_cost(&self) -> H::Decimal {
        H::EMPTY_DECIMAL
    }
    fn adiabatically_ordered(&self) -> bool {
        false
    }
    type MeasurementEvent = crate::bridge::trace::NullMeasurementEvent<H>;
    fn measurement_event(&self) -> &[Self::MeasurementEvent] {
        &[]
    }
    fn is_ar1_ordered(&self) -> bool {
        false
    }
    fn is_dc10_selected(&self) -> bool {
        false
    }
}
impl<'r, R: LinearTraceResolver<H>, H: HostTypes> LinearTrace<H> for ResolvedLinearTrace<'r, R, H> {}

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

/// Phase 8 (orphan-closure) — typed record for `LinearBudget<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 LinearBudgetRecord<H: HostTypes> {
    pub budget_context_handle: crate::user::state::ContextHandle<H>,
    pub remaining_count: u64,
    pub stack_budget_bytes: u64,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `LinearBudget<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 ResolvedLinearBudget<'r, R: LinearBudgetResolver<H>, H: HostTypes> {
    handle: LinearBudgetHandle<H>,
    resolver: &'r R,
    record: Option<LinearBudgetRecord<H>>,
}
impl<'r, R: LinearBudgetResolver<H>, H: HostTypes> ResolvedLinearBudget<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: LinearBudgetHandle<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) -> LinearBudgetHandle<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<&LinearBudgetRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: LinearBudgetResolver<H>, H: HostTypes> LinearBudget<H>
    for ResolvedLinearBudget<'r, R, H>
{
    type LinearSite = NullLinearSite<H>;
    fn budget_sites(&self) -> &[Self::LinearSite] {
        &[]
    }
    type Context = crate::user::state::NullContext<H>;
    fn budget_context(&self) -> &Self::Context {
        &<crate::user::state::NullContext<H>>::ABSENT
    }
    fn remaining_count(&self) -> u64 {
        match &self.record {
            Some(r) => r.remaining_count,
            None => 0,
        }
    }
    fn stack_budget_bytes(&self) -> u64 {
        match &self.record {
            Some(r) => r.stack_budget_bytes,
            None => 0,
        }
    }
}
impl<'r, R: LinearBudgetResolver<H>, H: HostTypes> ResolvedLinearBudget<'r, R, H> {
    /// Promote the `budget_context` 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_budget_context<'r2, R2: crate::user::state::ContextResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::user::state::ResolvedContext<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::user::state::ResolvedContext::new(
            record.budget_context_handle,
            r,
        ))
    }
}

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

/// Phase 8 (orphan-closure) — typed record for `LeaseAllocation<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 LeaseAllocationRecord<H: HostTypes> {
    pub lease_source_handle: crate::user::state::ContextLeaseHandle<H>,
    pub lease_cardinality: u64,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `LeaseAllocation<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 ResolvedLeaseAllocation<'r, R: LeaseAllocationResolver<H>, H: HostTypes> {
    handle: LeaseAllocationHandle<H>,
    resolver: &'r R,
    record: Option<LeaseAllocationRecord<H>>,
}
impl<'r, R: LeaseAllocationResolver<H>, H: HostTypes> ResolvedLeaseAllocation<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: LeaseAllocationHandle<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) -> LeaseAllocationHandle<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<&LeaseAllocationRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: LeaseAllocationResolver<H>, H: HostTypes> LeaseAllocation<H>
    for ResolvedLeaseAllocation<'r, R, H>
{
    type LinearSite = NullLinearSite<H>;
    fn lease_target(&self) -> &[Self::LinearSite] {
        &[]
    }
    type ContextLease = crate::user::state::NullContextLease<H>;
    fn lease_source(&self) -> &Self::ContextLease {
        &<crate::user::state::NullContextLease<H>>::ABSENT
    }
    fn lease_cardinality(&self) -> u64 {
        match &self.record {
            Some(r) => r.lease_cardinality,
            None => 0,
        }
    }
}
impl<'r, R: LeaseAllocationResolver<H>, H: HostTypes> ResolvedLeaseAllocation<'r, R, H> {
    /// Promote the `lease_source` 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_lease_source<'r2, R2: crate::user::state::ContextLeaseResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::user::state::ResolvedContextLease<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::user::state::ResolvedContextLease::new(
            record.lease_source_handle,
            r,
        ))
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `AffineSite<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 ResolvedAffineSite<'r, R: AffineSiteResolver<H>, H: HostTypes> {
    handle: AffineSiteHandle<H>,
    resolver: &'r R,
    record: Option<AffineSiteRecord<H>>,
}
impl<'r, R: AffineSiteResolver<H>, H: HostTypes> ResolvedAffineSite<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: AffineSiteHandle<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) -> AffineSiteHandle<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<&AffineSiteRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: AffineSiteResolver<H>, H: HostTypes> crate::bridge::partition::SiteIndex<H>
    for ResolvedAffineSite<'r, R, H>
{
    fn site_position(&self) -> u64 {
        0
    }
    fn site_state(&self) -> u64 {
        0
    }
    type SiteIndexTarget = crate::bridge::partition::NullSiteIndex<H>;
    fn ancilla_site(&self) -> &Self::SiteIndexTarget {
        &<crate::bridge::partition::NullSiteIndex<H>>::ABSENT
    }
}
impl<'r, R: AffineSiteResolver<H>, H: HostTypes> AffineSite<H> for ResolvedAffineSite<'r, R, H> {}