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 AUTHOR_KEYS: &'static [&'static str]

Substrate-canonical exhaustive accept-set on the DepList :-prefixed kebab-case tatara-lisp author-surface key axis — the closed two-arm roster of every byte-string Self::as_str returns, routed byte-for-byte through the paired crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV lifted pub const scalars the Self::as_str emitter (and the std::fmt::Display / AsRef<str> / From<{Self,&Self}> for {&'static str, String, Cow<'static, str>, Box<str>, Arc<str>} trait triple + quintuple routed through it) walks, and the same two strings the paired Self::from_wire reverse projection accepts.

Peer of the sibling crate::CaixaKind::WIRE_NAMES (bd708bd) / crate::supervisor::RestartStrategy::WIRE_NAMES (3033f45) / crate::supervisor::RestartPolicy::WIRE_NAMES (ce9412b) / crate::aplicacao::PlacementStrategy::WIRE_NAMES (3e5b194) rosters on the PascalCase wire byte-string axis, the sibling crate::CaixaKind::LABELS (427fe75) / crate::aplicacao::WitShape::LABELS (9d9f585) rosters on the lowercase kebab census-label byte-string axis, the sibling crate::aplicacao::RateLimitUnit::SUFFIXES (b553ec9) roster on the single-char canonical-suffix axis, and the sibling crate::upgrade::UpgradeInstruction::LISP_FORMS (1898d77) / crate::upgrade::UpgradeInstruction::WIRE_FORMS (cc42c0e) rosters on the OTP-appup discriminator’s two-axis roster split — the same closed-set exhaustive-accept-set roster discipline extended here onto the outer-Caixa two-list dep-graph closed-set typed enum, the ninth substrate-side closed-set typed enum on the roster-discipline axis and the last unlifted &'static str-carrying closed-set typed enum on the top-level manifest surface (the sibling AsRef<str> doc block at AsRef<str> already names the two-list dep-graph as “the seventh (and last unlifted) closed-set typed enum on the caixa surface” for the trait-idiomatic projection family — the same closure applies here on the exhaustive-roster family).

Downstream consumers of the closed accepted-key set — a future feira dep --list <deps|deps-dev> CLI arg-parse’s “did you mean” hint that scans this slice rather than open-coding a two-string array literal, a future M4 mesh.pleme.io/v1alpha1/Caixa CR admission-webhook rejection body enumerating the accepted :deps / :deps-dev author- surface keys verbatim on an unknown-key miss, a future feira dep census per-Caixa :deps / :deps-dev histogram column that walks the roster to render every arm’s tally (including zero-count arms — a hand-rolled projection off Self::ALL alone would need a companion per-variant-to-key map at every consumer; this roster closes the two-axis walk in one lifted const), any future K8s CRD generation tool that emits the accepted-key enum on the Caixa CR schema, 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 — every consumer that wants to enumerate the closed dep-list author-key set outside caixa-core now reaches for one lifted substrate-primitive roster rather than open- coding a [":deps", ":deps-dev"] array-literal whose arm-set has no compile-time link back to the typed DepList enum. A future arm addition (a :build-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 — both trajectory items the sibling Self::from_wire doc block already names) extends this roster as a single edit — paired with the Self::as_str match’s compiler-checked exhaustiveness on the new arm — and every consumer picks up the new key by construction rather than a coordinated array-literal rewrite across every downstream site.

Length is pinned load-bearing at DepList::ALL.len() (two) by [tests::dep_list_author_keys_covers_every_arm], every variant’s Self::as_str projection is pinned to a member of the roster on every arm so a silent skew between the emitter’s arm-set and this const’s arm-set trips at caixa-core test time rather than at a downstream consumer’s accepted-set enumeration miss, and every entry is further pinned to open with the ASCII : byte (the tatara-lisp author-surface keyword marker) so a silent collapse with any hypothetical peer un-prefixed wire-form axis (an entry byte-identical to a sibling deps / deps-dev bare-kebab byte-string that would let an author-key-axis consumer accept the un-prefixed vocabulary) trips here rather than at a downstream K8s-CR round-trip miss.

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<[u8]> for DepList

Substrate-canonical [AsRef<[u8]>] byte-view projection on the caixa-core-internal two-list dep-graph DepList closed-set fieldless typed enum — routes byte-for-byte through the substrate- primitive DepList::as_str pub const fn accessor via str::as_bytes on the returned &'static str, so any future consumer that binds a DepList through a standard-library <T: AsRef<[u8]>> trait bound reaches the same lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str roster the paired sibling AsRef<str> / std::fmt::Display / DepList::as_str / {Self, &Self} × {&'static str, String, Cow<'static, str>, Box<str>, std::sync::Arc<str>, std::rc::Rc<str>} str-view + reverse-projection surfaces already return — through the byte-view axis, which the str-view axes cannot express.

The primary compounding target is the same crate-adjacent caixa-lacre BLAKE3 content-address closure the peer crate::CaixaKind (69d8d86) and crate::dialeto::CaixaDialeto (8151347) AsRef<[u8]> impls open onto: [blake3::hash] and [blake3::Hasher::update] both bind their input through impl AsRef<[u8]>, so any future per-caixa content-address tag that folds a dep-list discriminator byte-tag into the [crate::Lacre] closure (a hypothetical hasher.update(list);-shape composition on the per-caixa BLAKE3 closure builder that partitions the runtime-closure :deps closure from the dev-only-closure :deps-dev closure at content-address time so a downstream Lacre consumer can key its per-list build cache off the typed discriminator directly rather than the sibling &'static str wire scalar) reaches the substrate-primitive DepList::as_str accessor through this impl and no other — without it, every such call site opens the two-hop composition list.as_str().as_bytes() whose byte-tail has no compile-time link back to the byte-projection axis. Peer consumer paths on the byte- view axis: any future std::io::Write::write_all-bound feira dep census per-list histogram-column emitter (whose input binds through impl AsRef<[u8]>), any future byte-keyed std::collections::HashMap <K: AsRef<[u8]>, V> per-list tally lookup whose entry-key trait bound rules out the sibling AsRef<str> str-view projection, and any future ring::digest::Context::update / sha2::Sha256::update / blake3::Hasher::update byte-input surface on any future per-list content-address digest.

Rust’s standard library carries impl AsRef<[u8]> for str and impl AsRef<[u8]> for String, so the two-hop composition list.as_str().as_bytes() (or, equivalently, AsRef::<str>::as_ref(&list).as_bytes()) is reachable through the pre-existing str-view axis alone. But that two-hop shape has no compile-time link back to the byte-projection axis, forces every downstream <T: AsRef<[u8]>>-bound consumer to open-code the two- hop composition at every call site rather than pass a DepList through the trait bound directly, and admits a silent split whenever a future call site takes the sibling std::fmt::Display or [From<Self> for String] axis (whose .as_bytes() byte-tails byte-equal as_str’s by construction but carry no compile-time byte-view surface, since Display returns a formatter and String allocates). The lifted single-hop impl closes the byte-view axis so every future <T: AsRef<[u8]>>-bound consumer reaches the substrate primitive through one trait dispatch, and every future arm addition (a :build-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 — both trajectory items the sibling DepList::from_wire doc block already names) grows the byte-view axis through one edit on the substrate-primitive as_str accessor, not a coordinated rewrite across every future <T: AsRef<[u8]>>-bound consumer’s arm-set.

Extends the trait-idiomatic byte-view axis onto the third caixa-core-internal closed-set fieldless typed-enum peer on the substrate — the two-list dep-graph enum — matching the trajectory the sibling crate::CaixaKind first-mover [AsRef<[u8]>] impl (69d8d86) and crate::dialeto::CaixaDialeto second-mover impl (8151347) walked before it on the caixa-core tier of the byte-view axis, and matching the discipline the paired sibling closed-set fieldless typed enums already carry on the peer str-view (AsRef<str>), parse (std::str::FromStr), and reverse- projection ({Self, &Self} × {&'static str, String, Cow<'static, str>, Box<str>, std::sync::Arc<str>, std::rc::Rc<str>}) axes on this same enum. Unlike crate::CaixaKind — which carries a two-axis split (crate::CaixaKind::as_str returning lowercase-Portuguese diagnostic form vs crate::CaixaKind::wire_name returning PascalCase tatara-lisp author-surface bytes) — DepList carries a single canonical axis: DepList::as_str returns the :-prefixed kebab-case tatara-lisp author-surface key (crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV), which is simultaneously the wire form the paired DepList::from_wire resolver reads back. The byte-view axis therefore lands on the same :-prefixed kebab byte-string every str-view and reverse- projection axis on this enum already returns, and no wire-axis cross-witness applies.

Pinned load-bearing by [tests::dep_list_as_ref_bytes_routes_through_as_str_accessor] (fail-before-pass-after byte-parity pin against DepList::as_str .as_bytes() across the two-arm DepList::ALL emit-set, cross-axis witness against the paired str-view AsRef<str> / std::fmt::Display / DepList::as_str axes’ .as_bytes() byte-tails, cross-axis witness against the paired reverse-projection {&'static str, String, Cow<'static, str>, Box<str>, std::sync::Arc<str>, std::rc::Rc<str>} return-shape axes’ .as_bytes() byte-tails, a <T: AsRef<[u8]>>-bound-consumer witness that a generic byte-input function accepts a DepList directly through the trait bound on both owned and borrowed input shapes, and a blake3::Hasher::update-shape byte-input surface witness routed through the <T: AsRef<[u8]>>-bound consumer axis to reach the caixa-lacre compounding target on both owned and borrowed input shapes). Any future silent detour that routes the byte-view impl off the substrate-primitive DepList::as_str accessor (a per-arm inline b":deps".as_slice()-shaped re-inlining that opens a compile-time link to the un-lifted arm-literal, a hypothetical un-prefixed bare-kebab byte-string swap that would silently collapse the :-prefixed tatara-lisp author-surface discipline the sibling DepList::AUTHOR_KEYS doc block explicitly pins) trips at caixa-core test time rather than at a downstream byte-consumer’s silent split.

fn as_ref(&self) -> &[u8]

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

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 String

Trait-idiomatic borrowed-input, owned-String output forward projection on the two-list dep-graph DepList closed-set typed enum — the fourth (and closing) corner of the {Self, &Self} × {&'static str, String} 2×2 trait-idiomatic projection family on this enum, mirror of the peer M2 OTP-shape [From<&RestartStrategy> for String] (579385f) and [From<&RestartPolicy> for String] (8465740) that opened and closed the corner on the sibling supervisor-level restart-strategy and per-child restart-decision enums. Routes byte-for-byte through the substrate-primitive DepList::as_str pub const fn accessor (via str::to_owned) so every consumer that holds a borrowed [&DepList] and needs an owned String — a future serde_json::Value::String(String::from(&list)) structured-payload composer over a borrowed field, a future Iterator::map over &[DepList] that projects to owned keys through .iter().map(String::from) (whose iterator yields &DepList, not DepList, so the owned-input [From<DepList> for String] axis alone forces every call site through an explicit .copied() / spurious Copy deref restatement rather than the direct trait- idiomatic projection), a future HashMap::<String, DepList>::from_iter that keys off a borrowed-iteration axis where dereferencing the list would force an unnecessary Copy at every step, the future wasm-operator’s per-manifest list_axes.iter().map(String::from).collect() per-list author-surface-tag diagnostic emit whose iteration axis is borrowed by construction — reaches the same two-arm lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV const the paired std::fmt::Display, AsRef<str>, DepList::as_str, and the three other trait-idiomatic forward-projection impls ([From<DepList> for &'static str], [From<&DepList> for &'static str], [From<DepList> for String]) already return.

Third peer on the substrate-wide trait-idiomatic borrowed-input, owned-String output forward-projection family opened on crate::supervisor::RestartStrategy (579385f) and closed on crate::supervisor::RestartPolicy (8465740) — extends the {Self, &Self} × {&'static str, String} 2×2 projection corner off the M2 OTP-shape axis pair onto the first non-M2 closed-set fieldless typed enum peer (the two-list dep-graph axis). 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> / Display / From<Self> for &'static str / From<&Self> for &'static str / From<Self> for String quintuple but not the borrowed-input owned- String axis forces every borrowed-input owned-string call site through a list.as_str().to_owned() / String::from(*list) (with a spurious Copy) / list.to_string() (through Display) detour whose type bounds have no compile-time link to the substrate primitive.

Same as the peer crate::supervisor::RestartStrategy / crate::supervisor::RestartPolicy borrowed-input owned-String axis pairs (whose forward emit and reverse parse share one vocabulary by construction — PascalCase on the M2 OTP-shape peers), 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 (the ":deps" / ":deps-dev" leading-colon lispy author-surface tags — there is no wire/diagnostic axis split on this enum), so the borrowed-input owned-String 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 (CaixaKind, CaixaDialeto, PlacementStrategy, WitShape, RateLimitUnit, PathShapeViolation, InvariantKind, ArchVerdict, Severity, FixSafety, Semantic, FerriteRuntime) are the future targets of this 2×2-completion campaign — each carries the same paired quintuple that this borrowed-input owned- String axis extends onto.

Pinned load-bearing by [tests::dep_list_from_into_borrowed_owned_string_routes_through_as_str_accessor] (byte-parity pin against DepList::as_str across the two-arm emit-set through the borrowed-input surface) and [tests::dep_list_from_into_borrowed_owned_string_agrees_with_paired_axes_on_every_arm] (cross-axis partition pin against the paired owned-input owned- String [From<DepList> for String] impl, the paired borrowed- input owned-[&'static str] [From<&DepList> for &'static str] impl, and the sibling ToString::to_string surface routed through std::fmt::Display, plus a direct round-trip witness through TryFrom<&str> on the owned-String’s String::as_str borrow that closes the two-way &Self → String → Self round-trip on the trait-idiomatic borrowed-input owned-String forward + reverse axis pair).

fn from(list: &DepList) -> String

Converts to this type from the input type.

impl From<&DepList> for Cow<'static, str>

Trait-idiomatic borrowed-input, std::borrow::Cow<'static, str> output forward projection on the two-list dep-graph DepList closed-set typed enum — the borrowed-input companion to the paired owned-input [From<DepList> for std::borrow::Cow<'static, str>] impl immediately above (6858bac). Routes byte-for-byte through the same substrate-primitive DepList::as_str pub const fn accessor (via std::borrow::Cow::Borrowed) so every consumer that holds a &DepList and needs a std::borrow::Cow<'static, str> — a DepList::ALL.iter().map(std::borrow::Cow::from).collect::<Vec<_>>() per-arm accept-set materializer whose iterator over &'static [DepList] yields &DepList (not DepList, so the paired owned-input [From<DepList> for std::borrow::Cow<'static, str>] 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: for<'a> Into<std::borrow::Cow<'static, str>>>-bound emitter on a per-:deps / :deps-dev diagnostic column that walks the iter().map(Into::into) shape verbatim, the future M4 caixa.pleme.io/v1alpha1/Caixa CR admission-webhook rejection body that composes the accepted-:deps / :deps-dev list-key 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 byte-string the paired std::fmt::Display, AsRef<str>, DepList::as_str, the four {Self, &Self} × {&'static str, String} 2×2 trait-idiomatic forward-projection corners, and the paired owned-input [From<DepList> for std::borrow::Cow<'static, str>] impl already return.

Deliberately returns std::borrow::Cow::Borrowed rather than std::borrow::Cow::Owned — the substrate-primitive DepList::as_str accessor’s return carries the &'static str lifetime by construction (each match arm resolves to one of the two lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str byte-strings with static lifetime), so the zero-alloc borrowed arm is the type-correct projection with no runtime allocation on the borrowed-input surface just as on the paired owned-input surface.

Closes the {Self, &Self} input-shape corner on the outside-M3 caixa-core two-list dep-graph std::borrow::Cow<'static, str> axis opened one commit prior (6858bac) on the paired owned-input [From<DepList> for std::borrow::Cow<'static, str>] impl — first outside-M3 caixa-core peer on the axis, one commit after the paired M3-mesh-shape crate::aplicacao::RateLimitUnit :politicas :rate-limit canonical-suffix (1d59925), the paired M3-mesh-shape crate::aplicacao::PlacementStrategy :placement :estrategia distribution-strategy (eee504d + afdf0f4), the paired M3-mesh-shape crate::aplicacao::WitShape :contratos :wit census-label (8634dec + 25690ef), the paired M2 OTP-shape crate::supervisor::RestartStrategy (7dd28b3 + 9b3e4b3) and crate::supervisor::RestartPolicy (0612398 + ee577fd), and the paired top-level crate::CaixaKind (99c1735 + d45c409) peers closed the M3-mesh-shape, M2-OTP-shape, and top-level tiers. Rust’s standard library does not carry a blanket impl<T: AsRef<str>> From<&T> for Cow<'static, str> (nor an impl<T: fmt::Display> From<&T> for Cow<'static, str>), so every closed-set fieldless typed enum peer on the substrate that carries the paired owned-input [Cow<'static, str>] axis but not the borrowed-input axis forces every borrowed-input [Cow<'static, str>]-parameterized call site through a spurious Copy deref (std::borrow::Cow::from(*list)) or a std::borrow::Cow::Borrowed(list.as_str()) open-code whose type bounds have no compile-time link to the substrate primitive.

The remaining outside-M3 caixa-core peers (crate::CaixaDialeto, crate::render::PathShapeViolation) and the outside-caixa-core peers (InvariantKind, ArchVerdict, Severity, FixSafety, Semantic, FerriteRuntime) are the remaining future targets of the campaign; closing this borrowed-input corner on DepList leaves crate::CaixaDialeto as the next outside-M3 caixa-core closed-set fieldless typed enum peer target on the std::borrow::Cow<'static, str> axis.

Same three-path convergence discipline as the paired sibling [From<&DepList> for &'static str], [From<&DepList> for String], std::fmt::Display, and AsRef<str> surfaces (this borrowed- input std::borrow::Cow<'static, str> axis, the paired owned- input [From<DepList> for std::borrow::Cow<'static, str>] axis, the paired sibling {Self, &Self} × {&'static str, String} 2×2 corners, and DepList::as_str all route through the same two lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str values by construction), so a future variant addition, rename, or per-arm wire-tag drift reaches every forward-projection path through exactly one caixa-core edit at the DepList::as_str match head.

Pinned load-bearing by [tests::dep_list_from_borrowed_into_static_cow_str_routes_through_as_str_accessor] (byte-parity + zero-alloc std::borrow::Cow::Borrowed-arm pin against DepList::as_str across the two-arm DepList::ALL through the borrowed-input surface) and [tests::dep_list_from_borrowed_into_static_cow_str_agrees_with_paired_axes_on_every_arm] (cross-axis partition pin against the paired owned-input [From<DepList> for std::borrow::Cow<'static, str>], the paired borrowed-input owned-&'static str [From<&DepList> for &'static str], and the paired borrowed-input owned-String [From<&DepList> for String] impls, plus a .iter().map(std::borrow::Cow::from) pipe witness over DepList::ALL — whose iterator yields &DepList by construction, so the borrowed-input std::borrow::Cow<'static, str> axis is what routes the pipe through the substrate-primitive DepList::as_str accessor with the zero-alloc std::borrow::Cow::Borrowed arm by construction and without a spurious Copy deref).

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

Converts to this type from the input type.

impl From<&DepList> for Box<str>

Trait-idiomatic borrowed-input, Box<str> output forward projection on the outside-M3 caixa-core two-list dep-graph DepList closed-set fieldless typed enum. Routes byte-for-byte through the substrate- primitive DepList::as_str pub const fn accessor via Box::<str>::from on the returned &'static str, so every consumer that binds a let key: Box<str> = (&list).into();-shaped call site or a DepList::ALL.iter().map(Box::<str>::from)-shaped pipe (whose iterator over &'static [DepList] yields &DepList by construction) — a per-:deps / :deps-dev census-key materializer that stashes the dep-list discriminator in a Box<str>-typed heap-owned scalar for cheap clone off a borrowed handle, a future M4 admission-webhook rejection body whose per-arm Box<str> field composes from a borrowed DepList handle off a &DepList borrow, a future feira lint --explain-dep-list per-axis listing that iterates DepList::ALL into per-arm owned Box<str> labels — reaches the same two lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str byte-strings the sibling {Self, &Self} × {&'static str, String, Cow<'static, str>} forward-projection corner and the paired owned-input [From<DepList> for Box<str>] already return.

Rust’s standard library carries impl From<&str> for Box<str> and impl From<String> for Box<str> but no blanket impl<T: AsRef<str>> From<&T> for Box<str> (nor a Copy-based impl<T: Copy, U: From<T>> From<&T> for U), so this borrowed-input axis is a distinct trait-idiomatic surface that the pipe shape DepList::ALL.iter().map(Box::<str>::from) reaches through this impl and no other — without it, the same pipe would force an explicit .copied() restatement (.iter().copied().map(Box::<str>::from)) whose type bounds have no compile-time link back to the substrate primitive, and a let key: Box<str> = (&list).into();-shaped call site would force an explicit Copy deref (Box::<str>::from(*list)) or a Box::<str>::from(list.as_str()) open-code with the same defect.

Closes the {Self, &Self} input-shape corner on the second caixa- core-internal closed-set fieldless typed enum peer of the substrate- wide trait-idiomatic Box<str> forward-projection campaign — one commit after the paired render-side path-shape-diagnostic crate::render::PathShapeViolation pair (0d87a72) opened the caixa- core-internal tier — matching the trajectory the paired caixa-theme [caixa_theme::style::Semantic] pair (0cd7dc3, both corners in one axis), the caixa-provedor [caixa_provedor::FerriteRuntime] pair (14886a8, both corners in one axis), and the render-side crate::render::PathShapeViolation pair (0d87a72, both corners in one axis) walked before it.

Same discipline as the paired outside-caixa-core, crate::supervisor, crate::aplicacao, and crate::render Box<str> {Self, &Self}-closers: forward emit (this impl, the paired owned-input [From<DepList> for Box<str>] impl, the sibling {&'static str, String, Cow<'static, str>} forward-projection corner, std::fmt::Display, AsRef<str>, DepList::as_str) and reverse parse (DepList::from_wire, TryFrom<&str>) route through the same two lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str byte-strings by construction, so the round-trip composes directly without the wire-vocab intermediate hop the peer crate::CaixaKind axis pair requires.

Pinned load-bearing by [tests::dep_list_from_borrowed_into_box_str_routes_through_as_str_accessor] (byte-parity pin against DepList::as_str across the two-arm DepList::ALL emit-set on the borrowed-input surface, plus a blanket-derived Into shape witness, plus a .iter().map(Box::<str>::from) pipe witness over DepList::ALL — whose iterator yields &DepList by construction, so the borrowed- input Box<str> axis is what routes the pipe through the substrate- primitive DepList::as_str accessor without a spurious Copy deref).

fn from(list: &DepList) -> Box<str>

Converts to this type from the input type.

impl From<&DepList> for Arc<str>

Trait-idiomatic borrowed-input, std::sync::Arc<str> output forward projection on the outside-M3 caixa-core two-list dep-graph DepList closed-set fieldless typed enum — the borrowed-input companion to the paired owned-input [From<DepList> for std::sync::Arc<str>] impl immediately above. Routes byte-for-byte through the substrate-primitive DepList::as_str pub const fn accessor via std::sync::Arc::<str>::from on the returned &'static str, so every consumer that binds a let key: std::sync::Arc<str> = (&list).into();-shaped call site or a DepList::ALL.iter().map(std::sync::Arc::<str>::from)-shaped pipe (whose iterator over &'static [DepList] yields &DepList by construction) reaches the same two lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str byte- strings the paired owned-input [From<DepList> for std::sync::Arc<str>] and the sibling {Self, &Self} × {&'static str, String, Cow<'static, str>, Box<str>} forward-projection corner already return.

Rust’s standard library carries impl From<&str> for std::sync::Arc<str> and impl From<String> for std::sync::Arc<str> but no blanket impl<T: AsRef<str>> From<&T> for std::sync::Arc<str> (nor a Copy- based impl<T: Copy, U: From<T>> From<&T> for U), so this borrowed- input axis is a distinct trait-idiomatic surface that the pipe shape DepList::ALL.iter().map(std::sync::Arc::<str>::from) reaches through this impl and no other — without it, the same pipe would force a spurious Copy deref (std::sync::Arc::<str>::from((*list).as_str())) or a .copied() restatement whose type bounds have no compile-time link back to the substrate primitive.

Closes the {Self, &Self} input-shape corner on the second caixa- core-internal closed-set fieldless typed enum peer of the substrate- wide trait-idiomatic std::sync::Arc<str> forward-projection campaign — one commit after the paired top-level crate::CaixaKind pair (c17be64) opened the caixa-core-internal Arc tier — matching the trajectory the paired top-level crate::CaixaKind pair (c17be64, both corners in one axis) walked before it. Leaves the remaining caixa-core-internal closed-set fieldless typed enum peers (crate::dialeto::CaixaDialeto, crate::render::PathShapeViolation) as the campaign’s next multi- peer targets on the caixa-core-internal tier of the Arc axis.

Pinned load-bearing by [tests::dep_list_from_borrowed_into_arc_str_routes_through_as_str_accessor] (byte-parity pin against DepList::as_str across the two-arm DepList::ALL emit-set on the borrowed-input surface, plus a blanket-derived Into shape witness, a cross-axis partition pin against the paired owned-input [From<DepList> for std::sync::Arc<str>] and the sibling borrowed- input {&'static str, String, Cow<'static, str>, Box<str>} return- shape axes, and a .iter().map(std::sync::Arc::<str>::from) pipe witness over DepList::ALL that resolves through the borrowed- input axis without a spurious Copy deref).

fn from(list: &DepList) -> Arc<str>

Converts to this type from the input type.

impl From<&DepList> for Rc<str>

Trait-idiomatic borrowed-input, std::rc::Rc<str> output forward projection on the outside-M3 caixa-core two-list dep-graph DepList closed-set fieldless typed enum — the borrowed-input companion to the paired owned-input [From<DepList> for std::rc::Rc<str>] impl immediately above, closing the {Self, &Self} input-shape corner of the caixa-core- internal tier of the std::rc::Rc<str> axis on the two-list dep-graph peer. Routes byte-for-byte through the substrate-primitive DepList::as_str pub const fn accessor via std::rc::Rc::<str>::from on the returned &'static str, so a DepList::ALL.iter().map(std::rc::Rc::<str>::from)-shaped pipe (whose iterator over &'static [DepList] yields &DepList by construction) reaches the same two lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str byte- strings the paired owned-input axis and the sibling {Self, &Self} × {&'static str, String, Cow<'static, str>, Box<str>, std::sync::Arc<str>} forward-projection corner already return.

Rust’s standard library carries no blanket impl<T: AsRef<str>> From<&T> for std::rc::Rc<str> (nor a Copy- based impl<T: Copy, U: From<T>> From<&T> for U), so this borrowed- input axis is a distinct trait-idiomatic surface that the pipe shape DepList::ALL.iter().map(std::rc::Rc::<str>::from) reaches through this impl and no other — without it, the same pipe would force a spurious Copy deref (std::rc::Rc::<str>::from((*list).as_str())) or a .copied() restatement whose type bounds have no compile-time link back to the substrate primitive, and a let key: std::rc::Rc<str> = (&list).into();-shaped call site would force an explicit Copy deref (std::rc::Rc::<str>::from(*list)) or a std::rc::Rc::<str>::from(list.as_str()) open-code with the same defect.

Closes the {Self, &Self} input-shape corner on the third caixa- core-internal closed-set fieldless typed enum peer of the substrate-wide trait-idiomatic std::rc::Rc<str> forward- projection campaign, matching the trajectory the paired crate::CaixaKind (e04aff0), crate::dialeto::CaixaDialeto (c5595e5), and crate::render::PathShapeViolation (31fc43e) pairs walked before it on the caixa-core-internal tier of the same axis. Leaves the outside-caixa-core peers ([caixa_theme::Semantic], [caixa_provedor::FerriteRuntime]) as the campaign’s next multi- peer targets on the std::rc::Rc<str> axis — this commit gives them a fifth-peer {Self, &Self} caixa-core-internal-tier template to converge onto.

Pinned load-bearing by [tests::dep_list_from_borrowed_into_rc_str_routes_through_as_str_accessor] (byte-parity pin against DepList::as_str across the two-arm DepList::ALL emit-set on the borrowed-input surface, plus a blanket-derived Into shape witness, a cross-axis partition pin against the paired owned-input [From<DepList> for std::rc::Rc<str>] and the sibling borrowed- input {&'static str, String, Cow<'static, str>, Box<str>, std::sync::Arc<str>} return-shape axes, and a .iter().map(std::rc::Rc::<str>::from) pipe witness over DepList::ALL that resolves through the borrowed-input axis without a spurious Copy deref).

fn from(list: &DepList) -> Rc<str>

Converts to this type from the input type.

impl From<&DepList> for Vec<u8>

Trait-idiomatic borrowed-input, owned-Vec<u8> output byte-owned reverse projection on the third caixa-core-internal closed-set fieldless typed enum peer (DepList) — the borrowed-input peer of [From<DepList> for Vec<u8>], closing the {Self, &Self} → Vec<u8> pair on the byte-owned reverse-projection axis in one lift. Routes byte-for-byte through the substrate- primitive DepList::as_str pub const fn accessor so every consumer that holds a borrowed [&DepList] and needs an owned Vec<u8> — a future .iter().map(Vec::<u8>::from).collect() pipe over &[DepList] (whose iterator yields &DepList, not DepList, so the owned-input axis alone forces every call site through an explicit .copied() / spurious Copy deref restatement rather than the direct trait-idiomatic projection), a future dep-graph audit-report body composer that walks DepList::ALL through an Into<Vec<u8>>-bound per-arm byte- writer to surface the accepted dep-list set — reaches the same two- arm lifted crate::render::DEP_AUTHOR_KEY_DEPS* const roster the paired owned-input peer already returns.

fn from(list: &DepList) -> Vec<u8>

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 From<DepList> for Cow<'static, str>

Trait-idiomatic forward projection on the two-list dep-graph DepList closed-set typed enum from an owned input onto the borrowed-heap-string std::borrow::Cow<'static, str> axis — routes byte-for-byte through the substrate-primitive DepList::as_str pub const fn accessor (via std::borrow::Cow::Borrowed) so every consumer that binds a DepList through the standard-library .into() / [From<Self> for std::borrow::Cow<'static, str>] (equivalently Into<std::borrow::Cow<'static, str>>) axis reaches the same two-arm lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV canonical pub const &str values the paired [From<DepList> for &'static str], [From<&DepList> for &'static str], [From<DepList> for String], and [From<&DepList> for String] 2×2 trait-idiomatic forward- projection corners, the sibling std::fmt::Display, AsRef<str>, and DepList::as_str surfaces already return, rather than an open-coded per-call-site std::borrow::Cow::Borrowed(list.as_str()) / std::borrow::Cow::Owned(list.to_string()) composition whose type bounds have no compile-time link back to the substrate primitive.

Deliberately returns std::borrow::Cow::Borrowed rather than std::borrow::Cow::Owned — the substrate-primitive DepList::as_str accessor’s return carries the &'static str lifetime by construction (each match arm resolves to one of the two lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str values with static lifetime), so the zero-alloc borrowed arm is the type-correct projection with no runtime allocation. The paired std::borrow::Cow::Owned arm stays reachable at the call site through the existing [From<DepList> for String] axis composed with std::borrow::Cow::from on the resulting owned String — a caller who chose to mutate the projection lands on the owned arm by their own composition, not by the substrate- primitive projection silently allocating on their behalf.

Rust’s standard library carries no blanket impl<T: AsRef<str>> From<T> for Cow<'static, str> (nor an impl<T: fmt::Display> From<T> for Cow<'static, str>), so the paired sibling [From<DepList> for &'static str], [From<DepList> for String], AsRef<str>, and std::fmt::Display surfaces do not implicitly extend to a std::borrow::Cow<'static, str>-bound call site — every such site is forced through a Cow::Borrowed(list.as_str()) / Cow::Owned(list.to_string()) open-code whose type bounds have no compile-time link back to the substrate primitive until this lift.

First-mover on the outside-M3 substrate-wide tier of the substrate-wide trait-idiomatic std::borrow::Cow<'static, str> forward-projection campaign, opening the tier on the first caixa-core-internal closed-set fieldless typed enum peer outside the M2 OTP-shape and M3 mesh-shape tiers. The crate::CaixaKind top-level first-mover (99c1735 owned-input, d45c409 borrowed-input) opened the axis on the structurally most fundamental closed-set fieldless typed enum; the paired M2 OTP-shape crate::supervisor::RestartStrategy (7dd28b3, 9b3e4b3) and crate::supervisor::RestartPolicy (0612398, ee577fd) closed the M2 OTP-shape tier; the paired M3-mesh-shape crate::aplicacao::WitShape :contratos :wit census-label (8634dec, 25690ef), crate::aplicacao::PlacementStrategy :placement :estrategia distribution-strategy (eee504d, afdf0f4), and crate::aplicacao::RateLimitUnit :politicas :rate-limit canonical-suffix (1d59925, From<&RateLimitUnit> Cow closer) closed the M3-mesh-shape tier. The remaining outside-M3 caixa-core peers (crate::CaixaDialeto, crate::render::PathShapeViolation) and the outside- caixa-core peers (InvariantKind, ArchVerdict, Severity, FixSafety, Semantic, FerriteRuntime) are the remaining future targets of this campaign; the paired borrowed-input [From<&DepList> for std::borrow::Cow<'static, str>] {Self, &Self}-closer on this outside-M3-tier-opening peer is the next commit’s target.

Same three-path convergence discipline as the paired sibling [From<DepList> for &'static str] / [From<DepList> for String] / std::fmt::Display / AsRef<str> surfaces (this std::borrow::Cow<'static, str> axis, the paired sibling surfaces, and DepList::as_str all route through the same two lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str values by construction), so a future variant addition, rename, or per-arm wire-tag drift reaches every forward-projection path through exactly one caixa-core edit at the DepList::as_str match head.

Pinned load-bearing by [tests::dep_list_from_into_static_cow_str_routes_through_as_str_accessor] (byte-parity + zero-alloc std::borrow::Cow::Borrowed-arm pin against DepList::as_str across the two-arm DepList::ALL) and [tests::dep_list_from_into_static_cow_str_agrees_with_paired_axes_on_every_arm] (cross-axis partition pin against the paired [From<DepList> for &'static str], [From<DepList> for String], and ToString-through-std::fmt::Display axes, plus a .iter().copied().map(Cow::from) pipe witness over DepList::ALL that materializes the two-arm accept-set through the std::borrow::Cow<'static, str> axis alone and pins the zero-alloc discipline on every element).

fn from(list: DepList) -> Cow<'static, str>

Converts to this type from the input type.

impl From<DepList> for Box<str>

Trait-idiomatic owned-input, Box<str> output forward projection on the outside-M3 caixa-core two-list dep-graph DepList closed-set fieldless typed enum. Routes byte-for-byte through the substrate- primitive DepList::as_str pub const fn accessor via Box::<str>::from on the returned &'static str, so every consumer that binds a let key: Box<str> = list.into();-shaped call site — a per-:deps / :deps-dev census-key materializer that stashes the dep-list discriminator in a Box<str>-typed heap-owned scalar for cheap clone off an owned handle, a future M4 [caixa.pleme.io/v1alpha1/Caixa] CR materializer’s per-list admission- webhook rejection body whose per-arm Box<str> field composes from an owned DepList handle naming the accepted-list-tag list, a future feira lint --explain-dep-list=<axis> per-arm listing that stashes each arm as an owned Box<str> label — reaches the same two lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str byte-strings the sibling {Self, &Self} × {&'static str, String, Cow<'static, str>} forward-projection corner already returns.

Rust’s standard library carries impl From<&str> for Box<str> and impl From<String> for Box<str> but no blanket impl<T: AsRef<str>> From<T> for Box<str>, so this axis is a distinct trait-idiomatic surface that a downstream DepList → Box<str> .into() reaches through this impl and no other — without a Box::from(list.as_str()) open-code whose type bounds have no compile-time link back to the substrate primitive.

Extends the caixa-core-internal tier of the substrate-wide trait- idiomatic Box<str> forward-projection campaign onto the second caixa-core-internal peer, after the render-side path-shape-diagnostic crate::render::PathShapeViolation pair (0d87a72, both corners in one axis) opened the tier. Follows the M2 OTP-shape crate::supervisor::RestartStrategy / crate::supervisor::RestartPolicy pair (59ae5dc + cb1d068), the M3 mesh-shape crate::aplicacao::PlacementStrategy / crate::aplicacao::WitShape / crate::aplicacao::RateLimitUnit triple (6d73e84 → df7040c) that closed the M3 mesh-shape tier, and the outside-caixa-core tier (InvariantKind 10613a7 + 5901887, ArchVerdict 3e08f5a + c4319a8, Severity 5116c95, FixSafety cf0174b, Semantic 0cd7dc3, FerriteRuntime 14886a8) that closed one tier prior. Same discipline as those peers: forward emit (this impl, the sibling {&'static str, String, Cow<'static, str>} forward-projection corner, std::fmt::Display, AsRef<str>, DepList::as_str) and reverse parse (DepList::from_wire, TryFrom<&str>) route through the same two lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str byte-strings by construction, so the round-trip composes directly without the wire-vocab intermediate hop the peer crate::CaixaKind axis pair requires.

A future variant addition (a Build build-time-only dep-list axis the CAIXA-SDLC hints name as a trajectory item once the Cargo [build-dependencies] table gains substrate visibility) reaches the paired Box<str> output axis through one match-arm edit on the DepList::as_str pub const fn accessor, not a coordinated rewrite of every downstream Box::from(list.as_str()) open-code.

Pinned load-bearing by [tests::dep_list_from_into_box_str_routes_through_as_str_accessor] (byte-parity pin against DepList::as_str across the two-arm DepList::ALL emit-set on the owned-input surface, plus a blanket- derived Into shape witness).

fn from(list: DepList) -> Box<str>

Converts to this type from the input type.

impl From<DepList> for Arc<str>

Trait-idiomatic owned-input, std::sync::Arc<str> output forward projection on the outside-M3 caixa-core two-list dep-graph DepList closed-set fieldless typed enum. Routes byte-for-byte through the substrate-primitive DepList::as_str pub const fn accessor via std::sync::Arc::<str>::from on the returned &'static str, so every consumer that binds a let key: std::sync::Arc<str> = list.into();-shaped call site reaches the same two lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str byte-strings the sibling {Self, &Self} × {&'static str, String, Cow<'static, str>, Box<str>} forward-projection corner already returns.

Rust’s standard library carries impl From<&str> for std::sync::Arc<str> and impl From<String> for std::sync::Arc<str> but no blanket impl<T: AsRef<str>> From<T> for std::sync::Arc<str> (nor an impl<T: fmt::Display> From<T> for std::sync::Arc<str>), so this axis is a distinct trait-idiomatic surface that a let key: std::sync::Arc<str> = list.into();-shaped call site reaches through this impl and no other — a paired std::sync::Arc::<str>::from(list.as_str()) open-code has no compile- time link back to the substrate primitive, and a two-step std::sync::Arc::<str>::from(String::from(list)) composition through the owned-String axis allocates twice (once into the intermediate String, once into the std::sync::Arc<str> on the From<String> conversion) where the single-step trait impl allocates once. The shared-ownership + Sync + Send contract std::sync::Arc<str> provides is the distinct value the sibling Box<str> axis’s owned- move return-shape cannot provide — a per-:deps / :deps-dev census key reachable from multiple concurrent per-Caixa reconcile / per-lint tasks through the same two lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV byte-strings, without a .clone()-per-task materialization the owned-move Box<str> axis would force.

Extends the caixa-core-internal tier of the substrate-wide trait- idiomatic std::sync::Arc<str> forward-projection campaign onto the second caixa-core-internal peer, after the top-level crate::CaixaKind pair (c17be64, both corners in one axis) opened the tier. Follows the M2 OTP-shape crate::supervisor::RestartStrategy / crate::supervisor::RestartPolicy pair (bca2ec8 + b3e72d7 / b05724e + ea91551), the M3 mesh-shape crate::aplicacao::PlacementStrategy / crate::aplicacao::WitShape / crate::aplicacao::RateLimitUnit triple (977d577 → dae722f), and the outside-caixa-core tier (InvariantKind 4e923c1 + 03c043f, ArchVerdict 1682f8b + 92ddfb2, Severity a7a9a6d + 4f041e1, FixSafety fb73edb + 822138e, Semantic 65dbcff + f3a55c7, FerriteRuntime 938d915 + 0afef4b) that closed prior tiers on this same Arc axis. Same discipline as those peers: forward emit (this impl, the sibling {Self, &Self} × {&'static str, String, Cow<'static, str>, Box<str>} forward-projection corner, std::fmt::Display, AsRef<str>, DepList::as_str) and reverse parse (DepList::from_wire, TryFrom<&str>) route through the same two lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str byte- strings by construction, so the round-trip composes directly without the wire-vocab intermediate hop the peer crate::CaixaKind axis pair requires.

A future variant addition (a Build build-time-only dep-list axis the CAIXA-SDLC hints name as a trajectory item once the Cargo [build-dependencies] table gains substrate visibility) reaches the paired std::sync::Arc<str> output axis through one match-arm edit on the DepList::as_str pub const fn accessor, not a coordinated rewrite of every downstream std::sync::Arc::<str>::from(list.as_str()) open-code.

Pinned load-bearing by [tests::dep_list_from_into_arc_str_routes_through_as_str_accessor] (byte-parity pin against DepList::as_str across the two-arm DepList::ALL emit-set on the owned-input surface, plus a blanket- derived Into shape witness and cross-axis byte-parity pins against the sibling owned-input {&'static str, String, Cow<'static, str>, Box<str>} return-shape axes).

fn from(list: DepList) -> Arc<str>

Converts to this type from the input type.

impl From<DepList> for Rc<str>

Trait-idiomatic owned-input, std::rc::Rc<str> output forward projection on the outside-M3 caixa-core two-list dep-graph DepList closed-set fieldless typed enum — routes byte-for-byte through the substrate-primitive DepList::as_str pub const fn accessor via std::rc::Rc::<str>::from on the returned &'static str, so every consumer that binds a DepList through the standard-library .into() / From::from surfaces onto the non-atomic single-threaded-reference-counted std::rc::Rc<str> axis reaches the same two lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV pub const &str byte- strings the sibling {&'static str, String, Cow<'static, str>, Box<str>, std::sync::Arc<str>} return-shape axes already return.

Rust’s standard library carries impl From<&str> for std::rc::Rc<str> and impl From<String> for std::rc::Rc<str> but no blanket impl<T: AsRef<str>> From<T> for std::rc::Rc<str>, and the std::sync::Arc<str> and std::rc::Rc<str> trait tables are disjoint — so a single-threaded caixa-core dep-graph pass whose per-list :deps / :deps-dev bucket key is cloned across intra- pass tree nodes through the cheaper non-atomic std::rc::Rc<str> refcount (the atomically-reference-counted std::sync::Arc<str> axis cannot elide the CAS-fence cost within a single-threaded caixa-core pass), a future feira dep --list <deps|deps-dev>- side per-list histogram-column emitter keyed on a shared-ownership per-arm bucket key, a future caixa-lsp-side dep-graph quick-fix panel composer holding a shared per-list canonical :-prefixed kebab tag across intra-file dep tree nodes without atomic contention — reaches the substrate primitive through this impl and no other. A paired std::rc::Rc::<str>::from(list.as_str()) open-code has no compile-time link back to the substrate primitive, and a two-step std::rc::Rc::<str>::from(String::from(list)) composition through the owned-String axis allocates twice (once into the intermediate String, once into the std::rc::Rc<str> on the From<String> conversion) where the single-step trait impl allocates once.

Opens the caixa-core-internal tier of the std::rc::Rc<str> forward-projection campaign onto the caixa-core two-list dep-graph peer, following the trajectory the paired top-level crate::CaixaKind pair (e04aff0), the second caixa-core-internal peer crate::dialeto::CaixaDialeto pair (c5595e5), the render- side path-shape-diagnostic peer crate::render::PathShapeViolation pair (31fc43e), the M3-mesh-primitive-defining crate::aplicacao::PlacementStrategy pair (91b4c92), and the outside-caixa-core peers (InvariantKind c71818b, ArchVerdict cc759ef, Severity d7c58b6, FixSafety 046cc5f) walked before it on the same axis — closes the caixa-core-internal tier’s third-peer slot after the render-side crate::render::PathShapeViolation second-peer pair. Leaves the outside-caixa-core peers (caixa_theme::Semantic, caixa_provedor::FerriteRuntime) as the campaign’s next multi-peer targets on the std::rc::Rc<str> axis.

Pinned load-bearing by [tests::dep_list_from_into_rc_str_routes_through_as_str_accessor] (byte-parity pin against DepList::as_str across the two-arm DepList::ALL emit-set on the owned-input surface, plus a blanket-derived Into shape witness and cross-axis byte-parity pins against the sibling owned-input {&'static str, String, Cow<'static, str>, Box<str>, std::sync::Arc<str>} return-shape axes).

fn from(list: DepList) -> Rc<str>

Converts to this type from the input type.

impl From<DepList> for Vec<u8>

Trait-idiomatic owned-input, owned-Vec<u8> output byte-owned reverse projection on the third caixa-core-internal closed-set fieldless typed enum peer (DepList) — the byte-mirror of the [From<DepList> for String] str-owned reverse-projection axis and the owned-Vec<u8> reverse-projection sibling of the paired [AsRef<[u8]>] borrowed byte-view axis lifted on this same enum. Routes byte-for-byte through the substrate-primitive DepList::as_str pub const fn accessor via str::as_bytes + slice::to_vec so every consumer that binds a DepList through the standard-library impl From<DepList> for Vec<u8> axis (equivalently <T: Into<Vec<u8>>>) — a future std::io::Write::write_all-shape per-:deps audit-log byte-sink whose input parameter is an owned Vec<u8> payload, a future bytes::Bytes::from(Vec::<u8>::from(list)) composer folding the per-arm dep-list discriminator byte-tag into the [bytes::Bytes] framing surface, a future hasher.update(&Vec::<u8>::from(list))- shape BLAKE3 content-address closure that needs the owned byte-tail buffered before folding into the [crate::Lacre] closure body so a downstream Lacre consumer can partition the runtime-closure :deps from the dev-only-closure :deps-dev at content-address time, a future per-dep-list protobuf/CBOR/msgpack payload composer whose framer takes an owned Vec<u8> rather than a borrowed byte-slice — reaches the same two-arm lifted crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV const roster the paired [AsRef<[u8]>] borrowed byte-view axis, the four {Self, &Self} × {&'static str, String} 2×2 str-view forward- projection corners, the std::borrow::Cow<'static, str> / Box<str> / std::sync::Arc<str> / std::rc::Rc<str> str- owned reverse-projection quartet, and the substrate-primitive DepList::as_str accessor already return, rather than an open- coded per-call-site list.as_str().as_bytes().to_vec() / <DepList as AsRef<[u8]>>::as_ref(&list).to_vec() / String::from(list).into_bytes() composition whose type bounds have no compile-time link back to the substrate primitive.

Third peer on the substrate-wide trait-idiomatic byte-owned reverse-projection family opened on the sibling top-level crate::CaixaKind enum (b245fd6 first-mover) and extended onto crate::dialeto::CaixaDialeto (4cceaf5 second-mover) — Rust’s standard library carries impl From<&[u8]> for Vec<u8> and impl From<String> for Vec<u8>, so a two-hop composition list.as_str().as_bytes().to_vec() (or String::from(list).into_bytes(), or <DepList as AsRef<[u8]>>::as_ref(&list).to_vec()) is reachable through the pre-existing str-view axes and the paired [AsRef<[u8]>] borrowed byte-view axis alone. But that two-hop shape has no compile-time link back to the byte-owned reverse- projection axis, forces every downstream <T: Into<Vec<u8>>>-bound consumer to open-code the composition at every call site, and admits a silent split whenever a future call site takes a sibling projection axis whose into_bytes() / to_vec() byte-tail carries no compile-time byte-owned surface. The lifted single-hop impl closes the byte-owned reverse-projection axis so every future Vec<u8>-parameterized consumer reaches the substrate primitive through one trait dispatch, and every future arm addition (the sibling DepList::from_wire doc block’s :deps-build build-only dep-list trajectory item and the [target.<cfg>.dev-dependencies] future admission surface both name) grows the byte-owned axis through one edit on the substrate-primitive DepList::as_str accessor.

Unlike the sibling first-mover crate::CaixaKind enum — which carries a two-axis split (lowercase-Portuguese diagnostic form vs PascalCase tatara-lisp author-surface bytes) so its byte-owned axis pins a wire-axis rejection witness — DepList carries a single canonical axis: DepList::as_str returns the :-prefixed kebab-case tatara-lisp author-surface key (crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV), which is simultaneously the wire form the paired DepList::from_wire resolver reads back. The byte-owned axis therefore lands on the same :-prefixed kebab byte-string every str-view / reverse- projection / byte-view axis on this enum already returns, and no wire-axis cross-witness applies (matching the discipline crate::dialeto::CaixaDialeto’s From<{Self, &Self}> for Vec<u8> impls established on the caixa-core-internal tier).

Extends the byte-owned reverse-projection axis onto the third closed-set fieldless typed enum peer on the caixa-core-internal tier — every remaining closed-set fieldless typed enum peer on the substrate (crate::supervisor::RestartStrategy, crate::supervisor::RestartPolicy, crate::aplicacao::PlacementStrategy, crate::aplicacao::RateLimitUnit, and the outside-caixa-core peers WitShape, PathShapeViolation, InvariantKind, ArchVerdict, Severity, FixSafety, Semantic, FerriteRuntime) is a future target of the campaign, mirroring the discipline the paired [AsRef<[u8]>] borrowed byte-view axis campaign already tracked across every closed-set fieldless typed enum peer on the substrate.

Pinned load-bearing by [tests::dep_list_from_into_owned_vec_bytes_routes_through_as_str_accessor] (byte-parity pin against DepList::as_str across the two-arm emit-set binding the byte-owned reverse-projection axis against the paired [AsRef<[u8]>] borrowed byte-view axis and the str-view family’s .as_bytes().to_vec() byte-tails, plus a <T: Into<Vec<u8>>>-bound generic-consumer witness and a std::io::Write::write_all-shape owned-byte-sink surface witness on both owned and borrowed input shapes).

fn from(list: DepList) -> Vec<u8>

Converts to this type from the input type.

impl FromStr for DepList

Trait-idiomatic std::str::FromStr parse axis on the two-list dep-graph DepList closed-set typed enum — routes byte-for-byte through the paired [TryFrom<&str> for DepList] impl (which in turn routes through the substrate-primitive DepList::from_wire Option<Self> accessor), so "...".parse::<DepList>() / <DepList as FromStr>::from_str(…) reaches the same two-arm accept-set the sibling method-named DepList::from_wire resolver and the paired TryFrom<&str> impl already resolve against.

Opens the trait-idiomatic str::parse-axis campaign on the substrate-wide closed-set fieldless typed-enum surface. The substrate already carries three peers per enum on the projection star: the method-named substrate-primitive pair (DepList::as_str pub const fn accessor + DepList::from_wire Option<Self> resolver), the emit-set trait pair (std::fmt::Display, AsRef<str>, the owned-input + borrowed-input {&'static str, String, Cow<'static, str>, Box<str>, std::sync::Arc<str>} From<{Self,&Self}> return-shape matrix), and the parse-set TryFrom<&str> reverse trait. [FromStr] is the canonical Rust-idiomatic parse-set entry point every stdlib-shaped consumer reaches for — str::parse::<T>() is a T: FromStr-bounded generic, not a T: for<'a> TryFrom<&'a str>- bounded one — so lifting [FromStr] onto the closed-set enum unlocks the .parse::<DepList>() short-form on every consumer (a future feira dep --list <deps|deps-dev> clap-style arg-parse composes arg.parse::<DepList>(); a serde string-tagged deserializer routes through the same FromStr bound; the future M4 admission webhook’s Deserialize derive reaches the enum through its FromStr impl via serde_with::DisplayFromStr).

The impl trivially delegates to the paired TryFrom<&str> — same type Err = () deliberate-deferral shape the sibling reverse-projection trait carries — so both trait-idiomatic parse-axis paths (TryFrom<&str> and FromStr::from_str) resolve to the same two-arm accept-set by construction. A future accept-set widening (a ":packages" rebrand, a ":dev-deps" alias) reaches every parse path through one edit on the substrate-primitive DepList::from_wire accessor, not a coordinated rewrite across the two reverse-projection trait impls.

Pinned load-bearing by [tests::dep_list_from_str_routes_through_try_from_str_impl] (byte-parity pin across the two-arm accept-set + delegated- .parse()-projection witness) and [tests::dep_list_from_str_rejects_unknown_byte_strings] (rejection witness against silent accept-set widening).

type Err = ()

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this 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<&[u8]> for DepList

Trait-idiomatic borrowed byte-slice input reverse projection on the third caixa-core-internal closed-set fieldless typed enum peer (DepList) — the byte-view mirror of the str-view reverse-projection axis carried by the paired [TryFrom<&str> for DepList] impl (which routes through the substrate-primitive DepList::from_wire Option<Self> accessor on the two-arm :-prefixed kebab-case accept- set the sibling DepList::as_str emitter returns — crate::render::DEP_AUTHOR_KEY_DEPS / crate::render::DEP_AUTHOR_KEY_DEPS_DEV). Routes byte-for-byte through the standard-library std::str::from_utf8 UTF-8 validator and then through DepList::from_wire so every consumer that holds a borrowed [&[u8]] and needs to project it back into a typed DepList — a future bytes::Bytes::as_ref()-fed reader that parses a per-caixa :deps / :deps-dev classification tag from an already- borrowed framing byte-tail (a tracing::field::valuable::Value::Bytes recorder on the caixa-lacre :deps / :deps-dev partitioning pipeline, a future audit-report re-loader binding a prior DepList::as_str output from an mmap’d byte-slice back through the typed enum for cross-run comparison), a future admission-webhook rejection body that reads a spec.dep_list field off a raw HTTP body byte-slice before UTF-8 validation commits allocation, a future generic <T: for<'a> TryFrom<&'a [u8]>>-bound loader over any of the substrate’s closed-set typed enums — reaches the same two-arm :-prefixed kebab-case wire accept-set the sibling method-named DepList::from_wire resolver and the paired trait-idiomatic TryFrom<&str> axis already resolve against, rather than an open- coded per-call-site std::str::from_utf8(bytes).ok().and_then(DepList::from_wire) composition or a <DepList as TryFrom<&str>>::try_from(std::str::from_utf8(bytes)?) two-hop shape whose type bounds have no compile-time link to the substrate primitive.

Extends the substrate-wide trait-idiomatic byte-view reverse- projection family — opened on the structurally most fundamental closed-set fieldless typed enum peer (crate::CaixaKind, commit 18d1940) and extended onto crate::dialeto::CaixaDialeto (d102cb8 second-mover) — onto the third caixa-core-internal closed-set fieldless typed enum peer, tracking the “route through from_wire via std::str::from_utf8” discipline the first-mover established. Rust’s standard library carries no blanket impl<T: for<'a> TryFrom<&'a str>> TryFrom<&[u8]> for T, so a two-hop composition through std::str::from_utf8 + the paired TryFrom<&str> axis is reachable at every call site but has no compile-time link back to the byte-view reverse-projection axis. Every future closed-set fieldless typed enum peer on the substrate (crate::supervisor::RestartStrategy, crate::supervisor::RestartPolicy, crate::aplicacao::PlacementStrategy, crate::aplicacao::RateLimitUnit, crate::aplicacao::WitShape, and the outside-caixa-core peers PathShapeViolation, InvariantKind, ArchVerdict, Severity, FixSafety, Semantic, FerriteRuntime) is a future target of the campaign, mirroring the trajectory the closed byte-owned reverse-projection family walked arm-by-arm onto each peer.

type Error = () matches the sibling DepList::from_wire’s Option<Self> return-shape’s deliberate deferral of error typing and the paired trait-idiomatic TryFrom<&str> axis’s unit-error shape — the caller picks the diagnostic form appropriate for its use site (a future feira dep --list <deps|deps-dev> arg-parse composes its own per-verb “unknown list: — accepted: {…}” message enumerating DepList::ALL; the M4 admission-webhook rejection body wraps Err(()) with the accepted-set enumeration for operator diagnostics; a Result::map_err at the call site lifts the unit-error to a per- verb error type). Two rejection paths route through the single unit- error: an invalid UTF-8 byte-sequence (std::str::from_utf8 returns Err) and a valid UTF-8 byte-string that falls outside the two-arm :-prefixed kebab-case accept-set (DepList::from_wire returns None) — both collapse onto Err(()) so the trait signature stays consistent with the sibling str-view reverse axis, and a caller that needs to distinguish the two failure modes composes std::str::from_utf8 + DepList::from_wire explicitly.

Pinned load-bearing by [tests::dep_list_try_from_bytes_routes_through_from_wire_accessor] (byte-parity pin against DepList::from_wire across the two-arm DepList::ALL accept-set on the borrowed byte-slice surface, plus a cross-axis witness that the byte-view reverse projection agrees with the paired TryFrom<&str> str-view reverse axis on every accepted arm) and [tests::dep_list_try_from_bytes_rejects_unknown_and_non_utf8_bytes] (rejection witness against silent accept-set widening on both the non-UTF-8 byte-sequence rejection path and the unknown-wire-vocabulary rejection path).

type Error = ()

The type returned in the event of a conversion error.

fn try_from(bytes: &[u8]) -> Result<Self, Self::Error>

Performs the conversion.

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.

impl TryFrom<Vec<u8>> for DepList

Trait-idiomatic owned byte-vec input reverse projection on the third caixa-core-internal closed-set fieldless typed enum peer (DepList) — the owned-input peer of [TryFrom<&[u8]> for DepList], mirroring the closed [From<DepList> for Vec<u8>] + [From<&DepList> for Vec<u8>] byte-owned forward-projection pair on this same enum onto the byte-owned reverse-projection axis. Routes byte-for-byte through [<Self as TryFrom<&[u8]>>::try_from] on the Vec<u8>::as_slice borrow, so the owned-input surface reaches the same std::str::from_utf8 + DepList::from_wire resolution chain the borrowed-input peer already carries — one substrate-primitive accessor, one trait dispatch, no per-consumer detour.

Rust’s standard library carries no blanket impl<T: for<'a> TryFrom<&'a [u8]>> TryFrom<Vec<u8>> for T, so a consumer that holds an owned Vec<u8> and needs a typed DepList otherwise picks between (a) an open-coded <DepList as TryFrom<&[u8]>>::try_from(bytes.as_slice()) at every call site (whose type bounds have no compile-time link to the byte- owned reverse-projection axis), (b) a two-hop String::from_utf8(bytes) + DepList::from_wire composition whose error surface leaks the standard-library std::string::FromUtf8Error (widening the sibling [TryFrom<&[u8]>] axis’s unit-error) and silently allocates a String on inputs that will never make it past the wire vocabulary, or (c) an intermediate <DepList as TryFrom<&str>>::try_from(std::str::from_utf8(&bytes)?) three-hop shape. This impl closes the owned-byte-vec reverse- projection axis at the substrate-primitive DepList::from_wire accessor so every future <T: TryFrom<Vec<u8>>>-bound owned-byte-vec consumer — a future admission-webhook body reader that hands raw request bytes off as a Vec<u8> before UTF-8 validation commits, a future std::io::Read::read_to_end-shape audit-log source whose framing yields an owned byte-vec per frame, a future protobuf/CBOR/msgpack per-field decoder whose bytes arm surfaces an owned Vec<u8> before dispatch, a bytes::Bytes::to_vec()-shape wire-body composer walking a prior audit’s payload back to the typed enum, an <T: TryFrom<Vec<u8>>>-bound generic loader over any of the substrate’s closed-set typed enums — reaches the same two-arm :-prefixed kebab-case wire accept-set through one trait dispatch.

Extends the substrate-wide trait-idiomatic byte-owned reverse- projection family onto the third caixa-core-internal closed-set fieldless typed enum peer, tracking the trajectory the sibling first-mover [TryFrom<Vec<u8>> for crate::CaixaKind] (99c2849) opened on the structurally most fundamental enum and the sibling second-mover [TryFrom<Vec<u8>> for crate::CaixaDialeto] (83a1526) continued through. Peer of the sibling closed byte-view reverse- projection family (TryFrom<&[u8]>; extended onto this enum b8f25d5) and of the closed byte-owned forward-projection family (From<{Self, &Self}> for Vec<u8>; extended onto this enum on the same commit as its TryFrom<&[u8]> peer) on this same enum — the {owned-input, borrowed-input} × {owned-output byte-vec, borrowed- output byte-slice} byte-view reverse-projection square now closes on DepList.

type Error = () matches the sibling [TryFrom<&[u8]> for DepList] unit-error shape, preserving the trait-family consistency across the borrowed-and-owned byte-view reverse-projection pair. Both rejection paths (invalid UTF-8, valid-UTF-8-but-unknown-wire) collapse onto Err(()) through the delegated borrowed axis. The owned Vec<u8> input is dropped on the error path (the standard-library String::from_utf8 convention of returning the input in the error deliberately declined — a caller that needs the bytes back holds a clone before the call, and the closed-set- enum use site rarely wants the raw bytes back past a “did you mean” diagnostic that operates on the wire vocabulary rather than the input).

Like the peer [TryFrom<Vec<u8>> for crate::CaixaDialeto] and unlike [TryFrom<Vec<u8>> for crate::CaixaKind] (which carries a wire-vs-diagnostic two-axis split — lowercase Portuguese as_str vs PascalCase wire_name), DepList has no such split: Self::as_str and Self::from_wire operate on the same two-arm :-prefixed kebab-case byte-vocabulary (":deps", ":deps-dev"). So on this enum the byte-owned reverse- projection axis can round-trip against the paired byte-owned forward-projection pair ([From<DepList> for Vec<u8>], [From<&DepList> for Vec<u8>]) — a four-corner witness the pinned load-bearing test makes explicit, and a witness the sibling [TryFrom<Vec<u8>> for crate::CaixaKind] axis deliberately declines.

Pinned load-bearing by [tests::dep_list_try_from_vec_bytes_routes_through_borrowed_byte_view_axis] (byte-parity pin against the paired borrowed [TryFrom<&[u8]>] axis across the two-arm DepList::ALL accept-set on the owned byte-vec surface, plus a cross-axis witness that the byte-owned reverse projection agrees with the paired str-view reverse- projection axis (TryFrom<&str>) on every accepted arm through the shared substrate-primitive DepList::from_wire accessor, plus a four-corner {owned-input, borrowed-input} × {owned-output byte-vec, borrowed-output byte-slice} round-trip witness against the paired [From<{Self, &Self}> for Vec<u8>] byte-owned forward- projection pair) and [tests::dep_list_try_from_vec_bytes_rejects_unknown_and_non_utf8_bytes] (rejection witness against silent accept-set widening on both the non-UTF-8 byte-sequence rejection path and the unknown-wire- vocabulary rejection path, plus a cross-axis witness that the owned byte-vec reverse-projection axis agrees with the borrowed byte-slice reverse-projection axis on every rejected input).

type Error = ()

The type returned in the event of a conversion error.

fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error>

Performs the conversion.