uor-foundation 0.3.2

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

//! `boundary/` namespace — Typed interface between kernel computation and the external world. Formalizes how data enters and exits the ring substrate..
//!
//! Space: Bridge

use crate::HostTypes;

/// A typed interface point between the kernel and the external world. Every data flow into or out of the ring crosses exactly one IOBoundary.
pub trait IOBoundary<H: HostTypes> {}

/// A typed source of external data entering the ring. Carries an expected TypeDefinition describing the shape of incoming data.
pub trait Source<H: HostTypes>: IOBoundary<H> {
    /// Associated type for `TypeDefinition`.
    type TypeDefinition: crate::user::type_::TypeDefinition<H>;
    /// The expected type of data arriving from this source.
    fn source_type(&self) -> &Self::TypeDefinition;
}

/// A typed destination for data leaving the ring. Carries an expected TypeDefinition describing the shape of outgoing data.
pub trait Sink<H: HostTypes>: IOBoundary<H> {
    /// Associated type for `TypeDefinition`.
    type TypeDefinition: crate::user::type_::TypeDefinition<H>;
    /// The expected type of data departing through this sink.
    fn sink_type(&self) -> &Self::TypeDefinition;
}

/// An effect that crosses the kernel/external boundary. Specializes effect:ExternalEffect with explicit source or sink binding.
pub trait BoundaryEffect<H: HostTypes>: crate::kernel::effect::ExternalEffect<H> {
    /// Associated type for `IOBoundary`.
    type IOBoundary: IOBoundary<H>;
    /// The boundary this effect crosses.
    fn effect_boundary(&self) -> &Self::IOBoundary;
    /// True iff applying the boundary effect twice produces the same result as applying it once.
    fn is_idempotent(&self) -> bool;
}

/// A BoundaryEffect that reads from a Source and produces a datum in the ring.
pub trait IngestEffect<H: HostTypes>: BoundaryEffect<H> {
    /// Associated type for `Source`.
    type Source: Source<H>;
    /// The source being read.
    fn ingest_source(&self) -> &Self::Source;
}

/// A BoundaryEffect that writes a ring datum to a Sink.
pub trait EmitEffect<H: HostTypes>: BoundaryEffect<H> {
    /// Associated type for `Sink`.
    type Sink: Sink<H>;
    /// The sink being written to.
    fn emit_sink(&self) -> &Self::Sink;
}

/// A specification of the data shape, ordering, and framing constraints for data crossing a boundary.
pub trait BoundaryProtocol<H: HostTypes> {
    /// Associated type for `TypeDefinition`.
    type TypeDefinition: crate::user::type_::TypeDefinition<H>;
    /// The type specification for boundary data.
    fn protocol_type(&self) -> &Self::TypeDefinition;
    /// Associated type for `Conjunction`.
    type Conjunction: crate::user::type_::Conjunction<H>;
    /// Sequencing constraints on boundary data.
    fn protocol_ordering(&self) -> &Self::Conjunction;
}

/// A Session that includes BoundaryEffects. Extends the session model to track which boundaries were crossed.
pub trait BoundarySession<H: HostTypes>: crate::user::state::Session<H> {
    /// Associated type for `IOBoundary`.
    type IOBoundary: IOBoundary<H>;
    /// The boundaries crossed during this session.
    fn session_boundaries(&self) -> &[Self::IOBoundary];
    /// Total number of boundary crossings in this session.
    fn crossing_count(&self) -> u64;
}

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

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

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

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

/// Phase 2 (orphan-closure) — resolver-absent default impl of `IngestEffect<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 NullIngestEffect<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullIngestEffect<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullIngestEffect<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullIngestEffect<H> = NullIngestEffect {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> crate::kernel::effect::Effect<H> for NullIngestEffect<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::ExternalEffect<H> for NullIngestEffect<H> {
    type EffectShape = crate::bridge::conformance_::NullEffectShape<H>;
    fn external_effect_shape(&self) -> &Self::EffectShape {
        &<crate::bridge::conformance_::NullEffectShape<H>>::ABSENT
    }
}
impl<H: HostTypes> BoundaryEffect<H> for NullIngestEffect<H> {
    type IOBoundary = NullIOBoundary<H>;
    fn effect_boundary(&self) -> &Self::IOBoundary {
        &<NullIOBoundary<H>>::ABSENT
    }
    fn is_idempotent(&self) -> bool {
        false
    }
}
impl<H: HostTypes> IngestEffect<H> for NullIngestEffect<H> {
    type Source = NullSource<H>;
    fn ingest_source(&self) -> &Self::Source {
        &<NullSource<H>>::ABSENT
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `EmitEffect<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 NullEmitEffect<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullEmitEffect<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullEmitEffect<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullEmitEffect<H> = NullEmitEffect {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> crate::kernel::effect::Effect<H> for NullEmitEffect<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::ExternalEffect<H> for NullEmitEffect<H> {
    type EffectShape = crate::bridge::conformance_::NullEffectShape<H>;
    fn external_effect_shape(&self) -> &Self::EffectShape {
        &<crate::bridge::conformance_::NullEffectShape<H>>::ABSENT
    }
}
impl<H: HostTypes> BoundaryEffect<H> for NullEmitEffect<H> {
    type IOBoundary = NullIOBoundary<H>;
    fn effect_boundary(&self) -> &Self::IOBoundary {
        &<NullIOBoundary<H>>::ABSENT
    }
    fn is_idempotent(&self) -> bool {
        false
    }
}
impl<H: HostTypes> EmitEffect<H> for NullEmitEffect<H> {
    type Sink = NullSink<H>;
    fn emit_sink(&self) -> &Self::Sink {
        &<NullSink<H>>::ABSENT
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `BoundaryProtocol<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 NullBoundaryProtocol<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullBoundaryProtocol<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullBoundaryProtocol<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullBoundaryProtocol<H> = NullBoundaryProtocol {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> BoundaryProtocol<H> for NullBoundaryProtocol<H> {
    type TypeDefinition = crate::user::type_::NullTypeDefinition<H>;
    fn protocol_type(&self) -> &Self::TypeDefinition {
        &<crate::user::type_::NullTypeDefinition<H>>::ABSENT
    }
    type Conjunction = crate::user::type_::NullConjunction<H>;
    fn protocol_ordering(&self) -> &Self::Conjunction {
        &<crate::user::type_::NullConjunction<H>>::ABSENT
    }
}

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

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `IOBoundary<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 ResolvedIOBoundary<'r, R: IOBoundaryResolver<H>, H: HostTypes> {
    handle: IOBoundaryHandle<H>,
    resolver: &'r R,
    record: Option<IOBoundaryRecord<H>>,
}
impl<'r, R: IOBoundaryResolver<H>, H: HostTypes> ResolvedIOBoundary<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: IOBoundaryHandle<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) -> IOBoundaryHandle<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<&IOBoundaryRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: IOBoundaryResolver<H>, H: HostTypes> IOBoundary<H> for ResolvedIOBoundary<'r, R, H> {}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `Source<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 ResolvedSource<'r, R: SourceResolver<H>, H: HostTypes> {
    handle: SourceHandle<H>,
    resolver: &'r R,
    record: Option<SourceRecord<H>>,
}
impl<'r, R: SourceResolver<H>, H: HostTypes> ResolvedSource<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: SourceHandle<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) -> SourceHandle<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<&SourceRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: SourceResolver<H>, H: HostTypes> IOBoundary<H> for ResolvedSource<'r, R, H> {}
impl<'r, R: SourceResolver<H>, H: HostTypes> Source<H> for ResolvedSource<'r, R, H> {
    type TypeDefinition = crate::user::type_::NullTypeDefinition<H>;
    fn source_type(&self) -> &Self::TypeDefinition {
        &<crate::user::type_::NullTypeDefinition<H>>::ABSENT
    }
}
impl<'r, R: SourceResolver<H>, H: HostTypes> ResolvedSource<'r, R, H> {
    /// Promote the `source_type` 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_source_type<'r2, R2: crate::user::type_::TypeDefinitionResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::user::type_::ResolvedTypeDefinition<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::user::type_::ResolvedTypeDefinition::new(
            record.source_type_handle,
            r,
        ))
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `Sink<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 ResolvedSink<'r, R: SinkResolver<H>, H: HostTypes> {
    handle: SinkHandle<H>,
    resolver: &'r R,
    record: Option<SinkRecord<H>>,
}
impl<'r, R: SinkResolver<H>, H: HostTypes> ResolvedSink<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: SinkHandle<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) -> SinkHandle<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<&SinkRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: SinkResolver<H>, H: HostTypes> IOBoundary<H> for ResolvedSink<'r, R, H> {}
impl<'r, R: SinkResolver<H>, H: HostTypes> Sink<H> for ResolvedSink<'r, R, H> {
    type TypeDefinition = crate::user::type_::NullTypeDefinition<H>;
    fn sink_type(&self) -> &Self::TypeDefinition {
        &<crate::user::type_::NullTypeDefinition<H>>::ABSENT
    }
}
impl<'r, R: SinkResolver<H>, H: HostTypes> ResolvedSink<'r, R, H> {
    /// Promote the `sink_type` 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_sink_type<'r2, R2: crate::user::type_::TypeDefinitionResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::user::type_::ResolvedTypeDefinition<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::user::type_::ResolvedTypeDefinition::new(
            record.sink_type_handle,
            r,
        ))
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `BoundaryEffect<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 ResolvedBoundaryEffect<'r, R: BoundaryEffectResolver<H>, H: HostTypes> {
    handle: BoundaryEffectHandle<H>,
    resolver: &'r R,
    record: Option<BoundaryEffectRecord<H>>,
}
impl<'r, R: BoundaryEffectResolver<H>, H: HostTypes> ResolvedBoundaryEffect<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: BoundaryEffectHandle<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) -> BoundaryEffectHandle<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<&BoundaryEffectRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: BoundaryEffectResolver<H>, H: HostTypes> crate::kernel::effect::Effect<H>
    for ResolvedBoundaryEffect<'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: BoundaryEffectResolver<H>, H: HostTypes> crate::kernel::effect::ExternalEffect<H>
    for ResolvedBoundaryEffect<'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: BoundaryEffectResolver<H>, H: HostTypes> BoundaryEffect<H>
    for ResolvedBoundaryEffect<'r, R, H>
{
    type IOBoundary = NullIOBoundary<H>;
    fn effect_boundary(&self) -> &Self::IOBoundary {
        &<NullIOBoundary<H>>::ABSENT
    }
    fn is_idempotent(&self) -> bool {
        match &self.record {
            Some(r) => r.is_idempotent,
            None => false,
        }
    }
}
impl<'r, R: BoundaryEffectResolver<H>, H: HostTypes> ResolvedBoundaryEffect<'r, R, H> {
    /// Promote the `effect_boundary` 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_boundary<'r2, R2: IOBoundaryResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedIOBoundary<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedIOBoundary::new(record.effect_boundary_handle, r))
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `IngestEffect<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 ResolvedIngestEffect<'r, R: IngestEffectResolver<H>, H: HostTypes> {
    handle: IngestEffectHandle<H>,
    resolver: &'r R,
    record: Option<IngestEffectRecord<H>>,
}
impl<'r, R: IngestEffectResolver<H>, H: HostTypes> ResolvedIngestEffect<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: IngestEffectHandle<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) -> IngestEffectHandle<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<&IngestEffectRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: IngestEffectResolver<H>, H: HostTypes> crate::kernel::effect::Effect<H>
    for ResolvedIngestEffect<'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: IngestEffectResolver<H>, H: HostTypes> crate::kernel::effect::ExternalEffect<H>
    for ResolvedIngestEffect<'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: IngestEffectResolver<H>, H: HostTypes> BoundaryEffect<H>
    for ResolvedIngestEffect<'r, R, H>
{
    type IOBoundary = NullIOBoundary<H>;
    fn effect_boundary(&self) -> &Self::IOBoundary {
        &<NullIOBoundary<H>>::ABSENT
    }
    fn is_idempotent(&self) -> bool {
        false
    }
}
impl<'r, R: IngestEffectResolver<H>, H: HostTypes> IngestEffect<H>
    for ResolvedIngestEffect<'r, R, H>
{
    type Source = NullSource<H>;
    fn ingest_source(&self) -> &Self::Source {
        &<NullSource<H>>::ABSENT
    }
}
impl<'r, R: IngestEffectResolver<H>, H: HostTypes> ResolvedIngestEffect<'r, R, H> {
    /// Promote the `ingest_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_ingest_source<'r2, R2: SourceResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedSource<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedSource::new(record.ingest_source_handle, r))
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `EmitEffect<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 ResolvedEmitEffect<'r, R: EmitEffectResolver<H>, H: HostTypes> {
    handle: EmitEffectHandle<H>,
    resolver: &'r R,
    record: Option<EmitEffectRecord<H>>,
}
impl<'r, R: EmitEffectResolver<H>, H: HostTypes> ResolvedEmitEffect<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: EmitEffectHandle<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) -> EmitEffectHandle<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<&EmitEffectRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: EmitEffectResolver<H>, H: HostTypes> crate::kernel::effect::Effect<H>
    for ResolvedEmitEffect<'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: EmitEffectResolver<H>, H: HostTypes> crate::kernel::effect::ExternalEffect<H>
    for ResolvedEmitEffect<'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: EmitEffectResolver<H>, H: HostTypes> BoundaryEffect<H>
    for ResolvedEmitEffect<'r, R, H>
{
    type IOBoundary = NullIOBoundary<H>;
    fn effect_boundary(&self) -> &Self::IOBoundary {
        &<NullIOBoundary<H>>::ABSENT
    }
    fn is_idempotent(&self) -> bool {
        false
    }
}
impl<'r, R: EmitEffectResolver<H>, H: HostTypes> EmitEffect<H> for ResolvedEmitEffect<'r, R, H> {
    type Sink = NullSink<H>;
    fn emit_sink(&self) -> &Self::Sink {
        &<NullSink<H>>::ABSENT
    }
}
impl<'r, R: EmitEffectResolver<H>, H: HostTypes> ResolvedEmitEffect<'r, R, H> {
    /// Promote the `emit_sink` 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_emit_sink<'r2, R2: SinkResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedSink<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedSink::new(record.emit_sink_handle, r))
    }
}

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

/// Phase 8 (orphan-closure) — typed record for `BoundaryProtocol<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 BoundaryProtocolRecord<H: HostTypes> {
    pub protocol_type_handle: crate::user::type_::TypeDefinitionHandle<H>,
    pub protocol_ordering_handle: crate::user::type_::ConjunctionHandle<H>,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `BoundaryProtocol<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 ResolvedBoundaryProtocol<'r, R: BoundaryProtocolResolver<H>, H: HostTypes> {
    handle: BoundaryProtocolHandle<H>,
    resolver: &'r R,
    record: Option<BoundaryProtocolRecord<H>>,
}
impl<'r, R: BoundaryProtocolResolver<H>, H: HostTypes> ResolvedBoundaryProtocol<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: BoundaryProtocolHandle<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) -> BoundaryProtocolHandle<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<&BoundaryProtocolRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: BoundaryProtocolResolver<H>, H: HostTypes> BoundaryProtocol<H>
    for ResolvedBoundaryProtocol<'r, R, H>
{
    type TypeDefinition = crate::user::type_::NullTypeDefinition<H>;
    fn protocol_type(&self) -> &Self::TypeDefinition {
        &<crate::user::type_::NullTypeDefinition<H>>::ABSENT
    }
    type Conjunction = crate::user::type_::NullConjunction<H>;
    fn protocol_ordering(&self) -> &Self::Conjunction {
        &<crate::user::type_::NullConjunction<H>>::ABSENT
    }
}
impl<'r, R: BoundaryProtocolResolver<H>, H: HostTypes> ResolvedBoundaryProtocol<'r, R, H> {
    /// Promote the `protocol_type` 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_protocol_type<'r2, R2: crate::user::type_::TypeDefinitionResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::user::type_::ResolvedTypeDefinition<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::user::type_::ResolvedTypeDefinition::new(
            record.protocol_type_handle,
            r,
        ))
    }
    /// Promote the `protocol_ordering` 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_protocol_ordering<'r2, R2: crate::user::type_::ConjunctionResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::user::type_::ResolvedConjunction<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::user::type_::ResolvedConjunction::new(
            record.protocol_ordering_handle,
            r,
        ))
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `BoundarySession<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 ResolvedBoundarySession<'r, R: BoundarySessionResolver<H>, H: HostTypes> {
    handle: BoundarySessionHandle<H>,
    resolver: &'r R,
    record: Option<BoundarySessionRecord<H>>,
}
impl<'r, R: BoundarySessionResolver<H>, H: HostTypes> ResolvedBoundarySession<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: BoundarySessionHandle<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) -> BoundarySessionHandle<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<&BoundarySessionRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: BoundarySessionResolver<H>, H: HostTypes> crate::user::state::Session<H>
    for ResolvedBoundarySession<'r, R, H>
{
    type Context = crate::user::state::NullContext<H>;
    fn session_bindings(&self) -> &Self::Context {
        &<crate::user::state::NullContext<H>>::ABSENT
    }
    fn session_queries(&self) -> u64 {
        0
    }
}
impl<'r, R: BoundarySessionResolver<H>, H: HostTypes> BoundarySession<H>
    for ResolvedBoundarySession<'r, R, H>
{
    type IOBoundary = NullIOBoundary<H>;
    fn session_boundaries(&self) -> &[Self::IOBoundary] {
        &[]
    }
    fn crossing_count(&self) -> u64 {
        match &self.record {
            Some(r) => r.crossing_count,
            None => 0,
        }
    }
}