uor-foundation 0.3.2

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

//! `effect/` namespace — Typed endomorphisms on state:Context classified by site target. Formalizes what reduction guard-effect pairs do to the site budget..
//!
//! Space: Kernel

use crate::HostTypes;

/// A typed endomorphism on state:Context. Maps one site-budget configuration to another. The atomic unit of state mutation in the kernel.
pub trait Effect<H: HostTypes> {
    /// Associated type for `EffectTarget`.
    type EffectTarget: EffectTarget<H>;
    /// The site coordinates this effect touches.
    fn effect_target(&self) -> &Self::EffectTarget;
    /// Associated type for `Context`.
    type Context: crate::user::state::Context<H>;
    /// The context before effect application.
    fn pre_context(&self) -> &Self::Context;
    /// The context after effect application.
    fn post_context(&self) -> &Self::Context;
    /// Change in freeRank: −1 for PinningEffect, +1 for UnbindingEffect, 0 for PhaseEffect.
    fn free_rank_delta(&self) -> i64;
    /// Position within a CompositeEffect sequence.
    fn composite_index(&self) -> u64;
    /// Computed: true iff effectTargets are disjoint with the compared effect. Derived from DisjointnessWitness existence.
    fn is_commutative_with(&self) -> bool;
}

/// An effect that has a well-defined inverse. PinningEffect and PhaseEffect are reversible; ExternalEffect and CompositeEffect are not in general.
pub trait ReversibleEffect<H: HostTypes>: Effect<H> {}

/// Pins a single free site to a definite value. Decrements freeRank by exactly 1. The effect produced by constraint resolution.
pub trait PinningEffect<H: HostTypes>: ReversibleEffect<H> {}

/// Releases a pinned site back to free state. Increments freeRank by exactly 1. The effect produced by session boundary reset.
pub trait UnbindingEffect<H: HostTypes>: Effect<H> {}

/// Rotates the reduction phase angle by Ω^k. Does not alter the site budget. The effect produced by reduction step transitions.
pub trait PhaseEffect<H: HostTypes>: ReversibleEffect<H> {
    /// The phase rotation applied, expressed as Ω^k.
    fn phase_angle_delta(&self) -> H::Decimal;
}

/// An ordered sequence of effects applied atomically. The composition E₁ ; E₂ applies E₁ then E₂.
pub trait CompositeEffect<H: HostTypes>: Effect<H> {
    /// Associated type for `Effect`.
    type Effect: Effect<H>;
    /// The first effect in the composite sequence.
    fn composite_head(&self) -> &Self::Effect;
    /// Subsequent effects in the composite sequence (ordered by effect:compositeIndex).
    fn composite_tail(&self) -> &[Self::Effect];
}

/// An opaque effect declared by a Prism implementation. The kernel treats it as a site-budget transformation satisfying the declared commutation contract. Must carry an effect:externalEffectShape linking to a conformance:EffectShape.
pub trait ExternalEffect<H: HostTypes>: Effect<H> {
    /// Associated type for `EffectShape`.
    type EffectShape: crate::bridge::conformance_::EffectShape<H>;
    /// The conformance shape that this external effect satisfies.
    fn external_effect_shape(&self) -> &Self::EffectShape;
}

/// The set of site coordinates that an effect reads or writes. Determines commutation.
pub trait EffectTarget<H: HostTypes> {
    /// Associated type for `SiteIndex`.
    type SiteIndex: crate::bridge::partition::SiteIndex<H>;
    /// The individual site coordinates in this target set.
    fn target_sites(&self) -> &[Self::SiteIndex];
    /// Number of site coordinates in this target set.
    fn target_cardinality(&self) -> u64;
}

/// A certificate that two EffectTargets have empty intersection, enabling commutative reordering.
pub trait DisjointnessWitness<H: HostTypes> {
    /// Associated type for `EffectTarget`.
    type EffectTarget: EffectTarget<H>;
    /// The left target in the disjointness claim.
    fn disjointness_left(&self) -> &Self::EffectTarget;
    /// The right target in the disjointness claim.
    fn disjointness_right(&self) -> &Self::EffectTarget;
}

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

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

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

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

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

/// Phase 2 (orphan-closure) — resolver-absent default impl of `CompositeEffect<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 NullCompositeEffect<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullCompositeEffect<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullCompositeEffect<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullCompositeEffect<H> = NullCompositeEffect {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> Effect<H> for NullCompositeEffect<H> {
    type EffectTarget = NullEffectTarget<H>;
    fn effect_target(&self) -> &Self::EffectTarget {
        &<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> CompositeEffect<H> for NullCompositeEffect<H> {
    type Effect = NullEffect<H>;
    fn composite_head(&self) -> &Self::Effect {
        &<NullEffect<H>>::ABSENT
    }
    fn composite_tail(&self) -> &[Self::Effect] {
        &[]
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `ExternalEffect<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 NullExternalEffect<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullExternalEffect<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullExternalEffect<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullExternalEffect<H> = NullExternalEffect {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> Effect<H> for NullExternalEffect<H> {
    type EffectTarget = NullEffectTarget<H>;
    fn effect_target(&self) -> &Self::EffectTarget {
        &<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> ExternalEffect<H> for NullExternalEffect<H> {
    type EffectShape = crate::bridge::conformance_::NullEffectShape<H>;
    fn external_effect_shape(&self) -> &Self::EffectShape {
        &<crate::bridge::conformance_::NullEffectShape<H>>::ABSENT
    }
}

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

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

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

/// Phase 8 (orphan-closure) — typed record for `Effect<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 EffectRecord<H: HostTypes> {
    pub effect_target_handle: EffectTargetHandle<H>,
    pub pre_context_handle: crate::user::state::ContextHandle<H>,
    pub post_context_handle: crate::user::state::ContextHandle<H>,
    pub free_rank_delta: i64,
    pub composite_index: u64,
    pub is_commutative_with: bool,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `Effect<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 ResolvedEffect<'r, R: EffectResolver<H>, H: HostTypes> {
    handle: EffectHandle<H>,
    resolver: &'r R,
    record: Option<EffectRecord<H>>,
}
impl<'r, R: EffectResolver<H>, H: HostTypes> ResolvedEffect<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: EffectHandle<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) -> EffectHandle<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<&EffectRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: EffectResolver<H>, H: HostTypes> Effect<H> for ResolvedEffect<'r, R, H> {
    type EffectTarget = NullEffectTarget<H>;
    fn effect_target(&self) -> &Self::EffectTarget {
        &<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 {
        match &self.record {
            Some(r) => r.free_rank_delta,
            None => 0,
        }
    }
    fn composite_index(&self) -> u64 {
        match &self.record {
            Some(r) => r.composite_index,
            None => 0,
        }
    }
    fn is_commutative_with(&self) -> bool {
        match &self.record {
            Some(r) => r.is_commutative_with,
            None => false,
        }
    }
}
impl<'r, R: EffectResolver<H>, H: HostTypes> ResolvedEffect<'r, R, H> {
    /// Promote the `effect_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_effect_target<'r2, R2: EffectTargetResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedEffectTarget<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedEffectTarget::new(record.effect_target_handle, r))
    }
    /// Promote the `pre_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_pre_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.pre_context_handle,
            r,
        ))
    }
    /// Promote the `post_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_post_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.post_context_handle,
            r,
        ))
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `ReversibleEffect<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 ResolvedReversibleEffect<'r, R: ReversibleEffectResolver<H>, H: HostTypes> {
    handle: ReversibleEffectHandle<H>,
    resolver: &'r R,
    record: Option<ReversibleEffectRecord<H>>,
}
impl<'r, R: ReversibleEffectResolver<H>, H: HostTypes> ResolvedReversibleEffect<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: ReversibleEffectHandle<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) -> ReversibleEffectHandle<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<&ReversibleEffectRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: ReversibleEffectResolver<H>, H: HostTypes> Effect<H>
    for ResolvedReversibleEffect<'r, R, H>
{
    type EffectTarget = NullEffectTarget<H>;
    fn effect_target(&self) -> &Self::EffectTarget {
        &<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: ReversibleEffectResolver<H>, H: HostTypes> ReversibleEffect<H>
    for ResolvedReversibleEffect<'r, R, H>
{
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `PinningEffect<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 ResolvedPinningEffect<'r, R: PinningEffectResolver<H>, H: HostTypes> {
    handle: PinningEffectHandle<H>,
    resolver: &'r R,
    record: Option<PinningEffectRecord<H>>,
}
impl<'r, R: PinningEffectResolver<H>, H: HostTypes> ResolvedPinningEffect<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: PinningEffectHandle<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) -> PinningEffectHandle<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<&PinningEffectRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: PinningEffectResolver<H>, H: HostTypes> Effect<H> for ResolvedPinningEffect<'r, R, H> {
    type EffectTarget = NullEffectTarget<H>;
    fn effect_target(&self) -> &Self::EffectTarget {
        &<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: PinningEffectResolver<H>, H: HostTypes> ReversibleEffect<H>
    for ResolvedPinningEffect<'r, R, H>
{
}
impl<'r, R: PinningEffectResolver<H>, H: HostTypes> PinningEffect<H>
    for ResolvedPinningEffect<'r, R, H>
{
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `UnbindingEffect<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 ResolvedUnbindingEffect<'r, R: UnbindingEffectResolver<H>, H: HostTypes> {
    handle: UnbindingEffectHandle<H>,
    resolver: &'r R,
    record: Option<UnbindingEffectRecord<H>>,
}
impl<'r, R: UnbindingEffectResolver<H>, H: HostTypes> ResolvedUnbindingEffect<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: UnbindingEffectHandle<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) -> UnbindingEffectHandle<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<&UnbindingEffectRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: UnbindingEffectResolver<H>, H: HostTypes> Effect<H>
    for ResolvedUnbindingEffect<'r, R, H>
{
    type EffectTarget = NullEffectTarget<H>;
    fn effect_target(&self) -> &Self::EffectTarget {
        &<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: UnbindingEffectResolver<H>, H: HostTypes> UnbindingEffect<H>
    for ResolvedUnbindingEffect<'r, R, H>
{
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `PhaseEffect<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 ResolvedPhaseEffect<'r, R: PhaseEffectResolver<H>, H: HostTypes> {
    handle: PhaseEffectHandle<H>,
    resolver: &'r R,
    record: Option<PhaseEffectRecord<H>>,
}
impl<'r, R: PhaseEffectResolver<H>, H: HostTypes> ResolvedPhaseEffect<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: PhaseEffectHandle<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) -> PhaseEffectHandle<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<&PhaseEffectRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: PhaseEffectResolver<H>, H: HostTypes> Effect<H> for ResolvedPhaseEffect<'r, R, H> {
    type EffectTarget = NullEffectTarget<H>;
    fn effect_target(&self) -> &Self::EffectTarget {
        &<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: PhaseEffectResolver<H>, H: HostTypes> ReversibleEffect<H>
    for ResolvedPhaseEffect<'r, R, H>
{
}
impl<'r, R: PhaseEffectResolver<H>, H: HostTypes> PhaseEffect<H> for ResolvedPhaseEffect<'r, R, H> {
    fn phase_angle_delta(&self) -> H::Decimal {
        match &self.record {
            Some(r) => r.phase_angle_delta,
            None => H::EMPTY_DECIMAL,
        }
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `CompositeEffect<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 ResolvedCompositeEffect<'r, R: CompositeEffectResolver<H>, H: HostTypes> {
    handle: CompositeEffectHandle<H>,
    resolver: &'r R,
    record: Option<CompositeEffectRecord<H>>,
}
impl<'r, R: CompositeEffectResolver<H>, H: HostTypes> ResolvedCompositeEffect<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: CompositeEffectHandle<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) -> CompositeEffectHandle<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<&CompositeEffectRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: CompositeEffectResolver<H>, H: HostTypes> Effect<H>
    for ResolvedCompositeEffect<'r, R, H>
{
    type EffectTarget = NullEffectTarget<H>;
    fn effect_target(&self) -> &Self::EffectTarget {
        &<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: CompositeEffectResolver<H>, H: HostTypes> CompositeEffect<H>
    for ResolvedCompositeEffect<'r, R, H>
{
    type Effect = NullEffect<H>;
    fn composite_head(&self) -> &Self::Effect {
        &<NullEffect<H>>::ABSENT
    }
    fn composite_tail(&self) -> &[Self::Effect] {
        &[]
    }
}
impl<'r, R: CompositeEffectResolver<H>, H: HostTypes> ResolvedCompositeEffect<'r, R, H> {
    /// Promote the `composite_head` 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_composite_head<'r2, R2: EffectResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedEffect<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedEffect::new(record.composite_head_handle, r))
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `ExternalEffect<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 ResolvedExternalEffect<'r, R: ExternalEffectResolver<H>, H: HostTypes> {
    handle: ExternalEffectHandle<H>,
    resolver: &'r R,
    record: Option<ExternalEffectRecord<H>>,
}
impl<'r, R: ExternalEffectResolver<H>, H: HostTypes> ResolvedExternalEffect<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: ExternalEffectHandle<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) -> ExternalEffectHandle<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<&ExternalEffectRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: ExternalEffectResolver<H>, H: HostTypes> Effect<H>
    for ResolvedExternalEffect<'r, R, H>
{
    type EffectTarget = NullEffectTarget<H>;
    fn effect_target(&self) -> &Self::EffectTarget {
        &<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: ExternalEffectResolver<H>, H: HostTypes> ExternalEffect<H>
    for ResolvedExternalEffect<'r, R, H>
{
    type EffectShape = crate::bridge::conformance_::NullEffectShape<H>;
    fn external_effect_shape(&self) -> &Self::EffectShape {
        &<crate::bridge::conformance_::NullEffectShape<H>>::ABSENT
    }
}
impl<'r, R: ExternalEffectResolver<H>, H: HostTypes> ResolvedExternalEffect<'r, R, H> {
    /// Promote the `external_effect_shape` 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_external_effect_shape<
        'r2,
        R2: crate::bridge::conformance_::EffectShapeResolver<H>,
    >(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::bridge::conformance_::ResolvedEffectShape<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::bridge::conformance_::ResolvedEffectShape::new(
            record.external_effect_shape_handle,
            r,
        ))
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `EffectTarget<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 ResolvedEffectTarget<'r, R: EffectTargetResolver<H>, H: HostTypes> {
    handle: EffectTargetHandle<H>,
    resolver: &'r R,
    record: Option<EffectTargetRecord<H>>,
}
impl<'r, R: EffectTargetResolver<H>, H: HostTypes> ResolvedEffectTarget<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: EffectTargetHandle<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) -> EffectTargetHandle<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<&EffectTargetRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: EffectTargetResolver<H>, H: HostTypes> EffectTarget<H>
    for ResolvedEffectTarget<'r, R, H>
{
    type SiteIndex = crate::bridge::partition::NullSiteIndex<H>;
    fn target_sites(&self) -> &[Self::SiteIndex] {
        &[]
    }
    fn target_cardinality(&self) -> u64 {
        match &self.record {
            Some(r) => r.target_cardinality,
            None => 0,
        }
    }
}