Enum DepList 

pub enum DepList {
    Prod,
    Dev,
}

Closed-set typed enum for the two dep-list author-surface axes every top-level crate::Caixa carries — the runtime-closure :deps slot (Prod) and the dev-only-closure :deps-dev slot (Dev). Every substrate consumer that dispatches on “which of the two dep-lists” (the feira add mutation head, the future per-cluster dev-closure- audit overlay the M4 CR materializer resolves per-CR, the future caixa app graph per-list dep summary, every future Caixa::push_dep / Caixa::deps_by_list typed-method dispatch a caller reaches for) reads through this enum rather than through a bare &'static str — the closed-set is expressed at the type layer, so a future third dep-list axis (a :deps-build build-only closure once the substrate grows cross-artifact heterogeneous dep-graphs, per CAIXA-SDLC §I) is one variant plus one arm per method and the compiler enforces exhaustiveness on every consumer’s match arms.

The wire byte-string Self::as_str returns is the same author- surface tag the sibling crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV constants carry — the DepError::DuplicateNome / DepError::DepIsSelf list: &'static str payload family the substrate already emits routes through the same source of truth (an author reading a DepError::DuplicateNome refusal can grep their caixa.lisp for the offending :deps / :deps-dev block in one edit whether the diagnostic came from a Caixa::validate_deps walk or a Caixa::push_dep mutation).

Same “closed-set typed-enum discriminator with canonical projections per axis” discipline the sibling closed-set typed enums on the caixa typed surface carry (crate::aplicacao::PlacementStrategy cc8f749, crate::aplicacao::RateLimitUnit 6bce03d, crate::supervisor::RestartStrategy, crate::supervisor::RestartPolicy, crate::upgrade::UpgradeInstruction, crate::CaixaKind) — extended onto the outer-Caixa two-list dep-graph axis, the substrate’s last unlifted closed-set-shaped &'static str-carrying axis on the top-level manifest surface.

Variants

Prod

Runtime-closure :deps axis — the load-bearing dep-list the lacre closure resolves at every build. Wire-format crate::render::DEP_AUTHOR_KEY_DEPS.

Dev

Dev-only-closure :deps-dev axis — Cargo’s [dev-dependencies] table’s dev-time-only visibility contract per CAIXA-SDLC §I. Wire-format crate::render::DEP_AUTHOR_KEY_DEPS_DEV.

Implementations

impl DepList

pub const fn is_prod(&self) -> bool

pub const fn is_dev(&self) -> bool

impl DepList

pub const ALL: &'static [Self]

Exhaustive iteration surface for every consumer that reads the full closed-set (the future M4 admission webhook’s per-list summary rejection body, any future round-trip pin harness). A future variant addition extends this slice as a single edit and every consumer picks up the new entry by construction — the compiler-checked exhaustiveness on the sibling method match arms is the build-time guarantee that no arm forgets to grow.

pub const fn as_str(self) -> &'static str

Canonical author-surface tag every substrate consumer that names the offending dep-list in a diagnostic reaches for — crate::render::DEP_AUTHOR_KEY_DEPS for Self::Prod and crate::render::DEP_AUTHOR_KEY_DEPS_DEV for Self::Dev, the same &'static str payload the sibling DepError::DuplicateNome and DepError::DepIsSelf variants already carry. Routing every dep-list diagnostic through the closed-set enum’s as_str closes the last &'static str-shape literal-carry axis on the two-list dep-graph surface — a future kebab-case rebrand (":deps" → ":packages") or a wire-format promotion (a distinct diagnostic form for the Dev arm) reaches every consumer through one edit on the canonical constant, not a coordinated rewrite across the substrate’s dep-graph consumers.

pub fn from_wire(s: &str) -> Option<Self>

Substrate-canonical reverse projection on the two-list dep-graph axis — parses the author-surface wire tag back to the typed variant, or None when s is outside the closed-set arm-string set Self::as_str emits. Dispatches on the same lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV constants the Self::as_str emitter walks, so the parse and emit halves of the round-trip migrate through one caixa-core edit on any future list-axis addition.

Prior to this lift the substrate carried only the forward Self → &str projection on the two-list dep-graph axis (the Self::as_str emitter, the std::fmt::Display impl routed through it, the two DepError::DuplicateNome / DepError::DepIsSelf variants that carry the wire tag verbatim as a &'static str list: field). Every future consumer that wanted to promote the wire tag back to the typed enum (a future feira dep --list <deps|deps-dev> CLI arg-parse that binds the wire form into the typed enum before dispatching to crate::Caixa::deps_of / crate::Caixa::push_dep, the M4 mesh.pleme.io/v1alpha1/Caixa CR materializer’s admission-time wire re-parse of the per-list diagnostic body, a future DepError widening that promotes the two list: &'static str fields to a typed list: DepList carry so downstream consumers dispatch on the enum rather than string-comparing the wire scalar) would have had to re-inline a two-arm match s { ":deps" => …, ":deps-dev" => …, _ => … } cascade that expressed no compile-time link back to the typed DepList enum. A future variant addition (a :build-dep or :test-dep third list once the substrate grows Cargo-style split-graphs, a :tool-dep for build-time-only tooling per the peer Cargo [build-dependencies] / [target.<cfg>.dev-dependencies] future admission surface) would silently split the wire byte-string the emitter walks from the parser’s arm-set — the round-trip would carry the new list through the forward projection but land on the fallback silently at every non-updated reverse parser, far from the arm-addition commit that caused the drift. Lifting the resolver to a typed method on the substrate primitive closes the drift footgun by construction: the parser’s accept-set is the same set the Self::as_str emitter walks (routed through the same lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV consts), so both halves of the round-trip migrate through one caixa-core edit on any future list-axis addition.

Same closed-set-reverse-projection discipline the sibling crate::CaixaKind::from_wire (2aa6d23) / crate::supervisor::RestartStrategy::from_wire (4eec29c) / crate::supervisor::RestartPolicy::from_wire (dd32ccf) / crate::aplicacao::PlacementStrategy::from_wire (18c7342) / crate::aplicacao::RateLimitUnit::from_suffix typed enums carry on the peer wire-side str → Self axes — extended onto the two-list dep-graph closed-set axis, the sixth substrate-side closed-set typed enum on the caixa surface to converge on the two-way str ↔ Self round-trip. Method-named from_wire (not from_str) to match the peer shapes verbatim and side-step the derived std::str::FromStr impls the sibling gen_platform::FromStrKind-carrying axes install on their kebab-case dispatcher-catalog identity. Returns Option<Self> (rather than Result<Self, _>) to match the peer shapes: the caller picks the diagnostic form appropriate for its use site — a future feira dep --list … arg-parse that surfaces unknown list: <arg> at the CLI builds one on top by iterating Self::ALL, while the future M4 admission-webhook’s rejection path folds None onto its per-CR structured refusal body.

Trait Implementations

impl AsRef<str> for DepList

Substrate-canonical AsRef<str> projection on the two-list dep-graph closed-set typed enum — routes through the same DepList::as_str pub const fn scalar accessor the paired std::fmt::Display impl already delegates through, so any future consumer that binds a DepList through the standard-library impl AsRef<str> bound (a std::process::Command::arg shell-out that composes the canonical author-surface tag into a feira dep --list <deps|deps-dev> diagnostic overlay, a tracing::field::Value::Str-arm structured-log recorder on the DepError::DuplicateNome / DepError::DepIsSelf refusal paths, a std::collections::HashMap lookup keyed on the canonical tag through map.get::<str>(list.as_ref()) on a future M4 admission- webhook’s per-list rejection-body composition table) reaches the paired crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV byte-string through one substrate-primitive dispatch rather than an open-coded .as_str() re-inlining at every wire-up.

Same “route the trait impl through the substrate-primitive accessor” discipline the sibling crate::CaixaDialeto AsRef<str> impl (1723611), the crate::aplicacao::RateLimitUnit AsRef<str> impl (d8136db), the crate::CaixaKind AsRef<str> impl (cd2091f), the M3 crate::aplicacao::PlacementStrategy AsRef<str> impl (d86edd2), the M2 crate::supervisor::RestartPolicy AsRef<str> impl (419ea81), the M2 crate::supervisor::RestartStrategy AsRef<str> impl (63eb1a4), and the crate::CaixaVersion AsRef<str> impl (16d5c7e) carry — closes the substrate primitive’s AsRef<str> projection axis on the seventh (and last unlifted) closed-set typed enum on the caixa surface: the two-list dep-graph axis previously carried [fmt::Display]-through-as_str but not yet the paired AsRef<str> impl, so a downstream consumer that bound the enum through the standard-library AsRef<str> trait had to reach the canonical byte-string through an open-coded .as_str() call rather than the trait-idiomatic .as_ref() the peer closed-set typed enums already admit.

Pinned load-bearing by [tests::dep_list_as_ref_str_routes_through_as_str_accessor] (byte-parity pin against DepList::as_str across the two-arm closed set) and [tests::dep_list_as_ref_str_routes_through_display_via_shared_accessor] (three-path convergence: AsRef<str> + Display + as_str all resolve to the same byte-string per arm) — any future silent detour that routes the impl through a divergent projection (a per-arm inline match self { DepList::Prod => ":deps", … } re-inlining that opens a compile-time link to the un-lifted arm-literal, a swap onto a second projection axis) trips at caixa-core test time under assert_eq! rather than at a downstream impl AsRef<str>-bound consumer’s silent split.

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for DepList

fn clone(&self) -> DepList

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for DepList

impl Debug for DepList

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

Formats the value using the given formatter.

impl Display for DepList

Route std::fmt::Display through DepList::as_str, so every consumer that formats the axis as user-facing text (a future feira app graph per-list summary, a future M4 admission-webhook rejection body naming the offending list, this crate’s own DepError #[error(...)] templates when they widen to carry a typed DepList) lands on the same author-surface tag the crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV constants carry. Same as-str-through-Display convergence discipline the sibling crate::aplicacao::PlacementStrategy, crate::aplicacao::RateLimitUnit, crate::supervisor::RestartStrategy, crate::supervisor::RestartPolicy, and crate::CaixaKind closed-set typed enums carry.

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

Formats the value using the given formatter.

impl Eq for DepList

impl From<&DepList> for &'static str

Trait-idiomatic forward projection on the two-list dep-graph DepList closed-set typed enum from a borrowed input onto the &'static str axis — the borrowed-input companion to the paired owned-input [From<DepList> for &'static str] impl immediately above. Routes byte-for-byte through the same substrate-primitive DepList::as_str pub const fn accessor so every consumer that binds a &DepList through the standard-library .into() / [From<&Self> for &'static str] axis (a DepList::ALL.iter().map(<&'static str>::from).collect::<Vec<_>>() per-arm accept-set materializer that iterates the substrate- canonical DepList::ALL slice — whose iterator yields &DepList, not DepList, so the owned-input From<DepList> axis alone forces every call site through an explicit .copied() / dereference / Copy-bound restatement rather than the direct trait-idiomatic projection; a future generic <T: Copy + for<'a> Into<&'static str>>-bound diagnostic column that walks the iter().map(Into::into) shape verbatim; the future M4 admission-webhook rejection body that composes the accepted-set enumeration from an iterated DepList::ALL.iter().map(|l| l.into()) pipe rather than a per-arm match l { … } cascade) reaches the same two-arm lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV const the paired owned-input [From<DepList> for &'static str], the sibling std::fmt::Display, AsRef<str>, and DepList::as_str surfaces already return.

Opens the substrate-wide trait-idiomatic borrowed-input forward-projection family on the last-touched closed-set fieldless typed enum — first-mover on the borrowed-input axis, mirroring the role crate::supervisor::RestartStrategy played on the owned- input axis (523157d). Rust’s From trait does not auto-derive the From<&Self> sibling from a From<Self> impl (the blanket impl<T, U> From<&T> for U where T: Copy, U: From<T> does not exist in core), so every closed-set typed enum that carries the owned-input axis but not the borrowed-input axis forces every borrowed-input call site through a .copied() / <&'static str>::from(*list) / list.as_str() detour whose type bounds have no compile-time link to the substrate primitive. The remaining fourteen substrate-wide closed-set fieldless typed enum peers (CaixaKind, CaixaDialeto, RestartStrategy, RestartPolicy, WitShape, RateLimitUnit, PlacementStrategy, PathShapeViolation, InvariantKind, ArchVerdict, Severity, FixSafety, Semantic, FerriteRuntime) are the future targets of this campaign.

Pinned load-bearing by [tests::dep_list_from_borrowed_into_static_str_routes_through_as_str_accessor] (byte-parity pin against DepList::as_str across the two-arm emit-set via a borrowed input, plus a const-context materialization witness) and [tests::dep_list_from_owned_and_borrowed_into_static_str_agree_on_every_arm] (cross-axis partition pin against the paired owned-input [From<DepList> for &'static str] impl).

fn from(list: &DepList) -> &'static str

Converts to this type from the input type.

impl From<DepList> for &'static str

Trait-idiomatic forward projection on the two-list dep-graph DepList closed-set typed enum onto the &'static str axis — routes byte-for-byte through the paired substrate-primitive DepList::as_str pub const fn accessor so <&'static str>::from(list) / list.into::<&'static str>() reaches the same two-arm lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV const the sibling std::fmt::Display, AsRef<str>, and DepList::as_str surfaces already return.

Closes the substrate-wide trait-idiomatic forward-projection campaign for real — the campaign opened on crate::supervisor::RestartStrategy via 523157d and traced through the 13 sibling closed-set typed enums (9fb37d0, edb827b, c189a6f, afa3562, 56998ec, 7fdfbf4, 070a6de, f2ca7bc, d4559cb, 5cc3b8b, 2a56127, 07f36bb, 85d0443) silently omitted DepList on both trait-idiomatic axes despite every peer’s docstring naming it as a sibling. Paired with the [TryFrom<&str> for DepList] impl immediately above, this closes the two-way DepList ↔ &'static str round-trip on the trait- idiomatic axis pair, mirroring the pre-existing method-named DepList::as_str + DepList::from_wire pair on the substrate-primitive axis pair.

The paired DepList::as_str returns &'static str by construction — each arm resolves to a crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str with static lifetime — so the trait’s return-type promise is upheld structurally.

Pinned load-bearing by [tests::dep_list_from_into_static_str_routes_through_as_str_accessor] (byte-parity pin against DepList::as_str across the two-arm emit-set, plus a const-context materialization witness for the &'static str lifetime promise) and [tests::dep_list_from_into_static_str_and_as_str_partition_the_emit_set] (partition pin + two-way round-trip through the paired TryFrom<&str> axis).

fn from(list: DepList) -> &'static str

Converts to this type from the input type.

impl From<DepList> for String

Trait-idiomatic forward projection on the two-list dep-graph DepList closed-set typed enum from an owned input onto the owned-String axis — routes byte-for-byte through the substrate-primitive DepList::as_str pub const fn accessor so every consumer that binds a DepList through the standard-library .into() / [From<Self> for String] (equivalently Into<String>) axis reaches the same two-arm lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV byte-string the paired owned-input [From<DepList> for &'static str], the borrowed-input [From<&DepList> for &'static str], the sibling std::fmt::Display, AsRef<str>, and DepList::as_str surfaces already return.

Extends the trait-idiomatic owned-String forward-projection family (opened on crate::supervisor::RestartStrategy — 7baa18a — the first-mover on the M2 OTP-shape sibling-restart-strategy axis, extended onto crate::supervisor::RestartPolicy — 7851725 — the second-of-two-in-M2 per-child restart-decision axis, then onto crate::CaixaKind — 231a18c — the structurally most fundamental closed-set fieldless typed enum on the caixa surface, then onto crate::CaixaDialeto — 88942cd — the dialect-classification axis) onto the fifth peer: the two-list dep-graph axis DepList carries. Rust’s standard library does not carry a blanket impl<T: AsRef<str>> From<T> for String (nor an impl<T: fmt::Display> From<T> for String), so every closed-set typed enum that carries the paired AsRef<str> / std::fmt::Display / [From<Self> for &'static str] / [From<&Self> for &'static str] quadruple but not the owned-String axis forces every owned-string call site through a .to_string() / .as_str().to_owned() / String::from(list.as_str()) detour whose type bounds have no compile-time link to the substrate primitive.

Same as the peer crate::supervisor::RestartStrategy / crate::supervisor::RestartPolicy / crate::CaixaDialeto owned-String axis pairs (whose forward emit and reverse parse share one vocabulary by construction — PascalCase on the three prior peers, the ":deps" / ":deps-dev" leading-colon lispy author-surface tags on this one), DepList’s DepList::as_str emit and DepList::from_wire parse resolve through the same lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV consts by construction (there is no wire/diagnostic axis split on this enum — both halves of the round-trip route through the same two pub const &str values), so the owned-String forward projection this impl exposes composes directly with the paired trait-idiomatic reverse TryFrom<&str> axis on the owned-String’s String::as_str borrow — no intermediate wire-vocab hop like the peer crate::CaixaKind axis pair requires.

The remaining ten closed-set typed enums on the caixa substrate surface (PlacementStrategy, WitShape, RateLimitUnit, PathShapeViolation, InvariantKind, ArchVerdict, Severity, FixSafety, Semantic, FerriteRuntime) are the future targets of this campaign — each carries the same paired AsRef<str> / std::fmt::Display / [From<Self> for &'static str] / [From<&Self> for &'static str] quadruple that this owned-String axis extends onto.

Pinned load-bearing by [tests::dep_list_from_into_owned_string_routes_through_as_str_accessor] (byte-parity pin against DepList::as_str across the two-arm DepList::ALL emit-set plus a blanket .into::<String>() shape witness) and [tests::dep_list_from_into_owned_string_and_static_str_agree_on_every_arm] (cross-axis partition against the sibling owned-&'static str axis and the ToString::to_string surface, a .iter().copied().map(String::from) pipe witness over DepList::ALL, plus a direct Self → String → Self round-trip via TryFrom<&str> on the owned-String’s String::as_str borrow — composes directly without the wire-vocab intermediate hop the peer crate::CaixaKind axis pair requires).

fn from(list: DepList) -> String

Converts to this type from the input type.

impl Hash for DepList

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for DepList

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for DepList

impl TryFrom<&str> for DepList

Trait-idiomatic reverse projection on the two-list dep-graph DepList closed-set typed enum — routes through the paired substrate-primitive DepList::from_wire Option<Self> accessor so <DepList>::try_from(":deps") reaches the same two-arm accept-set the sibling DepList::from_wire resolver dispatches through, rather than an open-coded per-arm match s { ":deps" => Ok(Self::Prod), … } cascade whose arm-set has no compile-time link back to the substrate primitive.

Corrects a completeness gap in the substrate-wide trait-idiomatic reverse-projection campaign (opened by crate::CaixaKind via 3c83606, closed onto 14 sibling closed-set fieldless typed enums across the caixa surface — 5b828ed, 6fdd0d9, 5472902, bf78400, e67e48a, e21a857, 0a4cc45, a7bf74c, df86c94, bd7da69, 42ab951 — which silently omitted DepList despite this enum being listed as a sibling closed-set fieldless typed enum in every peer’s docstring). Every sibling closed-set fieldless typed enum on the caixa surface now carries both trait-idiomatic axes (TryFrom<&str> for Self + From<Self> for &'static str) paired against the substrate-primitive canonical projection accessors (as_str/variant_slug + from_wire) — the two-list dep-graph closed-set is the fifteenth and true-final peer.

type Error = () matches the sibling DepList::from_wire’s Option<Self> return-shape’s deliberate deferral of error typing: the caller picks the diagnostic form appropriate for its use site (a future feira dep --list <deps|deps-dev> arg-parse composes unknown list: <arg> — accepted: {…} enumerating DepList::ALL; the M4 admission-webhook rejection body wraps Err(()) with the accepted-set enumeration).

Pinned load-bearing by [tests::dep_list_try_from_str_routes_through_from_wire_accessor] (byte-parity pin against DepList::from_wire across the two-arm accept-set) and [tests::dep_list_try_from_str_rejects_unknown_byte_strings] (rejection witness against silent accept-set widening).

type Error = ()

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Self, Self::Error>

Performs the conversion.