uor-foundation 0.4.5

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

//! `homology/` namespace — Simplicial complexes, chain complexes, boundary operators, and homology groups for structural reasoning..
//!
//! Space: Bridge

use crate::HostTypes;

/// A k-simplex: a finite set of k+1 vertices drawn from constraint objects.
pub trait Simplex<H: HostTypes> {
    /// The dimension k of a simplex (number of vertices minus one).
    fn dimension(&self) -> i64;
    /// Associated type for `Constraint`.
    type Constraint: crate::user::type_::Constraint<H>;
    /// A vertex of this simplex, drawn from the set of constraint objects.
    fn vertex(&self) -> &[Self::Constraint];
    /// The number of vertices in this simplex (dimension + 1).
    fn vertex_count(&self) -> u64;
    /// Associated type for `Simplex`.
    type SimplexTarget: Simplex<H>;
    /// Indicates that this simplex is a face of another simplex.
    fn is_face_of(&self) -> &[Self::SimplexTarget];
    /// Associated type for `SiteIndex`.
    type SiteIndex: crate::bridge::partition::SiteIndex<H>;
    /// A site coordinate in the partition whose intersection pins this simplex.
    fn pin_intersection(&self) -> &[Self::SiteIndex];
}

/// A simplicial complex: a set of simplices closed under taking faces.
pub trait SimplicialComplex<H: HostTypes> {
    /// Associated type for `Simplex`.
    type Simplex: Simplex<H>;
    /// A simplex belonging to this simplicial complex.
    fn has_simplex(&self) -> &[Self::Simplex];
    /// The maximum dimension of any simplex in this simplicial complex.
    fn max_dimension(&self) -> i64;
    /// The Euler characteristic of this simplicial complex: the alternating sum of simplex counts by dimension.
    fn euler_characteristic(&self) -> i64;
    /// The total number of vertices (0-simplices) in this simplicial complex.
    fn simplicial_vertex_count(&self) -> u64;
}

/// A face map d_i: removes vertex i from a simplex, producing a face.
pub trait FaceMap<H: HostTypes> {
    /// The index i of the vertex removed by this face map d_i.
    fn removes_vertex(&self) -> u64;
    /// Associated type for `Simplex`.
    type Simplex: Simplex<H>;
    /// The source simplex of this face map.
    fn source_simplex(&self) -> &Self::Simplex;
    /// The target face (result simplex) of this face map.
    fn target_face(&self) -> &Self::Simplex;
}

/// A free abelian group generated by k-simplices (the k-th chain group C_k).
pub trait ChainGroup<H: HostTypes> {
    /// The degree k of this chain group (the dimension of its generating simplices).
    fn degree(&self) -> i64;
    /// Associated type for `Simplex`.
    type Simplex: Simplex<H>;
    /// A simplex that generates this chain group.
    fn generated_by(&self) -> &[Self::Simplex];
}

/// The boundary operator ∂_k: C_k → C_{k-1}. Satisfies ∂² = 0.
pub trait BoundaryOperator<H: HostTypes> {
    /// Associated type for `ChainGroup`.
    type ChainGroup: ChainGroup<H>;
    /// The source chain group C_k of this boundary operator.
    fn source_group(&self) -> &Self::ChainGroup;
    /// The target chain group C_{k-1} of this boundary operator.
    fn target_group(&self) -> &Self::ChainGroup;
    /// Whether this boundary operator satisfies the fundamental property ∂² = 0.
    fn satisfies_boundary_squared_zero(&self) -> bool;
}

/// A chain complex: a sequence of chain groups connected by boundary operators.
pub trait ChainComplex<H: HostTypes> {
    /// Associated type for `ChainGroup`.
    type ChainGroup: ChainGroup<H>;
    /// A chain group belonging to this chain complex.
    fn has_chain_group(&self) -> &[Self::ChainGroup];
    /// Associated type for `BoundaryOperator`.
    type BoundaryOperator: BoundaryOperator<H>;
    /// A boundary operator belonging to this chain complex.
    fn has_boundary(&self) -> &[Self::BoundaryOperator];
}

/// The k-th homology group H_k = ker(∂_k) / im(∂_{k+1}). Measures k-dimensional holes.
pub trait HomologyGroup<H: HostTypes> {
    /// The degree k of this homology group H_k.
    fn homology_degree(&self) -> i64;
    /// The Betti number β_k = rank(H_k): the rank of this homology group.
    fn betti_number(&self) -> u64;
}

/// The nerve functor N: maps a set of constraints to a simplicial complex.
pub trait NerveFunctor<H: HostTypes> {}

/// The chain functor C: maps a simplicial complex to a chain complex.
pub trait ChainFunctor<H: HostTypes> {}

/// A simplicial set satisfying the Kan extension condition. The constraint nerve, when promoted from a SimplicialComplex to a KanComplex, carries a full homotopy type — not just its homology groups.
pub trait KanComplex<H: HostTypes>: SimplicialComplex<H> {
    /// Associated type for `HornFiller`.
    type HornFiller: HornFiller<H>;
    /// A horn filler witnessing the Kan condition for this complex.
    fn kan_witness(&self) -> &[Self::HornFiller];
}

/// A witness that a given horn (an incomplete simplex boundary) can be filled, certifying the Kan condition at a specific dimension and position.
pub trait HornFiller<H: HostTypes> {
    /// The dimension of the horn that this filler completes.
    fn horn_dimension(&self) -> u64;
    /// The position (missing face index) of the horn that this filler completes.
    fn horn_position(&self) -> u64;
}

/// The k-th Postnikov truncation τ≤k of the constraint nerve: a KanComplex whose homotopy groups πj vanish for j > k.
pub trait PostnikovTruncation<H: HostTypes> {
    /// The truncation level k of this Postnikov truncation τ≤k.
    fn truncation_level(&self) -> u64;
    /// Associated type for `KanComplex`.
    type KanComplex: KanComplex<H>;
    /// The KanComplex from which this Postnikov truncation is derived.
    fn truncation_source(&self) -> &Self::KanComplex;
    /// Associated type for `KInvariant`.
    type KInvariant: KInvariant<H>;
    /// The k-invariant classifying the extension at this truncation level.
    fn k_invariant(&self) -> &Self::KInvariant;
}

/// The k-invariant κk that classifies the extension from the (k−1)-truncation to the k-truncation of the Postnikov tower. Trivial κk means the truncation splits as a product.
pub trait KInvariant<H: HostTypes> {
    /// True iff this k-invariant is trivial, meaning the Postnikov truncation splits as a product.
    fn k_invariant_trivial(&self) -> bool;
}

/// The deformation complex of a CompleteType T: a chain complex whose H⁰ = automorphisms, H¹ = first-order deformations, H² = obstructions to extending deformations.
pub trait DeformationComplex<H: HostTypes>: ChainComplex<H> {
    /// Associated type for `CompleteType`.
    type CompleteType: crate::user::type_::CompleteType<H>;
    /// The CompleteType whose deformation complex this is.
    fn deformation_base(&self) -> &Self::CompleteType;
    /// The dimension of the tangent space H¹(Def(T)): the number of first-order deformations.
    fn tangent_dimension(&self) -> u64;
    /// The dimension of the obstruction space H²(Def(T)): the number of independent obstructions to extending deformations.
    fn obstruction_dimension(&self) -> u64;
}

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

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

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

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

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

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

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

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

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

/// Phase 2 (orphan-closure) — resolver-absent default impl of `KanComplex<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 NullKanComplex<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullKanComplex<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullKanComplex<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullKanComplex<H> = NullKanComplex {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> SimplicialComplex<H> for NullKanComplex<H> {
    type Simplex = NullSimplex<H>;
    fn has_simplex(&self) -> &[Self::Simplex] {
        &[]
    }
    fn max_dimension(&self) -> i64 {
        0
    }
    fn euler_characteristic(&self) -> i64 {
        0
    }
    fn simplicial_vertex_count(&self) -> u64 {
        0
    }
}
impl<H: HostTypes> KanComplex<H> for NullKanComplex<H> {
    type HornFiller = NullHornFiller<H>;
    fn kan_witness(&self) -> &[Self::HornFiller] {
        &[]
    }
}

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

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

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

/// Phase 2 (orphan-closure) — resolver-absent default impl of `DeformationComplex<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 NullDeformationComplex<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullDeformationComplex<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullDeformationComplex<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullDeformationComplex<H> = NullDeformationComplex {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> ChainComplex<H> for NullDeformationComplex<H> {
    type ChainGroup = NullChainGroup<H>;
    fn has_chain_group(&self) -> &[Self::ChainGroup] {
        &[]
    }
    type BoundaryOperator = NullBoundaryOperator<H>;
    fn has_boundary(&self) -> &[Self::BoundaryOperator] {
        &[]
    }
}
impl<H: HostTypes> DeformationComplex<H> for NullDeformationComplex<H> {
    type CompleteType = crate::user::type_::NullCompleteType<H>;
    fn deformation_base(&self) -> &Self::CompleteType {
        &<crate::user::type_::NullCompleteType<H>>::ABSENT
    }
    fn tangent_dimension(&self) -> u64 {
        0
    }
    fn obstruction_dimension(&self) -> u64 {
        0
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `Simplex<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 ResolvedSimplex<'r, R: SimplexResolver<H>, H: HostTypes> {
    handle: SimplexHandle<H>,
    resolver: &'r R,
    record: Option<SimplexRecord<H>>,
}
impl<'r, R: SimplexResolver<H>, H: HostTypes> ResolvedSimplex<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: SimplexHandle<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) -> SimplexHandle<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<&SimplexRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: SimplexResolver<H>, H: HostTypes> Simplex<H> for ResolvedSimplex<'r, R, H> {
    fn dimension(&self) -> i64 {
        match &self.record {
            Some(r) => r.dimension,
            None => 0,
        }
    }
    type Constraint = crate::user::type_::NullConstraint<H>;
    fn vertex(&self) -> &[Self::Constraint] {
        &[]
    }
    fn vertex_count(&self) -> u64 {
        match &self.record {
            Some(r) => r.vertex_count,
            None => 0,
        }
    }
    type SimplexTarget = NullSimplex<H>;
    fn is_face_of(&self) -> &[Self::SimplexTarget] {
        &[]
    }
    type SiteIndex = crate::bridge::partition::NullSiteIndex<H>;
    fn pin_intersection(&self) -> &[Self::SiteIndex] {
        &[]
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `SimplicialComplex<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 ResolvedSimplicialComplex<'r, R: SimplicialComplexResolver<H>, H: HostTypes> {
    handle: SimplicialComplexHandle<H>,
    resolver: &'r R,
    record: Option<SimplicialComplexRecord<H>>,
}
impl<'r, R: SimplicialComplexResolver<H>, H: HostTypes> ResolvedSimplicialComplex<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: SimplicialComplexHandle<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) -> SimplicialComplexHandle<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<&SimplicialComplexRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: SimplicialComplexResolver<H>, H: HostTypes> SimplicialComplex<H>
    for ResolvedSimplicialComplex<'r, R, H>
{
    type Simplex = NullSimplex<H>;
    fn has_simplex(&self) -> &[Self::Simplex] {
        &[]
    }
    fn max_dimension(&self) -> i64 {
        match &self.record {
            Some(r) => r.max_dimension,
            None => 0,
        }
    }
    fn euler_characteristic(&self) -> i64 {
        match &self.record {
            Some(r) => r.euler_characteristic,
            None => 0,
        }
    }
    fn simplicial_vertex_count(&self) -> u64 {
        match &self.record {
            Some(r) => r.simplicial_vertex_count,
            None => 0,
        }
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `FaceMap<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 ResolvedFaceMap<'r, R: FaceMapResolver<H>, H: HostTypes> {
    handle: FaceMapHandle<H>,
    resolver: &'r R,
    record: Option<FaceMapRecord<H>>,
}
impl<'r, R: FaceMapResolver<H>, H: HostTypes> ResolvedFaceMap<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: FaceMapHandle<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) -> FaceMapHandle<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<&FaceMapRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: FaceMapResolver<H>, H: HostTypes> FaceMap<H> for ResolvedFaceMap<'r, R, H> {
    fn removes_vertex(&self) -> u64 {
        match &self.record {
            Some(r) => r.removes_vertex,
            None => 0,
        }
    }
    type Simplex = NullSimplex<H>;
    fn source_simplex(&self) -> &Self::Simplex {
        &<NullSimplex<H>>::ABSENT
    }
    fn target_face(&self) -> &Self::Simplex {
        &<NullSimplex<H>>::ABSENT
    }
}
impl<'r, R: FaceMapResolver<H>, H: HostTypes> ResolvedFaceMap<'r, R, H> {
    /// Promote the `source_simplex` 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_simplex<'r2, R2: SimplexResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedSimplex<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedSimplex::new(record.source_simplex_handle, r))
    }
    /// Promote the `target_face` 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_face<'r2, R2: SimplexResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedSimplex<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedSimplex::new(record.target_face_handle, r))
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `ChainGroup<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 ResolvedChainGroup<'r, R: ChainGroupResolver<H>, H: HostTypes> {
    handle: ChainGroupHandle<H>,
    resolver: &'r R,
    record: Option<ChainGroupRecord<H>>,
}
impl<'r, R: ChainGroupResolver<H>, H: HostTypes> ResolvedChainGroup<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: ChainGroupHandle<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) -> ChainGroupHandle<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<&ChainGroupRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: ChainGroupResolver<H>, H: HostTypes> ChainGroup<H> for ResolvedChainGroup<'r, R, H> {
    fn degree(&self) -> i64 {
        match &self.record {
            Some(r) => r.degree,
            None => 0,
        }
    }
    type Simplex = NullSimplex<H>;
    fn generated_by(&self) -> &[Self::Simplex] {
        &[]
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `BoundaryOperator<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 ResolvedBoundaryOperator<'r, R: BoundaryOperatorResolver<H>, H: HostTypes> {
    handle: BoundaryOperatorHandle<H>,
    resolver: &'r R,
    record: Option<BoundaryOperatorRecord<H>>,
}
impl<'r, R: BoundaryOperatorResolver<H>, H: HostTypes> ResolvedBoundaryOperator<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: BoundaryOperatorHandle<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) -> BoundaryOperatorHandle<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<&BoundaryOperatorRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: BoundaryOperatorResolver<H>, H: HostTypes> BoundaryOperator<H>
    for ResolvedBoundaryOperator<'r, R, H>
{
    type ChainGroup = NullChainGroup<H>;
    fn source_group(&self) -> &Self::ChainGroup {
        &<NullChainGroup<H>>::ABSENT
    }
    fn target_group(&self) -> &Self::ChainGroup {
        &<NullChainGroup<H>>::ABSENT
    }
    fn satisfies_boundary_squared_zero(&self) -> bool {
        match &self.record {
            Some(r) => r.satisfies_boundary_squared_zero,
            None => false,
        }
    }
}
impl<'r, R: BoundaryOperatorResolver<H>, H: HostTypes> ResolvedBoundaryOperator<'r, R, H> {
    /// Promote the `source_group` 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_group<'r2, R2: ChainGroupResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedChainGroup<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedChainGroup::new(record.source_group_handle, r))
    }
    /// Promote the `target_group` 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_group<'r2, R2: ChainGroupResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedChainGroup<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedChainGroup::new(record.target_group_handle, r))
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `ChainComplex<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 ResolvedChainComplex<'r, R: ChainComplexResolver<H>, H: HostTypes> {
    handle: ChainComplexHandle<H>,
    resolver: &'r R,
    record: Option<ChainComplexRecord<H>>,
}
impl<'r, R: ChainComplexResolver<H>, H: HostTypes> ResolvedChainComplex<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: ChainComplexHandle<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) -> ChainComplexHandle<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<&ChainComplexRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: ChainComplexResolver<H>, H: HostTypes> ChainComplex<H>
    for ResolvedChainComplex<'r, R, H>
{
    type ChainGroup = NullChainGroup<H>;
    fn has_chain_group(&self) -> &[Self::ChainGroup] {
        &[]
    }
    type BoundaryOperator = NullBoundaryOperator<H>;
    fn has_boundary(&self) -> &[Self::BoundaryOperator] {
        &[]
    }
}

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

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

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

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

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

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

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

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

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

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `KanComplex<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 ResolvedKanComplex<'r, R: KanComplexResolver<H>, H: HostTypes> {
    handle: KanComplexHandle<H>,
    resolver: &'r R,
    record: Option<KanComplexRecord<H>>,
}
impl<'r, R: KanComplexResolver<H>, H: HostTypes> ResolvedKanComplex<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: KanComplexHandle<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) -> KanComplexHandle<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<&KanComplexRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: KanComplexResolver<H>, H: HostTypes> SimplicialComplex<H>
    for ResolvedKanComplex<'r, R, H>
{
    type Simplex = NullSimplex<H>;
    fn has_simplex(&self) -> &[Self::Simplex] {
        &[]
    }
    fn max_dimension(&self) -> i64 {
        0
    }
    fn euler_characteristic(&self) -> i64 {
        0
    }
    fn simplicial_vertex_count(&self) -> u64 {
        0
    }
}
impl<'r, R: KanComplexResolver<H>, H: HostTypes> KanComplex<H> for ResolvedKanComplex<'r, R, H> {
    type HornFiller = NullHornFiller<H>;
    fn kan_witness(&self) -> &[Self::HornFiller] {
        &[]
    }
}

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

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

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

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

/// Phase 8 (orphan-closure) — typed record for `PostnikovTruncation<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 PostnikovTruncationRecord<H: HostTypes> {
    pub truncation_level: u64,
    pub truncation_source_handle: KanComplexHandle<H>,
    pub k_invariant_handle: KInvariantHandle<H>,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `PostnikovTruncation<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 ResolvedPostnikovTruncation<'r, R: PostnikovTruncationResolver<H>, H: HostTypes> {
    handle: PostnikovTruncationHandle<H>,
    resolver: &'r R,
    record: Option<PostnikovTruncationRecord<H>>,
}
impl<'r, R: PostnikovTruncationResolver<H>, H: HostTypes> ResolvedPostnikovTruncation<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: PostnikovTruncationHandle<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) -> PostnikovTruncationHandle<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<&PostnikovTruncationRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: PostnikovTruncationResolver<H>, H: HostTypes> PostnikovTruncation<H>
    for ResolvedPostnikovTruncation<'r, R, H>
{
    fn truncation_level(&self) -> u64 {
        match &self.record {
            Some(r) => r.truncation_level,
            None => 0,
        }
    }
    type KanComplex = NullKanComplex<H>;
    fn truncation_source(&self) -> &Self::KanComplex {
        &<NullKanComplex<H>>::ABSENT
    }
    type KInvariant = NullKInvariant<H>;
    fn k_invariant(&self) -> &Self::KInvariant {
        &<NullKInvariant<H>>::ABSENT
    }
}
impl<'r, R: PostnikovTruncationResolver<H>, H: HostTypes> ResolvedPostnikovTruncation<'r, R, H> {
    /// Promote the `truncation_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_truncation_source<'r2, R2: KanComplexResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedKanComplex<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedKanComplex::new(record.truncation_source_handle, r))
    }
    /// Promote the `k_invariant` 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_k_invariant<'r2, R2: KInvariantResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedKInvariant<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedKInvariant::new(record.k_invariant_handle, r))
    }
}

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

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

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

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

/// Phase 8 (orphan-closure) — typed record for `DeformationComplex<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 DeformationComplexRecord<H: HostTypes> {
    pub deformation_base_handle: crate::user::type_::CompleteTypeHandle<H>,
    pub tangent_dimension: u64,
    pub obstruction_dimension: u64,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `DeformationComplex<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 ResolvedDeformationComplex<'r, R: DeformationComplexResolver<H>, H: HostTypes> {
    handle: DeformationComplexHandle<H>,
    resolver: &'r R,
    record: Option<DeformationComplexRecord<H>>,
}
impl<'r, R: DeformationComplexResolver<H>, H: HostTypes> ResolvedDeformationComplex<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: DeformationComplexHandle<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) -> DeformationComplexHandle<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<&DeformationComplexRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: DeformationComplexResolver<H>, H: HostTypes> ChainComplex<H>
    for ResolvedDeformationComplex<'r, R, H>
{
    type ChainGroup = NullChainGroup<H>;
    fn has_chain_group(&self) -> &[Self::ChainGroup] {
        &[]
    }
    type BoundaryOperator = NullBoundaryOperator<H>;
    fn has_boundary(&self) -> &[Self::BoundaryOperator] {
        &[]
    }
}
impl<'r, R: DeformationComplexResolver<H>, H: HostTypes> DeformationComplex<H>
    for ResolvedDeformationComplex<'r, R, H>
{
    type CompleteType = crate::user::type_::NullCompleteType<H>;
    fn deformation_base(&self) -> &Self::CompleteType {
        &<crate::user::type_::NullCompleteType<H>>::ABSENT
    }
    fn tangent_dimension(&self) -> u64 {
        match &self.record {
            Some(r) => r.tangent_dimension,
            None => 0,
        }
    }
    fn obstruction_dimension(&self) -> u64 {
        match &self.record {
            Some(r) => r.obstruction_dimension,
            None => 0,
        }
    }
}
impl<'r, R: DeformationComplexResolver<H>, H: HostTypes> ResolvedDeformationComplex<'r, R, H> {
    /// Promote the `deformation_base` 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_deformation_base<'r2, R2: crate::user::type_::CompleteTypeResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::user::type_::ResolvedCompleteType<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::user::type_::ResolvedCompleteType::new(
            record.deformation_base_handle,
            r,
        ))
    }
}

/// ∂² = 0: the boundary of a boundary is zero.
pub mod boundary_squared_zero {
    /// `forAll` -> `term_boundarySquaredZero_forAll`
    pub const FOR_ALL: &str = "https://uor.foundation/schema/term_boundarySquaredZero_forAll";
    /// `lhs` -> `term_boundarySquaredZero_lhs`
    pub const LHS: &str = "https://uor.foundation/schema/term_boundarySquaredZero_lhs";
    /// `rhs` -> `term_boundarySquaredZero_rhs`
    pub const RHS: &str = "https://uor.foundation/schema/term_boundarySquaredZero_rhs";
    /// `verificationDomain` -> `Topological`
    pub const VERIFICATION_DOMAIN: &str = "https://uor.foundation/op/Topological";
}

/// The nerve functor N: constraints → simplicial complex.
pub mod nerve_functor_n {}

/// The chain functor C: simplicial complex → chain complex.
pub mod chain_functor_c {}

/// ψ_4: HomologyGroups → BettiNumbers (extraction functor).
pub mod psi_4 {
    /// `forAll` -> `term_psi_4_forAll`
    pub const FOR_ALL: &str = "https://uor.foundation/schema/term_psi_4_forAll";
    /// `lhs` -> `term_psi_4_lhs`
    pub const LHS: &str = "https://uor.foundation/schema/term_psi_4_lhs";
    /// `rhs` -> `term_psi_4_rhs`
    pub const RHS: &str = "https://uor.foundation/schema/term_psi_4_rhs";
    /// `verificationDomain` -> `Topological`
    pub const VERIFICATION_DOMAIN: &str = "https://uor.foundation/op/Topological";
}

/// Index bridge: connects Euler characteristic to alternating Betti sum.
pub mod index_bridge {
    /// `forAll` -> `term_indexBridge_forAll`
    pub const FOR_ALL: &str = "https://uor.foundation/schema/term_indexBridge_forAll";
    /// `lhs` -> `term_indexBridge_lhs`
    pub const LHS: &str = "https://uor.foundation/schema/term_indexBridge_lhs";
    /// `rhs` -> `term_indexBridge_rhs`
    pub const RHS: &str = "https://uor.foundation/schema/term_indexBridge_rhs";
    /// `verificationDomain` -> `Topological`
    pub const VERIFICATION_DOMAIN: &str = "https://uor.foundation/op/Topological";
}