uor-foundation 0.4.5

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

//! `query/` namespace — Information extraction queries. Users initiate queries; the kernel resolves them against the ring substrate..
//!
//! Space: Bridge

use crate::enums::TriadProjection;
use crate::HostTypes;

/// A request for information from the UOR kernel. The root abstraction for all query types.
pub trait Query<H: HostTypes> {
    /// The type of input the query accepts.
    fn input_type(&self) -> &H::HostString;
    /// The type of output the query produces.
    fn output_type(&self) -> &H::HostString;
}

/// A query for the ring-coordinate position of a datum: its stratum, spectrum, and address within the ring geometry.
pub trait CoordinateQuery<H: HostTypes>: Query<H> {
    /// The typed coordinate kind this query extracts. Replaces the string-valued query:coordinate property with a typed reference to a TriadProjection individual.
    fn has_triad_projection(&self) -> TriadProjection;
}

/// A query for a metric value between two datums: ring distance, Hamming distance, or their divergence (curvature).
pub trait MetricQuery<H: HostTypes>: Query<H> {}

/// A query for the canonical representation of a datum or term: its normal form under the active resolver strategy.
pub trait RepresentationQuery<H: HostTypes>: Query<H> {}

/// A Query with a known source address, a typed relation constraint, and an open target partition:FreeRank. Represents any question of the form: given this source symbol and relation type, what is the target? The relation type is read from the observable coordinate triple (d_R, d_H, d_I) — not externally supplied. Applies across NLP, ARC-AGI grids, music, images, sensor streams, and logical formulae.
pub trait RelationQuery<H: HostTypes>: Query<H> {
    /// Associated type for `Element`.
    type Element: crate::kernel::address::Element<H>;
    /// The ring address of the grounded source symbol.
    fn source_address(&self) -> &Self::Element;
    /// Associated type for `Constraint`.
    type Constraint: crate::user::type_::Constraint<H>;
    /// The transformation type, expressed as a type:Conjunction composed from the primitive BoundConstraint basis. At inference time this is the output of an observable coordinate read on example pairs — computed from (d_R, d_H, d_I). Not an externally supplied input; read from the representation space.
    fn relation_type(&self) -> &Self::Constraint;
    /// Associated type for `FreeRank`.
    type FreeRank: crate::bridge::partition::FreeRank<H>;
    /// The open site budget for the unknown target. Begins fully free; closes to isClosed = true upon resolution.
    fn target_site(&self) -> &Self::FreeRank;
    /// Associated type for `GroundingMap`.
    type GroundingMap: crate::user::morphism::GroundingMap<H>;
    /// The GroundingMap that resolved the source symbol to its ring address.
    fn grounding_map(&self) -> &Self::GroundingMap;
    /// Associated type for `ProjectionMap`.
    type ProjectionMap: crate::user::morphism::ProjectionMap<H>;
    /// The ProjectionMap that will render the resolved address neighbourhood back to surface symbols.
    fn projection_map(&self) -> &Self::ProjectionMap;
    /// Associated type for `Context`.
    type Context: crate::user::state::Context<H>;
    /// Accumulated session state carrying all state:Binding instances produced by prior queries. Each binding records a resolved address, its datum, and the type under which it was resolved. Prior bindings monotonically reduce the free site space for subsequent queries.
    fn session_context(&self) -> &Self::Context;
}

/// A RelationQuery that explicitly declares its session membership, allowing the conformance suite to validate session-scoped site reduction across multi-turn Prism deployments.
pub trait SessionQuery<H: HostTypes>: RelationQuery<H> {
    /// Associated type for `Session`.
    type Session: crate::user::state::Session<H>;
    /// The session this query belongs to.
    fn session_membership(&self) -> &Self::Session;
}

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

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

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

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

/// Phase 2 (orphan-closure) — resolver-absent default impl of `RelationQuery<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 NullRelationQuery<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullRelationQuery<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullRelationQuery<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullRelationQuery<H> = NullRelationQuery {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> Query<H> for NullRelationQuery<H> {
    fn input_type(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn output_type(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
}
impl<H: HostTypes> RelationQuery<H> for NullRelationQuery<H> {
    type Element = crate::kernel::address::NullElement<H>;
    fn source_address(&self) -> &Self::Element {
        &<crate::kernel::address::NullElement<H>>::ABSENT
    }
    type Constraint = crate::user::type_::NullConstraint<H>;
    fn relation_type(&self) -> &Self::Constraint {
        &<crate::user::type_::NullConstraint<H>>::ABSENT
    }
    type FreeRank = crate::bridge::partition::NullFreeRank<H>;
    fn target_site(&self) -> &Self::FreeRank {
        &<crate::bridge::partition::NullFreeRank<H>>::ABSENT
    }
    type GroundingMap = crate::user::morphism::NullGroundingMap<H>;
    fn grounding_map(&self) -> &Self::GroundingMap {
        &<crate::user::morphism::NullGroundingMap<H>>::ABSENT
    }
    type ProjectionMap = crate::user::morphism::NullProjectionMap<H>;
    fn projection_map(&self) -> &Self::ProjectionMap {
        &<crate::user::morphism::NullProjectionMap<H>>::ABSENT
    }
    type Context = crate::user::state::NullContext<H>;
    fn session_context(&self) -> &Self::Context {
        &<crate::user::state::NullContext<H>>::ABSENT
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `SessionQuery<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 NullSessionQuery<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullSessionQuery<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullSessionQuery<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullSessionQuery<H> = NullSessionQuery {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> Query<H> for NullSessionQuery<H> {
    fn input_type(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn output_type(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
}
impl<H: HostTypes> RelationQuery<H> for NullSessionQuery<H> {
    type Element = crate::kernel::address::NullElement<H>;
    fn source_address(&self) -> &Self::Element {
        &<crate::kernel::address::NullElement<H>>::ABSENT
    }
    type Constraint = crate::user::type_::NullConstraint<H>;
    fn relation_type(&self) -> &Self::Constraint {
        &<crate::user::type_::NullConstraint<H>>::ABSENT
    }
    type FreeRank = crate::bridge::partition::NullFreeRank<H>;
    fn target_site(&self) -> &Self::FreeRank {
        &<crate::bridge::partition::NullFreeRank<H>>::ABSENT
    }
    type GroundingMap = crate::user::morphism::NullGroundingMap<H>;
    fn grounding_map(&self) -> &Self::GroundingMap {
        &<crate::user::morphism::NullGroundingMap<H>>::ABSENT
    }
    type ProjectionMap = crate::user::morphism::NullProjectionMap<H>;
    fn projection_map(&self) -> &Self::ProjectionMap {
        &<crate::user::morphism::NullProjectionMap<H>>::ABSENT
    }
    type Context = crate::user::state::NullContext<H>;
    fn session_context(&self) -> &Self::Context {
        &<crate::user::state::NullContext<H>>::ABSENT
    }
}
impl<H: HostTypes> SessionQuery<H> for NullSessionQuery<H> {
    type Session = crate::user::state::NullSession<H>;
    fn session_membership(&self) -> &Self::Session {
        &<crate::user::state::NullSession<H>>::ABSENT
    }
}

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

/// Phase 8 (orphan-closure) — typed record for `Query<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 QueryRecord<H: HostTypes> {
    pub input_type: &'static H::HostString,
    pub output_type: &'static H::HostString,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `Query<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 ResolvedQuery<'r, R: QueryResolver<H>, H: HostTypes> {
    handle: QueryHandle<H>,
    resolver: &'r R,
    record: Option<QueryRecord<H>>,
}
impl<'r, R: QueryResolver<H>, H: HostTypes> ResolvedQuery<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: QueryHandle<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) -> QueryHandle<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<&QueryRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: QueryResolver<H>, H: HostTypes> Query<H> for ResolvedQuery<'r, R, H> {
    fn input_type(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn output_type(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `CoordinateQuery<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 ResolvedCoordinateQuery<'r, R: CoordinateQueryResolver<H>, H: HostTypes> {
    handle: CoordinateQueryHandle<H>,
    resolver: &'r R,
    record: Option<CoordinateQueryRecord<H>>,
}
impl<'r, R: CoordinateQueryResolver<H>, H: HostTypes> ResolvedCoordinateQuery<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: CoordinateQueryHandle<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) -> CoordinateQueryHandle<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<&CoordinateQueryRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: CoordinateQueryResolver<H>, H: HostTypes> Query<H>
    for ResolvedCoordinateQuery<'r, R, H>
{
    fn input_type(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn output_type(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
}
impl<'r, R: CoordinateQueryResolver<H>, H: HostTypes> CoordinateQuery<H>
    for ResolvedCoordinateQuery<'r, R, H>
{
    fn has_triad_projection(&self) -> TriadProjection {
        match &self.record {
            Some(r) => r.has_triad_projection,
            None => <TriadProjection>::default(),
        }
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `MetricQuery<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 ResolvedMetricQuery<'r, R: MetricQueryResolver<H>, H: HostTypes> {
    handle: MetricQueryHandle<H>,
    resolver: &'r R,
    record: Option<MetricQueryRecord<H>>,
}
impl<'r, R: MetricQueryResolver<H>, H: HostTypes> ResolvedMetricQuery<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: MetricQueryHandle<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) -> MetricQueryHandle<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<&MetricQueryRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: MetricQueryResolver<H>, H: HostTypes> Query<H> for ResolvedMetricQuery<'r, R, H> {
    fn input_type(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn output_type(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
}
impl<'r, R: MetricQueryResolver<H>, H: HostTypes> MetricQuery<H> for ResolvedMetricQuery<'r, R, H> {}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `RepresentationQuery<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 ResolvedRepresentationQuery<'r, R: RepresentationQueryResolver<H>, H: HostTypes> {
    handle: RepresentationQueryHandle<H>,
    resolver: &'r R,
    record: Option<RepresentationQueryRecord<H>>,
}
impl<'r, R: RepresentationQueryResolver<H>, H: HostTypes> ResolvedRepresentationQuery<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: RepresentationQueryHandle<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) -> RepresentationQueryHandle<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<&RepresentationQueryRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: RepresentationQueryResolver<H>, H: HostTypes> Query<H>
    for ResolvedRepresentationQuery<'r, R, H>
{
    fn input_type(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn output_type(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
}
impl<'r, R: RepresentationQueryResolver<H>, H: HostTypes> RepresentationQuery<H>
    for ResolvedRepresentationQuery<'r, R, H>
{
}

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

/// Phase 8 (orphan-closure) — typed record for `RelationQuery<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 RelationQueryRecord<H: HostTypes> {
    pub source_address_handle: crate::kernel::address::ElementHandle<H>,
    pub relation_type_handle: crate::user::type_::ConstraintHandle<H>,
    pub target_site_handle: crate::bridge::partition::FreeRankHandle<H>,
    pub grounding_map_handle: crate::user::morphism::GroundingMapHandle<H>,
    pub projection_map_handle: crate::user::morphism::ProjectionMapHandle<H>,
    pub session_context_handle: crate::user::state::ContextHandle<H>,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `RelationQuery<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 ResolvedRelationQuery<'r, R: RelationQueryResolver<H>, H: HostTypes> {
    handle: RelationQueryHandle<H>,
    resolver: &'r R,
    record: Option<RelationQueryRecord<H>>,
}
impl<'r, R: RelationQueryResolver<H>, H: HostTypes> ResolvedRelationQuery<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: RelationQueryHandle<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) -> RelationQueryHandle<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<&RelationQueryRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: RelationQueryResolver<H>, H: HostTypes> Query<H> for ResolvedRelationQuery<'r, R, H> {
    fn input_type(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn output_type(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
}
impl<'r, R: RelationQueryResolver<H>, H: HostTypes> RelationQuery<H>
    for ResolvedRelationQuery<'r, R, H>
{
    type Element = crate::kernel::address::NullElement<H>;
    fn source_address(&self) -> &Self::Element {
        &<crate::kernel::address::NullElement<H>>::ABSENT
    }
    type Constraint = crate::user::type_::NullConstraint<H>;
    fn relation_type(&self) -> &Self::Constraint {
        &<crate::user::type_::NullConstraint<H>>::ABSENT
    }
    type FreeRank = crate::bridge::partition::NullFreeRank<H>;
    fn target_site(&self) -> &Self::FreeRank {
        &<crate::bridge::partition::NullFreeRank<H>>::ABSENT
    }
    type GroundingMap = crate::user::morphism::NullGroundingMap<H>;
    fn grounding_map(&self) -> &Self::GroundingMap {
        &<crate::user::morphism::NullGroundingMap<H>>::ABSENT
    }
    type ProjectionMap = crate::user::morphism::NullProjectionMap<H>;
    fn projection_map(&self) -> &Self::ProjectionMap {
        &<crate::user::morphism::NullProjectionMap<H>>::ABSENT
    }
    type Context = crate::user::state::NullContext<H>;
    fn session_context(&self) -> &Self::Context {
        &<crate::user::state::NullContext<H>>::ABSENT
    }
}
impl<'r, R: RelationQueryResolver<H>, H: HostTypes> ResolvedRelationQuery<'r, R, H> {
    /// Promote the `source_address` 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_address<'r2, R2: crate::kernel::address::ElementResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::kernel::address::ResolvedElement<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::kernel::address::ResolvedElement::new(
            record.source_address_handle,
            r,
        ))
    }
    /// Promote the `relation_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_relation_type<'r2, R2: crate::user::type_::ConstraintResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::user::type_::ResolvedConstraint<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::user::type_::ResolvedConstraint::new(
            record.relation_type_handle,
            r,
        ))
    }
    /// Promote the `target_site` 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_target_site<'r2, R2: crate::bridge::partition::FreeRankResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::bridge::partition::ResolvedFreeRank<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::bridge::partition::ResolvedFreeRank::new(
            record.target_site_handle,
            r,
        ))
    }
    /// Promote the `grounding_map` 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_grounding_map<'r2, R2: crate::user::morphism::GroundingMapResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::user::morphism::ResolvedGroundingMap<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::user::morphism::ResolvedGroundingMap::new(
            record.grounding_map_handle,
            r,
        ))
    }
    /// Promote the `projection_map` 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_projection_map<'r2, R2: crate::user::morphism::ProjectionMapResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::user::morphism::ResolvedProjectionMap<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::user::morphism::ResolvedProjectionMap::new(
            record.projection_map_handle,
            r,
        ))
    }
    /// Promote the `session_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_session_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.session_context_handle,
            r,
        ))
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `SessionQuery<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 ResolvedSessionQuery<'r, R: SessionQueryResolver<H>, H: HostTypes> {
    handle: SessionQueryHandle<H>,
    resolver: &'r R,
    record: Option<SessionQueryRecord<H>>,
}
impl<'r, R: SessionQueryResolver<H>, H: HostTypes> ResolvedSessionQuery<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: SessionQueryHandle<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) -> SessionQueryHandle<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<&SessionQueryRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: SessionQueryResolver<H>, H: HostTypes> Query<H> for ResolvedSessionQuery<'r, R, H> {
    fn input_type(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn output_type(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
}
impl<'r, R: SessionQueryResolver<H>, H: HostTypes> RelationQuery<H>
    for ResolvedSessionQuery<'r, R, H>
{
    type Element = crate::kernel::address::NullElement<H>;
    fn source_address(&self) -> &Self::Element {
        &<crate::kernel::address::NullElement<H>>::ABSENT
    }
    type Constraint = crate::user::type_::NullConstraint<H>;
    fn relation_type(&self) -> &Self::Constraint {
        &<crate::user::type_::NullConstraint<H>>::ABSENT
    }
    type FreeRank = crate::bridge::partition::NullFreeRank<H>;
    fn target_site(&self) -> &Self::FreeRank {
        &<crate::bridge::partition::NullFreeRank<H>>::ABSENT
    }
    type GroundingMap = crate::user::morphism::NullGroundingMap<H>;
    fn grounding_map(&self) -> &Self::GroundingMap {
        &<crate::user::morphism::NullGroundingMap<H>>::ABSENT
    }
    type ProjectionMap = crate::user::morphism::NullProjectionMap<H>;
    fn projection_map(&self) -> &Self::ProjectionMap {
        &<crate::user::morphism::NullProjectionMap<H>>::ABSENT
    }
    type Context = crate::user::state::NullContext<H>;
    fn session_context(&self) -> &Self::Context {
        &<crate::user::state::NullContext<H>>::ABSENT
    }
}
impl<'r, R: SessionQueryResolver<H>, H: HostTypes> SessionQuery<H>
    for ResolvedSessionQuery<'r, R, H>
{
    type Session = crate::user::state::NullSession<H>;
    fn session_membership(&self) -> &Self::Session {
        &<crate::user::state::NullSession<H>>::ABSENT
    }
}
impl<'r, R: SessionQueryResolver<H>, H: HostTypes> ResolvedSessionQuery<'r, R, H> {
    /// Promote the `session_membership` 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_session_membership<'r2, R2: crate::user::state::SessionResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::user::state::ResolvedSession<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::user::state::ResolvedSession::new(
            record.session_membership_handle,
            r,
        ))
    }
}

/// The stratum coordinate: the layer position of a datum within the ring's stratification.
pub mod two_adic_valuation {}

/// The spectrum coordinate: the spectral decomposition of a datum under the ring's Fourier analysis.
pub mod walsh_hadamard_image {}

/// The address coordinate: the content-addressable position of a datum in the Braille glyph encoding. Renamed from RingElement in v0.2.2 W8 to unify vocabulary with the schema:Triad bundling properties.
pub mod address {}