uor-foundation 0.4.5

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

//! `morphism/` namespace — Runtime abstractions for maps between UOR objects: transforms, isometries, embeddings, and group actions. The foundation provides the vocabulary; Prism writes the sentences..
//!
//! Space: User

use crate::enums::ProofStrategy;
use crate::HostTypes;

/// A map between UOR objects. The root abstraction: source, target, and optionally what structure (if any) is preserved. This is what cert:TransformCertificate certifies.
/// Disjoint with: CompositionLaw.
pub trait Transform<H: HostTypes> {
    /// The domain of the transform.
    fn source(&self) -> &H::HostString;
    /// The codomain of the transform.
    fn target(&self) -> &H::HostString;
    /// The structure preserved by this transform (if any). E.g., a ring homomorphism preserves addition and multiplication.
    fn preserves_count(&self) -> usize;
    /// Returns the item at `index`. Must satisfy `index < self.preserves_count()`.
    fn preserves_at(&self, index: usize) -> &H::HostString;
    /// Associated type for `ComputationTrace`.
    type ComputationTrace: crate::bridge::trace::ComputationTrace<H>;
    /// The computation trace that realized this transform at runtime. A Transform is an abstraction; a trace is the kernel's record of how it was executed via concrete operations.
    fn trace(&self) -> &Self::ComputationTrace;
    /// Associated type for `Transform`.
    type TransformTarget: Transform<H>;
    /// A transform that this transform can be composed with. The target of this transform must match the source of the composed transform.
    fn composes_with(&self) -> &[Self::TransformTarget];
    /// Associated type for `Identity`.
    type Identity: crate::kernel::op::Identity<H>;
    /// The identity preserved by this transform (reference to the op:Identity that the transform commutes with).
    fn preserved_invariant(&self) -> &Self::Identity;
    /// The OWL class of inputs this transform accepts. Uses OWL2 punning so the value is a class IRI treated as an individual at this position.
    fn input_class(&self) -> &H::HostString;
    /// The OWL class of outputs this transform produces. Uses OWL2 punning.
    fn output_class(&self) -> &H::HostString;
    /// Associated type for `Witness`.
    type Witness: Witness<H>;
    /// Zero or more witness pairs documenting specific input/output bindings of this transform.
    fn has_witness(&self) -> &[Self::Witness];
}

/// A transform that preserves metric structure with respect to a specified metric. In UOR, isometry is metric-relative: neg is a ring isometry, bnot is a Hamming isometry. A transform can be an isometry with respect to one metric but not the other. This is what cert:IsometryCertificate certifies.
/// Disjoint with: Composition.
pub trait Isometry<H: HostTypes>: Transform<H> {
    /// Associated type for `MetricObservable`.
    type MetricObservable: crate::bridge::observable::MetricObservable<H>;
    /// The specific metric this isometry preserves. Points to observable:RingMetric or observable:HammingMetric. A transform that preserves both is an isometry of the full UOR geometry. A transform that preserves one but not the other has nontrivial curvature — observable:CurvatureObservable measures this gap.
    fn preserves_metric(&self) -> &[Self::MetricObservable];
}

/// An injective, structure-preserving transform across quantum levels. The canonical instance is the level embedding ι : R_n → R_{n'} (n < n'), which preserves addition, multiplication, and content addressing.
/// Disjoint with: Composition.
pub trait Embedding<H: HostTypes>: Transform<H> {
    /// The quantum level n of the source ring for an embedding.
    fn source_quantum(&self) -> u64;
    /// The quantum level n' of the target ring for an embedding. Must satisfy n' > n (embeddings go to larger rings).
    fn target_quantum(&self) -> u64;
    /// Certificate that this embedding's addressing diagram commutes: glyph ∘ ι ∘ addresses is well-defined and injective.
    fn address_coherence(&self) -> &Self::Identity;
}

/// The mechanism by which a group applies transforms systematically to a set. Each group element induces a transform of the set. The dihedral action on type space is an action by isometries — every element of D_{2^n} produces an isometric transform of 𝒯_n.
pub trait Action<H: HostTypes> {
    /// Associated type for `Group`.
    type Group: crate::kernel::op::Group<H>;
    /// The group acting in this group action.
    fn group(&self) -> &Self::Group;
    /// The set being acted upon by this group action.
    fn acting_on(&self) -> &H::HostString;
    /// Whether every transform induced by this action is an isometry. True for the dihedral action on 𝒯_n (Frame Theorem).
    fn action_isometry(&self) -> bool;
}

/// A transform formed by composing two or more transforms sequentially. The categorical composition operation that turns transforms into a category.
/// Disjoint with: Isometry, Embedding, Identity.
pub trait Composition<H: HostTypes>: Transform<H> {
    /// Associated type for `Transform`.
    type Transform: Transform<H>;
    /// The transform that results from this composition.
    fn composition_result(&self) -> &Self::Transform;
    /// A component transform of this composition.
    fn composition_components(&self) -> &[Self::Transform];
}

/// The identity transform on a type: maps every element to itself. The categorical identity morphism.
/// Disjoint with: Composition.
pub trait Identity<H: HostTypes>: Transform<H> {
    /// Associated type for `TypeDefinition`.
    type TypeDefinition: crate::user::type_::TypeDefinition<H>;
    /// The type on which this identity transform acts.
    fn identity_on(&self) -> &Self::TypeDefinition;
}

/// A law governing how operations compose. Records whether the composition is associative, commutative, and what the result operation is. The critical composition law (neg ∘ bnot = succ) is the foundational instance.
/// Disjoint with: Transform.
pub trait CompositionLaw<H: HostTypes> {
    /// Whether this composition law is associative.
    fn is_associative(&self) -> bool;
    /// Whether this composition law is commutative.
    fn is_commutative(&self) -> bool;
    /// Associated type for `Operation`.
    type Operation: crate::kernel::op::Operation<H>;
    /// An operation that is a component of this composition law.
    fn law_components(&self) -> &[Self::Operation];
    /// The operation that results from this composition law.
    fn law_result(&self) -> &Self::Operation;
}

/// A Transform mapping a surface symbol (any schema:Literal) to its ring datum (a schema:Datum) via the content-addressing bijection. Typed, derivation-witnessed, constraint-preserving map from surface to coordinate. Applies identically across NLP tokens, ARC-AGI grid cells, MIDI notes, pixels, sensor readings, and logical propositions.
/// Disjoint with: ProjectionMap.
pub trait GroundingMap<H: HostTypes>: Transform<H> {
    /// Associated type for `Derivation`.
    type Derivation: crate::bridge::derivation::Derivation<H>;
    /// The derivation witnessing the content-addressing computation that produced the grounded address from the surface symbol.
    fn grounding_derivation(&self) -> &Self::Derivation;
    /// Associated type for `Constraint`.
    type Constraint: crate::user::type_::Constraint<H>;
    /// A typed attribute preserved by this grounding. Non-functional: one assertion per active constraint axis (vertical, horizontal, diagonal).
    fn symbol_constraints(&self) -> &[Self::Constraint];
}

/// A Transform mapping a resolved partition:Partition (address neighbourhood) to an ordered sequence of surface symbols. Output ordering determined by the active state:Frame — the same constraint frame that decomposed the input symbol sequence.
/// Disjoint with: GroundingMap.
pub trait ProjectionMap<H: HostTypes>: Transform<H> {
    /// Associated type for `Frame`.
    type Frame: crate::user::state::Frame<H>;
    /// The active frame — shared with the grounding that produced the query. The shared-frame condition (Surface Symmetry Theorem) requires G and P to reference the same frame.
    fn projection_frame(&self) -> &Self::Frame;
    /// Associated type for `Conjunction`.
    type Conjunction: crate::user::type_::Conjunction<H>;
    /// Ordering constraint determining the output symbol sequence. Domain-specific: syntactic position (NLP), row-major scan (ARC), temporal sequence (music).
    fn projection_order(&self) -> &Self::Conjunction;
    /// Completeness criterion: does projecting the grounded source address recover a symbol in the same type class as the input? True iff the shared-frame condition holds.
    fn round_trip_coherence(&self) -> bool;
    /// When outputClass is a sequence type, the OWL class of individual sequence elements. Uses OWL2 punning.
    fn output_element_class(&self) -> &H::HostString;
}

/// A certificate attesting that a specific grounding round-trip (P∘Π∘G) satisfied the shared-frame condition and landed in the type-equivalent neighbourhood of the source symbol. Witnesses the Surface Symmetry Theorem (op:surfaceSymmetry) for one specific symbol instance.
pub trait GroundingCertificate<H: HostTypes>: crate::bridge::cert::Certificate<H> {
    /// Associated type for `GroundingMap`.
    type GroundingMap: GroundingMap<H>;
    /// The GroundingMap used in this certified round-trip.
    fn grounding_cert_map(&self) -> &Self::GroundingMap;
    /// Associated type for `ProjectionMap`.
    type ProjectionMap: ProjectionMap<H>;
    /// The ProjectionMap used in this certified round-trip.
    fn grounding_cert_projection(&self) -> &Self::ProjectionMap;
    /// Associated type for `Literal`.
    type Literal: crate::kernel::schema::Literal<H>;
    /// The surface symbol that entered the grounding boundary.
    fn grounding_cert_source_symbol(&self) -> &Self::Literal;
    /// Associated type for `Element`.
    type Element: crate::kernel::address::Element<H>;
    /// The ring address the symbol was grounded to.
    fn grounding_cert_address(&self) -> &Self::Element;
}

/// A topological delta: records changes in topological invariants (Betti numbers, Euler characteristic, nerve structure) before and after a morphism.
pub trait TopologicalDelta<H: HostTypes> {
    /// Associated type for `BettiNumber`.
    type BettiNumber: crate::bridge::observable::BettiNumber<H>;
    /// Betti numbers before the morphism.
    fn bettis_before(&self) -> &Self::BettiNumber;
    /// Betti numbers after the morphism.
    fn bettis_after(&self) -> &Self::BettiNumber;
    /// Euler characteristic before the morphism.
    fn euler_before(&self) -> i64;
    /// Euler characteristic after the morphism.
    fn euler_after(&self) -> i64;
    /// Associated type for `SimplicialComplex`.
    type SimplicialComplex: crate::bridge::homology::SimplicialComplex<H>;
    /// Constraint nerve (simplicial complex) before the morphism.
    fn nerve_before(&self) -> &Self::SimplicialComplex;
    /// Constraint nerve (simplicial complex) after the morphism.
    fn nerve_after(&self) -> &Self::SimplicialComplex;
}

/// A datum whose ring value is the content address of a cert:TransformCertificate. Represents a certified computation as a first-class value within the ring.
pub trait ComputationDatum<H: HostTypes>: crate::kernel::schema::Datum<H> {
    /// Associated type for `TransformCertificate`.
    type TransformCertificate: crate::bridge::cert::TransformCertificate<H>;
    /// The certificate this computation datum encodes.
    fn referenced_certificate(&self) -> &Self::TransformCertificate;
    /// The content address of the referenced certificate.
    fn computation_address(&self) -> &Self::Element;
}

/// A transform that applies a ComputationDatum to an input datum, producing an output datum. The output inherits the certificate of the ComputationDatum.
pub trait ApplicationMorphism<H: HostTypes>: Transform<H> {
    /// Associated type for `ComputationDatum`.
    type ComputationDatum: ComputationDatum<H>;
    /// The computation being applied.
    fn application_target(&self) -> &Self::ComputationDatum;
    /// Associated type for `Datum`.
    type Datum: crate::kernel::schema::Datum<H>;
    /// The input datum to the application.
    fn application_input(&self) -> &Self::Datum;
}

/// A ComputationDatum formed by fixing some but not all inputs of a multi-argument transform.
pub trait PartialApplication<H: HostTypes>: ComputationDatum<H> {
    /// Associated type for `ComputationDatum`.
    type ComputationDatum: ComputationDatum<H>;
    /// The base computation being partially applied.
    fn partial_base(&self) -> &Self::ComputationDatum;
    /// Associated type for `Datum`.
    type Datum: crate::kernel::schema::Datum<H>;
    /// The arguments already bound.
    fn bound_arguments(&self) -> &[Self::Datum];
    /// Number of unbound arguments remaining.
    fn remaining_arity(&self) -> u64;
}

/// A ComputationDatum representing the composition f ∘ g of two ComputationDatums. Certified iff both components are certified and range(g) = domain(f).
pub trait TransformComposition<H: HostTypes>: ComputationDatum<H> {
    /// Associated type for `ComputationDatum`.
    type ComputationDatum: ComputationDatum<H>;
    /// The outer function f in f ∘ g.
    fn composition_left(&self) -> &Self::ComputationDatum;
    /// The inner function g in f ∘ g.
    fn composition_right(&self) -> &Self::ComputationDatum;
}

/// Abstract supertype for one specific input/output pair witnessing a Transform.
pub trait Witness<H: HostTypes> {}

/// One specific surface symbol mapped to one specific grounded address by some GroundingMap.
/// Disjoint with: ProjectionWitness.
pub trait GroundingWitness<H: HostTypes>: Witness<H> {
    /// Associated type for `SurfaceSymbol`.
    type SurfaceSymbol: crate::kernel::schema::SurfaceSymbol<H>;
    /// The surface symbol that is the source of this grounding witness.
    fn surface_symbol(&self) -> &Self::SurfaceSymbol;
    /// Associated type for `Element`.
    type Element: crate::kernel::address::Element<H>;
    /// The resolved ring address that is the target of this grounding witness.
    fn grounded_address(&self) -> &Self::Element;
}

/// One specific input partition mapped to one specific surface symbol sequence by some ProjectionMap.
/// Disjoint with: GroundingWitness.
pub trait ProjectionWitness<H: HostTypes>: Witness<H> {
    /// Associated type for `Partition`.
    type Partition: crate::bridge::partition::Partition<H>;
    /// The resolved partition (address neighbourhood) that this projection witness projects back to surface symbols.
    fn projection_source(&self) -> &Self::Partition;
    /// Associated type for `SymbolSequence`.
    type SymbolSequence: SymbolSequence<H>;
    /// The single SymbolSequence produced by this projection witness.
    fn projection_output(&self) -> &Self::SymbolSequence;
}

/// An ordered sequence of surface symbols. Elements are reified as SequenceElement individuals with explicit position indices.
pub trait SymbolSequence<H: HostTypes> {
    /// Associated type for `SequenceElement`.
    type SequenceElement: SequenceElement<H>;
    /// Membership of a SymbolSequence. The sequence is reconstructed by sorting elements by elementIndex.
    fn has_element(&self) -> &[Self::SequenceElement];
}

/// One position in a SymbolSequence: a reified (value, index) pair.
pub trait SequenceElement<H: HostTypes> {
    /// Associated type for `SurfaceSymbol`.
    type SurfaceSymbol: crate::kernel::schema::SurfaceSymbol<H>;
    /// The surface symbol value of this sequence element.
    fn element_value(&self) -> &Self::SurfaceSymbol;
    /// The zero-based position of this element in the sequence.
    fn element_index(&self) -> u64;
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `Transform<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 NullTransform<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullTransform<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullTransform<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullTransform<H> = NullTransform {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> Transform<H> for NullTransform<H> {
    fn source(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn target(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn preserves_count(&self) -> usize {
        0
    }
    fn preserves_at(&self, _index: usize) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type ComputationTrace = crate::bridge::trace::NullComputationTrace<H>;
    fn trace(&self) -> &Self::ComputationTrace {
        &<crate::bridge::trace::NullComputationTrace<H>>::ABSENT
    }
    type TransformTarget = NullTransform<H>;
    fn composes_with(&self) -> &[Self::TransformTarget] {
        &[]
    }
    type Identity = crate::kernel::op::NullIdentity<H>;
    fn preserved_invariant(&self) -> &Self::Identity {
        &<crate::kernel::op::NullIdentity<H>>::ABSENT
    }
    fn input_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn output_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type Witness = NullWitness<H>;
    fn has_witness(&self) -> &[Self::Witness] {
        &[]
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `Isometry<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 NullIsometry<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullIsometry<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullIsometry<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullIsometry<H> = NullIsometry {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> Transform<H> for NullIsometry<H> {
    fn source(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn target(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn preserves_count(&self) -> usize {
        0
    }
    fn preserves_at(&self, _index: usize) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type ComputationTrace = crate::bridge::trace::NullComputationTrace<H>;
    fn trace(&self) -> &Self::ComputationTrace {
        &<crate::bridge::trace::NullComputationTrace<H>>::ABSENT
    }
    type TransformTarget = NullTransform<H>;
    fn composes_with(&self) -> &[Self::TransformTarget] {
        &[]
    }
    type Identity = crate::kernel::op::NullIdentity<H>;
    fn preserved_invariant(&self) -> &Self::Identity {
        &<crate::kernel::op::NullIdentity<H>>::ABSENT
    }
    fn input_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn output_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type Witness = NullWitness<H>;
    fn has_witness(&self) -> &[Self::Witness] {
        &[]
    }
}
impl<H: HostTypes> Isometry<H> for NullIsometry<H> {
    type MetricObservable = crate::bridge::observable::NullMetricObservable<H>;
    fn preserves_metric(&self) -> &[Self::MetricObservable] {
        &[]
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `Embedding<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 NullEmbedding<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullEmbedding<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullEmbedding<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullEmbedding<H> = NullEmbedding {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> Transform<H> for NullEmbedding<H> {
    fn source(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn target(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn preserves_count(&self) -> usize {
        0
    }
    fn preserves_at(&self, _index: usize) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type ComputationTrace = crate::bridge::trace::NullComputationTrace<H>;
    fn trace(&self) -> &Self::ComputationTrace {
        &<crate::bridge::trace::NullComputationTrace<H>>::ABSENT
    }
    type TransformTarget = NullTransform<H>;
    fn composes_with(&self) -> &[Self::TransformTarget] {
        &[]
    }
    type Identity = crate::kernel::op::NullIdentity<H>;
    fn preserved_invariant(&self) -> &Self::Identity {
        &<crate::kernel::op::NullIdentity<H>>::ABSENT
    }
    fn input_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn output_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type Witness = NullWitness<H>;
    fn has_witness(&self) -> &[Self::Witness] {
        &[]
    }
}
impl<H: HostTypes> Embedding<H> for NullEmbedding<H> {
    fn source_quantum(&self) -> u64 {
        0
    }
    fn target_quantum(&self) -> u64 {
        0
    }
    fn address_coherence(&self) -> &Self::Identity {
        &<crate::kernel::op::NullIdentity<H>>::ABSENT
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `Action<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 NullAction<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullAction<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullAction<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullAction<H> = NullAction {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> Action<H> for NullAction<H> {
    type Group = crate::kernel::op::NullGroup<H>;
    fn group(&self) -> &Self::Group {
        &<crate::kernel::op::NullGroup<H>>::ABSENT
    }
    fn acting_on(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn action_isometry(&self) -> bool {
        false
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `Composition<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 NullComposition<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullComposition<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullComposition<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullComposition<H> = NullComposition {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> Transform<H> for NullComposition<H> {
    fn source(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn target(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn preserves_count(&self) -> usize {
        0
    }
    fn preserves_at(&self, _index: usize) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type ComputationTrace = crate::bridge::trace::NullComputationTrace<H>;
    fn trace(&self) -> &Self::ComputationTrace {
        &<crate::bridge::trace::NullComputationTrace<H>>::ABSENT
    }
    type TransformTarget = NullTransform<H>;
    fn composes_with(&self) -> &[Self::TransformTarget] {
        &[]
    }
    type Identity = crate::kernel::op::NullIdentity<H>;
    fn preserved_invariant(&self) -> &Self::Identity {
        &<crate::kernel::op::NullIdentity<H>>::ABSENT
    }
    fn input_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn output_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type Witness = NullWitness<H>;
    fn has_witness(&self) -> &[Self::Witness] {
        &[]
    }
}
impl<H: HostTypes> Composition<H> for NullComposition<H> {
    type Transform = NullTransform<H>;
    fn composition_result(&self) -> &Self::Transform {
        &<NullTransform<H>>::ABSENT
    }
    fn composition_components(&self) -> &[Self::Transform] {
        &[]
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `Identity<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 NullIdentity<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullIdentity<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullIdentity<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullIdentity<H> = NullIdentity {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> Transform<H> for NullIdentity<H> {
    fn source(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn target(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn preserves_count(&self) -> usize {
        0
    }
    fn preserves_at(&self, _index: usize) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type ComputationTrace = crate::bridge::trace::NullComputationTrace<H>;
    fn trace(&self) -> &Self::ComputationTrace {
        &<crate::bridge::trace::NullComputationTrace<H>>::ABSENT
    }
    type TransformTarget = NullTransform<H>;
    fn composes_with(&self) -> &[Self::TransformTarget] {
        &[]
    }
    type Identity = crate::kernel::op::NullIdentity<H>;
    fn preserved_invariant(&self) -> &Self::Identity {
        &<crate::kernel::op::NullIdentity<H>>::ABSENT
    }
    fn input_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn output_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type Witness = NullWitness<H>;
    fn has_witness(&self) -> &[Self::Witness] {
        &[]
    }
}
impl<H: HostTypes> Identity<H> for NullIdentity<H> {
    type TypeDefinition = crate::user::type_::NullTypeDefinition<H>;
    fn identity_on(&self) -> &Self::TypeDefinition {
        &<crate::user::type_::NullTypeDefinition<H>>::ABSENT
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `CompositionLaw<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 NullCompositionLaw<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullCompositionLaw<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullCompositionLaw<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullCompositionLaw<H> = NullCompositionLaw {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> CompositionLaw<H> for NullCompositionLaw<H> {
    fn is_associative(&self) -> bool {
        false
    }
    fn is_commutative(&self) -> bool {
        false
    }
    type Operation = crate::kernel::op::NullOperation<H>;
    fn law_components(&self) -> &[Self::Operation] {
        &[]
    }
    fn law_result(&self) -> &Self::Operation {
        &<crate::kernel::op::NullOperation<H>>::ABSENT
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `GroundingMap<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 NullGroundingMap<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullGroundingMap<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullGroundingMap<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullGroundingMap<H> = NullGroundingMap {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> Transform<H> for NullGroundingMap<H> {
    fn source(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn target(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn preserves_count(&self) -> usize {
        0
    }
    fn preserves_at(&self, _index: usize) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type ComputationTrace = crate::bridge::trace::NullComputationTrace<H>;
    fn trace(&self) -> &Self::ComputationTrace {
        &<crate::bridge::trace::NullComputationTrace<H>>::ABSENT
    }
    type TransformTarget = NullTransform<H>;
    fn composes_with(&self) -> &[Self::TransformTarget] {
        &[]
    }
    type Identity = crate::kernel::op::NullIdentity<H>;
    fn preserved_invariant(&self) -> &Self::Identity {
        &<crate::kernel::op::NullIdentity<H>>::ABSENT
    }
    fn input_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn output_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type Witness = NullWitness<H>;
    fn has_witness(&self) -> &[Self::Witness] {
        &[]
    }
}
impl<H: HostTypes> GroundingMap<H> for NullGroundingMap<H> {
    type Derivation = crate::bridge::derivation::NullDerivation<H>;
    fn grounding_derivation(&self) -> &Self::Derivation {
        &<crate::bridge::derivation::NullDerivation<H>>::ABSENT
    }
    type Constraint = crate::user::type_::NullConstraint<H>;
    fn symbol_constraints(&self) -> &[Self::Constraint] {
        &[]
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `ProjectionMap<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 NullProjectionMap<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullProjectionMap<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullProjectionMap<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullProjectionMap<H> = NullProjectionMap {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> Transform<H> for NullProjectionMap<H> {
    fn source(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn target(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn preserves_count(&self) -> usize {
        0
    }
    fn preserves_at(&self, _index: usize) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type ComputationTrace = crate::bridge::trace::NullComputationTrace<H>;
    fn trace(&self) -> &Self::ComputationTrace {
        &<crate::bridge::trace::NullComputationTrace<H>>::ABSENT
    }
    type TransformTarget = NullTransform<H>;
    fn composes_with(&self) -> &[Self::TransformTarget] {
        &[]
    }
    type Identity = crate::kernel::op::NullIdentity<H>;
    fn preserved_invariant(&self) -> &Self::Identity {
        &<crate::kernel::op::NullIdentity<H>>::ABSENT
    }
    fn input_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn output_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type Witness = NullWitness<H>;
    fn has_witness(&self) -> &[Self::Witness] {
        &[]
    }
}
impl<H: HostTypes> ProjectionMap<H> for NullProjectionMap<H> {
    type Frame = crate::user::state::NullFrame<H>;
    fn projection_frame(&self) -> &Self::Frame {
        &<crate::user::state::NullFrame<H>>::ABSENT
    }
    type Conjunction = crate::user::type_::NullConjunction<H>;
    fn projection_order(&self) -> &Self::Conjunction {
        &<crate::user::type_::NullConjunction<H>>::ABSENT
    }
    fn round_trip_coherence(&self) -> bool {
        false
    }
    fn output_element_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `GroundingCertificate<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 NullGroundingCertificate<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullGroundingCertificate<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullGroundingCertificate<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullGroundingCertificate<H> = NullGroundingCertificate {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> crate::bridge::cert::Certificate<H> for NullGroundingCertificate<H> {
    fn method(&self) -> ProofStrategy {
        <ProofStrategy>::default()
    }
    fn verified(&self) -> bool {
        false
    }
    fn witt_length(&self) -> u64 {
        0
    }
    fn timestamp(&self) -> &H::WitnessBytes {
        H::EMPTY_WITNESS_BYTES
    }
    fn certifies(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
}
impl<H: HostTypes> GroundingCertificate<H> for NullGroundingCertificate<H> {
    type GroundingMap = NullGroundingMap<H>;
    fn grounding_cert_map(&self) -> &Self::GroundingMap {
        &<NullGroundingMap<H>>::ABSENT
    }
    type ProjectionMap = NullProjectionMap<H>;
    fn grounding_cert_projection(&self) -> &Self::ProjectionMap {
        &<NullProjectionMap<H>>::ABSENT
    }
    type Literal = crate::kernel::schema::NullLiteral<H>;
    fn grounding_cert_source_symbol(&self) -> &Self::Literal {
        &<crate::kernel::schema::NullLiteral<H>>::ABSENT
    }
    type Element = crate::kernel::address::NullElement<H>;
    fn grounding_cert_address(&self) -> &Self::Element {
        &<crate::kernel::address::NullElement<H>>::ABSENT
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `TopologicalDelta<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 NullTopologicalDelta<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullTopologicalDelta<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullTopologicalDelta<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullTopologicalDelta<H> = NullTopologicalDelta {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> TopologicalDelta<H> for NullTopologicalDelta<H> {
    type BettiNumber = crate::bridge::observable::NullBettiNumber<H>;
    fn bettis_before(&self) -> &Self::BettiNumber {
        &<crate::bridge::observable::NullBettiNumber<H>>::ABSENT
    }
    fn bettis_after(&self) -> &Self::BettiNumber {
        &<crate::bridge::observable::NullBettiNumber<H>>::ABSENT
    }
    fn euler_before(&self) -> i64 {
        0
    }
    fn euler_after(&self) -> i64 {
        0
    }
    type SimplicialComplex = crate::bridge::homology::NullSimplicialComplex<H>;
    fn nerve_before(&self) -> &Self::SimplicialComplex {
        &<crate::bridge::homology::NullSimplicialComplex<H>>::ABSENT
    }
    fn nerve_after(&self) -> &Self::SimplicialComplex {
        &<crate::bridge::homology::NullSimplicialComplex<H>>::ABSENT
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `ComputationDatum<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 NullComputationDatum<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullComputationDatum<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullComputationDatum<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullComputationDatum<H> = NullComputationDatum {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> crate::kernel::schema::Datum<H> for NullComputationDatum<H> {
    fn value(&self) -> u64 {
        0
    }
    fn witt_length(&self) -> u64 {
        0
    }
    fn stratum(&self) -> u64 {
        0
    }
    fn spectrum(&self) -> u64 {
        0
    }
    type Element = crate::kernel::address::NullElement<H>;
    fn element(&self) -> &Self::Element {
        &<crate::kernel::address::NullElement<H>>::ABSENT
    }
}
impl<H: HostTypes> ComputationDatum<H> for NullComputationDatum<H> {
    type TransformCertificate = crate::bridge::cert::NullTransformCertificate<H>;
    fn referenced_certificate(&self) -> &Self::TransformCertificate {
        &<crate::bridge::cert::NullTransformCertificate<H>>::ABSENT
    }
    fn computation_address(&self) -> &Self::Element {
        &<crate::kernel::address::NullElement<H>>::ABSENT
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `ApplicationMorphism<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 NullApplicationMorphism<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullApplicationMorphism<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullApplicationMorphism<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullApplicationMorphism<H> = NullApplicationMorphism {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> Transform<H> for NullApplicationMorphism<H> {
    fn source(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn target(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn preserves_count(&self) -> usize {
        0
    }
    fn preserves_at(&self, _index: usize) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type ComputationTrace = crate::bridge::trace::NullComputationTrace<H>;
    fn trace(&self) -> &Self::ComputationTrace {
        &<crate::bridge::trace::NullComputationTrace<H>>::ABSENT
    }
    type TransformTarget = NullTransform<H>;
    fn composes_with(&self) -> &[Self::TransformTarget] {
        &[]
    }
    type Identity = crate::kernel::op::NullIdentity<H>;
    fn preserved_invariant(&self) -> &Self::Identity {
        &<crate::kernel::op::NullIdentity<H>>::ABSENT
    }
    fn input_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn output_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type Witness = NullWitness<H>;
    fn has_witness(&self) -> &[Self::Witness] {
        &[]
    }
}
impl<H: HostTypes> ApplicationMorphism<H> for NullApplicationMorphism<H> {
    type ComputationDatum = NullComputationDatum<H>;
    fn application_target(&self) -> &Self::ComputationDatum {
        &<NullComputationDatum<H>>::ABSENT
    }
    type Datum = crate::kernel::schema::NullDatum<H>;
    fn application_input(&self) -> &Self::Datum {
        &<crate::kernel::schema::NullDatum<H>>::ABSENT
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `PartialApplication<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 NullPartialApplication<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullPartialApplication<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullPartialApplication<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullPartialApplication<H> = NullPartialApplication {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> crate::kernel::schema::Datum<H> for NullPartialApplication<H> {
    fn value(&self) -> u64 {
        0
    }
    fn witt_length(&self) -> u64 {
        0
    }
    fn stratum(&self) -> u64 {
        0
    }
    fn spectrum(&self) -> u64 {
        0
    }
    type Element = crate::kernel::address::NullElement<H>;
    fn element(&self) -> &Self::Element {
        &<crate::kernel::address::NullElement<H>>::ABSENT
    }
}
impl<H: HostTypes> ComputationDatum<H> for NullPartialApplication<H> {
    type TransformCertificate = crate::bridge::cert::NullTransformCertificate<H>;
    fn referenced_certificate(&self) -> &Self::TransformCertificate {
        &<crate::bridge::cert::NullTransformCertificate<H>>::ABSENT
    }
    fn computation_address(&self) -> &Self::Element {
        &<crate::kernel::address::NullElement<H>>::ABSENT
    }
}
impl<H: HostTypes> PartialApplication<H> for NullPartialApplication<H> {
    type ComputationDatum = NullComputationDatum<H>;
    fn partial_base(&self) -> &Self::ComputationDatum {
        &<NullComputationDatum<H>>::ABSENT
    }
    type Datum = crate::kernel::schema::NullDatum<H>;
    fn bound_arguments(&self) -> &[Self::Datum] {
        &[]
    }
    fn remaining_arity(&self) -> u64 {
        0
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `TransformComposition<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 NullTransformComposition<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullTransformComposition<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullTransformComposition<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullTransformComposition<H> = NullTransformComposition {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> crate::kernel::schema::Datum<H> for NullTransformComposition<H> {
    fn value(&self) -> u64 {
        0
    }
    fn witt_length(&self) -> u64 {
        0
    }
    fn stratum(&self) -> u64 {
        0
    }
    fn spectrum(&self) -> u64 {
        0
    }
    type Element = crate::kernel::address::NullElement<H>;
    fn element(&self) -> &Self::Element {
        &<crate::kernel::address::NullElement<H>>::ABSENT
    }
}
impl<H: HostTypes> ComputationDatum<H> for NullTransformComposition<H> {
    type TransformCertificate = crate::bridge::cert::NullTransformCertificate<H>;
    fn referenced_certificate(&self) -> &Self::TransformCertificate {
        &<crate::bridge::cert::NullTransformCertificate<H>>::ABSENT
    }
    fn computation_address(&self) -> &Self::Element {
        &<crate::kernel::address::NullElement<H>>::ABSENT
    }
}
impl<H: HostTypes> TransformComposition<H> for NullTransformComposition<H> {
    type ComputationDatum = NullComputationDatum<H>;
    fn composition_left(&self) -> &Self::ComputationDatum {
        &<NullComputationDatum<H>>::ABSENT
    }
    fn composition_right(&self) -> &Self::ComputationDatum {
        &<NullComputationDatum<H>>::ABSENT
    }
}

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

/// Phase 2 (orphan-closure) — resolver-absent default impl of `GroundingWitness<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 NullGroundingWitness<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullGroundingWitness<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullGroundingWitness<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullGroundingWitness<H> = NullGroundingWitness {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> Witness<H> for NullGroundingWitness<H> {}
impl<H: HostTypes> GroundingWitness<H> for NullGroundingWitness<H> {
    type SurfaceSymbol = crate::kernel::schema::NullSurfaceSymbol<H>;
    fn surface_symbol(&self) -> &Self::SurfaceSymbol {
        &<crate::kernel::schema::NullSurfaceSymbol<H>>::ABSENT
    }
    type Element = crate::kernel::address::NullElement<H>;
    fn grounded_address(&self) -> &Self::Element {
        &<crate::kernel::address::NullElement<H>>::ABSENT
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `ProjectionWitness<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 NullProjectionWitness<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullProjectionWitness<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullProjectionWitness<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullProjectionWitness<H> = NullProjectionWitness {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> Witness<H> for NullProjectionWitness<H> {}
impl<H: HostTypes> ProjectionWitness<H> for NullProjectionWitness<H> {
    type Partition = crate::enforcement::NullPartition<H>;
    fn projection_source(&self) -> &Self::Partition {
        &<crate::enforcement::NullPartition<H>>::ABSENT
    }
    type SymbolSequence = NullSymbolSequence<H>;
    fn projection_output(&self) -> &Self::SymbolSequence {
        &<NullSymbolSequence<H>>::ABSENT
    }
}

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

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

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

/// Phase 8 (orphan-closure) — typed record for `Transform<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 TransformRecord<H: HostTypes> {
    pub source: &'static H::HostString,
    pub target: &'static H::HostString,
    pub trace_handle: crate::bridge::trace::ComputationTraceHandle<H>,
    pub preserved_invariant_handle: crate::kernel::op::IdentityHandle<H>,
    pub input_class: &'static H::HostString,
    pub output_class: &'static H::HostString,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `Transform<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 ResolvedTransform<'r, R: TransformResolver<H>, H: HostTypes> {
    handle: TransformHandle<H>,
    resolver: &'r R,
    record: Option<TransformRecord<H>>,
}
impl<'r, R: TransformResolver<H>, H: HostTypes> ResolvedTransform<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: TransformHandle<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) -> TransformHandle<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<&TransformRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: TransformResolver<H>, H: HostTypes> Transform<H> for ResolvedTransform<'r, R, H> {
    fn source(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn target(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn preserves_count(&self) -> usize {
        0
    }
    fn preserves_at(&self, _index: usize) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type ComputationTrace = crate::bridge::trace::NullComputationTrace<H>;
    fn trace(&self) -> &Self::ComputationTrace {
        &<crate::bridge::trace::NullComputationTrace<H>>::ABSENT
    }
    type TransformTarget = NullTransform<H>;
    fn composes_with(&self) -> &[Self::TransformTarget] {
        &[]
    }
    type Identity = crate::kernel::op::NullIdentity<H>;
    fn preserved_invariant(&self) -> &Self::Identity {
        &<crate::kernel::op::NullIdentity<H>>::ABSENT
    }
    fn input_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn output_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type Witness = NullWitness<H>;
    fn has_witness(&self) -> &[Self::Witness] {
        &[]
    }
}
impl<'r, R: TransformResolver<H>, H: HostTypes> ResolvedTransform<'r, R, H> {
    /// Promote the `trace` 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_trace<'r2, R2: crate::bridge::trace::ComputationTraceResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::bridge::trace::ResolvedComputationTrace<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::bridge::trace::ResolvedComputationTrace::new(
            record.trace_handle,
            r,
        ))
    }
    /// Promote the `preserved_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_preserved_invariant<'r2, R2: crate::kernel::op::IdentityResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::kernel::op::ResolvedIdentity<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::kernel::op::ResolvedIdentity::new(
            record.preserved_invariant_handle,
            r,
        ))
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `Isometry<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 ResolvedIsometry<'r, R: IsometryResolver<H>, H: HostTypes> {
    handle: IsometryHandle<H>,
    resolver: &'r R,
    record: Option<IsometryRecord<H>>,
}
impl<'r, R: IsometryResolver<H>, H: HostTypes> ResolvedIsometry<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: IsometryHandle<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) -> IsometryHandle<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<&IsometryRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: IsometryResolver<H>, H: HostTypes> Transform<H> for ResolvedIsometry<'r, R, H> {
    fn source(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn target(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn preserves_count(&self) -> usize {
        0
    }
    fn preserves_at(&self, _index: usize) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type ComputationTrace = crate::bridge::trace::NullComputationTrace<H>;
    fn trace(&self) -> &Self::ComputationTrace {
        &<crate::bridge::trace::NullComputationTrace<H>>::ABSENT
    }
    type TransformTarget = NullTransform<H>;
    fn composes_with(&self) -> &[Self::TransformTarget] {
        &[]
    }
    type Identity = crate::kernel::op::NullIdentity<H>;
    fn preserved_invariant(&self) -> &Self::Identity {
        &<crate::kernel::op::NullIdentity<H>>::ABSENT
    }
    fn input_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn output_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type Witness = NullWitness<H>;
    fn has_witness(&self) -> &[Self::Witness] {
        &[]
    }
}
impl<'r, R: IsometryResolver<H>, H: HostTypes> Isometry<H> for ResolvedIsometry<'r, R, H> {
    type MetricObservable = crate::bridge::observable::NullMetricObservable<H>;
    fn preserves_metric(&self) -> &[Self::MetricObservable] {
        &[]
    }
}

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

/// Phase 8 (orphan-closure) — typed record for `Embedding<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 EmbeddingRecord<H: HostTypes> {
    pub source_quantum: u64,
    pub target_quantum: u64,
    pub address_coherence_handle: crate::kernel::op::IdentityHandle<H>,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `Embedding<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 ResolvedEmbedding<'r, R: EmbeddingResolver<H>, H: HostTypes> {
    handle: EmbeddingHandle<H>,
    resolver: &'r R,
    record: Option<EmbeddingRecord<H>>,
}
impl<'r, R: EmbeddingResolver<H>, H: HostTypes> ResolvedEmbedding<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: EmbeddingHandle<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) -> EmbeddingHandle<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<&EmbeddingRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: EmbeddingResolver<H>, H: HostTypes> Transform<H> for ResolvedEmbedding<'r, R, H> {
    fn source(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn target(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn preserves_count(&self) -> usize {
        0
    }
    fn preserves_at(&self, _index: usize) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type ComputationTrace = crate::bridge::trace::NullComputationTrace<H>;
    fn trace(&self) -> &Self::ComputationTrace {
        &<crate::bridge::trace::NullComputationTrace<H>>::ABSENT
    }
    type TransformTarget = NullTransform<H>;
    fn composes_with(&self) -> &[Self::TransformTarget] {
        &[]
    }
    type Identity = crate::kernel::op::NullIdentity<H>;
    fn preserved_invariant(&self) -> &Self::Identity {
        &<crate::kernel::op::NullIdentity<H>>::ABSENT
    }
    fn input_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn output_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type Witness = NullWitness<H>;
    fn has_witness(&self) -> &[Self::Witness] {
        &[]
    }
}
impl<'r, R: EmbeddingResolver<H>, H: HostTypes> Embedding<H> for ResolvedEmbedding<'r, R, H> {
    fn source_quantum(&self) -> u64 {
        match &self.record {
            Some(r) => r.source_quantum,
            None => 0,
        }
    }
    fn target_quantum(&self) -> u64 {
        match &self.record {
            Some(r) => r.target_quantum,
            None => 0,
        }
    }
    fn address_coherence(&self) -> &Self::Identity {
        &<crate::kernel::op::NullIdentity<H>>::ABSENT
    }
}
impl<'r, R: EmbeddingResolver<H>, H: HostTypes> ResolvedEmbedding<'r, R, H> {
    /// Promote the `address_coherence` 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_address_coherence<'r2, R2: crate::kernel::op::IdentityResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::kernel::op::ResolvedIdentity<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::kernel::op::ResolvedIdentity::new(
            record.address_coherence_handle,
            r,
        ))
    }
}

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

/// Phase 8 (orphan-closure) — typed record for `Action<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 ActionRecord<H: HostTypes> {
    pub group_handle: crate::kernel::op::GroupHandle<H>,
    pub acting_on: &'static H::HostString,
    pub action_isometry: bool,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `Action<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 ResolvedAction<'r, R: ActionResolver<H>, H: HostTypes> {
    handle: ActionHandle<H>,
    resolver: &'r R,
    record: Option<ActionRecord<H>>,
}
impl<'r, R: ActionResolver<H>, H: HostTypes> ResolvedAction<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: ActionHandle<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) -> ActionHandle<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<&ActionRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: ActionResolver<H>, H: HostTypes> Action<H> for ResolvedAction<'r, R, H> {
    type Group = crate::kernel::op::NullGroup<H>;
    fn group(&self) -> &Self::Group {
        &<crate::kernel::op::NullGroup<H>>::ABSENT
    }
    fn acting_on(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn action_isometry(&self) -> bool {
        match &self.record {
            Some(r) => r.action_isometry,
            None => false,
        }
    }
}
impl<'r, R: ActionResolver<H>, H: HostTypes> ResolvedAction<'r, R, H> {
    /// Promote the `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_group<'r2, R2: crate::kernel::op::GroupResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::kernel::op::ResolvedGroup<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::kernel::op::ResolvedGroup::new(
            record.group_handle,
            r,
        ))
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `Composition<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 ResolvedComposition<'r, R: CompositionResolver<H>, H: HostTypes> {
    handle: CompositionHandle<H>,
    resolver: &'r R,
    record: Option<CompositionRecord<H>>,
}
impl<'r, R: CompositionResolver<H>, H: HostTypes> ResolvedComposition<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: CompositionHandle<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) -> CompositionHandle<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<&CompositionRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: CompositionResolver<H>, H: HostTypes> Transform<H> for ResolvedComposition<'r, R, H> {
    fn source(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn target(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn preserves_count(&self) -> usize {
        0
    }
    fn preserves_at(&self, _index: usize) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type ComputationTrace = crate::bridge::trace::NullComputationTrace<H>;
    fn trace(&self) -> &Self::ComputationTrace {
        &<crate::bridge::trace::NullComputationTrace<H>>::ABSENT
    }
    type TransformTarget = NullTransform<H>;
    fn composes_with(&self) -> &[Self::TransformTarget] {
        &[]
    }
    type Identity = crate::kernel::op::NullIdentity<H>;
    fn preserved_invariant(&self) -> &Self::Identity {
        &<crate::kernel::op::NullIdentity<H>>::ABSENT
    }
    fn input_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn output_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type Witness = NullWitness<H>;
    fn has_witness(&self) -> &[Self::Witness] {
        &[]
    }
}
impl<'r, R: CompositionResolver<H>, H: HostTypes> Composition<H> for ResolvedComposition<'r, R, H> {
    type Transform = NullTransform<H>;
    fn composition_result(&self) -> &Self::Transform {
        &<NullTransform<H>>::ABSENT
    }
    fn composition_components(&self) -> &[Self::Transform] {
        &[]
    }
}
impl<'r, R: CompositionResolver<H>, H: HostTypes> ResolvedComposition<'r, R, H> {
    /// Promote the `composition_result` 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_composition_result<'r2, R2: TransformResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedTransform<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedTransform::new(record.composition_result_handle, r))
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `Identity<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 ResolvedIdentity<'r, R: IdentityResolver<H>, H: HostTypes> {
    handle: IdentityHandle<H>,
    resolver: &'r R,
    record: Option<IdentityRecord<H>>,
}
impl<'r, R: IdentityResolver<H>, H: HostTypes> ResolvedIdentity<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: IdentityHandle<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) -> IdentityHandle<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<&IdentityRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: IdentityResolver<H>, H: HostTypes> Transform<H> for ResolvedIdentity<'r, R, H> {
    fn source(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn target(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn preserves_count(&self) -> usize {
        0
    }
    fn preserves_at(&self, _index: usize) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type ComputationTrace = crate::bridge::trace::NullComputationTrace<H>;
    fn trace(&self) -> &Self::ComputationTrace {
        &<crate::bridge::trace::NullComputationTrace<H>>::ABSENT
    }
    type TransformTarget = NullTransform<H>;
    fn composes_with(&self) -> &[Self::TransformTarget] {
        &[]
    }
    type Identity = crate::kernel::op::NullIdentity<H>;
    fn preserved_invariant(&self) -> &Self::Identity {
        &<crate::kernel::op::NullIdentity<H>>::ABSENT
    }
    fn input_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn output_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type Witness = NullWitness<H>;
    fn has_witness(&self) -> &[Self::Witness] {
        &[]
    }
}
impl<'r, R: IdentityResolver<H>, H: HostTypes> Identity<H> for ResolvedIdentity<'r, R, H> {
    type TypeDefinition = crate::user::type_::NullTypeDefinition<H>;
    fn identity_on(&self) -> &Self::TypeDefinition {
        &<crate::user::type_::NullTypeDefinition<H>>::ABSENT
    }
}
impl<'r, R: IdentityResolver<H>, H: HostTypes> ResolvedIdentity<'r, R, H> {
    /// Promote the `identity_on` 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_identity_on<'r2, R2: crate::user::type_::TypeDefinitionResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::user::type_::ResolvedTypeDefinition<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::user::type_::ResolvedTypeDefinition::new(
            record.identity_on_handle,
            r,
        ))
    }
}

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

/// Phase 8 (orphan-closure) — typed record for `CompositionLaw<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 CompositionLawRecord<H: HostTypes> {
    pub is_associative: bool,
    pub is_commutative: bool,
    pub law_result_handle: crate::kernel::op::OperationHandle<H>,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `CompositionLaw<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 ResolvedCompositionLaw<'r, R: CompositionLawResolver<H>, H: HostTypes> {
    handle: CompositionLawHandle<H>,
    resolver: &'r R,
    record: Option<CompositionLawRecord<H>>,
}
impl<'r, R: CompositionLawResolver<H>, H: HostTypes> ResolvedCompositionLaw<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: CompositionLawHandle<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) -> CompositionLawHandle<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<&CompositionLawRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: CompositionLawResolver<H>, H: HostTypes> CompositionLaw<H>
    for ResolvedCompositionLaw<'r, R, H>
{
    fn is_associative(&self) -> bool {
        match &self.record {
            Some(r) => r.is_associative,
            None => false,
        }
    }
    fn is_commutative(&self) -> bool {
        match &self.record {
            Some(r) => r.is_commutative,
            None => false,
        }
    }
    type Operation = crate::kernel::op::NullOperation<H>;
    fn law_components(&self) -> &[Self::Operation] {
        &[]
    }
    fn law_result(&self) -> &Self::Operation {
        &<crate::kernel::op::NullOperation<H>>::ABSENT
    }
}
impl<'r, R: CompositionLawResolver<H>, H: HostTypes> ResolvedCompositionLaw<'r, R, H> {
    /// Promote the `law_result` 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_law_result<'r2, R2: crate::kernel::op::OperationResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::kernel::op::ResolvedOperation<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::kernel::op::ResolvedOperation::new(
            record.law_result_handle,
            r,
        ))
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `GroundingMap<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 ResolvedGroundingMap<'r, R: GroundingMapResolver<H>, H: HostTypes> {
    handle: GroundingMapHandle<H>,
    resolver: &'r R,
    record: Option<GroundingMapRecord<H>>,
}
impl<'r, R: GroundingMapResolver<H>, H: HostTypes> ResolvedGroundingMap<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: GroundingMapHandle<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) -> GroundingMapHandle<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<&GroundingMapRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: GroundingMapResolver<H>, H: HostTypes> Transform<H> for ResolvedGroundingMap<'r, R, H> {
    fn source(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn target(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn preserves_count(&self) -> usize {
        0
    }
    fn preserves_at(&self, _index: usize) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type ComputationTrace = crate::bridge::trace::NullComputationTrace<H>;
    fn trace(&self) -> &Self::ComputationTrace {
        &<crate::bridge::trace::NullComputationTrace<H>>::ABSENT
    }
    type TransformTarget = NullTransform<H>;
    fn composes_with(&self) -> &[Self::TransformTarget] {
        &[]
    }
    type Identity = crate::kernel::op::NullIdentity<H>;
    fn preserved_invariant(&self) -> &Self::Identity {
        &<crate::kernel::op::NullIdentity<H>>::ABSENT
    }
    fn input_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn output_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type Witness = NullWitness<H>;
    fn has_witness(&self) -> &[Self::Witness] {
        &[]
    }
}
impl<'r, R: GroundingMapResolver<H>, H: HostTypes> GroundingMap<H>
    for ResolvedGroundingMap<'r, R, H>
{
    type Derivation = crate::bridge::derivation::NullDerivation<H>;
    fn grounding_derivation(&self) -> &Self::Derivation {
        &<crate::bridge::derivation::NullDerivation<H>>::ABSENT
    }
    type Constraint = crate::user::type_::NullConstraint<H>;
    fn symbol_constraints(&self) -> &[Self::Constraint] {
        &[]
    }
}
impl<'r, R: GroundingMapResolver<H>, H: HostTypes> ResolvedGroundingMap<'r, R, H> {
    /// Promote the `grounding_derivation` 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_derivation<
        'r2,
        R2: crate::bridge::derivation::DerivationResolver<H>,
    >(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::bridge::derivation::ResolvedDerivation<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::bridge::derivation::ResolvedDerivation::new(
            record.grounding_derivation_handle,
            r,
        ))
    }
}

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

/// Phase 8 (orphan-closure) — typed record for `ProjectionMap<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 ProjectionMapRecord<H: HostTypes> {
    pub projection_frame_handle: crate::user::state::FrameHandle<H>,
    pub projection_order_handle: crate::user::type_::ConjunctionHandle<H>,
    pub round_trip_coherence: bool,
    pub output_element_class: &'static H::HostString,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `ProjectionMap<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 ResolvedProjectionMap<'r, R: ProjectionMapResolver<H>, H: HostTypes> {
    handle: ProjectionMapHandle<H>,
    resolver: &'r R,
    record: Option<ProjectionMapRecord<H>>,
}
impl<'r, R: ProjectionMapResolver<H>, H: HostTypes> ResolvedProjectionMap<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: ProjectionMapHandle<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) -> ProjectionMapHandle<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<&ProjectionMapRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: ProjectionMapResolver<H>, H: HostTypes> Transform<H>
    for ResolvedProjectionMap<'r, R, H>
{
    fn source(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn target(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn preserves_count(&self) -> usize {
        0
    }
    fn preserves_at(&self, _index: usize) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type ComputationTrace = crate::bridge::trace::NullComputationTrace<H>;
    fn trace(&self) -> &Self::ComputationTrace {
        &<crate::bridge::trace::NullComputationTrace<H>>::ABSENT
    }
    type TransformTarget = NullTransform<H>;
    fn composes_with(&self) -> &[Self::TransformTarget] {
        &[]
    }
    type Identity = crate::kernel::op::NullIdentity<H>;
    fn preserved_invariant(&self) -> &Self::Identity {
        &<crate::kernel::op::NullIdentity<H>>::ABSENT
    }
    fn input_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn output_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type Witness = NullWitness<H>;
    fn has_witness(&self) -> &[Self::Witness] {
        &[]
    }
}
impl<'r, R: ProjectionMapResolver<H>, H: HostTypes> ProjectionMap<H>
    for ResolvedProjectionMap<'r, R, H>
{
    type Frame = crate::user::state::NullFrame<H>;
    fn projection_frame(&self) -> &Self::Frame {
        &<crate::user::state::NullFrame<H>>::ABSENT
    }
    type Conjunction = crate::user::type_::NullConjunction<H>;
    fn projection_order(&self) -> &Self::Conjunction {
        &<crate::user::type_::NullConjunction<H>>::ABSENT
    }
    fn round_trip_coherence(&self) -> bool {
        match &self.record {
            Some(r) => r.round_trip_coherence,
            None => false,
        }
    }
    fn output_element_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
}
impl<'r, R: ProjectionMapResolver<H>, H: HostTypes> ResolvedProjectionMap<'r, R, H> {
    /// Promote the `projection_frame` 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_frame<'r2, R2: crate::user::state::FrameResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::user::state::ResolvedFrame<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::user::state::ResolvedFrame::new(
            record.projection_frame_handle,
            r,
        ))
    }
    /// Promote the `projection_order` 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_order<'r2, R2: crate::user::type_::ConjunctionResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::user::type_::ResolvedConjunction<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::user::type_::ResolvedConjunction::new(
            record.projection_order_handle,
            r,
        ))
    }
}

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

/// Phase 8 (orphan-closure) — typed record for `GroundingCertificate<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 GroundingCertificateRecord<H: HostTypes> {
    pub grounding_cert_map_handle: GroundingMapHandle<H>,
    pub grounding_cert_projection_handle: ProjectionMapHandle<H>,
    pub grounding_cert_source_symbol_handle: crate::kernel::schema::LiteralHandle<H>,
    pub grounding_cert_address_handle: crate::kernel::address::ElementHandle<H>,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `GroundingCertificate<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 ResolvedGroundingCertificate<'r, R: GroundingCertificateResolver<H>, H: HostTypes> {
    handle: GroundingCertificateHandle<H>,
    resolver: &'r R,
    record: Option<GroundingCertificateRecord<H>>,
}
impl<'r, R: GroundingCertificateResolver<H>, H: HostTypes> ResolvedGroundingCertificate<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: GroundingCertificateHandle<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) -> GroundingCertificateHandle<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<&GroundingCertificateRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: GroundingCertificateResolver<H>, H: HostTypes> crate::bridge::cert::Certificate<H>
    for ResolvedGroundingCertificate<'r, R, H>
{
    fn method(&self) -> ProofStrategy {
        <ProofStrategy>::default()
    }
    fn verified(&self) -> bool {
        false
    }
    fn witt_length(&self) -> u64 {
        0
    }
    fn timestamp(&self) -> &H::WitnessBytes {
        H::EMPTY_WITNESS_BYTES
    }
    fn certifies(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
}
impl<'r, R: GroundingCertificateResolver<H>, H: HostTypes> GroundingCertificate<H>
    for ResolvedGroundingCertificate<'r, R, H>
{
    type GroundingMap = NullGroundingMap<H>;
    fn grounding_cert_map(&self) -> &Self::GroundingMap {
        &<NullGroundingMap<H>>::ABSENT
    }
    type ProjectionMap = NullProjectionMap<H>;
    fn grounding_cert_projection(&self) -> &Self::ProjectionMap {
        &<NullProjectionMap<H>>::ABSENT
    }
    type Literal = crate::kernel::schema::NullLiteral<H>;
    fn grounding_cert_source_symbol(&self) -> &Self::Literal {
        &<crate::kernel::schema::NullLiteral<H>>::ABSENT
    }
    type Element = crate::kernel::address::NullElement<H>;
    fn grounding_cert_address(&self) -> &Self::Element {
        &<crate::kernel::address::NullElement<H>>::ABSENT
    }
}
impl<'r, R: GroundingCertificateResolver<H>, H: HostTypes> ResolvedGroundingCertificate<'r, R, H> {
    /// Promote the `grounding_cert_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_cert_map<'r2, R2: GroundingMapResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedGroundingMap<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedGroundingMap::new(
            record.grounding_cert_map_handle,
            r,
        ))
    }
    /// Promote the `grounding_cert_projection` 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_cert_projection<'r2, R2: ProjectionMapResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedProjectionMap<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedProjectionMap::new(
            record.grounding_cert_projection_handle,
            r,
        ))
    }
    /// Promote the `grounding_cert_source_symbol` 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_cert_source_symbol<
        'r2,
        R2: crate::kernel::schema::LiteralResolver<H>,
    >(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::kernel::schema::ResolvedLiteral<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::kernel::schema::ResolvedLiteral::new(
            record.grounding_cert_source_symbol_handle,
            r,
        ))
    }
    /// Promote the `grounding_cert_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_grounding_cert_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.grounding_cert_address_handle,
            r,
        ))
    }
}

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

/// Phase 8 (orphan-closure) — typed record for `TopologicalDelta<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 TopologicalDeltaRecord<H: HostTypes> {
    pub bettis_before_handle: crate::bridge::observable::BettiNumberHandle<H>,
    pub bettis_after_handle: crate::bridge::observable::BettiNumberHandle<H>,
    pub euler_before: i64,
    pub euler_after: i64,
    pub nerve_before_handle: crate::bridge::homology::SimplicialComplexHandle<H>,
    pub nerve_after_handle: crate::bridge::homology::SimplicialComplexHandle<H>,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `TopologicalDelta<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 ResolvedTopologicalDelta<'r, R: TopologicalDeltaResolver<H>, H: HostTypes> {
    handle: TopologicalDeltaHandle<H>,
    resolver: &'r R,
    record: Option<TopologicalDeltaRecord<H>>,
}
impl<'r, R: TopologicalDeltaResolver<H>, H: HostTypes> ResolvedTopologicalDelta<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: TopologicalDeltaHandle<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) -> TopologicalDeltaHandle<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<&TopologicalDeltaRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: TopologicalDeltaResolver<H>, H: HostTypes> TopologicalDelta<H>
    for ResolvedTopologicalDelta<'r, R, H>
{
    type BettiNumber = crate::bridge::observable::NullBettiNumber<H>;
    fn bettis_before(&self) -> &Self::BettiNumber {
        &<crate::bridge::observable::NullBettiNumber<H>>::ABSENT
    }
    fn bettis_after(&self) -> &Self::BettiNumber {
        &<crate::bridge::observable::NullBettiNumber<H>>::ABSENT
    }
    fn euler_before(&self) -> i64 {
        match &self.record {
            Some(r) => r.euler_before,
            None => 0,
        }
    }
    fn euler_after(&self) -> i64 {
        match &self.record {
            Some(r) => r.euler_after,
            None => 0,
        }
    }
    type SimplicialComplex = crate::bridge::homology::NullSimplicialComplex<H>;
    fn nerve_before(&self) -> &Self::SimplicialComplex {
        &<crate::bridge::homology::NullSimplicialComplex<H>>::ABSENT
    }
    fn nerve_after(&self) -> &Self::SimplicialComplex {
        &<crate::bridge::homology::NullSimplicialComplex<H>>::ABSENT
    }
}
impl<'r, R: TopologicalDeltaResolver<H>, H: HostTypes> ResolvedTopologicalDelta<'r, R, H> {
    /// Promote the `bettis_before` 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_bettis_before<'r2, R2: crate::bridge::observable::BettiNumberResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::bridge::observable::ResolvedBettiNumber<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::bridge::observable::ResolvedBettiNumber::new(
            record.bettis_before_handle,
            r,
        ))
    }
    /// Promote the `bettis_after` 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_bettis_after<'r2, R2: crate::bridge::observable::BettiNumberResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::bridge::observable::ResolvedBettiNumber<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::bridge::observable::ResolvedBettiNumber::new(
            record.bettis_after_handle,
            r,
        ))
    }
    /// Promote the `nerve_before` 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_nerve_before<'r2, R2: crate::bridge::homology::SimplicialComplexResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::bridge::homology::ResolvedSimplicialComplex<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::bridge::homology::ResolvedSimplicialComplex::new(
            record.nerve_before_handle,
            r,
        ))
    }
    /// Promote the `nerve_after` 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_nerve_after<'r2, R2: crate::bridge::homology::SimplicialComplexResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::bridge::homology::ResolvedSimplicialComplex<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::bridge::homology::ResolvedSimplicialComplex::new(
            record.nerve_after_handle,
            r,
        ))
    }
}

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

/// Phase 8 (orphan-closure) — typed record for `ComputationDatum<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 ComputationDatumRecord<H: HostTypes> {
    pub referenced_certificate_handle: crate::bridge::cert::TransformCertificateHandle<H>,
    pub computation_address_handle: crate::kernel::address::ElementHandle<H>,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `ComputationDatum<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 ResolvedComputationDatum<'r, R: ComputationDatumResolver<H>, H: HostTypes> {
    handle: ComputationDatumHandle<H>,
    resolver: &'r R,
    record: Option<ComputationDatumRecord<H>>,
}
impl<'r, R: ComputationDatumResolver<H>, H: HostTypes> ResolvedComputationDatum<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: ComputationDatumHandle<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) -> ComputationDatumHandle<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<&ComputationDatumRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: ComputationDatumResolver<H>, H: HostTypes> crate::kernel::schema::Datum<H>
    for ResolvedComputationDatum<'r, R, H>
{
    fn value(&self) -> u64 {
        0
    }
    fn witt_length(&self) -> u64 {
        0
    }
    fn stratum(&self) -> u64 {
        0
    }
    fn spectrum(&self) -> u64 {
        0
    }
    type Element = crate::kernel::address::NullElement<H>;
    fn element(&self) -> &Self::Element {
        &<crate::kernel::address::NullElement<H>>::ABSENT
    }
}
impl<'r, R: ComputationDatumResolver<H>, H: HostTypes> ComputationDatum<H>
    for ResolvedComputationDatum<'r, R, H>
{
    type TransformCertificate = crate::bridge::cert::NullTransformCertificate<H>;
    fn referenced_certificate(&self) -> &Self::TransformCertificate {
        &<crate::bridge::cert::NullTransformCertificate<H>>::ABSENT
    }
    fn computation_address(&self) -> &Self::Element {
        &<crate::kernel::address::NullElement<H>>::ABSENT
    }
}
impl<'r, R: ComputationDatumResolver<H>, H: HostTypes> ResolvedComputationDatum<'r, R, H> {
    /// Promote the `referenced_certificate` 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_referenced_certificate<
        'r2,
        R2: crate::bridge::cert::TransformCertificateResolver<H>,
    >(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::bridge::cert::ResolvedTransformCertificate<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::bridge::cert::ResolvedTransformCertificate::new(
            record.referenced_certificate_handle,
            r,
        ))
    }
    /// Promote the `computation_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_computation_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.computation_address_handle,
            r,
        ))
    }
}

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

/// Phase 8 (orphan-closure) — typed record for `ApplicationMorphism<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 ApplicationMorphismRecord<H: HostTypes> {
    pub application_target_handle: ComputationDatumHandle<H>,
    pub application_input_handle: crate::kernel::schema::DatumHandle<H>,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `ApplicationMorphism<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 ResolvedApplicationMorphism<'r, R: ApplicationMorphismResolver<H>, H: HostTypes> {
    handle: ApplicationMorphismHandle<H>,
    resolver: &'r R,
    record: Option<ApplicationMorphismRecord<H>>,
}
impl<'r, R: ApplicationMorphismResolver<H>, H: HostTypes> ResolvedApplicationMorphism<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: ApplicationMorphismHandle<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) -> ApplicationMorphismHandle<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<&ApplicationMorphismRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: ApplicationMorphismResolver<H>, H: HostTypes> Transform<H>
    for ResolvedApplicationMorphism<'r, R, H>
{
    fn source(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn target(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn preserves_count(&self) -> usize {
        0
    }
    fn preserves_at(&self, _index: usize) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type ComputationTrace = crate::bridge::trace::NullComputationTrace<H>;
    fn trace(&self) -> &Self::ComputationTrace {
        &<crate::bridge::trace::NullComputationTrace<H>>::ABSENT
    }
    type TransformTarget = NullTransform<H>;
    fn composes_with(&self) -> &[Self::TransformTarget] {
        &[]
    }
    type Identity = crate::kernel::op::NullIdentity<H>;
    fn preserved_invariant(&self) -> &Self::Identity {
        &<crate::kernel::op::NullIdentity<H>>::ABSENT
    }
    fn input_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn output_class(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type Witness = NullWitness<H>;
    fn has_witness(&self) -> &[Self::Witness] {
        &[]
    }
}
impl<'r, R: ApplicationMorphismResolver<H>, H: HostTypes> ApplicationMorphism<H>
    for ResolvedApplicationMorphism<'r, R, H>
{
    type ComputationDatum = NullComputationDatum<H>;
    fn application_target(&self) -> &Self::ComputationDatum {
        &<NullComputationDatum<H>>::ABSENT
    }
    type Datum = crate::kernel::schema::NullDatum<H>;
    fn application_input(&self) -> &Self::Datum {
        &<crate::kernel::schema::NullDatum<H>>::ABSENT
    }
}
impl<'r, R: ApplicationMorphismResolver<H>, H: HostTypes> ResolvedApplicationMorphism<'r, R, H> {
    /// Promote the `application_target` handle on the cached record into a
    /// resolved wrapper, given a resolver for the range class.
    /// Returns `None` if no record was resolved at construction.
    #[inline]
    pub fn resolve_application_target<'r2, R2: ComputationDatumResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedComputationDatum<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedComputationDatum::new(
            record.application_target_handle,
            r,
        ))
    }
    /// Promote the `application_input` 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_application_input<'r2, R2: crate::kernel::schema::DatumResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::kernel::schema::ResolvedDatum<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::kernel::schema::ResolvedDatum::new(
            record.application_input_handle,
            r,
        ))
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `PartialApplication<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 ResolvedPartialApplication<'r, R: PartialApplicationResolver<H>, H: HostTypes> {
    handle: PartialApplicationHandle<H>,
    resolver: &'r R,
    record: Option<PartialApplicationRecord<H>>,
}
impl<'r, R: PartialApplicationResolver<H>, H: HostTypes> ResolvedPartialApplication<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: PartialApplicationHandle<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) -> PartialApplicationHandle<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<&PartialApplicationRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: PartialApplicationResolver<H>, H: HostTypes> crate::kernel::schema::Datum<H>
    for ResolvedPartialApplication<'r, R, H>
{
    fn value(&self) -> u64 {
        0
    }
    fn witt_length(&self) -> u64 {
        0
    }
    fn stratum(&self) -> u64 {
        0
    }
    fn spectrum(&self) -> u64 {
        0
    }
    type Element = crate::kernel::address::NullElement<H>;
    fn element(&self) -> &Self::Element {
        &<crate::kernel::address::NullElement<H>>::ABSENT
    }
}
impl<'r, R: PartialApplicationResolver<H>, H: HostTypes> ComputationDatum<H>
    for ResolvedPartialApplication<'r, R, H>
{
    type TransformCertificate = crate::bridge::cert::NullTransformCertificate<H>;
    fn referenced_certificate(&self) -> &Self::TransformCertificate {
        &<crate::bridge::cert::NullTransformCertificate<H>>::ABSENT
    }
    fn computation_address(&self) -> &Self::Element {
        &<crate::kernel::address::NullElement<H>>::ABSENT
    }
}
impl<'r, R: PartialApplicationResolver<H>, H: HostTypes> PartialApplication<H>
    for ResolvedPartialApplication<'r, R, H>
{
    type ComputationDatum = NullComputationDatum<H>;
    fn partial_base(&self) -> &Self::ComputationDatum {
        &<NullComputationDatum<H>>::ABSENT
    }
    type Datum = crate::kernel::schema::NullDatum<H>;
    fn bound_arguments(&self) -> &[Self::Datum] {
        &[]
    }
    fn remaining_arity(&self) -> u64 {
        match &self.record {
            Some(r) => r.remaining_arity,
            None => 0,
        }
    }
}
impl<'r, R: PartialApplicationResolver<H>, H: HostTypes> ResolvedPartialApplication<'r, R, H> {
    /// Promote the `partial_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_partial_base<'r2, R2: ComputationDatumResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedComputationDatum<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedComputationDatum::new(record.partial_base_handle, r))
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `TransformComposition<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 ResolvedTransformComposition<'r, R: TransformCompositionResolver<H>, H: HostTypes> {
    handle: TransformCompositionHandle<H>,
    resolver: &'r R,
    record: Option<TransformCompositionRecord<H>>,
}
impl<'r, R: TransformCompositionResolver<H>, H: HostTypes> ResolvedTransformComposition<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: TransformCompositionHandle<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) -> TransformCompositionHandle<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<&TransformCompositionRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: TransformCompositionResolver<H>, H: HostTypes> crate::kernel::schema::Datum<H>
    for ResolvedTransformComposition<'r, R, H>
{
    fn value(&self) -> u64 {
        0
    }
    fn witt_length(&self) -> u64 {
        0
    }
    fn stratum(&self) -> u64 {
        0
    }
    fn spectrum(&self) -> u64 {
        0
    }
    type Element = crate::kernel::address::NullElement<H>;
    fn element(&self) -> &Self::Element {
        &<crate::kernel::address::NullElement<H>>::ABSENT
    }
}
impl<'r, R: TransformCompositionResolver<H>, H: HostTypes> ComputationDatum<H>
    for ResolvedTransformComposition<'r, R, H>
{
    type TransformCertificate = crate::bridge::cert::NullTransformCertificate<H>;
    fn referenced_certificate(&self) -> &Self::TransformCertificate {
        &<crate::bridge::cert::NullTransformCertificate<H>>::ABSENT
    }
    fn computation_address(&self) -> &Self::Element {
        &<crate::kernel::address::NullElement<H>>::ABSENT
    }
}
impl<'r, R: TransformCompositionResolver<H>, H: HostTypes> TransformComposition<H>
    for ResolvedTransformComposition<'r, R, H>
{
    type ComputationDatum = NullComputationDatum<H>;
    fn composition_left(&self) -> &Self::ComputationDatum {
        &<NullComputationDatum<H>>::ABSENT
    }
    fn composition_right(&self) -> &Self::ComputationDatum {
        &<NullComputationDatum<H>>::ABSENT
    }
}
impl<'r, R: TransformCompositionResolver<H>, H: HostTypes> ResolvedTransformComposition<'r, R, H> {
    /// Promote the `composition_left` 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_composition_left<'r2, R2: ComputationDatumResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedComputationDatum<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedComputationDatum::new(
            record.composition_left_handle,
            r,
        ))
    }
    /// Promote the `composition_right` 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_composition_right<'r2, R2: ComputationDatumResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedComputationDatum<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedComputationDatum::new(
            record.composition_right_handle,
            r,
        ))
    }
}

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

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

/// Phase 8 (orphan-closure) — content-addressed wrapper for `SymbolSequence<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 ResolvedSymbolSequence<'r, R: SymbolSequenceResolver<H>, H: HostTypes> {
    handle: SymbolSequenceHandle<H>,
    resolver: &'r R,
    record: Option<SymbolSequenceRecord<H>>,
}
impl<'r, R: SymbolSequenceResolver<H>, H: HostTypes> ResolvedSymbolSequence<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: SymbolSequenceHandle<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) -> SymbolSequenceHandle<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<&SymbolSequenceRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: SymbolSequenceResolver<H>, H: HostTypes> SymbolSequence<H>
    for ResolvedSymbolSequence<'r, R, H>
{
    type SequenceElement = NullSequenceElement<H>;
    fn has_element(&self) -> &[Self::SequenceElement] {
        &[]
    }
}

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

/// Phase 8 (orphan-closure) — typed record for `SequenceElement<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 SequenceElementRecord<H: HostTypes> {
    pub element_value_handle: crate::kernel::schema::SurfaceSymbolHandle<H>,
    pub element_index: u64,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `SequenceElement<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 ResolvedSequenceElement<'r, R: SequenceElementResolver<H>, H: HostTypes> {
    handle: SequenceElementHandle<H>,
    resolver: &'r R,
    record: Option<SequenceElementRecord<H>>,
}
impl<'r, R: SequenceElementResolver<H>, H: HostTypes> ResolvedSequenceElement<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: SequenceElementHandle<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) -> SequenceElementHandle<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<&SequenceElementRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: SequenceElementResolver<H>, H: HostTypes> SequenceElement<H>
    for ResolvedSequenceElement<'r, R, H>
{
    type SurfaceSymbol = crate::kernel::schema::NullSurfaceSymbol<H>;
    fn element_value(&self) -> &Self::SurfaceSymbol {
        &<crate::kernel::schema::NullSurfaceSymbol<H>>::ABSENT
    }
    fn element_index(&self) -> u64 {
        match &self.record {
            Some(r) => r.element_index,
            None => 0,
        }
    }
}
impl<'r, R: SequenceElementResolver<H>, H: HostTypes> ResolvedSequenceElement<'r, R, H> {
    /// Promote the `element_value` 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_element_value<'r2, R2: crate::kernel::schema::SurfaceSymbolResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::kernel::schema::ResolvedSurfaceSymbol<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::kernel::schema::ResolvedSurfaceSymbol::new(
            record.element_value_handle,
            r,
        ))
    }
}

/// The critical composition law: neg ∘ bnot = succ. This is the operational form of the critical identity theorem. The composition of the two involutions (neg, bnot) yields the successor operation. Non-associative and non-commutative.
pub mod critical_composition {
    /// `isAssociative`
    pub const IS_ASSOCIATIVE: bool = false;
    /// `isCommutative`
    pub const IS_COMMUTATIVE: bool = false;
    /// `lawComponents`
    pub const LAW_COMPONENTS: &[&str] = &[
        "https://uor.foundation/op/neg",
        "https://uor.foundation/op/bnot",
    ];
    /// `lawResult` -> `succ`
    pub const LAW_RESULT: &str = "https://uor.foundation/op/succ";
}

/// Grounds integer surface symbols to ring addresses.
pub mod integer_grounding_map {
    /// `inputClass` -> `Literal`
    pub const INPUT_CLASS: &str = "https://uor.foundation/schema/Literal";
    /// `outputClass` -> `Element`
    pub const OUTPUT_CLASS: &str = "https://uor.foundation/u/Element";
}

/// Grounds UTF-8 host strings to ring addresses.
pub mod utf8_grounding_map {
    /// `inputClass` -> `HostStringLiteral`
    pub const INPUT_CLASS: &str = "https://uor.foundation/schema/HostStringLiteral";
    /// `outputClass` -> `Element`
    pub const OUTPUT_CLASS: &str = "https://uor.foundation/u/Element";
}

/// Grounds JSON host strings to ring addresses.
pub mod json_grounding_map {
    /// `inputClass` -> `HostStringLiteral`
    pub const INPUT_CLASS: &str = "https://uor.foundation/schema/HostStringLiteral";
    /// `outputClass` -> `Element`
    pub const OUTPUT_CLASS: &str = "https://uor.foundation/u/Element";
}

/// A GroundingMap that maps fixed-size external byte strings to ring datums via a one-way digest function (e.g., SHA-256). Total but not invertible: every input grounds, but distinct inputs may collide; the inverse is computationally unbounded. Preserves no algebraic structure.
pub mod digest_grounding_map {
    /// `inputClass` -> `HostStringLiteral`
    pub const INPUT_CLASS: &str = "https://uor.foundation/schema/HostStringLiteral";
    /// `outputClass` -> `Element`
    pub const OUTPUT_CLASS: &str = "https://uor.foundation/u/Element";
}

/// A GroundingMap that maps host-supplied byte sequences to ring datums via a fixed bit-pattern interpretation (e.g., little-endian unsigned integer reading). Total and invertible on its declared bit-width; preserves no algebraic structure beyond bit identity.
pub mod binary_grounding_map {
    /// `inputClass` -> `HostStringLiteral`
    pub const INPUT_CLASS: &str = "https://uor.foundation/schema/HostStringLiteral";
    /// `outputClass` -> `Element`
    pub const OUTPUT_CLASS: &str = "https://uor.foundation/u/Element";
}

/// Projects partitions to integer symbol sequences.
pub mod integer_projection_map {
    /// `inputClass` -> `Partition`
    pub const INPUT_CLASS: &str = "https://uor.foundation/partition/Partition";
    /// `outputClass` -> `SymbolSequence`
    pub const OUTPUT_CLASS: &str = "https://uor.foundation/morphism/SymbolSequence";
    /// `outputElementClass` -> `Literal`
    pub const OUTPUT_ELEMENT_CLASS: &str = "https://uor.foundation/schema/Literal";
}

/// Projects partitions to UTF-8 symbol sequences.
pub mod utf8_projection_map {
    /// `inputClass` -> `Partition`
    pub const INPUT_CLASS: &str = "https://uor.foundation/partition/Partition";
    /// `outputClass` -> `SymbolSequence`
    pub const OUTPUT_CLASS: &str = "https://uor.foundation/morphism/SymbolSequence";
    /// `outputElementClass` -> `HostStringLiteral`
    pub const OUTPUT_ELEMENT_CLASS: &str = "https://uor.foundation/schema/HostStringLiteral";
}

/// Projects partitions to JSON symbol sequences.
pub mod json_projection_map {
    /// `inputClass` -> `Partition`
    pub const INPUT_CLASS: &str = "https://uor.foundation/partition/Partition";
    /// `outputClass` -> `SymbolSequence`
    pub const OUTPUT_CLASS: &str = "https://uor.foundation/morphism/SymbolSequence";
    /// `outputElementClass` -> `HostStringLiteral`
    pub const OUTPUT_ELEMENT_CLASS: &str = "https://uor.foundation/schema/HostStringLiteral";
}

/// Projects partitions to fixed-size digest symbol sequences. Dual of DigestGroundingMap.
pub mod digest_projection_map {
    /// `inputClass` -> `Partition`
    pub const INPUT_CLASS: &str = "https://uor.foundation/partition/Partition";
    /// `outputClass` -> `SymbolSequence`
    pub const OUTPUT_CLASS: &str = "https://uor.foundation/morphism/SymbolSequence";
    /// `outputElementClass` -> `Literal`
    pub const OUTPUT_ELEMENT_CLASS: &str = "https://uor.foundation/schema/Literal";
}

/// Projects partitions to raw byte symbol sequences. Dual of BinaryGroundingMap.
pub mod binary_projection_map {
    /// `inputClass` -> `Partition`
    pub const INPUT_CLASS: &str = "https://uor.foundation/partition/Partition";
    /// `outputClass` -> `SymbolSequence`
    pub const OUTPUT_CLASS: &str = "https://uor.foundation/morphism/SymbolSequence";
    /// `outputElementClass` -> `Literal`
    pub const OUTPUT_ELEMENT_CLASS: &str = "https://uor.foundation/schema/Literal";
}