Struct Classification 

pub struct Classification {
    pub point_type: ConvergencePointType,
    pub substrate: SubstrateType,
    pub horizon: Horizon,
    pub calm: CalmClassification,
    pub data_classification: DataClassification,
}

Lattice position of a Process — six orthogonal axes.

Fields

point_type: ConvergencePointType

substrate: SubstrateType

horizon: Horizon

calm: CalmClassification

data_classification: DataClassification

Implementations

impl Classification

pub fn gate_compute() -> Self

The workspace-baseline classification — a ConvergencePointType::Gate point on the SubstrateType::Compute substrate with every other axis at its Default. The (Gate, Compute) pair names an unremarkable barrier point in the Compute plane: no domain-specific structural claim (no fan-out / fan-in / broadcast / observation semantics beyond the barrier gate) and no domain-specific substrate claim (no Financial / Network / Storage / Security / Identity / Observability / Regulatory plane bringing in its own compliance baselines). The three defaulted axes ride at the intentional workspace baseline the sibling closed-set primitives already own: Horizon at HorizonKind::Bounded (terminates naturally, no asymptotic metric axes required), CalmClassification::Monotone (no coordination required per CALM), and DataClassification::Internal (access-controlled but not externally regulated).

Pre-lift the six-line Classification { point_type: Gate, substrate: Compute, horizon: Default::default(), calm: Default::default(), data_classification: Default::default() } struct-literal recurred at TEN sites past the ★★ PRIME-DIRECTIVE ≥ 2 duplication threshold — one production consumer plus nine test-fixture callsites spread across four crates, each restating the SAME (Gate, Compute) baseline verbatim:

• crate::ephemeral::default_ephemeral_class — the substitute [EphemeralSpec::into::<crate::crd::ProcessSpec>] fills into crate::crd::ProcessSpec::classification when the operator omits an explicit :classification slot on (defephemeral …). The one PRODUCTION consumer of the shape — a regression that drifted its point-type or substrate axis silently retargets every unadorned ephemeral to a different plane.
• crate::crd’s + crate::lib’s + crate::lifetime_clock’s + tatara_reconciler::{claim,render}’s + tatara_pool_reconciler:: controller_pool’s empty_spec / empty_process_spec / ephemeral_process / permanent_process test-fixture helpers + inline ProcessSpec literals — nine test-fixture callsites restating the SAME six-line struct-literal at the same shape.

Post-lift every callsite reads Classification::gate_compute(); a future workspace-wide baseline shift (a new Horizon default, a promotion of Compute to a compound baseline that pre-fills a canonical CalmClassification, a per-baseline compliance overlay stamping through the classification, or a rename of either axis enum) lands at ONE substrate function here and every downstream consumer inherits the upgrade mechanically. The current pin ties the three defaulted axes to the sibling closed-set defaults (HorizonKind::Bounded, CalmClassification::Monotone, DataClassification::Internal) so a future change to any sibling default surfaces at this primitive’s tests rather than as silent drift across ten independent callsites.

Sibling to the _or_default / _or_placeholder primitive family on crate::prelude::Process on the (return-form × axis) axis — those primitives own the borrow-form projections off a live Process; this one owns the construction shape for a fresh crate::crd::ProcessSpec whose classification axis is unremarkable. A future peer Classification::observe_observability() or similar named variant lands as a sibling method here when a second unremarkable-baseline shape opens.

Theory anchor: THEORY.md §VI.1 (generation over composition — the six-line struct-literal shape recurred at TEN hand-authored sites past the ★★ PRIME-DIRECTIVE ≥ 2 duplication trigger and is lifted onto ONE workspace-wide owner here). THEORY.md §II.1 invariant 5 (composition preserves proofs — a regression that drifted the baseline axis choice at only one consumer, or that broke the sibling-default correspondence, surfaces at this primitive’s tests rather than as silent operator-visible skew between the ephemeral sugar substitute and the ten downstream test-fixtures whose assertions depend on the shape).

pub fn has_point_type(&self, kind: ConvergencePointType) -> bool

Closed-set-driven presence probe — does this Classification carry the given ConvergencePointType discriminator on its Self::point_type slot? The ONE substrate primitive that owns the (Classification, ConvergencePointType) -> bool scalar-carrier walk shape.

Third scalar-carrier peer on the presence-probe axis

Peer of crate::spec::SignalPolicy::has_sighup_strategy and crate::encapsulates::EncapsulatesSpec::has_mode — all three probe a scalar closed-set-discriminator field on an inner crate::crd::ProcessSpec struct via a one-line self.<field> == kind body. Together they compose the SCALAR-CARRIER stratum of the workspace-wide closed-set-driven presence-probe algebra (the workspace-wide algebra spans three underlying representation kinds — Option-slot, slice, scalar — see the crate::spec::SignalPolicy::has_sighup_strategy docstring for the full-shape rundown; this method is the third scalar-carrier instance).

Semantics — VARIANT match, not POPULATED slot

has_point_type(kind) returns true iff self.point_type == kind. Distinct from BOTH prior scalar-carrier peers on the (parent-shape × child-shape) axis:

• crate::spec::SignalPolicy::has_sighup_strategy lives on a non-Option, DEFAULTED parent (SignalPolicy: Default) with a defaulted scalar child (SighupStrategy: Default = Reconverge) — a default carrier reads true for the default variant only.
• crate::encapsulates::EncapsulatesSpec::has_mode lives on an OPTION parent (spec.encapsulates: Option<EncapsulatesSpec>) with a defaulted scalar child (EncapsulationMode: Default = Manage) — a bare None parent reads false for every variant.
• has_point_type lives on a REQUIRED, non-Option, NON-DEFAULT parent (Classification has no impl Default) with a NON-DEFAULT scalar child (ConvergencePointType has no impl Default) — every well-formed crate::crd::ProcessSpec carries a Classification whose point_type slot is deliberately chosen by the operator, so the probe returns true on exactly ONE variant per spec and false on the other seven, with no default-arm short-circuit shortcut.

This closes the (required-parent × required-scalar-child) corner of the workspace-wide closed-set-driven presence-probe algebra at its first substrate primitive.

Compounding

A future closed-set-discriminator scalar field on Classification (a peer has_substrate, has_calm, has_data_classification — the four remaining classification-axis closed sets) lands as ONE peer inherent method with the same one-line self.<field> == kind body and routes through the same strip_and_classify_prefixed_kind::<K, _> shape in tatara-check. A future ConvergencePointType variant (a hypothetical Demux / Mux / Pipeline for finer topology carving) reaches every downstream through ONE ALL entry on the closed set with the probe body untouched.

Theory anchor: THEORY.md §II.1 invariant 5 — composition preserves proofs; the scalar-carrier presence-probe body lives at ONE substrate site so every downstream (point-type-<kind> require-tag family in tatara-check, closed-set audit dispatchers, future variant additions on ConvergencePointType) binds through the SAME shape rather than restating the classification.point_type == kind closure body at each callsite. THEORY.md §VI.1 — generation over composition; a future ConvergencePointType variant lands at ONE ALL entry + ONE as_str arm on the closed set and the probe picks it up mechanically without further per-consumer edits.

pub fn has_substrate(&self, kind: SubstrateType) -> bool

Closed-set-driven presence probe — does this Classification carry the given SubstrateType discriminator on its Self::substrate slot? The ONE substrate primitive that owns the (Classification, SubstrateType) -> bool scalar-carrier walk shape.

Fourth scalar-carrier peer on the presence-probe axis

Peer of crate::spec::SignalPolicy::has_sighup_strategy, crate::encapsulates::EncapsulatesSpec::has_mode, and Self::has_point_type — all four probe a scalar closed-set- discriminator field on an inner crate::crd::ProcessSpec struct via a one-line self.<field> == kind body. Together they compose the SCALAR-CARRIER stratum of the workspace-wide closed-set-driven presence-probe algebra (the workspace-wide algebra spans three underlying representation kinds — Option- slot, slice, scalar — see the crate::spec::SignalPolicy::has_sighup_strategy docstring for the full-shape rundown; this method is the fourth scalar- carrier instance).

Semantics — VARIANT match, not POPULATED slot

has_substrate(kind) returns true iff self.substrate == kind. FIRST co-tenant on the (required-parent × required- scalar-child) corner of the algebra with Self::has_point_type — both probe REQUIRED, non-Option, NON-DEFAULT slots on the same Classification parent whose two required axes carry no Default impl, so exactly ONE of the eight SubstrateType variants and exactly ONE of the eight ConvergencePointType variants answer true per well-formed crate::crd::ProcessSpec, with no default-arm short-circuit shortcut. Distinct from the two prior scalar-carrier peers on the (parent-shape × child- shape) axis: has_sighup_strategy lives on a non-Option, DEFAULTED parent (crate::spec::SignalPolicy carries #[derive(Default)]) with a defaulted scalar child (crate::signal::SighupStrategy defaults to crate::signal::SighupStrategy::Reconverge); has_mode lives on an OPTION parent (spec.encapsulates: Option<EncapsulatesSpec>) with a defaulted scalar child (crate::encapsulates::EncapsulationMode defaults to crate::encapsulates::EncapsulationMode::Manage).

This POPULATES the (required-parent × required-scalar-child) corner of the workspace-wide closed-set-driven presence-probe algebra at its SECOND substrate primitive after Self::has_point_type opened the corner, pinning the corner as a proven-repeatable primitive shape rather than a single- example curiosity.

Compounding

A future closed-set-discriminator scalar field on Classification (a peer has_calm on CalmClassification, has_data_classification on DataClassification — the two remaining defaulted-scalar-child classification-axis closed sets) lands as ONE peer inherent method with the same one-line self.<field> == kind body and routes through the same strip_and_classify_prefixed_kind::<K, _> shape in tatara-check. A future SubstrateType variant (a hypothetical Consensus for governance substrates, Physical for hardware substrates, Cache for ephemeral memoization substrates) reaches every downstream through ONE ALL entry on the closed set with the probe body untouched.

Theory anchor: THEORY.md §II.1 invariant 5 — composition preserves proofs; the scalar-carrier presence-probe body lives at ONE substrate site so every downstream (substrate-<kind> require-tag family in tatara-check, closed-set audit dispatchers, future variant additions on SubstrateType) binds through the SAME shape rather than restating the classification.substrate == kind closure body at each callsite. THEORY.md §VI.1 — generation over composition; a future SubstrateType variant lands at ONE ALL entry + ONE as_str arm on the closed set and the probe picks it up mechanically without further per-consumer edits.

pub fn has_calm(&self, kind: CalmClassification) -> bool

Closed-set-driven presence probe — does this Classification carry the given CalmClassification discriminator on its Self::calm slot? The ONE substrate primitive that owns the (Classification, CalmClassification) -> bool scalar-carrier walk shape.

Fifth scalar-carrier peer on the presence-probe axis

Peer of crate::spec::SignalPolicy::has_sighup_strategy, crate::encapsulates::EncapsulatesSpec::has_mode, Self::has_point_type, and Self::has_substrate — all five probe a scalar closed-set-discriminator field on an inner crate::crd::ProcessSpec struct via a one-line self.<field> == kind body. Together they compose the SCALAR-CARRIER stratum of the workspace-wide closed-set-driven presence-probe algebra (the workspace-wide algebra spans three underlying representation kinds — Option-slot, slice, scalar — see the crate::spec::SignalPolicy::has_sighup_strategy docstring for the full-shape rundown; this method is the fifth scalar-carrier instance).

Semantics — VARIANT match, not POPULATED slot

has_calm(kind) returns true iff self.calm == kind. FIRST occupant on a FRESH corner of the (parent-shape × child-shape) axis: a REQUIRED, non-Option, NON-DEFAULT parent (Classification has no impl Default because its two required axes point_type/substrate carry no default) combined with a DEFAULTED scalar child (CalmClassification defaults to CalmClassification::Monotone via #[default]). Distinct from every prior scalar-carrier peer on the (parent-shape × child-shape) axis:

• crate::spec::SignalPolicy::has_sighup_strategy lives on a non-Option, DEFAULTED parent (crate::spec::SignalPolicy carries #[derive(Default)]) with a defaulted scalar child (crate::signal::SighupStrategy defaults to crate::signal::SighupStrategy::Reconverge) — a bare SignalPolicy reads true on the default variant only.
• crate::encapsulates::EncapsulatesSpec::has_mode lives on an OPTION parent (spec.encapsulates: Option<EncapsulatesSpec>) with a defaulted scalar child (crate::encapsulates::EncapsulationMode defaults to crate::encapsulates::EncapsulationMode::Manage) — a bare None parent reads false for every variant.
• Self::has_point_type + Self::has_substrate both live on the REQUIRED, non-Option, NON-DEFAULT Classification parent with a NON-DEFAULT scalar child — every well-formed crate::crd::ProcessSpec carries a Classification whose corresponding slot was deliberately chosen by the operator, so exactly ONE of the eight variants answers true per spec.
• has_calm lives on the REQUIRED, non-Option, NON-DEFAULT Classification parent with a DEFAULTED scalar child (CalmClassification::Monotone is the Default via #[default]) — a bare Classification filled via ..Default::default() on the defaulted axes reads true for the default variant (CalmClassification::Monotone) and false for every other. Exactly ONE of the two variants answers true per spec, and the default-arm short-circuit is present (the operator can DECLINE to name the CALM axis and the spec still answers true on the default variant).

This OPENS the (required-parent × defaulted-scalar-child) corner of the workspace-wide closed-set-driven presence-probe algebra at its first substrate primitive — a corner distinct from all four prior scalar-carrier peers (which sit on the three prior corners: defaulted-parent × defaulted-child, Option-parent × defaulted-child, required-parent × required-child).

Compounding

A future closed-set-discriminator scalar field on Classification whose child carries #[derive(Default)] (a peer has_data_classification on DataClassification, whose default is DataClassification::Internal via #[default] — the remaining classification-axis closed set on a defaulted-scalar-child slot) lands as ONE peer inherent method with the same one-line self.<field> == kind body and routes through the same strip_and_classify_prefixed_kind::<K, _> shape in tatara-check. A future CalmClassification variant (a hypothetical ConditionallyMonotone for ops that are monotone under a witness, like CRDT joins under a fixed schema) reaches every downstream through ONE ALL entry on the closed set with the probe body untouched.

Theory anchor: THEORY.md §II.1 invariant 5 — composition preserves proofs; the scalar-carrier presence-probe body lives at ONE substrate site so every downstream (calm-<kind> require-tag family in tatara-check, closed-set audit dispatchers, future variant additions on CalmClassification) binds through the SAME shape rather than restating the classification.calm == kind closure body at each callsite. THEORY.md §VI.1 — generation over composition; a future CalmClassification variant lands at ONE ALL entry + ONE as_str arm on the closed set and the probe picks it up mechanically without further per-consumer edits.

pub fn has_data_classification(&self, kind: DataClassification) -> bool

Closed-set-driven presence probe — does this Classification carry the given DataClassification discriminator on its Self::data_classification slot? The ONE substrate primitive that owns the (Classification, DataClassification) -> bool scalar-carrier walk shape.

Sixth scalar-carrier peer on the presence-probe axis

Peer of crate::spec::SignalPolicy::has_sighup_strategy, crate::encapsulates::EncapsulatesSpec::has_mode, Self::has_point_type, Self::has_substrate, and Self::has_calm — all six probe a scalar closed-set- discriminator field on an inner crate::crd::ProcessSpec struct via a one-line self.<field> == kind body. Together they compose the SCALAR-CARRIER stratum of the workspace-wide closed-set-driven presence-probe algebra (the workspace-wide algebra spans three underlying representation kinds — Option- slot, slice, scalar — see the crate::spec::SignalPolicy::has_sighup_strategy docstring for the full-shape rundown; this method is the sixth scalar- carrier instance).

Semantics — VARIANT match, not POPULATED slot

has_data_classification(kind) returns true iff self.data_classification == kind. SECOND co-tenant on the (required-parent × defaulted-scalar-child) corner of the algebra alongside Self::has_calm — both probe REQUIRED, non-Option, NON-DEFAULT Classification parent slots with a DEFAULTED scalar child (DataClassification defaults to DataClassification::Internal via #[default], sibling to CalmClassification::Monotone’s #[default]), so exactly ONE of the six DataClassification variants answers true per spec AND the default-arm short-circuit is present (a Classification filled via ..Default::default() on the data_classification axis reads true on the default variant DataClassification::Internal and false on every other).

This POPULATES the (required-parent × defaulted-scalar-child) corner of the workspace-wide closed-set-driven presence-probe algebra at its SECOND substrate primitive after Self::has_calm opened the corner, pinning the corner as a proven-repeatable primitive shape rather than a single-example curiosity. The corner-property contract (“bare Classification reads true on the default variant”) now walks TWO independent defaulted-scalar-child slots on the SAME Classification parent — a regression that promoted a different DataClassification variant to #[default] (or wired the arm to a fixed variant answer) fails HERE at ONE narrow substrate site before drifting through every unadorned Process’s baseline data-classification answer.

Compounding

This method exhausts the four scalar closed-set-discriminator axes on Classification (Self::has_point_type, Self::has_substrate, Self::has_calm, and Self::has_data_classification) — the six-axis classification lattice now publishes ALL FOUR of its scalar-carrier presence probes at ONE substrate site each. The remaining two axes (horizon — a nested struct threading HorizonKind through horizon.kind; the sixth axis is variant-dependent on the HorizonKind::Asymptotic arm) live on nested-struct-scalar slots rather than the direct-scalar corner the four current peers span. A future DataClassification variant (a hypothetical seventh variant beyond Public / Internal / Confidential / Pii / Phi / Pci — say a TradeSecret bucket for competitive-sensitive data, or an Anonymized bucket for pseudonymized-PII whose regulatory posture differs) reaches every downstream through ONE ALL entry on the closed set + ONE as_str arm + ONE sensitivity_rank arm + one arm per predicate with the probe body untouched.

Theory anchor: THEORY.md §II.1 invariant 5 — composition preserves proofs; the scalar-carrier presence-probe body lives at ONE substrate site so every downstream (data-classification-<kind> require-tag family in tatara-check, closed-set audit dispatchers, future variant additions on DataClassification) binds through the SAME shape rather than restating the classification.data_classification == kind closure body at each callsite. THEORY.md §VI.1 — generation over composition; a future DataClassification variant lands at ONE ALL entry + ONE as_str arm on the closed set and the probe picks it up mechanically without further per-consumer edits.

Trait Implementations

impl Clone for Classification

fn clone(&self) -> Classification

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Classification

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Classification

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Classification

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl PartialEq for Classification

fn eq(&self, other: &Classification) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Classification

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Classification