Struct RoutingSpec 

pub struct RoutingSpec {
    pub hostnames: Vec<RoutingHostname>,
    pub backend: RoutingBackend,
    pub stable_name_claim: bool,
    pub priority: i32,
}

Declared external edges (DNS + Ingress) this Process exposes.

Optional on ProcessSpec — None means the Process is in-cluster- only, matching today’s default behavior. The reconciler only emits routing artifacts when this slot is populated.

Fields

hostnames: Vec<RoutingHostname>

Hostnames this Process answers on. Empty list is legal but nonsensical (no Ingress, no DNS) — operators should drop the routing slot entirely instead. The reconciler warns on empty hostnames.

backend: RoutingBackend

Single backend Service every hostname routes to. Per-hostname backends are a future extension; v1 keeps the simple shape.

stable_name_claim: bool

When true, additionally emit the unprefixed form of every hostname (${app}.${cluster}.${loc}.${domain} — no eph_id segment) iff this Process currently holds the ProcessTable claim for (cluster, app). At most one Process per (cluster, app) holds the claim.

priority: i32

Claim arbitration priority. Higher wins. Ties broken by oldest creationTimestamp. Negative values legal (signals “prefer not to hold the claim”). Default 0.

Implementations

impl RoutingSpec

pub fn has_hostnames(&self) -> bool

True iff at least one hostname is declared. The reconciler uses this to short-circuit: empty routing ⇒ no emission.

pub fn emitted_fqdn_count(&self, claim_held: bool) -> usize

Total count of FQDNs this Process will emit: hostnames.len() per-instance + hostnames.len() stable when the claim is held.

pub const fn form(&self) -> RoutingForm

Declared routing form for this Process — the typed projection over the Self::stable_name_claim bool through the ONE substrate composer RoutingForm::from_is_stable. Every downstream axis (the crate::annotations::ROUTING_FORM annotation / label the reconciler stamps, the routing-form-<kind> require-tag prefix family in tatara-check, any future audit dispatcher walking RoutingForm::ALL) reads THIS ONE projection so a shift in how “which routing form does this spec declare intent for” is derived lands at ONE site.

Semantics — DECLARED intent, not RESOLVED emission: this is what the operator authored on the spec. The reconciler still gates on the ProcessTable claim before emitting the stable FQDN form — a stable_name_claim: true spec that loses the claim to a higher-priority peer still form() == Stable at this site (the declared intent), even though the runtime-effective emission is Instance on that reconcile tick. The routing-form-<kind> require-tag is intentionally a spec-shape probe, not a runtime-status probe, so it stays pinned to this projection.

Peer to [crate::classification::Classification::horizon_kind] / [crate::classification::Classification::optimization_direction] on the “typed projection over a stored field on ONE spec slot → closed-set discriminator” axis — both hide the raw wire-form field behind ONE typed projection so a future normalization (widening Self::stable_name_claim into a typed enum with a third variant, canonicalizing across a new Gateway form) lands at THIS ONE site and every downstream consumer inherits the upgrade mechanically.

pub fn has_form(&self, kind: RoutingForm) -> bool

Scalar-carrier presence probe on the derived Self::form projection — true iff this routing spec’s declared RoutingForm (as read through RoutingForm::from_is_stable over the stable_name_claim bool) matches the queried variant.

The one-line collapse of the <r>.form() == kind closure body lifted to ONE substrate owner past the ★★ PRIME-DIRECTIVE ≥ 2 duplication threshold — the nineteenth closed-set-driven prefix family in [tatara-check]’s point-domain require-tag classifier (routing-form-<kind>) is the first workspace-wide consumer. The shape is a peer of crate::lifetime::EphemeralLifetime::has_teardown_policy on the SAME (Option-parent × defaulted-scalar-child) corner of the workspace-wide presence-probe algebra: the parent is Option<RoutingSpec> on crate::crd::ProcessSpec::routing (None short-circuits every kind), and the child is a scalar derived from a #[serde(default)] bool (stable_name_claim: false by default → RoutingForm::Instance by default).

Sibling scalar-carrier probes

• crate::spec::SignalPolicy::has_sighup_strategy — required parent × defaulted scalar child (stored).
• crate::classification::Classification::has_calm / crate::classification::Classification::has_data_classification — required parent × defaulted scalar child (stored).
• crate::classification::Classification::has_horizon_kind / crate::classification::Classification::has_optimization_direction — required parent × nested-struct-scalar-child (stored).
• crate::lifetime::EphemeralLifetime::has_teardown_policy — Option parent × defaulted-scalar-child (stored).
• THIS — Option parent (Option<RoutingSpec> on crate::crd::ProcessSpec::routing) × defaulted-scalar-child (RoutingForm DERIVED from the defaulted-false bool stable_name_claim). Second occupant on the (Option-parent × defaulted-scalar-child) corner, and the FIRST occupant whose child is derived rather than stored — the shape composes through the ONE RoutingForm::from_is_stable projection so a future widening of the underlying stable_name_claim bool into a typed enum lands at RoutingForm::from_is_stable alone and every has_form consumer inherits the upgrade mechanically.

Semantics — DECLARED form, not RESOLVED emission

has_form(kind) returns true iff self.form() == kind. See Self::form for the “declared intent” vs “runtime-effective emission” distinction — the probe is a spec-shape probe, not a runtime-status probe, so a stable_name_claim: true spec that loses the ProcessTable claim still reads has_form(Stable) == true at this site. The reconciler-side “actually emit stable FQDNs” gate lives downstream at claim arbitration, not here.

Compounding

A future third RoutingForm variant added to ALL (a hypothetical Gateway for a future Gateway-API HTTPRoute edge, distinct from both the per-instance and stable-claim FQDN shapes) reaches this probe through ONE ALL entry + one as_str arm + one from_is_stable widening alone, no per-caller edit at the routing-form-<kind> require-tag classifier and no per-consumer restatement of the spec.routing.as_ref().is_some_and(|r| r.form() == kind) closure body.

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 (routing-form-<kind> require-tag family in tatara-check, closed-set audit dispatchers, future variant additions on RoutingForm) binds through the SAME has(kind) shape. THEORY.md §VI.1 — generation over composition; a future variant lands at ONE ALL entry + one as_str arm + one from_is_stable widening on the closed set and the probe picks it up mechanically without further per-consumer edits.

Trait Implementations

impl Clone for RoutingSpec

fn clone(&self) -> RoutingSpec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RoutingSpec

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RoutingSpec

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for RoutingSpec

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 Serialize for RoutingSpec

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TataraDomain for RoutingSpec

const KEYWORD: &'static str = "defrouting"

The Lisp keyword (e.g., "defmonitor").

fn compile_from_args(args: &[Sexp]) -> Result<Self>

Parse the argument list (everything after the keyword) into Self.

fn compile_from_sexp(form: &Sexp) -> Result<Self, LispError>

Parse a complete form; validates the head symbol matches KEYWORD.