caixa_core/

dialeto.rs

//! `defcaixa` is spoken by two unrelated declarations. This module makes that
//! a **typed fact** instead of an anonymous parse failure.
//!
//! # The finding
//!
//! Measured 2026-07-31 over the pleme-io org checkout (270 `caixa.lisp` /
//! `*.caixa.lisp` files found with `rg --no-ignore`; a bare `rg` from the org
//! root returns 0, which is how this stayed invisible), the corpus splits into
//! two schemas that share zero required slots:
//!
//! * [`CaixaDialeto::Pacote`] — this crate's [`crate::Caixa`]. `:nome
//!   :versao :kind :deps :bibliotecas :exe :servicos` + the supervisor/mesh
//!   slots. It declares a **tatara-lisp package**: the thing `feira` resolves,
//!   builds, links and publishes.
//! * [`CaixaDialeto::Molde`] — `:name :kind :ecosystem :package {…} :workflows
//!   […] :ci-config {…} :files […]`. It declares a **repo's generated
//!   surface**: which foreign ecosystem (rust / go / python / …), that
//!   ecosystem's own package metadata, the CI shims to emit, and byte-captured
//!   file bodies. Read by `pleme-doc-gen`, never by `feira`.
//!
//! `:package`, `:ecosystem`, `:supports` and `:profile` have no counterpart in
//! [`crate::Caixa`] at all — the theory doc's own D4 note records the same
//! thing: those manifests "are authored against a schema that does not exist in
//! Rust". They are not two spellings of one declaration. They are two domains
//! that collided on one word, because *caixa* names a box and both are boxes.
//!
//! # Why this is not a bug report about broken files
//!
//! The Molde-dialect files are not malformed. They are correct inputs to their
//! own consumer, and nothing in the shipped `feira` reads them, so nothing is
//! failing today. The hazard is **latent and certain**: any new declarative
//! surface written against "a `.caixa.lisp` is a [`crate::Caixa`]" meets a
//! corpus where that is false for the large majority of files, and gets a flat
//! unknown-keyword rejection that reads as "this manifest is broken" rather
//! than "this manifest is not yours".
//!
//! # What this module does about it
//!
//! [`classify`] is total: every `(defcaixa …)` form lands in exactly one
//! [`CaixaDialeto`], including [`CaixaDialeto::Desconhecido`] for one that
//! matches neither. [`crate::Caixa::from_lisp`] runs it first, so a foreign
//! dialect is [`crate::ManifestError::DialetoEstrangeiro`] — an error that
//! names the dialect it found and the consumer that speaks it — rather than an
//! unknown-kwarg error indistinguishable from a typo.
//!
//! Tier-honest: this is **parse-time rejection with a named cause**, not
//! unrepresentability. A caller that ignores the `Err` still gets nothing
//! useful; what it can no longer do is mistake "wrong dialect" for "bad file".

use tatara_lisp::{Atom, Sexp};

/// Canonical `PascalCase` variant-name byte-string the internal-
/// classification [`CaixaDialeto::Pacote`] arm surfaces under — the
/// per-arm `&'static str` payload every consumer that formats the
/// dialect axis as census-facing text (the `feira dialeto` census
/// counter output line, future `feira dialeto --list-dialects` /
/// `--filter <Pacote|Molde|MoldePosicional|Desconhecido>` CLI-side
/// enumerations, a future M4 `mesh.pleme.io/v1alpha1/Manifesto` CR
/// materializer's admission-webhook rejection body naming the
/// accepted-dialect set, structured-log `tracing::field::Value::Str`
/// per-dialect emits on the caixa-build pipeline's per-file classify
/// path) converges onto verbatim through the paired
/// [`CaixaDialeto::as_str`] `pub const fn` accessor and the sibling
/// [`CaixaDialeto::from_wire`] reverse-projection parser. Peer of
/// [`CAIXA_DIALETO_WIRE_MOLDE`] / [`CAIXA_DIALETO_WIRE_MOLDE_POSICIONAL`]
/// / [`CAIXA_DIALETO_WIRE_DESCONHECIDO`] on the four-arm dialect-
/// classification wire-form axis.
///
/// Same "one canonical byte-string per typed axis" discipline the
/// peer [`crate::render::RENDER_PATH_SHAPE_VIOLATION_WIRE_EMPTY`]
/// (0330bd3) / [`crate::render::CAIXA_KIND_WIRE_BIBLIOTECA`] /
/// [`crate::render::M2_UPGRADE_INSTRUCTION_WIRE_LOAD_MODULE`]
/// (36ffe65) / [`crate::render::SUPERVISOR_ESTRATEGIA_ONE_FOR_ONE`]
/// (be40492) / [`crate::render::M3_PLACEMENT_ESTRATEGIA_SINGLE_NODE`]
/// families established for the sibling render-side path-shape-
/// diagnostic / M2 OTP-shape / supervisor / M3 mesh-shape closed-set
/// typed-enum wire-form axes — extends the discipline onto the
/// tatara-lisp dialect-classification axis, the eleventh substrate-
/// side closed-set typed enum to converge onto it and the first
/// dialect-classification axis (as distinct from the top-level
/// manifest surface or a render-side path-shape-diagnostic surface)
/// to reach it. Until this lift landed the byte-string sat twice
/// inline in [`CaixaDialeto::as_str`] and [`CaixaDialeto::from_wire`]
/// with no compile-time link between the emit and parse arms nor to
/// any downstream roster; a future rebrand (a per-arm variant
/// rename under an M4 vocabulary shift, an operator-vocabulary
/// migration for a `feira dialeto --list-dialects` per-arm listing)
/// would have desynchronized the paired arm-set until a downstream
/// consumer surfaced the drift at runtime. Routing all halves
/// (`as_str` + `from_wire` + the paired
/// [`CaixaDialeto::WIRE_NAMES`] roster) through this const closes
/// the drift structurally by construction. Pinned load-bearing by
/// [`tests::caixa_dialeto_wire_names_covers_every_arm`] (paired
/// roster / emitter round-trip).
pub const CAIXA_DIALETO_WIRE_PACOTE: &str = "Pacote";

/// Canonical `PascalCase` variant-name byte-string the internal-
/// classification [`CaixaDialeto::Molde`] arm surfaces under. Peer of
/// [`CAIXA_DIALETO_WIRE_PACOTE`] on the four-arm dialect-classification
/// wire-form axis; see [`CAIXA_DIALETO_WIRE_PACOTE`] for the full lift
/// rationale.
pub const CAIXA_DIALETO_WIRE_MOLDE: &str = "Molde";

/// Canonical `PascalCase` variant-name byte-string the internal-
/// classification [`CaixaDialeto::MoldePosicional`] arm surfaces under.
/// Peer of [`CAIXA_DIALETO_WIRE_PACOTE`] on the four-arm dialect-
/// classification wire-form axis; see [`CAIXA_DIALETO_WIRE_PACOTE`] for
/// the full lift rationale. The full-word (rather than abbreviated)
/// spelling here is load-bearing — a `format!("{:?}", …).to_lowercase()`
/// round-trip on the source-side `Debug` derive would collapse the
/// multi-word arm to `"moldeposicional"` and desynchronize the tag
/// from every peer substrate-side census-facing `PascalCase` axis.
pub const CAIXA_DIALETO_WIRE_MOLDE_POSICIONAL: &str = "MoldePosicional";

/// Canonical `PascalCase` variant-name byte-string the internal-
/// classification [`CaixaDialeto::Desconhecido`] arm surfaces under.
/// Peer of [`CAIXA_DIALETO_WIRE_PACOTE`] on the four-arm dialect-
/// classification wire-form axis; see [`CAIXA_DIALETO_WIRE_PACOTE`] for
/// the full lift rationale.
pub const CAIXA_DIALETO_WIRE_DESCONHECIDO: &str = "Desconhecido";

/// Which `(defcaixa …)` declaration a source speaks.
///
/// The [`gen_platform::IsVariant`] derive emits per-arm arm-discriminator
/// predicates (`is_pacote` / `is_molde` / `is_molde_posicional` /
/// `is_desconhecido`) as substrate-side typed dispatches on the closed
/// four-arm dialect-classification discriminator. Peer of the sibling
/// closed-set fieldless typed enums' [`crate::CaixaKind`] /
/// [`crate::supervisor::RestartStrategy`] /
/// [`crate::supervisor::RestartPolicy`] /
/// [`crate::aplicacao::PlacementStrategy`] /
/// [`crate::aplicacao::RateLimitUnit`] /
/// [`crate::dep::DepList`] `IsVariant` derives on the sibling
/// closed-set typed-enum discriminator axes.
///
/// The pre-lift `is_molde_family` predicate hand-rolled its own
/// `matches!(self, Self::Molde | Self::MoldePosicional)` two-arm literal
/// with no compile-time link back to the closed set — post-lift it routes
/// through `self.is_molde() || self.is_molde_posicional()` so a future
/// arm rename (e.g. `Molde → MoldeKW` under an M4 vocabulary shift) trips
/// exhaustively at every derive-generated predicate site rather than
/// leaving the hand-rolled `matches!` silently drifting.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, gen_platform::IsVariant)]
pub enum CaixaDialeto {
    /// This crate's [`crate::Caixa`] — a tatara-lisp package manifest.
    /// Keyword-argument form headed by `:nome`.
    Pacote,
    /// `pleme-doc-gen`'s repo-surface declaration, keyword-argument form
    /// headed by `:name` (plus `:ecosystem` / `:package`).
    Molde,
    /// The same declaration as [`Self::Molde`], written with the package name
    /// as a bare positional symbol — `(defcaixa todoku-go :kind :Biblioteca
    /// :ecosystem :go …)`. `pleme-doc-gen`'s parser reads the first token
    /// after the head as the name, so this is one arity of one declaration,
    /// not a third schema.
    MoldePosicional,
    /// A `(defcaixa …)` form matching neither. Kept as a variant rather than
    /// an error so [`classify`] is total and a census can COUNT the residue —
    /// a classifier that threw here would report "0 unknown" by construction.
    Desconhecido,
}

impl CaixaDialeto {
    /// Exhaustive iteration surface for every consumer that walks the
    /// closed four-arm [`CaixaDialeto`] discriminator set — the
    /// [`feira dialeto`](../../caixa_feira/cmd/dialeto/index.html)
    /// census counter's per-arm accept-set, a future
    /// `feira dialeto --list-dialects` CLI listing of the accepted
    /// classifications, a future M4 `mesh.pleme.io/v1alpha1/Manifesto`
    /// CR materializer's admission-webhook rejection body naming the
    /// accepted-dialect set, any future census-report shape probe that
    /// sweeps every arm to compute per-arm coverage. A future arm
    /// addition (a fifth dialect the [`crate::dialeto`] module doc's
    /// "third dialect" hazard actualises — the module explicitly frames
    /// its purpose as "what stops a third dialect appearing", and this
    /// slice is the substrate-side answer: the arm-set is one edit and
    /// every consumer picks up the new entry by construction) extends
    /// this slice as one edit and every downstream consumer picks up
    /// the new entry through the shared iteration; the compiler-checked
    /// exhaustiveness on the sibling method `match` arms
    /// ([`Self::palavra_canonica`] / [`Self::consumidor`] /
    /// [`Self::descricao`] / [`std::fmt::Display`]) is the build-time
    /// guarantee that no arm forgets to grow.
    ///
    /// Peer of the sibling closed-set typed enums'
    /// [`crate::CaixaKind::ALL`] (6b1f4fb) /
    /// [`crate::aplicacao::PlacementStrategy::ALL`] (18c7342) /
    /// [`crate::aplicacao::RateLimitUnit::ALL`] (6bce03d) /
    /// [`crate::dep::DepList::ALL`] (45ee563) /
    /// [`crate::supervisor::RestartStrategy::ALL`] (4eec29c) /
    /// [`crate::supervisor::RestartPolicy::ALL`] (dd32ccf)
    /// exhaustive-iteration surfaces — the seventh closed-set typed
    /// enum on the caixa surface to converge onto the same
    /// one-canonical-arm-list-per-enum discipline, and the first
    /// dialect-classification axis (as distinct from an OTP-shape M2
    /// slot or an M3 mesh slot) to reach it. Order matches variant
    /// declaration order verbatim (`Pacote` → `Molde` →
    /// `MoldePosicional` → `Desconhecido`) so the slice is the
    /// canonical ordering every listing / rendering consumer defers to.
    pub const ALL: &'static [Self] = &[
        Self::Pacote,
        Self::Molde,
        Self::MoldePosicional,
        Self::Desconhecido,
    ];

    /// Substrate-canonical `PascalCase` variant-name byte-string every consumer
    /// that formats the dialect as census-facing text lands on. Returns the
    /// per-arm `PascalCase` name of the variant (`"Pacote"` / `"Molde"` /
    /// `"MoldePosicional"` / `"Desconhecido"`) — the one canonical
    /// byte-string the paired [`std::fmt::Display`] impl routes through so
    /// every downstream consumer (the `feira dialeto` census counter output
    /// line, a future `feira dialeto --list-dialects` CLI enumeration, a
    /// future M4 `mesh.pleme.io/v1alpha1/Manifesto` CR materializer's
    /// admission-webhook rejection body naming the accepted-dialect set)
    /// reaches for the same substrate primitive rather than the pre-lift
    /// hand-rolled four-arm literal-string match every [`std::fmt::Display`]
    /// call previously routed through in place.
    ///
    /// Peer of the sibling closed-set typed enums'
    /// [`crate::CaixaKind::as_str`] / [`crate::supervisor::RestartStrategy::as_str`]
    /// / [`crate::supervisor::RestartPolicy::as_str`] /
    /// [`crate::aplicacao::PlacementStrategy::as_str`] /
    /// [`crate::dep::DepList::as_str`] projections on the sibling closed-set
    /// typed-enum discriminator axes — the seventh (and last unlifted)
    /// closed-set fieldless typed enum on the caixa surface to converge
    /// onto the same one-canonical-byte-string-per-arm-through-`as_str`
    /// discipline the six siblings already carry. Unlike [`crate::CaixaKind`]
    /// (which carries two axes: `as_str` returning lowercase Portuguese
    /// diagnostic form vs `wire_name` returning `PascalCase` tatara-lisp
    /// author-surface bytes), [`CaixaDialeto`] is an internal
    /// classification with no wire surface — the `PascalCase` variant name
    /// is the census-facing form every consumer reads, so `as_str`
    /// suffices without a paired `wire_name` axis.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Pacote => CAIXA_DIALETO_WIRE_PACOTE,
            Self::Molde => CAIXA_DIALETO_WIRE_MOLDE,
            Self::MoldePosicional => CAIXA_DIALETO_WIRE_MOLDE_POSICIONAL,
            Self::Desconhecido => CAIXA_DIALETO_WIRE_DESCONHECIDO,
        }
    }

    /// Substrate-canonical exhaustive accept-set on the
    /// [`CaixaDialeto`] `PascalCase` variant-name wire-form byte-string
    /// axis — the closed four-arm roster of every byte-string
    /// [`Self::as_str`] returns, routed byte-for-byte through the paired
    /// [`CAIXA_DIALETO_WIRE_PACOTE`] / [`CAIXA_DIALETO_WIRE_MOLDE`] /
    /// [`CAIXA_DIALETO_WIRE_MOLDE_POSICIONAL`] /
    /// [`CAIXA_DIALETO_WIRE_DESCONHECIDO`] 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 byte-for-byte the same four strings
    /// the paired [`Self::from_wire`] and [`TryFrom<&str>`] reverse
    /// projections accept.
    ///
    /// 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) /
    /// [`crate::render::PathShapeViolation::WIRE_NAMES`] (0330bd3)
    /// rosters on the `PascalCase` / lowercase-kebab wire-form axes, the
    /// sibling [`crate::CaixaKind::LABELS`] (427fe75) /
    /// [`crate::aplicacao::WitShape::LABELS`] (9d9f585) rosters on the
    /// lowercase-kebab census-label axis, the sibling
    /// [`crate::aplicacao::RateLimitUnit::SUFFIXES`] (b553ec9) roster on
    /// the single-char canonical-suffix axis, the sibling
    /// [`crate::upgrade::UpgradeInstruction::LISP_FORMS`] (1898d77) /
    /// [`crate::upgrade::UpgradeInstruction::WIRE_FORMS`] (cc42c0e)
    /// rosters on the OTP-appup two-axis roster split, and the sibling
    /// [`crate::dep::DepList::AUTHOR_KEYS`] (af6ad3a) roster on the
    /// two-list dep-graph axis — the same closed-set exhaustive-accept-
    /// set roster discipline extended here onto the tatara-lisp dialect-
    /// classification closed-set typed enum, the eleventh substrate-side
    /// closed-set typed enum on the roster axis and the first
    /// dialect-classification axis (as distinct from the top-level
    /// manifest surface or a render-side path-shape-diagnostic surface)
    /// to converge onto the discipline. The sibling
    /// [`crate::render::PathShapeViolation::WIRE_NAMES`] doc block's
    /// closing sentence names this enum ("The sibling
    /// [`crate::dialeto::CaixaDialeto`] closed-set typed enum on the
    /// tatara-lisp dialect axis remains the next natural peer, still
    /// carrying only [`crate::dialeto::CaixaDialeto::ALL`]") as the next
    /// natural peer — this lift closes the naming.
    ///
    /// Downstream consumers of the closed accepted-wire-form set — a
    /// future `feira dialeto --list-dialects` CLI-side enumeration of
    /// the accepted dialect classifications whose candidate-list must
    /// byte-match the wire byte-string [`Self::as_str`] emits (rather
    /// than the source-side variant identifier), a future `feira dialeto
    /// --filter <Pacote|Molde|MoldePosicional|Desconhecido>` CLI arg-
    /// parse's "did you mean" hint that scans this slice rather than
    /// open-coding the four literal `PascalCase` strings, a future M4
    /// `mesh.pleme.io/v1alpha1/Manifesto` CR admission-webhook rejection
    /// body enumerating accepted per-dialect wire-form slugs on an
    /// unknown-tag miss, a future `feira dialeto` per-arm 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-tag
    /// map at every consumer; this roster closes the two-axis walk in
    /// one lifted const), a future `tracing::field::valuable::Value::List`
    /// structured-log accepted-dialect emit on the caixa-build
    /// pipeline's per-file classify emission path — now reach for one
    /// lifted substrate-primitive roster rather than open-coding a
    /// `["Pacote", "Molde", "MoldePosicional", "Desconhecido"]` four-
    /// string array literal whose arm-set has no compile-time link back
    /// to the typed [`CaixaDialeto`] enum. A future arm addition (the
    /// module doc's "third dialect" hazard actualising as a fifth arm —
    /// a third arity variant, an alias-declaration family pleme-doc-gen
    /// sharpens as its schema evolves) 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 wire form by construction.
    ///
    /// Length is pinned load-bearing at `CaixaDialeto::ALL.len()`
    /// (four) by
    /// [`tests::caixa_dialeto_wire_names_covers_every_arm`], every
    /// variant's [`Self::as_str`] projection is pinned to a member of
    /// the roster 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, every
    /// entry is pinned to open with an uppercase ASCII byte (matching
    /// the substrate-wide `PascalCase` convention every peer closed-set
    /// enum whose canonical projection is a `PascalCase` census-facing
    /// name carries), and the roster's declaration order is pinned
    /// byte-for-byte against the variant declaration order (`Pacote` →
    /// `Molde` → `MoldePosicional` → `Desconhecido`) so a future arm-
    /// swap on the roster or the paired `CAIXA_DIALETO_WIRE_*` constants
    /// trips at caixa-core test time under `assert_eq!` rather than at
    /// a downstream per-dialect ordering table's miss.
    pub const WIRE_NAMES: &'static [&'static str] = &[
        CAIXA_DIALETO_WIRE_PACOTE,
        CAIXA_DIALETO_WIRE_MOLDE,
        CAIXA_DIALETO_WIRE_MOLDE_POSICIONAL,
        CAIXA_DIALETO_WIRE_DESCONHECIDO,
    ];

    /// Substrate-canonical reverse projection on the [`CaixaDialeto`]
    /// closed-set dialect-classification axis — parses the `PascalCase`
    /// variant-name byte-string back to the typed variant, or `None` when
    /// `s` is outside the closed-set arm-string set [`Self::as_str`]
    /// emits. Walks the same four `"Pacote"` / `"Molde"` /
    /// `"MoldePosicional"` / `"Desconhecido"` byte-strings the sibling
    /// [`Self::as_str`] emitter returns, so the parse and emit halves of
    /// the round-trip migrate through one caixa-core edit on any future
    /// arm addition (the module doc's "third dialect" hazard actualising
    /// as a fifth arm) — the compiler-checked exhaustiveness on
    /// [`Self::as_str`]'s `match self` arms and the round-trip pin
    /// [`tests::caixa_dialeto_round_trips_through_as_str_and_from_wire`]
    /// together lock the two halves mutually.
    ///
    /// Prior to this lift the substrate carried only the forward
    /// `Self → &str` projection on the dialect-classification axis (the
    /// [`Self::as_str`] emitter, the [`std::fmt::Display`] impl routed
    /// through it, the [`AsRef<str>`] impl routed through it) — every
    /// future consumer that wanted to promote the census-facing text back
    /// to the typed enum (a future `feira dialeto --filter
    /// <Pacote|Molde|MoldePosicional|Desconhecido>` CLI arg-parse that
    /// binds the wire form into the typed enum before dispatching to the
    /// per-arm counter, a future M4 `mesh.pleme.io/v1alpha1/Manifesto`
    /// CR materializer's admission-time re-parse of the per-dialect
    /// audit body, a future audit-report re-loader that binds a prior
    /// [`Self::as_str`] output back to the typed enum for cross-run
    /// comparison) would have had to re-inline a four-arm `match s`
    /// cascade that expressed no compile-time link back to the typed
    /// [`CaixaDialeto`] enum.
    ///
    /// 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::dep::DepList::from_wire`] (45ee563) typed enums carry on
    /// the peer wire-side `str → Self` axes — extends the family onto
    /// the seventh closed-set fieldless typed enum on the caixa surface
    /// (the dialect-classification axis), matching the same
    /// two-way `str ↔ Self` round-trip every sibling closed-set enum
    /// already carries. 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.
    #[must_use]
    pub fn from_wire(s: &str) -> Option<Self> {
        match s {
            CAIXA_DIALETO_WIRE_PACOTE => Some(Self::Pacote),
            CAIXA_DIALETO_WIRE_MOLDE => Some(Self::Molde),
            CAIXA_DIALETO_WIRE_MOLDE_POSICIONAL => Some(Self::MoldePosicional),
            CAIXA_DIALETO_WIRE_DESCONHECIDO => Some(Self::Desconhecido),
            _ => None,
        }
    }

    /// The keyword an author should write for this dialect, once the
    /// migration named in [`Self::consumidor`] completes.
    #[must_use]
    pub const fn palavra_canonica(self) -> &'static str {
        match self {
            Self::Pacote => "defcaixa",
            Self::Molde | Self::MoldePosicional => "defmolde",
            Self::Desconhecido => "?",
        }
    }

    /// Who reads this dialect.
    #[must_use]
    pub const fn consumidor(self) -> &'static str {
        match self {
            Self::Pacote => "caixa-core / feira",
            Self::Molde | Self::MoldePosicional => "pleme-doc-gen",
            Self::Desconhecido => "nobody known",
        }
    }

    /// A one-line description for a census row or an error message.
    #[must_use]
    pub const fn descricao(self) -> &'static str {
        match self {
            Self::Pacote => "tatara-lisp package manifest (:nome :versao :kind :deps …)",
            Self::Molde => "repo-surface declaration (:name :ecosystem :package {…} …)",
            Self::MoldePosicional => {
                "repo-surface declaration, positional name (defcaixa <nome> :kind …)"
            }
            Self::Desconhecido => "unrecognised — matches no known defcaixa schema",
        }
    }

    /// True when this arm belongs to the `defmolde` declaration family —
    /// the two-arity closure of [`Self::Molde`] and [`Self::MoldePosicional`]
    /// under the shared `defmolde` head keyword the sibling
    /// [`Self::palavra_canonica`] projection already collapses onto
    /// `"defmolde"` for both arms (and the sibling [`Self::consumidor`]
    /// projection collapses onto `"pleme-doc-gen"` for the same two arms).
    /// False on [`Self::Pacote`] (the sibling `defcaixa` tatara-lisp
    /// package manifest, [`Self::palavra_canonica`] `→ "defcaixa"`) and
    /// on [`Self::Desconhecido`] (the residue that names no known
    /// declaration, [`Self::palavra_canonica`] `→ "?"`).
    ///
    /// The [`Self::Molde`] / [`Self::MoldePosicional`] split is one
    /// declaration written two ways ([`Self::MoldePosicional`]'s
    /// variant-declaration docstring at [`Self::MoldePosicional`] frames
    /// it exactly: "the same declaration as [`Self::Molde`], written with
    /// the package name as a bare positional symbol … this is one arity
    /// of one declaration, not a third schema"). Every downstream gate
    /// that keys off "does this dialect belong to the `defmolde` family"
    /// (as distinct from the four-arm-per-arm census-counter axis the
    /// sibling `feira dialeto` verb already fans on separately at
    /// `caixa-feira/src/cmd/dialeto.rs:110-127`) previously hand-rolled
    /// the two-arm collapse inline as `matches!(d, CaixaDialeto::Molde |
    /// CaixaDialeto::MoldePosicional)` — a compile-time-anonymous
    /// two-arm literal set with no link back to the [`CaixaDialeto`]
    /// variant declaration nor to the sibling
    /// [`Self::palavra_canonica`] / [`Self::consumidor`] projections
    /// that already carry the same two-arm collapse under the shared
    /// `defmolde` / `pleme-doc-gen` axis. The `feira dialeto` verb's
    /// [`caixa-feira/src/cmd/dialeto.rs`] carried the same
    /// `matches!` twice — once in the `--strict-palavra` gate that
    /// refuses a repo-surface declaration still written as
    /// `(defcaixa …)`, once in the wrong-declaration-under-`caixa.lisp`
    /// gate that refuses a repo-surface declaration under the filename
    /// `feira` loads as a package manifest — with no compile-time link
    /// between the two hand-rolled arm sets. A future arm addition (the
    /// module doc's "third dialect" hazard actualises as a fifth arm
    /// [`CaixaDialeto`] that belongs to the `defmolde` declaration
    /// family — a third arity variant, an alias-declaration family
    /// pleme-doc-gen sharpens as its schema evolves) would silently
    /// split the two hand-rolled `matches!` arm-sets from each other
    /// and from the paired [`Self::palavra_canonica`] projection: one
    /// call site picks up the new arm, one does not, and the disagreement
    /// surfaces far from the arm-addition commit as a `feira dialeto`
    /// consumer reporting a repo-surface declaration under one gate but
    /// not the other. Routing every "belongs to the `defmolde` family"
    /// predicate through this one substrate primitive closes the axis:
    /// a future arm addition lands one match arm here (a compile-time
    /// exhaustiveness error otherwise), not a coordinated per-`matches!`
    /// rewrite across every caller.
    ///
    /// Peer of the sibling [`crate::CaixaKind::requires_lib`] (0421c22)
    /// per-arm-set predicate on the [`crate::CaixaKind`] closed-set
    /// discriminator's "kind requires a `lib/` surface" axis — extends
    /// the same "one canonical typed predicate per per-arm-set gate,
    /// one dispatch on the substrate primitive" discipline onto the
    /// [`CaixaDialeto`] closed-set discriminator's "belongs to the
    /// `defmolde` declaration family" axis. The dialect-classification
    /// axis's second per-arm-set predicate (first being the implicit
    /// palavra_canonica-through-consumidor-through-descricao arm-set
    /// collapse already carried on the sibling projections) — the first
    /// explicitly-typed per-arm-set predicate on the axis, matching the
    /// discipline the sibling M2 [`crate::CaixaKind`] closed-set
    /// discriminator already carries with `requires_lib`.
    ///
    /// Three consumers now route through this one typed dispatch: the
    /// [`caixa-feira`](../../caixa_feira/cmd/dialeto/index.html) verb's
    /// `--strict-palavra` gate (refusing a repo-surface declaration
    /// still written as `(defcaixa …)`), the same verb's wrong-
    /// declaration-under-`caixa.lisp` gate (refusing a repo-surface
    /// declaration under the filename `feira` loads as a package
    /// manifest), and [`crate::Caixa::from_lisp`]'s foreign-dialect
    /// gate (raising [`crate::ManifestError::DialetoEstrangeiro`] before
    /// the derive's `parse_kwargs_strict` walk on any `defmolde`-family
    /// classification — the pre-lift hand-rolled three-arm
    /// `match { Pacote => {}, Desconhecido => {}, foreign => Err(…) }`
    /// literal whose `foreign =>` wildcard silently absorbed anything
    /// non-Pacote-non-Desconhecido, now the third external consumer of
    /// the `defmolde`-family partition).
    #[must_use]
    pub const fn is_molde_family(self) -> bool {
        // Routed through the derive-generated per-arm predicates
        // [`Self::is_molde`] + [`Self::is_molde_posicional`] so the
        // two-arm collapse links compile-time back to the closed-set
        // typed dispatch every peer arm-set predicate on the caixa
        // surface (e.g. [`crate::CaixaKind::requires_lib`] on the
        // sibling `:kind` axis) now carries. Byte-equivalent to the
        // pre-lift `matches!(self, Self::Molde | Self::MoldePosicional)`
        // form (the derived `is_*` predicates each expand to the same
        // `matches!(self, Self::X)` shape by construction), but a
        // future arm rename or IsVariant `#[is_variant(name = "…")]`
        // override lands at exactly one dispatch on the substrate
        // primitive rather than a hand-rolled two-arm literal.
        self.is_molde() || self.is_molde_posicional()
    }
}

/// [`std::fmt::Display`] routed through [`CaixaDialeto::as_str`], so the
/// pretty-printed byte-string every consumer that formats the dialect as
/// user-facing / census text lands on (the `feira dialeto` per-manifest
/// `--list` row, the `feira dialeto` census summary line's per-arm
/// counters, a future M4 admission-webhook's rejection body naming the
/// accepted-dialect set) reaches for the same `PascalCase` per-arm
/// byte-string the [`CaixaDialeto::as_str`] helper returns.
///
/// Prior to this lift the [`std::fmt::Display`] impl hand-rolled its own
/// four-arm literal-string match — the one hand-rolled per-arm dispatch
/// on the closed [`CaixaDialeto`] discriminator that had NO substrate
/// primitive accessor to defer to (the sibling [`CaixaDialeto::palavra_canonica`] /
/// [`CaixaDialeto::consumidor`] / [`CaixaDialeto::descricao`] projections
/// carry distinct byte-shapes per axis, so none of them could serve as
/// the Display source). A future variant addition (a fifth dialect the
/// module doc's "third dialect" hazard actualises) would land one arm at
/// the enum and per-arm returns at the paired accessors, but a hand-rolled
/// [`std::fmt::Display`] match would silently drop the new arm to compile-
/// fail-at-the-match-arm-site rather than through the shared substrate
/// primitive. Routing [`std::fmt::Display`] through [`CaixaDialeto::as_str`]
/// closes the last unlifted per-arm `PascalCase`-name projection on the
/// caixa surface — the seventh (and last unlifted) closed-set fieldless
/// typed enum on the caixa surface to converge onto the same
/// `Display`-through-`as_str` discipline the six siblings
/// ([`crate::CaixaKind`] / [`crate::supervisor::RestartStrategy`] /
/// [`crate::supervisor::RestartPolicy`] /
/// [`crate::aplicacao::PlacementStrategy`] / [`crate::aplicacao::RateLimitUnit`]
/// / [`crate::dep::DepList`]) already carry.
impl std::fmt::Display for CaixaDialeto {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

/// Substrate-canonical [`AsRef<str>`] projection on the [`CaixaDialeto`]
/// closed-set fieldless typed dialect-classification enum — routes through
/// the same [`CaixaDialeto::as_str`] `pub const fn` scalar accessor the
/// paired [`std::fmt::Display`] impl already delegates through, so any
/// future consumer that binds a [`CaixaDialeto`] through the standard-
/// library `impl AsRef<str>` bound (a [`std::process::Command::arg`]
/// shell-out that composes the canonical `PascalCase` variant-name into a
/// `feira dialeto --strict-palavra <Pacote|Molde|MoldePosicional|Desconhecido>`
/// diagnostic overlay, a `tracing::field::Value::Str`-arm structured-log
/// recorder on the [`crate::Caixa::from_lisp`] foreign-dialect
/// [`crate::ManifestError::DialetoEstrangeiro`] refusal path, a
/// [`std::collections::HashMap`] lookup keyed on the canonical name
/// through `map.get::<str>(dialeto.as_ref())` on a future M4 admission-
/// webhook's per-dialect rejection-body composition table) reaches the
/// paired `"Pacote"` / `"Molde"` / `"MoldePosicional"` / `"Desconhecido"`
/// 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::CaixaVersion`] [`AsRef<str>`] impl
/// (16d5c7e), the paired M2 [`crate::supervisor::RestartStrategy`]
/// [`AsRef<str>`] impl (63eb1a4), the paired M2
/// [`crate::supervisor::RestartPolicy`] [`AsRef<str>`] impl (419ea81),
/// the M3 [`crate::aplicacao::PlacementStrategy`] [`AsRef<str>`] impl
/// (d86edd2), the M3 [`crate::aplicacao::RateLimitUnit`] [`AsRef<str>`]
/// impl (d8136db), and the top-level [`crate::CaixaKind`] [`AsRef<str>`]
/// impl (cd2091f) carry — extends the substrate primitive's
/// [`AsRef<str>`] projection axis onto the seventh closed-set typed enum
/// on the caixa surface: the dialect-classification 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::caixa_dialeto_as_ref_str_routes_through_as_str_accessor`]
/// (byte-parity pin against [`CaixaDialeto::as_str`] across the four-arm
/// closed set) and
/// [`tests::caixa_dialeto_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 { CaixaDialeto::Pacote => "Pacote", … }` re-inlining that
/// opens a compile-time link to the un-lifted arm-literal, a swap onto
/// the second-axis [`CaixaDialeto::palavra_canonica`] /
/// [`CaixaDialeto::consumidor`] / [`CaixaDialeto::descricao`] accessors
/// that carry distinct byte-shapes per axis) trips at caixa-core test
/// time under `assert_eq!` rather than at a downstream
/// `impl AsRef<str>`-bound consumer's silent split.
impl AsRef<str> for CaixaDialeto {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

/// Trait-idiomatic reverse projection on the [`CaixaDialeto`] closed-set
/// dialect-classification typed enum — routes byte-for-byte through the
/// paired substrate-primitive [`CaixaDialeto::from_wire`] `Option<Self>`
/// accessor so every future consumer that binds a `PascalCase` variant-
/// name byte-string through the standard-library `.try_into()` /
/// [`TryFrom`] axis (a future `feira dialeto --filter
/// <Pacote|Molde|MoldePosicional|Desconhecido>` CLI arg-parse that
/// composes into `let d: CaixaDialeto = s.try_into()?`, a future audit-
/// report re-loader binding a prior [`CaixaDialeto::as_str`] output
/// through `CaixaDialeto::try_from(&s)?`, a generic
/// `<T: TryFrom<&str>>`-bound loader over any of the substrate's closed-
/// set typed enums) reaches the same four-arm accept-set the sibling
/// [`CaixaDialeto::from_wire`] parses through and the sibling
/// [`CaixaDialeto::as_str`] emits, rather than an open-coded per-arm
/// `match s { "Pacote" => …, … }` cascade whose arm-set has no
/// compile-time link back to the substrate primitive.
///
/// Complements the pre-existing forward-projection triple
/// ([`std::fmt::Display`], [`AsRef<str>`], [`CaixaDialeto::as_str`]) with
/// the paired trait-idiomatic reverse-projection axis: Rust-side
/// newtype/typed-enum convention pairs [`AsRef<str>`] with either
/// [`std::str::FromStr`] or [`TryFrom<&str>`] on the same primitive so a
/// caller who can project *out to* a `&str` can also project *in from*
/// one. The [`TryFrom<&str>`] axis is deliberately chosen over
/// [`std::str::FromStr`] to sidestep the `clippy::should_implement_trait`
/// lint that the sibling method-named `from_wire` would trigger under a
/// `FromStr` impl (the same design tradeoff the peer
/// [`crate::CaixaKind`] `TryFrom<&str>` impl (3c83606) and the peer
/// [`crate::provedor::ferrite::FerriteRuntime::from_wire`] block note)
/// — this impl closes the trait-idiomatic reverse axis without disturbing
/// the method-named `from_wire` shape every sibling closed-set typed
/// enum on the substrate already carries.
///
/// `type Error = ()` matches the sibling [`CaixaDialeto::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 dialeto --filter` arg-parse composes its own per-verb
/// "unknown dialect: <arg> — accepted: {…}" message enumerating
/// [`CaixaDialeto::ALL`], a future admission-webhook rejection body
/// wraps the `Err(())` outcome 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). Same shape the peer
/// [`crate::CaixaKind`] `TryFrom<&str>` impl (3c83606) and the peer
/// [`FerriteRuntime::from_wire`] doc block motivate on the sibling
/// closed-set typed enums' reverse projections.
///
/// The paired [`TryFrom<&str>`] impl reaches the same four-arm accept-
/// set the [`CaixaDialeto::from_wire`] resolver dispatches through, so
/// any future arm addition (the module doc's "third dialect" hazard
/// actualises as a fifth arm belonging to the `defmolde` family or a
/// wholly new declaration) grows the trait-idiomatic axis by
/// construction — one caixa-core edit on [`CaixaDialeto::from_wire`]
/// extends both the method-named reverse projection every existing
/// consumer keys off and the trait-idiomatic reverse projection this
/// impl exposes, without a coordinated rewrite across every future
/// `TryFrom<&str>`-bound consumer's arm-set.
///
/// Pinned load-bearing by
/// [`tests::caixa_dialeto_try_from_str_routes_through_from_wire_accessor`]
/// (byte-parity pin against [`CaixaDialeto::from_wire`] across the four-
/// arm accept-set) and
/// [`tests::caixa_dialeto_try_from_str_rejects_unknown_byte_strings`]
/// (rejection witness against silent accept-set widening).
impl TryFrom<&str> for CaixaDialeto {
    type Error = ();

    fn try_from(s: &str) -> Result<Self, Self::Error> {
        Self::from_wire(s).ok_or(())
    }
}

/// Trait-idiomatic [`std::str::FromStr`] parse axis on the
/// [`CaixaDialeto`] closed-set dialect-classification typed enum —
/// routes byte-for-byte through the paired
/// [`TryFrom<&str> for CaixaDialeto`] impl (which in turn routes
/// through the substrate-primitive [`CaixaDialeto::from_wire`]
/// `Option<Self>` accessor), so `"...".parse::<CaixaDialeto>()` /
/// `<CaixaDialeto as FromStr>::from_str(…)` reaches the same four-arm
/// `PascalCase` accept-set the sibling method-named
/// [`CaixaDialeto::from_wire`] resolver and the paired
/// [`TryFrom<&str>`] impl already resolve against.
///
/// Extends the substrate-wide trait-idiomatic `str::parse`-axis
/// campaign — opened on [`crate::dep::DepList`] via 6167092 as
/// first-mover on the two-list dep-graph closed-set typed enum, then
/// extended onto the structurally most fundamental closed-set typed
/// enum via [`crate::CaixaKind`] (9867432), then onto the first
/// M3-mesh-primitive-defining slot enum via
/// [`crate::aplicacao::PlacementStrategy`] (62ef49a) — onto the
/// dialect-classification axis every [`crate::Caixa`] carries through
/// its parsed manifest form. Unlike the peer
/// [`crate::supervisor::RestartStrategy`] /
/// [`crate::supervisor::RestartPolicy`] enums (which carry a
/// [`gen_platform::FromStrKind`]-derived `FromStr` on a paired
/// *kebab-case dispatcher-catalog* axis and therefore rule the
/// `PascalCase` wire axis out of a second `FromStr` impl by
/// coherence), and unlike the peer
/// [`crate::aplicacao::WitShape`] /
/// [`crate::aplicacao::RateLimitUnit`] enums (whose two-axis splits
/// [`WitShape::from_wire`] + [`WitShape::classify`] and
/// [`RateLimitUnit::from_suffix`] + [`RateLimitUnit::from_window`]
/// motivate deliberate deferral of the `FromStr` axis so a plain
/// `s.parse::<T>()` cannot obscure which axis the caller reaches),
/// [`CaixaDialeto`] carries exactly one census-facing `PascalCase`
/// axis (the module doc block above the [`CaixaDialeto::as_str`]
/// accessor names this out: "an internal classification with no wire
/// surface — the `PascalCase` variant name is the census-facing form
/// every consumer reads, so `as_str` suffices without a paired
/// `wire_name` axis"), so lifting [`FromStr`] onto it is coherent by
/// construction.
///
/// [`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::<CaixaDialeto>()`
/// short-form on every consumer (a future `feira dialeto --filter
/// <Pacote|Molde|MoldePosicional|Desconhecido>` clap-style arg-parse
/// composes `arg.parse::<CaixaDialeto>()`; a `serde` string-tagged
/// deserializer routes through the same `FromStr` bound; a future
/// dialect-partitioned census-column loader that walks a
/// `Vec<String>` of prior `CaixaDialeto::as_str` outputs reaches the
/// typed enum through `line.parse::<CaixaDialeto>()` without a
/// per-consumer `TryFrom<&str>` restatement).
///
/// 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 four-arm accept-set by construction. A
/// future accept-set widening (the module doc's "third dialect"
/// hazard actualising as a fifth arm belonging to the `defmolde`
/// family or a wholly new declaration) reaches every parse path
/// through one edit on the substrate-primitive
/// [`CaixaDialeto::from_wire`] accessor, not a coordinated rewrite
/// across the two reverse-projection trait impls.
///
/// Pinned load-bearing by
/// [`tests::caixa_dialeto_from_str_routes_through_try_from_str_impl`]
/// (byte-parity pin across the four-arm accept-set + delegated-
/// `.parse()`-projection witness) and
/// [`tests::caixa_dialeto_from_str_rejects_unknown_byte_strings`]
/// (rejection witness against silent accept-set widening).
impl std::str::FromStr for CaixaDialeto {
    type Err = ();

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        <Self as TryFrom<&str>>::try_from(s)
    }
}

/// Trait-idiomatic forward projection on the [`CaixaDialeto`] closed-set
/// dialect-classification typed enum — routes byte-for-byte through the
/// sibling substrate-primitive [`CaixaDialeto::as_str`] `pub const fn`
/// accessor so every future consumer that needs `&'static str` lifetime
/// bytes on the dialect-classification axis (a
/// `tracing::field::valuable::Value::Str` recording where the `Str` arm's
/// typing demands `&'static str`, a
/// `Cow::Borrowed::<'static, str>(dialeto.into())` composer on the future
/// M4 admission-webhook rejection body where the `Cow<'static, str>`
/// typing rules out the sibling [`AsRef<str>`] borrowed return, a generic
/// `<T: Into<&'static str>>`-bound serializer or error formatter that
/// requires the `'static` bound) reaches the same four `"Pacote"` /
/// `"Molde"` / `"MoldePosicional"` / `"Desconhecido"` byte-strings the
/// sibling [`CaixaDialeto::as_str`] emitter returns, rather than an
/// open-coded per-arm literal cascade whose arm-set has no compile-time
/// link back to the substrate primitive.
///
/// Return type is `&'static str` by construction — every
/// [`CaixaDialeto::as_str`] arm resolves to a compile-time `pub const fn`
/// return of a `&'static str` literal, so the trait's return-type promise
/// is upheld structurally without a `String::leak()` cast or a per-arm
/// inline literal.
///
/// Complements the pre-existing reverse-projection axis pair
/// ([`TryFrom<&str>`] above + method-named [`CaixaDialeto::from_wire`])
/// with the trait-idiomatic forward-projection axis: Rust-side
/// newtype/typed-enum convention pairs [`TryFrom<&str>`] with the mirror-
/// image [`From<Self> for &'static str`] on the same primitive so a
/// caller who can project *in from* a `&str` can also project *out to*
/// one under a `'static`-lifetime bound. The
/// [`AsRef<str>`] impl already carries the same emit-set on the borrowed
/// return path; this impl closes the trait-idiomatic axis pair with the
/// stricter `&'static str` lifetime the sibling `AsRef<str>` cannot
/// promise (its return borrows from `&self`, not from the
/// [`CaixaDialeto::as_str`] `pub const fn`'s static-string result).
///
/// Same "route the trait impl through the substrate-primitive accessor"
/// discipline the sibling [`crate::supervisor::RestartStrategy`]
/// `From<Self> for &'static str` impl (523157d — first-mover on this
/// forward-projection family), [`crate::supervisor::RestartPolicy`]
/// `From<Self> for &'static str` impl (9fb37d0 — second peer, closing
/// the M2 OTP-shape sibling pair), and [`crate::CaixaKind`]
/// `From<Self> for &'static str` impl (edb827b — third peer, opening
/// the campaign onto the top-level caixa surface) carry — extends the
/// substrate primitive's trait-idiomatic forward-projection axis onto
/// the fourth closed-set fieldless typed enum on the caixa surface: the
/// dialect-classification axis, previously carrying the paired
/// [`std::fmt::Display`] / [`AsRef<str>`] / [`CaixaDialeto::as_str`] /
/// [`TryFrom<&str>`] / [`CaixaDialeto::from_wire`] forward+reverse
/// projections but not yet the trait-idiomatic forward projection with
/// the `&'static str` lifetime bound.
///
/// Unlike the peer [`crate::CaixaKind`] impl (which carries a two-axis
/// split between the lowercase Portuguese `as_str` diagnostic axis and
/// the `PascalCase` `wire_name` author-surface axis, so the trait's
/// round-trip witness must cross through the wire axis rather than
/// composing the two trait impls directly), [`CaixaDialeto`] is an
/// internal classification whose [`CaixaDialeto::as_str`] output and
/// [`CaixaDialeto::from_wire`] input share the same `PascalCase`
/// vocabulary by construction — the trait-idiomatic axis pair
/// ([`From<Self> for &'static str`] + [`TryFrom<&str> for Self`])
/// therefore round-trips directly, without an intermediate wire-vocab
/// hop.
///
/// The paired [`CaixaDialeto::as_str`] accessor's four-arm emit-set is
/// the single source of truth — every future arm addition (the module
/// doc's "third dialect" hazard actualises as a fifth arm belonging to
/// the `defmolde` family or a wholly new declaration) grows the trait-
/// idiomatic forward axis by construction: one caixa-core edit on
/// [`CaixaDialeto::as_str`] extends every one of the sibling forward-
/// projection paths ([`std::fmt::Display`], [`AsRef<str>`],
/// [`CaixaDialeto::as_str`] itself, and this
/// [`From<Self> for &'static str`]) without a coordinated rewrite across
/// every future `Into<&'static str>`-bound consumer's arm-set. This lift
/// closes the fourth peer on the trait-idiomatic forward-projection
/// campaign the recently-landed peer commits opened; 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.
///
/// Pinned load-bearing by
/// [`tests::caixa_dialeto_from_into_static_str_routes_through_as_str_accessor`]
/// (byte-parity pin against [`CaixaDialeto::as_str`] across the four-arm
/// emit-set, plus a `const`-context materialization witness for the
/// `&'static str` lifetime promise, plus a paired `.into()` shape
/// assertion covering the blanket-derived `Into<&'static str>` shape)
/// and
/// [`tests::caixa_dialeto_from_into_static_str_and_as_str_partition_the_emit_set`]
/// (partition pin asserting `<&'static str as From<CaixaDialeto>>::from`
/// and [`CaixaDialeto::as_str`] agree on every arm, plus a two-way
/// direct round-trip witness through the paired trait-idiomatic
/// [`TryFrom<&str>`] axis that closes the two-way `Self ↔ &'static str`
/// round-trip on the trait-idiomatic axis pair without the wire-vocab
/// intermediate the peer [`crate::CaixaKind`] axis pair requires).
impl From<CaixaDialeto> for &'static str {
    fn from(dialeto: CaixaDialeto) -> &'static str {
        dialeto.as_str()
    }
}

/// Trait-idiomatic *forward* projection on [`CaixaDialeto`] from a
/// *borrowed* input onto the `&'static str` axis — the borrowed-input
/// companion to the paired owned-input [`From<CaixaDialeto> for &'static
/// str`] impl immediately above. Routes byte-for-byte through the same
/// substrate-primitive [`CaixaDialeto::as_str`] `pub const fn` accessor so
/// every consumer that binds a `&CaixaDialeto` through the standard-
/// library `.into()` / [`From<&Self> for &'static str`] axis (a
/// `CaixaDialeto::ALL.iter().map(<&'static str>::from).collect::<Vec<_>>()`
/// per-arm accept-set materializer — whose iterator over
/// `&'static [CaixaDialeto]` yields `&CaixaDialeto`, not `CaixaDialeto`,
/// so the owned-input [`From<CaixaDialeto>`] 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 over any of the substrate's closed-set typed enums; the
/// future M4 admission-webhook rejection body composer's per-dialect
/// accepted-set enumeration built from an iterated
/// `CaixaDialeto::ALL.iter().map(|d| d.into())` pipe rather than a
/// per-arm `match d { … }` cascade; a
/// `HashMap::<&'static str, CaixaDialeto>::from_iter(
///     CaixaDialeto::ALL.iter().map(|d| (d.into(), *d)))`-style
/// per-dialect reverse-lookup table the sibling [`TryFrom<&str>`] impl
/// cannot compose without this borrowed-input axis in place) reaches the
/// same four `"Pacote"` / `"Molde"` / `"MoldePosicional"` /
/// `"Desconhecido"` byte-strings the paired owned-input
/// [`From<CaixaDialeto> for &'static str`], the sibling
/// [`std::fmt::Display`], [`AsRef<str>`], and [`CaixaDialeto::as_str`]
/// surfaces already return.
///
/// Third peer on the substrate-wide trait-idiomatic *borrowed-input*
/// forward-projection family opened on
/// [`crate::dep::DepList`] (64aa742) and extended onto
/// [`crate::CaixaKind`] (5ab993a). 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(*dialeto)` / `dialeto.as_str()` detour whose
/// type bounds have no compile-time link to the substrate primitive.
///
/// Unlike the peer [`crate::CaixaKind`] impl (which carries a two-axis
/// split between the lowercase Portuguese `as_str` diagnostic axis and
/// the `PascalCase` `wire_name` author-surface axis, so a `.into()`
/// pipe over `CaixaKind::ALL` yields the diagnostic vocabulary rather
/// than the wire vocabulary), [`CaixaDialeto`]'s [`CaixaDialeto::as_str`]
/// and [`CaixaDialeto::from_wire`] share the same `PascalCase`
/// vocabulary by construction — the borrowed-input projection this impl
/// exposes therefore composes directly with the sibling
/// [`TryFrom<&str>`] axis to build reverse-lookup tables without the
/// wire-vocab intermediate hop the peer axis pair requires.
///
/// Pinned load-bearing by
/// [`tests::caixa_dialeto_from_borrowed_into_static_str_routes_through_as_str_accessor`]
/// (byte-parity pin against [`CaixaDialeto::as_str`] across the four-arm
/// emit-set via a borrowed input, plus a `const`-context materialization
/// witness for the `&'static str` lifetime promise, plus a blanket
/// `.into()` shape assertion) and
/// [`tests::caixa_dialeto_from_owned_and_borrowed_into_static_str_agree_on_every_arm`]
/// (cross-axis partition pin against the paired owned-input
/// [`From<CaixaDialeto> for &'static str`] impl, plus a
/// `.iter().map(Into::into)` pipe witness over [`CaixaDialeto::ALL`]
/// that materializes the four-arm accept-set through the borrowed-input
/// axis alone, plus a direct round-trip witness through the paired
/// trait-idiomatic [`TryFrom<&str>`] axis that closes the two-way
/// `&Self → &'static str → Self` round-trip on the borrowed-input axis
/// without the wire-vocab intermediate the peer [`crate::CaixaKind`]
/// axis pair requires).
impl From<&CaixaDialeto> for &'static str {
    fn from(dialeto: &CaixaDialeto) -> &'static str {
        dialeto.as_str()
    }
}

/// Trait-idiomatic *forward* projection on [`CaixaDialeto`] from an *owned*
/// input onto the owned-[`String`] axis — routes byte-for-byte through the
/// substrate-primitive [`CaixaDialeto::as_str`] `pub const fn` accessor so
/// every consumer that binds a [`CaixaDialeto`] through the standard-library
/// `.into()` / [`From<Self> for String`] (equivalently [`Into<String>`]) axis
/// reaches the same four `"Pacote"` / `"Molde"` / `"MoldePosicional"` /
/// `"Desconhecido"` byte-strings the paired owned-input
/// [`From<CaixaDialeto> for &'static str`], the borrowed-input
/// [`From<&CaixaDialeto> for &'static str`], the sibling [`std::fmt::Display`],
/// [`AsRef<str>`], and [`CaixaDialeto::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) onto the fourth peer: the dialect-classification axis
/// [`CaixaDialeto`] 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>` / `Display` /
/// `From<Self> for &'static str` triple but not the owned-[`String`] axis
/// forces every owned-string call site through a `.to_string()` /
/// `.as_str().to_owned()` / `String::from(dialeto.as_str())` detour whose
/// type bounds have no compile-time link to the substrate primitive.
///
/// Unlike the peer [`crate::CaixaKind`] enum (which carries a two-axis split
/// between the lowercase Portuguese [`crate::CaixaKind::as_str`] diagnostic
/// axis and the `PascalCase` [`crate::CaixaKind::wire_name`] author-surface
/// axis, so the owned-[`String`] forward emit and the reverse
/// [`TryFrom<&str>`] parse land on disjoint vocabularies and the round-trip
/// crosses through [`crate::CaixaKind::wire_name`] as the reverse-axis
/// vocabulary rather than composing the owned-[`String`] emit directly),
/// [`CaixaDialeto`]'s [`CaixaDialeto::as_str`] emit and
/// [`CaixaDialeto::from_wire`] parse share the same `PascalCase` vocabulary
/// by construction (there is no wire/diagnostic axis split on this enum —
/// it is an internal classification with no wire surface), so the
/// owned-[`String`] forward projection this impl exposes composes directly
/// with the sibling [`TryFrom<&str>`] axis on the owned-[`String`]'s
/// [`String::as_str`] borrow, byte-identically to the peer
/// [`crate::supervisor::RestartStrategy`] /
/// [`crate::supervisor::RestartPolicy`] owned-[`String`] axis pairs
/// (whose forward emit and reverse parse also share one `PascalCase`
/// vocabulary by construction).
///
/// The remaining ten closed-set typed enums on the caixa substrate surface
/// (`DepList`, `PlacementStrategy`, `WitShape`, `RateLimitUnit`,
/// `PathShapeViolation`, `InvariantKind`, `ArchVerdict`, `Severity`,
/// `FixSafety`, `Semantic`, `FerriteRuntime`) are the future targets of
/// this campaign — each carries the same paired `AsRef<str>` / `Display` /
/// `From<Self> for &'static str` / `From<&Self> for &'static str` quadruple
/// that this owned-[`String`] axis extends onto.
///
/// Pinned load-bearing by
/// [`tests::caixa_dialeto_from_into_owned_string_routes_through_as_str_accessor`]
/// (byte-parity pin against [`CaixaDialeto::as_str`] across the four-arm
/// emit-set, plus a blanket `.into::<String>()` shape witness) and
/// [`tests::caixa_dialeto_from_into_owned_string_and_static_str_agree_on_every_arm`]
/// (cross-axis partition pin against the paired owned-input
/// [`From<CaixaDialeto> for &'static str`] impl and the sibling
/// [`ToString::to_string`] surface routed through [`std::fmt::Display`],
/// plus a `.iter().copied().map(String::from)` pipe witness over
/// [`CaixaDialeto::ALL`], 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 owned-[`String`] forward + reverse axis pair without
/// the wire-vocab intermediate hop the peer [`crate::CaixaKind`] axis pair
/// requires).
impl From<CaixaDialeto> for String {
    fn from(dialeto: CaixaDialeto) -> String {
        dialeto.as_str().to_owned()
    }
}

/// Trait-idiomatic *borrowed-input, owned-`String` output* forward
/// projection on the dialect-classification [`CaixaDialeto`] 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<&crate::supervisor::RestartStrategy> for String`] (579385f) /
/// [`From<&crate::supervisor::RestartPolicy> for String`] (8465740),
/// the two-list dep-graph [`From<&crate::dep::DepList> for String`]
/// (e0cb617), and the top-level [`From<&crate::CaixaKind> for String`]
/// (e76436d) that opened and extended the corner off the M2 OTP-shape
/// sibling axis pair onto the sibling closed-set fieldless typed enum
/// peers. Routes byte-for-byte through the substrate-primitive
/// [`CaixaDialeto::as_str`] `pub const fn` accessor (via
/// [`str::to_owned`]) so every consumer that holds a borrowed
/// [`&CaixaDialeto`] and needs an owned [`String`] — a future
/// `serde_json::Value::String(String::from(&dialeto))` structured-
/// payload composer over a borrowed field, a future `Iterator::map`
/// over `&[CaixaDialeto]` that projects to owned keys through
/// `.iter().map(String::from)` (whose iterator yields `&CaixaDialeto`,
/// not `CaixaDialeto`, so the owned-input
/// [`From<CaixaDialeto> 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, CaixaDialeto>::from_iter` that keys off a
/// borrowed-iteration axis where dereferencing the dialect would force
/// an unnecessary [`Copy`] at every step, the future
/// `feira dialeto --list-dialects` CLI enumeration that walks
/// [`CaixaDialeto::ALL`] through the borrowed-iteration axis by
/// construction, the future M4
/// `mesh.pleme.io/v1alpha1/Manifesto` CR materializer's admission-
/// webhook rejection body composer that names the accepted-dialect
/// set through an iterated `.iter().map(String::from).collect()`
/// pipe rather than a per-arm cascade — reaches the same four
/// `"Pacote"` / `"Molde"` / `"MoldePosicional"` / `"Desconhecido"`
/// byte-strings the paired [`std::fmt::Display`], [`AsRef<str>`],
/// [`CaixaDialeto::as_str`], and the three other trait-idiomatic
/// forward-projection impls ([`From<CaixaDialeto> for &'static str`],
/// [`From<&CaixaDialeto> for &'static str`],
/// [`From<CaixaDialeto> for String`]) already return.
///
/// Fifth peer on the substrate-wide trait-idiomatic *borrowed-input,
/// owned-`String` output* forward-projection family opened on
/// [`crate::supervisor::RestartStrategy`] (579385f), closed on the M2
/// OTP-shape sibling axis pair by
/// [`crate::supervisor::RestartPolicy`] (8465740), extended onto the
/// two-list dep-graph peer by [`crate::dep::DepList`] (e0cb617) and
/// onto the top-level [`crate::CaixaKind`] (e76436d) — extends the
/// `{Self, &Self} × {&'static str, String}` 2×2 projection corner off
/// the top-level `:kind` axis onto the dialect-classification axis
/// (the fourth closed-set fieldless typed enum on the caixa surface;
/// second peer outside the M2 OTP-shape sibling pair to reach the
/// 2×2-completion corner). 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 `dialeto.as_str().to_owned()` /
/// `String::from(*dialeto)` (with a spurious [`Copy`]) /
/// `dialeto.to_string()` (through [`std::fmt::Display`]) detour whose
/// type bounds have no compile-time link to the substrate primitive.
///
/// Same as the peer [`crate::supervisor::RestartStrategy`] /
/// [`crate::supervisor::RestartPolicy`] / [`crate::dep::DepList`]
/// borrowed-input owned-[`String`] axis pairs (whose forward emit and
/// reverse parse share one vocabulary by construction — `PascalCase`
/// on the M2 OTP-shape peers, the lifted
/// [`crate::render::DEP_AUTHOR_KEY_DEPS`] /
/// [`crate::render::DEP_AUTHOR_KEY_DEPS_DEV`] consts on the two-list
/// dep-graph peer) and unlike the peer [`crate::CaixaKind`] pair
/// (whose forward emit lands on the lowercase Portuguese
/// diagnostic vocabulary while the reverse parse lands on the
/// `PascalCase` wire vocabulary, forcing the round-trip through an
/// intermediate [`crate::CaixaKind::wire_name`] hop), [`CaixaDialeto`]
/// is an internal classification with no wire surface — the
/// [`CaixaDialeto::as_str`] emit and [`CaixaDialeto::from_wire`] parse
/// share the same `PascalCase` vocabulary by construction (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 required.
///
/// The remaining nine 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 2×2-completion campaign — each carries the same paired
/// quintuple that this borrowed-input owned-[`String`] axis extends
/// onto.
///
/// Pinned load-bearing by
/// [`tests::caixa_dialeto_from_into_borrowed_owned_string_routes_through_as_str_accessor`]
/// (byte-parity pin against [`CaixaDialeto::as_str`] across the
/// four-arm emit-set through the borrowed-input surface) and
/// [`tests::caixa_dialeto_from_into_borrowed_owned_string_agrees_with_paired_axes_on_every_arm`]
/// (cross-axis partition pin against the paired owned-input owned-
/// [`String`] [`From<CaixaDialeto> for String`] impl, the paired
/// borrowed-input owned-[`&'static str`]
/// [`From<&CaixaDialeto> for &'static str`] impl, the paired owned-
/// input owned-[`&'static str`] [`From<CaixaDialeto> for &'static str`]
/// impl, and the sibling [`ToString::to_string`] surface routed
/// through [`std::fmt::Display`], plus a `.iter().map(String::from)`
/// pipe witness over [`CaixaDialeto::ALL`] (whose iterator yields
/// `&CaixaDialeto` by construction, so the borrowed-input owned-
/// [`String`] axis is what routes the pipe through the substrate-
/// primitive [`CaixaDialeto::as_str`] accessor without a spurious
/// [`Copy`] deref), 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 — no intermediate wire-vocab hop like the peer
/// [`crate::CaixaKind`] axis pair requires).
impl From<&CaixaDialeto> for String {
    fn from(dialeto: &CaixaDialeto) -> String {
        dialeto.as_str().to_owned()
    }
}

/// Trait-idiomatic *owned-input, [`std::borrow::Cow<'static, str>`]
/// output* forward projection on the dialect-classification
/// [`CaixaDialeto`] closed-set typed enum — routes byte-for-byte
/// through the substrate-primitive [`CaixaDialeto::as_str`]
/// `pub const fn` accessor (via [`std::borrow::Cow::Borrowed`]) so
/// every consumer that binds a [`CaixaDialeto`] through the
/// standard-library `.into()` /
/// [`From<Self> for std::borrow::Cow<'static, str>`] (equivalently
/// [`Into<std::borrow::Cow<'static, str>>`]) axis — a future
/// `axum::response::IntoResponse` body composer whose typing folds a
/// per-arm rejection line into a [`std::borrow::Cow<'static, str>`]
/// boundary, a future M4 `mesh.pleme.io/v1alpha1/Manifesto` CR
/// materializer's admission-webhook rejection body composer whose
/// typing rules out the sibling [`AsRef<str>`] borrowed return and
/// the sibling [`From<Self> for &'static str`] axis's non-
/// [`std::borrow::Cow`]-parameterized shape, a future substrate-wide
/// per-arm diagnostic surface that folds either the zero-alloc
/// [`std::borrow::Cow::Borrowed`] arm (for the closed-set arms whose
/// byte-string is build-time-lifted) or the [`std::borrow::Cow::Owned`]
/// arm (for a caller that mutates the projection) through one uniform
/// trait dispatch, a future generic
/// `<T: Into<std::borrow::Cow<'static, str>>>`-bound emitter on a
/// per-dialect structured-log or admission-webhook rejection body —
/// reaches the same four `"Pacote"` / `"Molde"` / `"MoldePosicional"` /
/// `"Desconhecido"` byte-strings the paired [`std::fmt::Display`],
/// [`AsRef<str>`], [`CaixaDialeto::as_str`], and the four
/// `{Self, &Self} × {&'static str, String}` 2×2 trait-idiomatic
/// forward-projection corners
/// ([`From<CaixaDialeto> for &'static str`],
/// [`From<&CaixaDialeto> for &'static str`],
/// [`From<CaixaDialeto> for String`],
/// [`From<&CaixaDialeto> for String`]) already return, rather than an
/// open-coded per-call-site
/// `std::borrow::Cow::Borrowed(dialeto.as_str())` /
/// `std::borrow::Cow::Owned(dialeto.to_string())` /
/// `String::from(dialeto).into()` 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
/// [`CaixaDialeto::as_str`] accessor's return carries the
/// `&'static str` lifetime by construction (each `match` arm resolves
/// to a `pub const &'static str` literal 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<CaixaDialeto> 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.
///
/// Same as the sibling [`crate::CaixaKind`] /
/// [`crate::supervisor::RestartStrategy`] /
/// [`crate::supervisor::RestartPolicy`] /
/// [`crate::aplicacao::WitShape`] /
/// [`crate::aplicacao::PlacementStrategy`] /
/// [`crate::aplicacao::RateLimitUnit`] /
/// [`crate::dep::DepList`] peers on the substrate-wide trait-idiomatic
/// [`std::borrow::Cow<'static, str>`] forward-projection campaign,
/// unlike the peer [`crate::CaixaKind`] pair (whose forward emit
/// lands on the lowercase Portuguese diagnostic vocabulary while the
/// reverse parse lands on the `PascalCase` wire vocabulary, forcing
/// the round-trip through an intermediate
/// [`crate::CaixaKind::wire_name`] hop), [`CaixaDialeto`] is an
/// internal classification with no wire surface — the
/// [`CaixaDialeto::as_str`] emit and [`CaixaDialeto::from_wire`]
/// parse share the same `PascalCase` vocabulary by construction (no
/// wire/diagnostic axis split on this enum), so the
/// [`std::borrow::Cow<'static, str>`] projection this impl exposes
/// composes directly with the paired trait-idiomatic reverse
/// [`TryFrom<&str>`] axis on the projection's
/// [`std::borrow::Cow::as_ref`] borrow — no intermediate wire-vocab
/// hop required.
///
/// Eighth peer on the substrate-wide trait-idiomatic
/// [`std::borrow::Cow<'static, str>`] forward-projection family
/// opened on the top-level [`crate::CaixaKind`] by 99c1735 (extended
/// off the closed `{Self, &Self} × {&'static str, String}` 2×2
/// corner closed on the last outside-caixa-core enum peer by
/// 29f8af3), closed on the `{Self, &Self}` input-shape corner on
/// [`crate::CaixaKind`] by d45c409, extended onto the M2 OTP-shape
/// tier by 7dd28b3 / 9b3e4b3 (opens/closes on
/// [`crate::supervisor::RestartStrategy`]) and 0612398 / ee577fd
/// (opens/closes on [`crate::supervisor::RestartPolicy`], closing the
/// M2 OTP-shape tier), extended onto the M3 mesh-shape tier by
/// 8634dec / 25690ef (opens/closes on [`crate::aplicacao::WitShape`])
/// and eee504d / afdf0f4 (opens/closes on
/// [`crate::aplicacao::PlacementStrategy`]) and 1d59925 (closes M3
/// mesh-shape tier on [`crate::aplicacao::RateLimitUnit`]), extended
/// onto the outside-M3 caixa-core tier by 6858bac / 702cdf4
/// (opens/closes on [`crate::dep::DepList`]) — extends the axis onto
/// the dialect-classification [`CaixaDialeto`] closed-set fieldless
/// typed enum (the second outside-M3 caixa-core peer, and the sole
/// remaining internal-classification enum on the caixa-core surface).
/// Rust's standard library does not carry a blanket
/// `impl<T: AsRef<str>> From<T> for std::borrow::Cow<'static, str>`
/// (nor an `impl<T: fmt::Display> From<T> for
/// std::borrow::Cow<'static, str>`), so every closed-set fieldless
/// typed enum peer on the substrate that carries the paired
/// [`AsRef<str>`] / [`std::fmt::Display`] /
/// [`From<Self> for &'static str`] / [`From<&Self> for &'static str`]
/// / [`From<Self> for String`] / [`From<&Self> for String`] sextet but
/// not the [`std::borrow::Cow<'static, str>`] axis forces every
/// [`std::borrow::Cow<'static, str>`]-parameterized call site through
/// a `std::borrow::Cow::Borrowed(dialeto.as_str())` /
/// `std::borrow::Cow::Owned(dialeto.to_string())` /
/// `String::from(dialeto).into()` detour whose type bounds have no
/// compile-time link to the substrate primitive.
///
/// The remaining outside-`caixa-core` closed-set fieldless typed
/// enum peers on the substrate surface (`PathShapeViolation`,
/// `InvariantKind`, `ArchVerdict`, `Severity`, `FixSafety`,
/// `Semantic`, `FerriteRuntime`) are the future targets of this
/// campaign — each carries the same paired sextet that this axis
/// extends onto.
///
/// Pinned load-bearing by
/// [`tests::caixa_dialeto_from_into_static_cow_str_routes_through_as_str_accessor`]
/// (byte-parity pin against [`CaixaDialeto::as_str`] across the
/// four-arm emit-set through the [`std::borrow::Cow<'static, str>`]
/// surface, plus a [`std::borrow::Cow::Borrowed`] discriminator
/// witness that the projection lands on the zero-alloc arm rather
/// than silently allocating through [`std::borrow::Cow::Owned`],
/// plus a blanket-derived [`Into<std::borrow::Cow<'static, str>>`]
/// shape witness that also lands on [`std::borrow::Cow::Borrowed`])
/// and
/// [`tests::caixa_dialeto_from_into_static_cow_str_agrees_with_paired_axes_on_every_arm`]
/// (cross-axis partition pin against the paired owned-input
/// [`From<CaixaDialeto> for &'static str`] and
/// [`From<CaixaDialeto> for String`] forward-projection corners plus
/// the sibling [`ToString::to_string`]-through-[`std::fmt::Display`]
/// surface, plus a `.iter().copied().map(std::borrow::Cow::from)`
/// pipe witness over [`CaixaDialeto::ALL`] whose zero-alloc
/// [`std::borrow::Cow::Borrowed`] outcome is load-bearing on every
/// arm, plus a direct round-trip witness through [`TryFrom<&str>`]
/// on the projection's [`std::borrow::Cow::as_ref`] borrow that
/// closes the two-way `Self → Cow<'static, str> → Self` round-trip
/// on the trait-idiomatic [`std::borrow::Cow<'static, str>`]
/// forward + reverse axis pair without the wire-vocab intermediate
/// hop the peer [`crate::CaixaKind`] axis pair requires).
impl From<CaixaDialeto> for std::borrow::Cow<'static, str> {
    fn from(dialeto: CaixaDialeto) -> std::borrow::Cow<'static, str> {
        std::borrow::Cow::Borrowed(dialeto.as_str())
    }
}

/// Trait-idiomatic *borrowed-input, [`std::borrow::Cow<'static, str>`]
/// output* forward projection on the dialect-classification
/// [`CaixaDialeto`] closed-set typed enum — the borrowed-input companion
/// to the paired owned-input [`From<CaixaDialeto> for
/// std::borrow::Cow<'static, str>`] impl immediately above (8322511).
/// Routes byte-for-byte through the same substrate-primitive
/// [`CaixaDialeto::as_str`] `pub const fn` accessor (via
/// [`std::borrow::Cow::Borrowed`]) so every consumer that holds a
/// [`&CaixaDialeto`] and needs a [`std::borrow::Cow<'static, str>`] — a
/// `CaixaDialeto::ALL.iter().map(std::borrow::Cow::from).collect::<Vec<_>>()`
/// per-arm accept-set materializer whose iterator over
/// `&'static [CaixaDialeto]` yields `&CaixaDialeto` (not
/// [`CaixaDialeto`], so the paired owned-input
/// [`From<CaixaDialeto> 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-dialect diagnostic column that walks the
/// `iter().map(Into::into)` shape verbatim, the future M4
/// `mesh.pleme.io/v1alpha1/Manifesto` CR admission-webhook rejection
/// body that composes the accepted-dialect enumeration from an iterated
/// `CaixaDialeto::ALL.iter().map(|d| d.into())` pipe rather than a
/// per-arm `match d { … }` cascade — reaches the same four `"Pacote"` /
/// `"Molde"` / `"MoldePosicional"` / `"Desconhecido"` byte-strings the
/// paired [`std::fmt::Display`], [`AsRef<str>`], [`CaixaDialeto::as_str`],
/// the four `{Self, &Self} × {&'static str, String}` 2×2 trait-idiomatic
/// forward-projection corners, and the paired owned-input
/// [`From<CaixaDialeto> for std::borrow::Cow<'static, str>`] impl
/// already return.
///
/// Deliberately returns [`std::borrow::Cow::Borrowed`] rather than
/// [`std::borrow::Cow::Owned`] — the substrate-primitive
/// [`CaixaDialeto::as_str`] accessor's return carries the `&'static str`
/// lifetime by construction (each `match` arm resolves to a `pub const
/// &'static str` literal), 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 second
/// outside-M3 caixa-core peer of the substrate-wide
/// [`std::borrow::Cow<'static, str>`] forward-projection campaign,
/// opened one commit prior (8322511) on the paired owned-input impl.
/// Rust's standard library does not carry a blanket
/// `impl<T: AsRef<str>> From<&T> for std::borrow::Cow<'static, str>`
/// (nor an `impl<T: fmt::Display> From<&T> for
/// std::borrow::Cow<'static, str>`, nor a `Copy`-based
/// `impl<T: Copy, U: From<T>> From<&T> for U`), 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(*dialeto)`) or a
/// `std::borrow::Cow::Borrowed(dialeto.as_str())` open-code whose type
/// bounds have no compile-time link to the substrate primitive.
///
/// Matches the closure discipline afdf0f4 landed on the M3-mesh-shape
/// [`crate::aplicacao::PlacementStrategy`] axis one commit after eee504d,
/// 25690ef on [`crate::aplicacao::WitShape`] one commit after 8634dec,
/// d45c409 on the top-level [`crate::CaixaKind`] one commit after
/// 99c1735, 9b3e4b3 / ee577fd on the M2 OTP-shape
/// [`crate::supervisor::RestartStrategy`] /
/// [`crate::supervisor::RestartPolicy`] sibling peers one commit after
/// 7dd28b3 / 0612398, and 702cdf4 on the two-list dep-graph
/// [`crate::dep::DepList`] axis one commit after 6858bac. The remaining
/// outside-M3 caixa-core peer ([`crate::render::PathShapeViolation`])
/// and the outside-`caixa-core` peers (`InvariantKind`, `ArchVerdict`,
/// `Severity`, `FixSafety`, `Semantic`, `FerriteRuntime`) are the
/// remaining future targets on the axis.
///
/// Unlike the peer [`crate::CaixaKind`] pair (whose forward emit lands
/// on the lowercase Portuguese diagnostic vocabulary while the reverse
/// parse lands on the `PascalCase` wire vocabulary, forcing the
/// round-trip through an intermediate [`crate::CaixaKind::wire_name`]
/// hop), [`CaixaDialeto`] is an internal classification with no wire
/// surface — the [`CaixaDialeto::as_str`] emit and
/// [`CaixaDialeto::from_wire`] parse share the same `PascalCase`
/// vocabulary by construction (no wire/diagnostic axis split on this
/// enum), so the borrowed-input [`std::borrow::Cow<'static, str>`]
/// projection this impl exposes composes directly with the paired
/// trait-idiomatic reverse [`TryFrom<&str>`] axis on the projection's
/// [`std::borrow::Cow::as_ref`] borrow — no intermediate wire-vocab hop
/// required.
///
/// Pinned load-bearing by
/// [`tests::caixa_dialeto_from_borrowed_into_static_cow_str_routes_through_as_str_accessor`]
/// (byte-parity + zero-alloc [`std::borrow::Cow::Borrowed`]-arm pin
/// against [`CaixaDialeto::as_str`] across the four-arm
/// [`CaixaDialeto::ALL`] through the borrowed-input surface, plus a
/// blanket-derived [`Into<std::borrow::Cow<'static, str>>`] shape
/// witness that also lands on [`std::borrow::Cow::Borrowed`]) and
/// [`tests::caixa_dialeto_from_borrowed_into_static_cow_str_agrees_with_paired_axes_on_every_arm`]
/// (cross-axis partition pin against the paired owned-input
/// [`From<CaixaDialeto> for std::borrow::Cow<'static, str>`], the paired
/// borrowed-input owned-`&'static str`
/// [`From<&CaixaDialeto> for &'static str`], and the paired
/// borrowed-input owned-`String` [`From<&CaixaDialeto> for String`]
/// impls plus [`ToString::to_string`]-through-[`std::fmt::Display`], a
/// `.iter().map(std::borrow::Cow::from)` pipe witness over
/// [`CaixaDialeto::ALL`] — whose iterator yields `&CaixaDialeto` by
/// construction, so the borrowed-input axis is what routes the pipe
/// without a spurious [`Copy`] deref and every collected element
/// satisfies the zero-alloc [`std::borrow::Cow::Borrowed`]-arm
/// predicate — plus a direct round-trip witness through
/// [`TryFrom<&str>`] on the projection's [`std::borrow::Cow::as_ref`]
/// borrow that closes the two-way `&Self → Cow<'static, str> → Self`
/// round-trip on the borrowed-input axis without the wire-vocab
/// intermediate hop the peer [`crate::CaixaKind`] axis pair requires).
impl From<&CaixaDialeto> for std::borrow::Cow<'static, str> {
    fn from(dialeto: &CaixaDialeto) -> std::borrow::Cow<'static, str> {
        std::borrow::Cow::Borrowed(dialeto.as_str())
    }
}

/// Trait-idiomatic *owned-input, [`Box<str>`] output* forward projection on
/// the outside-M3 caixa-core dialect-classification [`CaixaDialeto`]
/// closed-set fieldless typed enum. Routes byte-for-byte through the
/// substrate-primitive [`CaixaDialeto::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> = dialeto.into();`-shaped
/// call site reaches the same four `"Pacote"` / `"Molde"` /
/// `"MoldePosicional"` / `"Desconhecido"` 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 `CaixaDialeto → Box<str>`
/// `.into()` reaches through this impl and no other — without a
/// `Box::from(dialeto.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 third
/// caixa-core-internal peer, after the render-side path-shape-diagnostic
/// [`crate::render::PathShapeViolation`] pair (0d87a72, both corners in
/// one axis) opened the tier and the outside-M3 caixa-core two-list
/// dep-graph [`crate::dep::DepList`] pair (4aada99, both corners in one
/// axis) extended it. 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>`], [`CaixaDialeto::as_str`]) and
/// reverse parse ([`CaixaDialeto::from_wire`], [`TryFrom<&str>`]) route
/// through the same four `PascalCase` 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 arm addition (the module doc's "third dialect" hazard
/// actualising as a fifth arm) reaches the paired [`Box<str>`] output
/// axis through one match-arm edit on the [`CaixaDialeto::as_str`]
/// `pub const fn` accessor, not a coordinated rewrite of every
/// downstream `Box::from(dialeto.as_str())` open-code.
///
/// Pinned load-bearing by
/// [`tests::caixa_dialeto_from_into_box_str_routes_through_as_str_accessor`]
/// (byte-parity pin against [`CaixaDialeto::as_str`] across the four-arm
/// [`CaixaDialeto::ALL`] emit-set on the owned-input surface, plus a
/// blanket-derived [`Into`] shape witness).
impl From<CaixaDialeto> for Box<str> {
    fn from(dialeto: CaixaDialeto) -> Box<str> {
        Box::<str>::from(dialeto.as_str())
    }
}

/// Trait-idiomatic *borrowed-input, [`Box<str>`] output* forward projection
/// on the outside-M3 caixa-core dialect-classification [`CaixaDialeto`]
/// closed-set fieldless typed enum. Routes byte-for-byte through the
/// substrate-primitive [`CaixaDialeto::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> = (&dialeto).into();`-shaped
/// call site or a `CaixaDialeto::ALL.iter().map(Box::<str>::from)`-shaped
/// pipe (whose iterator over `&'static [CaixaDialeto]` yields
/// `&CaixaDialeto` by construction) reaches the same four `"Pacote"` /
/// `"Molde"` / `"MoldePosicional"` / `"Desconhecido"` byte-strings the
/// sibling `{Self, &Self} × {&'static str, String, Cow<'static, str>}`
/// forward-projection corner and the paired owned-input
/// [`From<CaixaDialeto> 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
/// [`CaixaDialeto::ALL`]`.iter().map(Box::<str>::from)` reaches through
/// this impl and no other — without it, the same pipe would force an
/// explicit `.copied()` restatement whose type bounds have no compile-
/// time link back to the substrate primitive, and a
/// `let key: Box<str> = (&dialeto).into();`-shaped call site would force
/// an explicit `Copy` deref (`Box::<str>::from(*dialeto)`) or a
/// `Box::<str>::from(dialeto.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 [`Box<str>`] forward-projection campaign,
/// matching the trajectory the paired render-side path-shape-diagnostic
/// [`crate::render::PathShapeViolation`] pair (0d87a72, both corners in
/// one axis) and the paired outside-M3 caixa-core two-list dep-graph
/// [`crate::dep::DepList`] pair (4aada99, both corners in one axis)
/// walked before it.
///
/// Pinned load-bearing by
/// [`tests::caixa_dialeto_from_borrowed_into_box_str_routes_through_as_str_accessor`]
/// (byte-parity pin against [`CaixaDialeto::as_str`] across the four-arm
/// [`CaixaDialeto::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
/// [`CaixaDialeto::ALL`] — whose iterator yields `&CaixaDialeto` by
/// construction, so the borrowed-input [`Box<str>`] axis is what routes
/// the pipe through the substrate-primitive [`CaixaDialeto::as_str`]
/// accessor without a spurious [`Copy`] deref).
impl From<&CaixaDialeto> for Box<str> {
    fn from(dialeto: &CaixaDialeto) -> Box<str> {
        Box::<str>::from(dialeto.as_str())
    }
}

/// Trait-idiomatic *owned-input, [`std::sync::Arc<str>`] output* forward
/// projection on the outside-M3 caixa-core dialect-classification
/// [`CaixaDialeto`] closed-set fieldless typed enum. Routes byte-for-byte
/// through the substrate-primitive [`CaixaDialeto::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> = dialeto.into();`-shaped call site
/// reaches the same four `"Pacote"` / `"Molde"` / `"MoldePosicional"` /
/// `"Desconhecido"` 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 downstream
/// `CaixaDialeto → std::sync::Arc<str>` `.into()` reaches through this impl
/// and no other — a paired `std::sync::Arc::<str>::from(dialeto.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(dialeto))`
/// 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.
///
/// Extends the caixa-core-internal tier of the substrate-wide trait-
/// idiomatic [`std::sync::Arc<str>`] forward-projection campaign onto the
/// third caixa-core-internal peer, after the structurally most fundamental
/// [`crate::CaixaKind`] pair (c17be64, both corners in one axis) opened the
/// tier and the outside-M3 two-list dep-graph [`crate::dep::DepList`] pair
/// (d8a4652, both corners in one axis) extended it. Follows the M2
/// OTP-shape [`crate::supervisor::RestartStrategy`] /
/// [`crate::supervisor::RestartPolicy`] pair (bca2ec8 → ea91551), the M3
/// mesh-shape [`crate::aplicacao::PlacementStrategy`] /
/// [`crate::aplicacao::WitShape`] / [`crate::aplicacao::RateLimitUnit`]
/// triple (977d577 → dae722f) that closed the M3 mesh-shape tier, 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 one tier prior. The
/// shared-ownership + [`Sync`] + [`Send`] contract [`std::sync::Arc<str>`]
/// provides is what makes the per-arm canonical dialect-classification
/// label safely reachable off both input-shape axes without a `.clone()`-
/// per-task materialization, distinct from the sibling [`Box<str>`] axis's
/// owned-move-only contract.
///
/// A future arm addition (the module doc's "third dialect" hazard
/// actualising as a fifth arm) reaches the paired [`std::sync::Arc<str>`]
/// output axis through one match-arm edit on the [`CaixaDialeto::as_str`]
/// `pub const fn` accessor, not a coordinated rewrite of every downstream
/// `std::sync::Arc::<str>::from(dialeto.as_str())` open-code.
///
/// Pinned load-bearing by
/// [`tests::caixa_dialeto_from_into_arc_str_routes_through_as_str_accessor`]
/// (byte-parity pin against [`CaixaDialeto::as_str`] across the four-arm
/// [`CaixaDialeto::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).
impl From<CaixaDialeto> for std::sync::Arc<str> {
    fn from(dialeto: CaixaDialeto) -> std::sync::Arc<str> {
        std::sync::Arc::<str>::from(dialeto.as_str())
    }
}

/// Trait-idiomatic *borrowed-input, [`std::sync::Arc<str>`] output* forward
/// projection on the outside-M3 caixa-core dialect-classification
/// [`CaixaDialeto`] closed-set fieldless typed enum — the borrowed-input
/// companion to the paired owned-input
/// [`From<CaixaDialeto> for std::sync::Arc<str>`] impl one commit above
/// that extends the caixa-core-internal tier of the substrate-wide trait-
/// idiomatic [`std::sync::Arc<str>`] forward-projection campaign onto the
/// third caixa-core-internal peer. Routes byte-for-byte through the
/// substrate-primitive [`CaixaDialeto::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> = (&dialeto).into();`
/// -shaped call site or a
/// `CaixaDialeto::ALL.iter().map(std::sync::Arc::<str>::from)`-shaped pipe
/// (whose iterator over `&'static [CaixaDialeto]` yields `&CaixaDialeto` by
/// construction) reaches the same four `"Pacote"` / `"Molde"` /
/// `"MoldePosicional"` / `"Desconhecido"` byte-strings the sibling
/// `{Self, &Self} × {&'static str, String, Cow<'static, str>, Box<str>}`
/// forward-projection corner and the paired owned-input
/// [`From<CaixaDialeto> for std::sync::Arc<str>`] 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
/// [`CaixaDialeto::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((*dialeto).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 third caixa-core-
/// internal closed-set fieldless typed enum peer of the substrate-wide
/// trait-idiomatic [`std::sync::Arc<str>`] forward-projection campaign,
/// matching the trajectory the paired structurally most fundamental
/// [`crate::CaixaKind`] pair (c17be64, both corners in one axis) and the
/// paired outside-M3 caixa-core two-list dep-graph [`crate::dep::DepList`]
/// pair (d8a4652, both corners in one axis) walked before it on the
/// caixa-core-internal tier of the same axis. Same
/// `{Self, &Self} × {&'static str, String, Cow<'static, str>, Box<str>,
/// std::sync::Arc<str>}` 2×5 forward-projection matrix the peer projection
/// surfaces already close on this same enum.
///
/// Pinned load-bearing by
/// [`tests::caixa_dialeto_from_borrowed_into_arc_str_routes_through_as_str_accessor`]
/// (byte-parity pin against [`CaixaDialeto::as_str`] across the four-arm
/// [`CaixaDialeto::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<CaixaDialeto> 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
/// [`CaixaDialeto::ALL`] that resolves through the borrowed-input axis
/// without a spurious [`Copy`] deref).
impl From<&CaixaDialeto> for std::sync::Arc<str> {
    fn from(dialeto: &CaixaDialeto) -> std::sync::Arc<str> {
        std::sync::Arc::<str>::from(dialeto.as_str())
    }
}

/// Trait-idiomatic *owned-input, [`std::rc::Rc<str>`] output* forward
/// projection on the outside-M3 caixa-core dialect-classification
/// [`CaixaDialeto`] closed-set fieldless typed enum — the single-threaded
/// shared-ownership companion to the paired atomically-refcounted
/// [`From<CaixaDialeto> for std::sync::Arc<str>`] impl one commit above.
/// Routes byte-for-byte through the substrate-primitive
/// [`CaixaDialeto::as_str`] `pub const fn` accessor via
/// [`std::rc::Rc::<str>::from`] on the returned `&'static str`, so every
/// consumer that binds a `let key: std::rc::Rc<str> = dialeto.into();`-
/// shaped call site reaches the same four `"Pacote"` / `"Molde"` /
/// `"MoldePosicional"` / `"Desconhecido"` byte-strings the sibling
/// `{Self, &Self} × {&'static str, String, Cow<'static, str>, Box<str>,
/// std::sync::Arc<str>}` forward-projection corner already returns.
///
/// 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>` (nor an
/// `impl<T: fmt::Display> From<T> for std::rc::Rc<str>`), and — critically
/// — the [`std::sync::Arc<str>`] and [`std::rc::Rc<str>`] layouts share
/// the same on-disk shape but the trait tables are disjoint (no blanket
/// `impl<T> From<T> for std::rc::Rc<str> where std::sync::Arc<str>: From<T>`
/// exists in `core`), so a closed-set enum that carries the paired
/// [`std::sync::Arc<str>`] axis but not the paired [`std::rc::Rc<str>`]
/// axis forces every single-threaded [`std::rc::Rc<str>`]-typed call site
/// through an [`std::rc::Rc::<str>::from`]`(dialeto.as_str())` open-code
/// (no compile-time link back to the substrate primitive) or a
/// [`std::rc::Rc::<str>::from`]`(String::from(dialeto))` two-step
/// composition through the owned-`String` axis that 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. The single-threaded shared-
/// ownership contract [`std::rc::Rc<str>`] provides — the non-atomic
/// strong-and-weak refcount header, cheaper `Clone` than the paired
/// atomically-refcounted [`std::sync::Arc<str>`] axis by a measurable
/// margin on hot single-threaded call sites — is the distinct value the
/// sibling [`std::sync::Arc<str>`] axis's [`Send`] and [`Sync`] return-
/// shape cannot provide without paying the atomic-increment cost on
/// every clone: a single-threaded `feira dialeto` census pipeline whose
/// per-file classify path composes a [`std::rc::Rc<str>`] label into a
/// per-arm counter reaches through this axis and not the atomic sibling;
/// a single-threaded `HashMap::<std::rc::Rc<str>, _>::from_iter` per-
/// dialect lookup where the map's key type is [`std::rc::Rc<str>`] so
/// the same dialect-label pointer can key both the map and the payload
/// without a second heap allocation reaches through this axis.
///
/// Extends the caixa-core-internal tier of the substrate-wide trait-
/// idiomatic [`std::rc::Rc<str>`] forward-projection campaign onto the
/// second caixa-core-internal peer, after the structurally most
/// fundamental [`crate::CaixaKind`] pair (4fdfa37, both corners in one
/// axis) opened the campaign on the closed-set fieldless typed-enum
/// family. Same `{Self, &Self} × {&'static str, String, Cow<'static, str>,
/// Box<str>, std::sync::Arc<str>, std::rc::Rc<str>}` 2×6 forward-
/// projection matrix the sibling projection surfaces already carry —
/// this impl extends the sixth column onto the dialect-classification
/// enum's owned-input row.
///
/// A future arm addition (the module doc's "third dialect" hazard
/// actualising as a fifth arm) reaches the paired [`std::rc::Rc<str>`]
/// output axis through one match-arm edit on the [`CaixaDialeto::as_str`]
/// `pub const fn` accessor, not a coordinated rewrite of every downstream
/// `std::rc::Rc::<str>::from(dialeto.as_str())` open-code.
///
/// Pinned load-bearing by
/// [`tests::caixa_dialeto_from_into_rc_str_routes_through_as_str_accessor`]
/// (byte-parity pin against [`CaixaDialeto::as_str`] across the four-arm
/// [`CaixaDialeto::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).
impl From<CaixaDialeto> for std::rc::Rc<str> {
    fn from(dialeto: CaixaDialeto) -> std::rc::Rc<str> {
        std::rc::Rc::<str>::from(dialeto.as_str())
    }
}

/// Trait-idiomatic *borrowed-input, [`std::rc::Rc<str>`] output* forward
/// projection on the outside-M3 caixa-core dialect-classification
/// [`CaixaDialeto`] closed-set fieldless typed enum — the borrowed-input
/// companion to the paired owned-input
/// [`From<CaixaDialeto> for std::rc::Rc<str>`] impl immediately above.
/// Routes byte-for-byte through the substrate-primitive
/// [`CaixaDialeto::as_str`] `pub const fn` accessor via
/// [`std::rc::Rc::<str>::from`] on the returned `&'static str`, so a
/// `CaixaDialeto::ALL.iter().map(std::rc::Rc::<str>::from)`-shaped pipe
/// (whose iterator over `&'static [CaixaDialeto]` yields `&CaixaDialeto`
/// by construction) reaches the same four `"Pacote"` / `"Molde"` /
/// `"MoldePosicional"` / `"Desconhecido"` 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
/// [`CaixaDialeto::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((*dialeto).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::rc::Rc<str>`] forward-projection campaign,
/// matching the trajectory the paired structurally most fundamental
/// [`crate::CaixaKind`] pair (4fdfa37, both corners in one axis) walked
/// before it on the caixa-core-internal tier of the same axis. Same
/// `{Self, &Self} × {&'static str, String, Cow<'static, str>, Box<str>,
/// std::sync::Arc<str>, std::rc::Rc<str>}` 2×6 forward-projection matrix
/// the peer projection surfaces already close on this same enum.
///
/// Pinned load-bearing by
/// [`tests::caixa_dialeto_from_borrowed_into_rc_str_routes_through_as_str_accessor`]
/// (byte-parity pin against [`CaixaDialeto::as_str`] across the four-arm
/// [`CaixaDialeto::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<CaixaDialeto> 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
/// [`CaixaDialeto::ALL`] that resolves through the borrowed-input axis
/// without a spurious [`Copy`] deref).
impl From<&CaixaDialeto> for std::rc::Rc<str> {
    fn from(dialeto: &CaixaDialeto) -> std::rc::Rc<str> {
        std::rc::Rc::<str>::from(dialeto.as_str())
    }
}

/// Substrate-canonical [`AsRef<[u8]>`] byte-view projection on the
/// caixa-core-internal dialect-classification [`CaixaDialeto`] closed-set
/// fieldless typed enum — routes byte-for-byte through the substrate-
/// primitive [`CaixaDialeto::as_str`] `pub const fn` accessor via
/// [`str::as_bytes`] on the returned `&'static str`, so any future
/// consumer that binds a [`CaixaDialeto`] through a standard-library
/// `<T: AsRef<[u8]>>` trait bound reaches the same lifted
/// [`CAIXA_DIALETO_WIRE_PACOTE`] / [`CAIXA_DIALETO_WIRE_MOLDE`] /
/// [`CAIXA_DIALETO_WIRE_MOLDE_POSICIONAL`] /
/// [`CAIXA_DIALETO_WIRE_DESCONHECIDO`] `pub const &str` roster the paired
/// sibling [`AsRef<str>`] / [`std::fmt::Display`] /
/// [`CaixaDialeto::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.
///
/// Unlike the sibling top-level [`crate::CaixaKind`] enum — 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) — [`CaixaDialeto`] is an internal
/// classification with no wire-surface split (see the
/// [`CaixaDialeto::as_str`] docstring: "the `PascalCase` variant name
/// is the census-facing form every consumer reads, so `as_str`
/// suffices without a paired `wire_name` axis"). The byte-view axis
/// therefore lands on the same `PascalCase` census-facing byte-string
/// every str-view and reverse-projection axis on this enum already
/// returns, and no wire-axis cross-witness applies.
///
/// The primary compounding target is the same [`crate`]-adjacent
/// [`caixa-lacre`](../../caixa-lacre/) BLAKE3 content-address closure
/// the peer [`crate::CaixaKind`] `AsRef<[u8]>` impl (69d8d86) opens
/// 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 `:dialect` classification-byte
/// into the [`crate::Lacre`] closure (a hypothetical
/// `hasher.update(dialeto);`-shape composition on the per-caixa
/// BLAKE3 closure builder that keys off the caixa source's dialect
/// classification) reaches the substrate-primitive
/// [`CaixaDialeto::as_str`] accessor through this impl and no other —
/// without it, every such call site opens the two-hop composition
/// `dialeto.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
/// structured-log dialect-column emitter (whose input binds through
/// `impl AsRef<[u8]>`), any future byte-keyed
/// [`std::collections::HashMap`] `<K: AsRef<[u8]>, V>` per-dialect
/// 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-
/// dialect content-address digest.
///
/// Rust's standard library carries `impl AsRef<[u8]> for str` and
/// `impl AsRef<[u8]> for String`, so the two-hop composition
/// `dialeto.as_str().as_bytes()` (or, equivalently,
/// `AsRef::<str>::as_ref(&dialeto).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
/// [`CaixaDialeto`] 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 (the
/// module doc's "third dialect" hazard actualising as a fifth arm)
/// 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 second
/// closed-set fieldless typed-enum peer on the substrate — the
/// caixa-core-internal dialect-classification enum — matching the
/// trajectory the sibling [`crate::CaixaKind`] first-mover
/// [`AsRef<[u8]>`] impl (69d8d86) 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.
///
/// Pinned load-bearing by
/// [`tests::caixa_dialeto_as_ref_bytes_routes_through_as_str_accessor`]
/// (fail-before-pass-after byte-parity pin against
/// [`CaixaDialeto::as_str`] `.as_bytes()` across the four-arm
/// [`CaixaDialeto::ALL`] emit-set, cross-axis witness against the
/// paired str-view [`AsRef<str>`] / [`std::fmt::Display`] /
/// [`CaixaDialeto::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
/// [`CaixaDialeto`] 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 [`CaixaDialeto::as_str`] accessor (a per-arm
/// inline `b"Pacote".as_slice()`-shaped re-inlining that opens a
/// compile-time link to the un-lifted arm-literal, a swap onto the
/// sibling [`CaixaDialeto::palavra_canonica`] /
/// [`CaixaDialeto::consumidor`] / [`CaixaDialeto::descricao`]
/// accessors that carry distinct byte-shapes per axis) trips at
/// caixa-core test time rather than at a downstream byte-consumer's
/// silent split.
impl AsRef<[u8]> for CaixaDialeto {
    fn as_ref(&self) -> &[u8] {
        self.as_str().as_bytes()
    }
}

/// Trait-idiomatic *owned-input, owned-`Vec<u8>` output* byte-owned
/// reverse projection on the second caixa-core-internal closed-set
/// fieldless typed enum peer ([`CaixaDialeto`]) — the byte-mirror of
/// the [`From<CaixaDialeto> 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
/// [`CaixaDialeto::as_str`] `pub const fn` accessor via
/// [`str::as_bytes`] + [`slice::to_vec`] so every consumer that binds
/// a [`CaixaDialeto`] through the standard-library
/// `impl From<CaixaDialeto> for Vec<u8>` axis (equivalently
/// `<T: Into<Vec<u8>>>`) — a future
/// [`std::io::Write::write_all`]-shape per-dialect audit-log byte-sink
/// whose input parameter is an owned [`Vec<u8>`] payload, a future
/// `bytes::Bytes::from(Vec::<u8>::from(dialeto))` composer folding the
/// per-arm classification byte-tag into the [`bytes::Bytes`] framing
/// surface, a future `hasher.update(&Vec::<u8>::from(dialeto))`-shape
/// BLAKE3 content-address closure that needs the owned byte-tail
/// buffered before folding into the [`crate::Lacre`] closure body, a
/// future per-dialect protobuf/CBOR/msgpack payload composer whose
/// framer takes an owned [`Vec<u8>`] rather than a borrowed byte-slice
/// — reaches the same four-arm lifted [`CAIXA_DIALETO_WIRE_PACOTE`] /
/// [`CAIXA_DIALETO_WIRE_MOLDE`] / [`CAIXA_DIALETO_WIRE_MOLDE_POSICIONAL`]
/// / [`CAIXA_DIALETO_WIRE_DESCONHECIDO`] 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
/// [`CaixaDialeto::as_str`] accessor already return, rather than an
/// open-coded per-call-site `dialeto.as_str().as_bytes().to_vec()` /
/// `<CaixaDialeto as AsRef<[u8]>>::as_ref(&dialeto).to_vec()` /
/// `String::from(dialeto).into_bytes()` composition whose type bounds
/// have no compile-time link back to the substrate primitive.
///
/// Second peer on the substrate-wide trait-idiomatic *byte-owned
/// reverse-projection* family opened on the sibling top-level
/// [`crate::CaixaKind`] enum (b245fd6 first-mover) — Rust's standard
/// library carries `impl From<&[u8]> for Vec<u8>` and
/// `impl From<String> for Vec<u8>`, so a two-hop composition
/// `dialeto.as_str().as_bytes().to_vec()` (or
/// `String::from(dialeto).into_bytes()`, or
/// `<CaixaDialeto as AsRef<[u8]>>::as_ref(&dialeto).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 module doc's "third dialect" hazard actualising
/// as a fifth arm landing on a new `CAIXA_DIALETO_WIRE_*` const)
/// grows the byte-owned axis through one edit on the substrate-
/// primitive [`CaixaDialeto::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 — [`CaixaDialeto`] is an
/// internal classification with no wire-surface split (see the
/// [`CaixaDialeto::as_str`] docstring: "the `PascalCase` variant name
/// is the census-facing form every consumer reads, so `as_str`
/// suffices without a paired `wire_name` axis"). The byte-owned axis
/// therefore lands on the same `PascalCase` census-facing byte-string
/// every str-view / reverse-projection / byte-view axis on this enum
/// already returns, and no wire-axis cross-witness applies.
///
/// Extends the byte-owned reverse-projection axis onto the second
/// closed-set fieldless typed enum peer on the caixa-core-internal
/// tier — every future closed-set fieldless typed enum peer on the
/// substrate ([`crate::supervisor::RestartStrategy`],
/// [`crate::supervisor::RestartPolicy`],
/// [`crate::aplicacao::PlacementStrategy`],
/// [`crate::aplicacao::RateLimitUnit`], [`crate::dep::DepList`], 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.
///
/// Pinned load-bearing by
/// [`tests::caixa_dialeto_from_into_owned_vec_bytes_routes_through_as_str_accessor`]
/// (byte-parity pin against [`CaixaDialeto::as_str`] across the four-
/// 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).
impl From<CaixaDialeto> for Vec<u8> {
    fn from(dialeto: CaixaDialeto) -> Vec<u8> {
        dialeto.as_str().as_bytes().to_vec()
    }
}

/// Trait-idiomatic *borrowed-input, owned-`Vec<u8>` output* byte-
/// owned reverse projection on the second caixa-core-internal closed-
/// set fieldless typed enum peer ([`CaixaDialeto`]) — the borrowed-
/// input peer of [`From<CaixaDialeto> 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 [`CaixaDialeto::as_str`] `pub const fn`
/// accessor so every consumer that holds a borrowed [`&CaixaDialeto`]
/// and needs an owned [`Vec<u8>`] — a future
/// `.iter().map(Vec::<u8>::from).collect()` pipe over
/// `&[CaixaDialeto]` (whose iterator yields `&CaixaDialeto`, not
/// `CaixaDialeto`, 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 census-report body composer that walks
/// [`CaixaDialeto::ALL`] through an `Into<Vec<u8>>`-bound per-arm
/// byte-writer to surface the accepted dialect set — reaches the same
/// four-arm lifted `CAIXA_DIALETO_WIRE_*` const roster the paired
/// owned-input peer already returns.
impl From<&CaixaDialeto> for Vec<u8> {
    fn from(dialeto: &CaixaDialeto) -> Vec<u8> {
        dialeto.as_str().as_bytes().to_vec()
    }
}

/// Trait-idiomatic *borrowed byte-slice input* reverse projection on the
/// second caixa-core-internal closed-set fieldless typed enum peer
/// ([`CaixaDialeto`]) — the byte-view mirror of the str-view reverse-
/// projection axis carried by the paired [`TryFrom<&str> for CaixaDialeto`]
/// impl (which routes through the substrate-primitive
/// [`CaixaDialeto::from_wire`] `Option<Self>` accessor on the four-arm
/// `PascalCase` accept-set the sibling [`CaixaDialeto::as_str`] emitter
/// returns). Routes byte-for-byte through the standard-library
/// [`std::str::from_utf8`] UTF-8 validator and then through
/// [`CaixaDialeto::from_wire`] so every consumer that holds a borrowed
/// [`&[u8]`] and needs to project it back into a typed [`CaixaDialeto`] —
/// a future `bytes::Bytes::as_ref()`-fed reader that parses a per-caixa
/// `:dialect` classification tag from an already-borrowed framing byte-
/// tail (a `tracing::field::valuable::Value::Bytes` recorder on the
/// caixa-build pipeline's per-file classify emission path, a future audit-
/// report re-loader binding a prior [`CaixaDialeto::as_str`] output from a
/// mmap'd byte-slice back through the typed enum for cross-run
/// comparison), a future admission-webhook rejection body that reads a
/// `spec.dialeto` 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 four-arm
/// `PascalCase` wire accept-set the sibling method-named
/// [`CaixaDialeto::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(CaixaDialeto::from_wire)`
/// composition or a
/// `<CaixaDialeto 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) — onto the second 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::dep::DepList`], [`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 [`CaixaDialeto::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 dialeto --filter` arg-parse composes its own per-verb
/// "unknown dialect: <arg> — accepted: {…}" message enumerating
/// [`CaixaDialeto::ALL`]; a future admission-webhook rejection body wraps
/// the `Err(())` outcome 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 four-arm `PascalCase` accept-set
/// ([`CaixaDialeto::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`] +
/// [`CaixaDialeto::from_wire`] explicitly.
///
/// Pinned load-bearing by
/// [`tests::caixa_dialeto_try_from_bytes_routes_through_from_wire_accessor`]
/// (byte-parity pin against [`CaixaDialeto::from_wire`] across the four-
/// arm [`CaixaDialeto::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::caixa_dialeto_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).
impl TryFrom<&[u8]> for CaixaDialeto {
    type Error = ();

    fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
        std::str::from_utf8(bytes)
            .ok()
            .and_then(Self::from_wire)
            .ok_or(())
    }
}

/// Trait-idiomatic *owned byte-vec input* reverse projection on the
/// second caixa-core-internal closed-set fieldless typed enum peer
/// ([`CaixaDialeto`]) — the owned-input peer of
/// [`TryFrom<&[u8]> for CaixaDialeto`], mirroring the closed
/// [`From<CaixaDialeto> for Vec<u8>`] + [`From<&CaixaDialeto> 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`] + [`CaixaDialeto::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
/// [`CaixaDialeto`] otherwise picks between (a) an open-coded
/// `<CaixaDialeto 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)` + [`CaixaDialeto::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
/// `<CaixaDialeto 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
/// [`CaixaDialeto::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 four-arm
/// `PascalCase` wire accept-set through one trait dispatch.
///
/// Extends the substrate-wide trait-idiomatic *byte-owned reverse-
/// projection* family onto the second caixa-core-internal closed-set
/// fieldless typed enum peer, tracking the trajectory the sibling
/// first-mover [`TryFrom<Vec<u8>> for CaixaKind`] (99c2849) opened on
/// the structurally most fundamental enum. Peer of the sibling closed
/// byte-view reverse-projection family (`TryFrom<&[u8]>`; extended
/// onto this enum d102cb8) 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 [`CaixaDialeto`].
///
/// `type Error = ()` matches the sibling [`TryFrom<&[u8]> for CaixaDialeto`]
/// 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).
///
/// Unlike the peer [`TryFrom<Vec<u8>> for crate::CaixaKind`] (which
/// carries a wire-vs-diagnostic two-axis split — `as_str` lowercase
/// Portuguese vs `wire_name` `PascalCase`), [`CaixaDialeto`] has no
/// such split: [`Self::as_str`] and [`Self::from_wire`] operate on
/// the same four-arm `PascalCase` byte-vocabulary
/// (`"Pacote"`, `"Molde"`, `"MoldePosicional"`, `"Desconhecido"`).
/// So on this enum the byte-owned reverse-projection axis *can*
/// round-trip against the paired byte-owned forward-projection pair
/// ([`From<CaixaDialeto> for Vec<u8>`], [`From<&CaixaDialeto> 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::caixa_dialeto_try_from_vec_bytes_routes_through_borrowed_byte_view_axis`]
/// (byte-parity pin against the paired borrowed [`TryFrom<&[u8]>`]
/// axis across the four-arm [`CaixaDialeto::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 [`CaixaDialeto::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::caixa_dialeto_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).
impl TryFrom<Vec<u8>> for CaixaDialeto {
    type Error = ();

    fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
        <Self as TryFrom<&[u8]>>::try_from(bytes.as_slice())
    }
}

/// A source that is not a `(defcaixa …)` / `(defmolde …)` form at all.
#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
pub enum DialetoError {
    #[error("source has no top-level form")]
    Vazio,
    #[error("top-level form is not a list — a manifest is `(defcaixa …)`")]
    NaoEhLista,
    #[error(
        "top-level form is headed by `{encontrado}`, not `defcaixa` or `defmolde` \
         (a manifest's first form must be the declaration itself)"
    )]
    CabecaErrada { encontrado: String },
    #[error("manifest does not parse as tatara-lisp: {0}")]
    Leitura(String),
}

impl DialetoError {
    /// Construct a [`DialetoError::CabecaErrada`] naming the offending
    /// head symbol found at the top-level form.
    ///
    /// Substrate primitive every [`classify_form`] wrong-head fallthrough
    /// wire-up site now routes through, folding the pre-lift uniform
    /// three-line `Self::CabecaErrada { encontrado: <head>.to_string() }`
    /// one-field struct-literal onto one substrate primitive matching the
    /// peer `LimitsError::unknown_byte_unit(unit: &str)` /
    /// `LimitsError::unknown_duration_unit(unit: &str)`
    /// (`limits_codec_unit_only_ctors!` — 29fac09) single-slot
    /// discipline on the sibling one-field `{ <field>: String }` envelope
    /// axis, and matching the peer `ManifestError::code_path_empty` /
    /// `BehaviorError::empty_path` / `UpgradeError::duplicate_from` /
    /// `AplicacaoError::placement_cluster_duplicate` (94dabc8 / 0e33b37 /
    /// 7e52aec / 92b1c92) single-slot inherent-ctor discipline every
    /// sibling `{ <field>: <T> }` error-envelope variant on caixa-core's
    /// error surface now carries.
    ///
    /// The one open-coded wire-up site — `classify_form`'s wrong-head
    /// fallthrough arm on the `head: &str` binding read from the
    /// top-level form via [`tatara_lisp::Sexp::as_symbol`] — opened the
    /// identical three-line
    /// `Self::CabecaErrada { encontrado: <head>.to_string() }` block
    /// against the codec-scoped `<head>: &str` binding. Now routes
    /// through `DialetoError::cabeca_errada(head)`, byte-equal to the
    /// pre-lift struct-literal on the same `&str` fixture, so any future
    /// widening of the diagnostic shape (e.g. carrying the source-file
    /// path alongside the head symbol, carrying the head symbol's
    /// position offset for an authoring-surface caret pointer) lands at
    /// exactly one dispatch on the substrate primitive rather than re-
    /// inlining the struct-literal at every wrong-head fallthrough
    /// consumer.
    #[must_use]
    pub fn cabeca_errada(encontrado: &str) -> Self {
        Self::CabecaErrada {
            encontrado: encontrado.to_string(),
        }
    }

    /// Construct a [`DialetoError::Leitura`] carrying the offending
    /// tatara-lisp reader-error message `reason` verbatim in the
    /// variant's tuple-newtype payload.
    ///
    /// Substrate primitive every [`classify`] tatara-lisp-reader
    /// map-err wire-up site now routes through, folding the pre-lift
    /// uniform `Self::Leitura(<into-String-expr>)` tuple-newtype
    /// construction onto one substrate primitive matching the peer
    /// `LimitsError::empty_byte_size` / `LimitsError::empty_duration`
    /// (7a4b003 / 319216c) `(String)` single-slot tuple-newtype
    /// discipline on the sibling
    /// [`crate::limits::LimitsError`] envelope's empty-shape axis of
    /// the paired codec-magnitude family. Peer to the sibling
    /// [`DialetoError::cabeca_errada`] ctor on the same envelope's
    /// wrong-head axis but on the tatara-lisp-reader axis rather than
    /// the classifier-fallthrough axis. Closes the last un-lifted
    /// variant on [`DialetoError`] — every one of the sole wire-up
    /// sites (the [`classify`] tatara-lisp-reader `.map_err(|e|
    /// Self::Leitura(e.to_string()))` arm) opened the identical
    /// `DialetoError::Leitura(<into-String-expr>)` block against the
    /// codec-scoped `String` (`e.to_string()`) binding, so the fold
    /// routes the site through one dispatch on a uniform
    /// `impl Into<String>` param, byte-equal to the pre-lift
    /// tuple-newtype construction on the same argument.
    ///
    /// The `impl Into<String>` bound covers both wire-up shapes on
    /// [`classify`] — a `String` binding (`e.to_string()` on the
    /// [`tatara_lisp::Error`]-carrying `e` binding) and a `&str`
    /// binding (a future admission-webhook consumer probing a
    /// caller-scoped `&'static str` fixture, a future
    /// `feira lint --tatara-reader-round-trip` verb sweeping every
    /// `tatara_lisp::read` return through the same shape gate) —
    /// without forcing the caller to spell the conversion at the
    /// wire-up site. Same shape the peer
    /// [`crate::limits::LimitsError::empty_byte_size`] /
    /// [`crate::limits::LimitsError::empty_duration`] /
    /// [`crate::limits::LimitsError::bad_millicores`] /
    /// [`crate::limits::LimitsError::bad_byte_magnitude`] /
    /// [`crate::limits::LimitsError::bad_duration_magnitude`] folds
    /// carry on the peer bad-magnitude and empty-shape axes of the
    /// same paired `(String)` tuple-newtype codec-magnitude family.
    /// `#[must_use]` fires a compile warning at any wire-up that
    /// mistakenly discards the constructed error.
    ///
    /// Every future consumer that wants to construct this variant
    /// outside [`classify`] (a deferred `feira lint --tatara-reader-
    /// round-trip` per-caixa admission verb probing each authored
    /// manifest against the tatara-lisp-reader shape gate, an M4
    /// typed `mesh.pleme.io/v1alpha1/Servico` CR materializer's
    /// per-manifest admission validator re-checking one edited
    /// `caixa.lisp` against the reader floor, a per-`caixa.lisp`
    /// value-shape pre-emitter probing each declared manifest ahead
    /// of the operator's admit-cycle) now reaches the variant
    /// through one call rather than re-inlining the tuple-newtype
    /// block in lockstep with the pre-existing wire-up.
    #[must_use]
    pub fn leitura(reason: impl Into<String>) -> Self {
        Self::Leitura(reason.into())
    }
}

/// Classify a manifest source without committing to either schema.
///
/// Deliberately reads only the head symbol and the set of top-level keywords —
/// enough to route, never enough to half-parse. A classifier that started
/// validating would grow into a third parser, which is the shape of the problem
/// it exists to name.
///
/// # Errors
/// [`DialetoError`] when the source is not a manifest declaration at all.
pub fn classify(src: &str) -> Result<CaixaDialeto, DialetoError> {
    let forms = tatara_lisp::read(src).map_err(|e| DialetoError::leitura(e.to_string()))?;
    let first = forms.first().ok_or(DialetoError::Vazio)?;
    classify_form(first)
}

/// [`classify`] over an already-read form.
///
/// # Errors
/// [`DialetoError`] when the form is not a manifest declaration.
pub fn classify_form(form: &Sexp) -> Result<CaixaDialeto, DialetoError> {
    let list = form.as_list().ok_or(DialetoError::NaoEhLista)?;
    let head = list
        .first()
        .and_then(Sexp::as_symbol)
        .ok_or(DialetoError::NaoEhLista)?;

    match head {
        // `defmolde` is unambiguous by construction — it exists precisely so a
        // consumer never has to infer which declaration it holds. Both arities
        // are the same declaration; the positional one keeps its own variant
        // only so a census can report the split.
        "defmolde" => {
            return Ok(if starts_with_positional_name(&list[1..]) {
                CaixaDialeto::MoldePosicional
            } else {
                CaixaDialeto::Molde
            });
        }
        "defcaixa" => {}
        other => {
            return Err(DialetoError::cabeca_errada(other));
        }
    }

    let args = &list[1..];

    // `(defcaixa <symbol> :kind … :ecosystem …)`. Only the Molde dialect has a
    // positional arity; `Caixa` is keyword-only, so a leading bare symbol
    // settles it without looking further.
    if starts_with_positional_name(args) {
        return Ok(CaixaDialeto::MoldePosicional);
    }

    let keys = top_level_keywords(args);
    let has = |k: &str| keys.iter().any(|s| s == k);

    // Order matters, and it is not arbitrary: `:nome` and `:name` are the two
    // required head slots and no file in the measured corpus carries both.
    // Checking them FIRST means the decision rests on the one slot each schema
    // makes mandatory, rather than on optional evidence like `:ecosystem`.
    if has("nome") {
        return Ok(CaixaDialeto::Pacote);
    }
    if has("name") || has("ecosystem") || has("package") {
        return Ok(CaixaDialeto::Molde);
    }
    Ok(CaixaDialeto::Desconhecido)
}

/// True when the first argument is a bare symbol rather than a keyword — the
/// positional-name arity.
fn starts_with_positional_name(args: &[Sexp]) -> bool {
    matches!(args.first(), Some(Sexp::Atom(Atom::Symbol(_))))
}

/// The top-level keyword names (without the leading `:`) of a kwarg list.
///
/// Steps in pairs so a keyword appearing as a VALUE — `:kind :Biblioteca`, or a
/// nested `(:nome "dep" :versao "^0.1")` inside `:deps` — is never counted as a
/// top-level slot. A naive scan for `:nome` anywhere in the source classifies
/// every Molde manifest with a `:deps` list as a Pacote.
fn top_level_keywords(args: &[Sexp]) -> Vec<String> {
    let mut out = Vec::new();
    let mut i = 0;
    while i < args.len() {
        if let Sexp::Atom(Atom::Keyword(k)) = &args[i] {
            out.push(k.clone());
            i += 2;
        } else {
            i += 1;
        }
    }
    out
}

#[cfg(test)]
mod tests {
    use super::*;

    const PACOTE: &str = r#"
      (defcaixa
        :nome   "checkout"
        :versao "0.1.0"
        :kind   Servico
        :deps   ((:nome "caixa-teia" :versao "^0.1")))
    "#;

    const MOLDE: &str = r#"
      (defcaixa
        :name "base64"
        :kind :Biblioteca
        :ecosystem :rust-single-crate
        :package {:name "base64" :version "0.22.1"}
        :workflows [:auto-release])
    "#;

    const MOLDE_POSICIONAL: &str = r#"
      (defcaixa todoku-go
        :kind :Biblioteca
        :ecosystem :go
        :package {:name "todoku-go" :version "0.3.0"})
    "#;

    #[test]
    fn the_package_dialect_is_recognised() {
        assert_eq!(classify(PACOTE), Ok(CaixaDialeto::Pacote));
    }

    #[test]
    fn the_repo_surface_dialect_is_recognised() {
        assert_eq!(classify(MOLDE), Ok(CaixaDialeto::Molde));
    }

    #[test]
    fn the_positional_arity_is_recognised() {
        assert_eq!(
            classify(MOLDE_POSICIONAL),
            Ok(CaixaDialeto::MoldePosicional)
        );
    }

    #[test]
    fn defmolde_classifies_without_inference() {
        // The whole point of the new keyword: no schema sniffing required.
        let src = r#"(defmolde :name "x" :kind :Biblioteca :ecosystem :go)"#;
        assert_eq!(classify(src), Ok(CaixaDialeto::Molde));
        let pos = r"(defmolde todoku-go :kind :Biblioteca :ecosystem :go)";
        assert_eq!(classify(pos), Ok(CaixaDialeto::MoldePosicional));
    }

    #[test]
    fn a_nested_nome_does_not_make_a_repo_surface_look_like_a_package() {
        // The exact failure a substring scan produces: `:deps ((:nome …))`
        // contains `:nome`, but not as a top-level slot.
        let src = r#"
          (defcaixa
            :name "x"
            :ecosystem :rust-single-crate
            :deps ((:nome "inner" :versao "^0.1")))
        "#;
        assert_eq!(classify(src), Ok(CaixaDialeto::Molde));
    }

    #[test]
    fn a_keyword_in_value_position_is_not_a_slot() {
        // `:kind :Biblioteca` — the value is itself a keyword. Stepping one at
        // a time would read `:Biblioteca` as a top-level slot.
        let src = r#"(defcaixa :kind :Biblioteca :name "x")"#;
        assert_eq!(classify(src), Ok(CaixaDialeto::Molde));
    }

    #[test]
    fn an_unrecognised_defcaixa_is_reported_not_guessed() {
        let src = r#"(defcaixa :licenca "MIT")"#;
        assert_eq!(classify(src), Ok(CaixaDialeto::Desconhecido));
    }

    #[test]
    fn a_form_that_is_not_a_manifest_is_an_error_not_a_dialect() {
        assert_eq!(
            classify("(defflake :nome \"x\")"),
            Err(DialetoError::cabeca_errada("defflake"))
        );
        assert_eq!(classify(""), Err(DialetoError::Vazio));
    }

    #[test]
    fn every_dialect_names_its_consumer_and_its_canonical_keyword() {
        // Guards the routing table itself: a new variant added without an arm
        // here is a compile error in the match, and a variant that claims
        // `defcaixa` while being read by pleme-doc-gen would re-open the
        // collision this module closes. Sweeps [`CaixaDialeto::ALL`] rather
        // than the pre-lift open-coded four-arm literal list — a future arm
        // addition extends the slice as one edit and this pin picks it up
        // by construction.
        for &d in CaixaDialeto::ALL {
            assert!(!d.descricao().is_empty(), "{d}");
            assert!(!d.consumidor().is_empty(), "{d}");
        }
        assert_eq!(CaixaDialeto::Pacote.palavra_canonica(), "defcaixa");
        assert_eq!(CaixaDialeto::Molde.palavra_canonica(), "defmolde");
        assert_ne!(
            CaixaDialeto::Pacote.palavra_canonica(),
            CaixaDialeto::Molde.palavra_canonica(),
            "the two dialects must not share a canonical keyword — that IS the defect"
        );
    }

    #[test]
    fn caixa_dialeto_all_enumerates_every_variant_exactly_once() {
        // Three-legged exhaustiveness pin, peer of the sibling
        // `caixa_kind_all_enumerates_every_variant_exactly_once`
        // (caixa-core/src/kind.rs) /
        // `restart_strategy_all_enumerates_every_variant_exactly_once`
        // (caixa-core/src/supervisor.rs) shape.
        //
        // 1. arm-count invariant: `ALL.len()` matches the declared arm
        //    count (four — a fifth arm added without extending `ALL`
        //    fails this pin at caixa-core test time);
        // 2. pairwise-distinctness invariant: every variant appears at
        //    most once in the slice (a duplicate arm would silently
        //    double-count in the census consumer, so the pin rejects
        //    duplicates outright);
        // 3. coverage invariant: every literal `CaixaDialeto::X` is in
        //    the slice (the compiler-checked exhaustiveness on the peer
        //    per-arm `match self` in the accessors keeps the enum arm
        //    set and the `ALL` slice mutually aligned).
        assert_eq!(
            CaixaDialeto::ALL.len(),
            4,
            "ALL must list every arm exactly once; a fifth arm added \
             without extending ALL fails this pin — extend ALL alongside \
             the new variant"
        );

        let mut seen: Vec<CaixaDialeto> = Vec::new();
        for &d in CaixaDialeto::ALL {
            assert!(
                !seen.contains(&d),
                "ALL contains a duplicate arm: {d}. Every variant appears \
                 exactly once — a duplicate would double-count in every \
                 iteration consumer"
            );
            seen.push(d);
        }

        // Coverage: exhaustively assert every literal variant is somewhere
        // in the slice. Written as an exhaustive `match` so a future arm
        // addition fails to compile here (missing match arm) until the
        // corresponding `assert` is added — the compiler enforces the pin's
        // completeness rather than a hand-maintained variant list.
        for variant in [
            CaixaDialeto::Pacote,
            CaixaDialeto::Molde,
            CaixaDialeto::MoldePosicional,
            CaixaDialeto::Desconhecido,
        ] {
            let coverage_probe = match variant {
                CaixaDialeto::Pacote
                | CaixaDialeto::Molde
                | CaixaDialeto::MoldePosicional
                | CaixaDialeto::Desconhecido => variant,
            };
            assert!(
                CaixaDialeto::ALL.contains(&coverage_probe),
                "ALL is missing variant {coverage_probe} — extend the slice"
            );
        }
    }

    #[test]
    fn caixa_dialeto_all_is_const_and_matches_iteration_count() {
        // Pins the const-ness of the slice at const-fold time. A future
        // change that promoted `ALL` to a non-const initializer (a lazy-
        // static, a runtime-computed Vec) would fail to compile here —
        // the pin locks in the compile-time-known iteration surface
        // every consumer builds against. Peer of the sibling
        // `caixa_kind_all_is_const_and_matches_iteration_count` (kind.rs)
        // / `restart_strategy_all_is_const_and_matches_iteration_count`
        // (supervisor.rs) shape.
        const ALL: &[CaixaDialeto] = CaixaDialeto::ALL;
        assert_eq!(ALL.len(), CaixaDialeto::ALL.len());
        // Sweep the iterator without collapsing to `.len()` so a future
        // change to `ALL`'s carrier that decouples `.len()` from the
        // iteration count (a lazy-computed shape, an alias `impl Iterator`
        // return, a wrapper newtype) still passes here iff the two agree
        // arm-for-arm; the `#[allow]` opts this local pin out of the
        // clippy `iter_count` collapse that would defeat the intent.
        #[allow(clippy::iter_count)]
        let iterated = ALL.iter().count();
        assert_eq!(iterated, CaixaDialeto::ALL.len());
    }

    #[test]
    fn caixa_dialeto_all_covers_every_variant_by_display_probe() {
        // Fanning `Display` over the slice sweeps the paired accessors
        // ([`CaixaDialeto::palavra_canonica`] / [`CaixaDialeto::consumidor`]
        // / [`CaixaDialeto::descricao`]) at every arm — every returned
        // byte-string is non-empty (the accessors' contract). A future
        // arm added without extending its per-arm `match self` return
        // would compile-fail at the accessor call inside the loop;
        // together with the `ALL.len() == 4` pin above, this locks the
        // accessor arm-set and the `ALL` slice mutually.
        for &d in CaixaDialeto::ALL {
            let display_form = d.to_string();
            assert!(
                !display_form.is_empty(),
                "Display must render a non-empty byte-string for every \
                 arm; empty: {d:?}"
            );
            // Consumidor / descricao / palavra-canonica must each surface
            // a non-empty scalar; every downstream diagnostic consumer
            // reaches through these accessors.
            assert!(!d.palavra_canonica().is_empty(), "{d}");
            assert!(!d.consumidor().is_empty(), "{d}");
            assert!(!d.descricao().is_empty(), "{d}");
        }
    }

    #[test]
    fn caixa_dialeto_as_str_returns_pascal_case_variant_name() {
        // Fail-before-pass-after per-arm shape pin: the four
        // [`CaixaDialeto::as_str`] arms must return the canonical
        // `PascalCase` byte-string that names the variant. Pre-lift this
        // byte-string existed only inside the hand-rolled Display impl's
        // four-arm literal-string match — every consumer that wanted the
        // `PascalCase` name reached through `format!("{d}")`'s allocation
        // path. Pinning the four arms explicitly here refuses a future
        // regression that ever reroutes an arm to a distinct spelling
        // (`"pacote"` lowercase, `"MoldePositional"` English rebrand,
        // `"Unknown"` for `Desconhecido`) — the census output and the
        // typed accessor would silently disagree until a downstream
        // consumer surfaced the drift at census time. Peer of the sibling
        // [`crate::supervisor::tests::restart_strategy_variants_serialize_to_lifted_scalar_values`]
        // / `placement_strategy_variants_serialize_to_lifted_scalar_values`
        // / `caixa_kind_as_str_returns_lifted_peer_const` shape on the
        // sibling closed-set typed-enum discriminator axes — the seventh
        // (and last unlifted) closed-set typed enum on the caixa surface
        // to converge onto the same per-arm-shape-pin discipline.
        for (variant, expected) in [
            (CaixaDialeto::Pacote, "Pacote"),
            (CaixaDialeto::Molde, "Molde"),
            (CaixaDialeto::MoldePosicional, "MoldePosicional"),
            (CaixaDialeto::Desconhecido, "Desconhecido"),
        ] {
            assert_eq!(
                variant.as_str(),
                expected,
                "CaixaDialeto::{variant:?}.as_str() must return the \
                 canonical `PascalCase` variant-name byte-string; drift here \
                 splits the census-facing text from the substrate \
                 primitive every downstream consumer will read"
            );
        }
    }

    #[test]
    fn caixa_dialeto_wire_names_covers_every_arm() {
        // Load-bearing pin on the substrate-canonical
        // [`super::CaixaDialeto::WIRE_NAMES`] exhaustive accept-set
        // roster on the `PascalCase` variant-name wire-form axis: every
        // variant of the sibling [`super::CaixaDialeto::ALL`] exhaustive-
        // iteration surface must project through
        // [`super::CaixaDialeto::as_str`] onto an entry the
        // [`super::CaixaDialeto::WIRE_NAMES`] roster carries, and the
        // roster's length must byte-equal `super::CaixaDialeto::ALL.len()`
        // so a silent skew between the [`super::CaixaDialeto::as_str`]
        // match's arm-set and the roster's arm-set trips here at
        // caixa-core test time rather than at a downstream `feira dialeto
        // --list-dialects` per-arm listing / M4 admission-webhook
        // rejection-body accepted-tag enumeration miss / structured-log
        // accepted-wire-form emit drift.
        //
        // A future arm addition (the module doc's "third dialect"
        // hazard actualising as a fifth arm — a third arity variant, an
        // alias-declaration family `pleme-doc-gen` sharpens as its
        // schema evolves) extends [`super::CaixaDialeto::ALL`] as a
        // single edit and this pin sweeps the new arm by iteration; the
        // paired [`super::CaixaDialeto::WIRE_NAMES`] roster must grow in
        // lockstep or this assertion trips. Every entry is further
        // pinned to open with an uppercase ASCII byte (matching the
        // substrate-wide `PascalCase` convention every peer closed-set
        // enum whose canonical projection is a `PascalCase` census-
        // facing name carries), so a silent collapse of the dialect-
        // classification wire-form axis with any hypothetical lowercase-
        // kebab peer wire-form axis (an entry byte-identical to a
        // sibling lowercase-Portuguese label that would let a wire-axis
        // consumer accept the diagnostic byte-string) trips here rather
        // than at a downstream census-report round-trip miss.
        //
        // Peer of the sibling
        // [`crate::kind::tests::caixa_kind_wire_names_covers_every_arm`]
        // (bd708bd) /
        // [`crate::kind::tests::caixa_kind_labels_covers_every_arm`]
        // (427fe75) /
        // [`crate::supervisor::tests::restart_strategy_wire_names_covers_every_arm`]
        // (3033f45) /
        // [`crate::supervisor::tests::restart_policy_wire_names_covers_every_arm`]
        // (ce9412b) /
        // [`crate::aplicacao::tests::placement_strategy_wire_names_covers_every_arm`]
        // (3e5b194) /
        // [`crate::aplicacao::tests::wit_shape_labels_covers_every_arm`]
        // (9d9f585) /
        // [`crate::aplicacao::tests::rate_limit_unit_suffixes_covers_every_arm`]
        // (b553ec9) /
        // [`crate::upgrade::tests::upgrade_instruction_lisp_forms_covers_every_arm`]
        // (1898d77) /
        // [`crate::upgrade::tests::upgrade_instruction_wire_forms_covers_every_arm`]
        // (cc42c0e) /
        // [`crate::dep::tests::dep_list_author_keys_covers_every_arm`]
        // (af6ad3a) /
        // [`crate::render::tests::path_shape_violation_wire_names_covers_every_arm`]
        // (0330bd3) pins — the same closed-set exhaustive-roster
        // coverage discipline extended here onto the tatara-lisp
        // dialect-classification closed-set typed enum, the eleventh
        // substrate-side closed-set typed enum on the roster axis and
        // the first dialect-classification axis to converge onto the
        // discipline.
        //
        // Fail-before-pass-after locally verified by mutating one arm
        // of the paired `CAIXA_DIALETO_WIRE_*` const family (e.g.
        // rebranding `CAIXA_DIALETO_WIRE_MOLDE_POSICIONAL` from
        // `"MoldePosicional"` to `"MoldePositional"`) — the length pin
        // still passes but the `contains` check fires on the mutated
        // arm; and by shortening the roster to three entries — the
        // length pin fires first.
        assert_eq!(
            CaixaDialeto::WIRE_NAMES.len(),
            CaixaDialeto::ALL.len(),
            "CaixaDialeto::WIRE_NAMES.len() must byte-equal \
             CaixaDialeto::ALL.len() — a mismatch means the roster and \
             the enum's arm-set have drifted; downstream consumers that \
             fan through both will silently disagree on the accepted \
             arm-set"
        );
        for &variant in CaixaDialeto::ALL {
            let wire = variant.as_str();
            assert!(
                CaixaDialeto::WIRE_NAMES.contains(&wire),
                "CaixaDialeto::{variant:?}.as_str() = {wire:?} must be \
                 a member of CaixaDialeto::WIRE_NAMES — the emitter and \
                 the roster have drifted out of lockstep"
            );
        }
        for tag in CaixaDialeto::WIRE_NAMES {
            let first = tag.chars().next().unwrap_or_else(|| {
                panic!(
                    "CaixaDialeto::WIRE_NAMES entry {tag:?} must be a \
                     non-empty `PascalCase` variant-name byte-string"
                )
            });
            assert!(
                first.is_ascii_uppercase(),
                "CaixaDialeto::WIRE_NAMES entry {tag:?} must open with \
                 an uppercase ASCII byte (matching the substrate-wide \
                 `PascalCase` convention) — an entry opening with a \
                 lowercase byte would collide the roster with any \
                 hypothetical peer lowercase-kebab wire-form axis a \
                 downstream consumer might disambiguate against"
            );
        }
        // Pin the exact four-arm roster in declaration order so a
        // future arm-swap on either the roster or the paired
        // `CAIXA_DIALETO_WIRE_*` constants (a rebrand of the arm-tag
        // mapping that leaves both the length pin and the membership
        // pin passing on their own) trips at caixa-core test time
        // under `assert_eq!`. Order matches variant declaration order
        // verbatim (`Pacote` → `Molde` → `MoldePosicional` →
        // `Desconhecido`) so the roster is the canonical ordering
        // every listing / rendering consumer defers to. Same
        // declaration-order pin the sibling
        // [`crate::render::tests::path_shape_violation_wire_names_covers_every_arm`]
        // (0330bd3) closes on the render-side path-shape-diagnostic
        // axis.
        assert_eq!(
            CaixaDialeto::WIRE_NAMES,
            &[
                CAIXA_DIALETO_WIRE_PACOTE,
                CAIXA_DIALETO_WIRE_MOLDE,
                CAIXA_DIALETO_WIRE_MOLDE_POSICIONAL,
                CAIXA_DIALETO_WIRE_DESCONHECIDO,
            ],
            "CaixaDialeto::WIRE_NAMES must enumerate every arm's wire-\
             form tag exactly once, in variant declaration order \
             (Pacote → Molde → MoldePosicional → Desconhecido)"
        );
        // Byte-parity pin on the paired reverse projection: every
        // entry in the roster must round-trip cleanly through
        // [`super::CaixaDialeto::from_wire`] back to the same arm the
        // [`super::CaixaDialeto::as_str`] emitter returned it for.
        // Refuses any future de-lift that swaps the four consts through
        // the reverse projection out of lockstep with the forward
        // emitter (a mid-arm rebrand touching only `as_str` but not
        // `from_wire`, an argument-ordering swap on one of the match
        // arms, a stray `to_lowercase` normalization on either side
        // that would silently pass the identity round-trip on the
        // already-PascalCase corpus but split the two projections on
        // any future non-PascalCase input).
        for (&variant, tag) in CaixaDialeto::ALL.iter().zip(CaixaDialeto::WIRE_NAMES) {
            assert_eq!(
                CaixaDialeto::from_wire(tag),
                Some(variant),
                "CaixaDialeto::from_wire({tag:?}) must round-trip back \
                 to CaixaDialeto::{variant:?} — emitter and parser have \
                 drifted off the paired CAIXA_DIALETO_WIRE_* const family"
            );
        }
    }

    #[test]
    fn caixa_dialeto_display_routes_through_as_str_helper() {
        // Fail-before-pass-after convergence pin: for every arm in
        // [`CaixaDialeto::ALL`], the [`std::fmt::Display`] rendered form
        // must byte-equal [`CaixaDialeto::as_str`]'s return value. Pre-
        // lift these two paths were structurally independent — the
        // Display impl hand-rolled its own four-arm literal-string
        // match with no compile-time link back to any substrate accessor
        // — so a future variant rename could land at `Display` without
        // touching a paired accessor (or vice versa), silently splitting
        // the two paths on the renamed arm. Pinning the byte-equality
        // here makes any such split a caixa-core build-time failure at
        // this test rather than surfacing far from the rename commit as
        // a downstream census consumer emitting one spelling while the
        // typed accessor returned another. Peer of the sibling
        // [`crate::kind::tests::caixa_kind_display_routes_through_as_str_helper`]
        // (which pins the same convergence on the [`crate::CaixaKind`]
        // closed-set axis) — extends the discipline onto the seventh
        // (and last unlifted) closed-set fieldless typed enum on the
        // caixa surface.
        for &variant in CaixaDialeto::ALL {
            assert_eq!(
                variant.to_string(),
                variant.as_str(),
                "CaixaDialeto::{variant:?} Display must route through \
                 CaixaDialeto::as_str (single source of truth: the \
                 lifted per-arm `PascalCase` variant-name byte-string)"
            );
        }
    }

    #[test]
    fn caixa_dialeto_as_ref_str_routes_through_as_str_accessor() {
        // Fail-before-pass-after byte-parity pin on the lifted
        // `impl AsRef<str> for CaixaDialeto` — asserts the standard-
        // library trait impl and the substrate-primitive
        // [`CaixaDialeto::as_str`] `pub const fn` accessor resolve to
        // the same `&str` per instance across the four-arm closed set,
        // so any future silent detour that routes the impl through a
        // divergent projection (a per-arm inline
        // `match self { CaixaDialeto::Pacote => "Pacote", … }` re-inlining
        // that opens a compile-time link to the un-lifted arm-literal,
        // a swap onto the second-axis
        // [`CaixaDialeto::palavra_canonica`] /
        // [`CaixaDialeto::consumidor`] / [`CaixaDialeto::descricao`]
        // accessors that carry distinct byte-shapes per axis) trips at
        // caixa-core test time under `PartialEq` rather than at a
        // downstream `impl AsRef<str>`-bound consumer's silent split.
        // Sweeps every one of the four arms [`CaixaDialeto::ALL`]
        // carries so no arm's projection is covered only by the sibling
        // `Display` path. Peer of the sibling
        // `rate_limit_unit_as_ref_str_routes_through_as_suffix_accessor`
        // (d8136db) on the M3 `:politicas :rate-limit` closed-set typed
        // enum, and the peer
        // [`crate::kind::tests::caixa_kind_as_ref_str_routes_through_as_str_accessor`]
        // (cd2091f) pin on the top-level closed-set typed
        // discriminator — the pins together close the substrate
        // primitive's `AsRef<str>` projection axis onto the seventh
        // closed-set fieldless typed enum on the caixa surface.
        for &variant in CaixaDialeto::ALL {
            assert_eq!(
                <CaixaDialeto as AsRef<str>>::as_ref(&variant),
                variant.as_str(),
                "AsRef<str> impl on CaixaDialeto::{variant:?} must \
                 byte-equal CaixaDialeto::as_str on the same instance \
                 — divergence signals a silent detour off the \
                 substrate-primitive accessor"
            );
        }
    }

    #[test]
    fn caixa_dialeto_as_ref_str_routes_through_display_via_shared_accessor() {
        // Fail-before-pass-after byte-parity pin on the three-path
        // convergence discipline the [`CaixaDialeto`] closed-set
        // dialect-classification enum now carries on the `&str`-
        // projection axis: `<CaixaDialeto as AsRef<str>>::as_ref(&v)`
        // (the newly lifted impl), `format!("{v}")` (the pre-existing
        // [`fmt::Display`] impl), and `v.as_str()` (the substrate-
        // primitive `pub const fn` accessor both trait impls delegate
        // through) must resolve to the same byte-string on every
        // instance across the four-arm closed set. Refuses any future
        // divergence between the two trait impls (a stray
        // [`fmt::Display::fmt`] rewrite that hand-rolls the arms
        // rather than delegating through the shared accessor; a
        // hypothetical `AsRef<str>` rewrite that inlines a per-arm
        // literal cascade) that would silently split the two
        // projection paths of the same closed-set typed enum. Mirrors
        // the sibling three-path-convergence discipline the peer
        // [`crate::aplicacao::RateLimitUnit`] typed enum carries
        // (`rate_limit_unit_as_ref_str_routes_through_display_via_shared_accessor`,
        // d8136db), the peer [`crate::CaixaKind`] triple
        // (`caixa_kind_as_ref_str_routes_through_display_via_shared_accessor`,
        // cd2091f), and the [`crate::CaixaVersion`] typed newtype
        // triple (`caixa_version_as_ref_str_routes_through_display_via_shared_accessor`,
        // 16d5c7e).
        for &variant in CaixaDialeto::ALL {
            let via_as_ref: &str = <CaixaDialeto as AsRef<str>>::as_ref(&variant);
            let via_display: String = format!("{variant}");
            let via_accessor: &str = variant.as_str();
            assert_eq!(via_as_ref, via_accessor);
            assert_eq!(via_display, via_accessor);
            assert_eq!(via_as_ref, via_display.as_str());
        }
    }

    #[test]
    fn caixa_dialeto_is_molde_family_returns_true_on_molde_and_positional_arms() {
        // Fail-before-pass-after per-arm shape pin on the two `defmolde`
        // declaration-family arms: [`CaixaDialeto::is_molde_family`] must
        // return `true` for [`CaixaDialeto::Molde`] and
        // [`CaixaDialeto::MoldePosicional`] — the two-arity closure of
        // one declaration ([`CaixaDialeto::MoldePosicional`]'s docstring:
        // "same declaration as [`Self::Molde`], written with the package
        // name as a bare positional symbol … one arity of one
        // declaration, not a third schema"). A future accidental flip that
        // reversed a per-arm arm's return without touching the paired
        // false-arm pin would silently open the substrate primitive to
        // false-positive on either arm — the `feira dialeto` verb's
        // `--strict-palavra` gate would then silently accept
        // repo-surface declarations under `(defcaixa …)` on one arm and
        // reject them on the other. Pinning the two true arms explicitly
        // here refuses that split at caixa-core build time.
        assert!(
            CaixaDialeto::Molde.is_molde_family(),
            "CaixaDialeto::Molde.is_molde_family() must return true — \
             Molde is the primary `defmolde` arm"
        );
        assert!(
            CaixaDialeto::MoldePosicional.is_molde_family(),
            "CaixaDialeto::MoldePosicional.is_molde_family() must return \
             true — MoldePosicional is the positional-arity form of the \
             same `defmolde` declaration Molde carries"
        );
    }

    #[test]
    fn caixa_dialeto_is_molde_family_returns_false_on_pacote_and_desconhecido_arms() {
        // Fail-before-pass-after per-arm shape pin on the two non-`defmolde`
        // arms: [`CaixaDialeto::is_molde_family`] must return `false` for
        // [`CaixaDialeto::Pacote`] (the sibling `defcaixa` tatara-lisp
        // package manifest, `palavra_canonica → "defcaixa"`) and for
        // [`CaixaDialeto::Desconhecido`] (the residue that names no
        // known declaration, `palavra_canonica → "?"`). Pinning the two
        // false arms explicitly here refuses a future accidental flip
        // that let the predicate widen to include either arm — the
        // `feira dialeto` verb's `--strict-palavra` gate would then
        // spuriously refuse every `(defcaixa …)` package manifest as if
        // it were a repo-surface declaration.
        assert!(
            !CaixaDialeto::Pacote.is_molde_family(),
            "CaixaDialeto::Pacote.is_molde_family() must return false — \
             Pacote is the `defcaixa` tatara-lisp package manifest, not \
             the `defmolde` repo-surface declaration"
        );
        assert!(
            !CaixaDialeto::Desconhecido.is_molde_family(),
            "CaixaDialeto::Desconhecido.is_molde_family() must return \
             false — the residue arm names no known declaration; it is \
             not silently promoted into the `defmolde` family"
        );
    }

    #[test]
    fn caixa_dialeto_is_molde_family_agrees_with_palavra_canonica_defmolde_projection() {
        // Load-bearing pin: for every arm in [`CaixaDialeto::ALL`], the
        // typed [`CaixaDialeto::is_molde_family`] predicate must agree
        // byte-for-byte with the paired [`CaixaDialeto::palavra_canonica`]
        // projection's `== "defmolde"` classifier — i.e. the two paths
        // partition the four-arm discriminator set into the same
        // `{Molde, MoldePosicional}` and `{Pacote, Desconhecido}` halves.
        // Pre-lift the sibling [`CaixaDialeto::palavra_canonica`] projection
        // (which returns `"defmolde"` for `Molde | MoldePosicional`,
        // `"defcaixa"` for `Pacote`, `"?"` for `Desconhecido`) was the
        // only substrate-side surface carrying the two-arm collapse; the
        // hand-rolled `matches!(d, CaixaDialeto::Molde |
        // CaixaDialeto::MoldePosicional)` sites in the `feira dialeto`
        // verb expressed no compile-time link back to it. A future arm
        // addition — the module doc's "third dialect" hazard actualises
        // as a fifth arm belonging to the `defmolde` family — would land
        // one match arm at [`Self::palavra_canonica`]'s `defmolde` return
        // (extending the sibling projection) but silently split the
        // hand-rolled two-arm `matches!` predicate sites if the new arm's
        // `is_molde_family` return were forgotten. Pinning byte-equality
        // between the two paths here makes any such split a caixa-core
        // build-time failure at this test rather than surfacing far from
        // the arm-addition commit as a downstream `--strict-palavra` /
        // `caixa.lisp`-holds-wrong-declaration gate silently ignoring the
        // new arm.
        for &d in CaixaDialeto::ALL {
            let via_palavra_canonica = d.palavra_canonica() == "defmolde";
            let via_is_molde_family = d.is_molde_family();
            assert_eq!(
                via_is_molde_family, via_palavra_canonica,
                "CaixaDialeto::{d:?}.is_molde_family() ({via_is_molde_family}) \
                 must agree with CaixaDialeto::{d:?}.palavra_canonica() == \
                 \"defmolde\" ({via_palavra_canonica}) — a split between the \
                 typed predicate and the sibling keyword projection would let \
                 a future arm addition land at one path and drift at the other, \
                 which is exactly the drift this pin refuses"
            );
        }
    }

    #[test]
    fn caixa_dialeto_is_molde_family_is_const_fn() {
        // Const-context pin: [`CaixaDialeto::is_molde_family`] must remain
        // `const fn` (its match is a fieldless-arm literal-pattern
        // discriminator, so no non-const operation exists on the resolution
        // path). Downstream consumers reaching for the predicate from a
        // `const` context (a future substrate-wide const-fold-driven audit
        // table that materializes per-arm gate-membership at build time,
        // a per-arm CR-admission-webhook gate registration in a `const`
        // context) rely on the const-ness. A future accidental downgrade
        // to non-`const` (an added runtime helper reachable only from a
        // non-`const` context) trips at caixa-core build time rather than
        // surfacing as a downstream `const`-context regression far from
        // the predicate declaration. Peer of the sibling
        // [`caixa_dialeto_as_str_is_const_fn`] pin on the paired
        // [`CaixaDialeto::as_str`] byte-string axis.
        const ARMS: [(CaixaDialeto, bool); 4] = [
            (CaixaDialeto::Pacote, CaixaDialeto::Pacote.is_molde_family()),
            (CaixaDialeto::Molde, CaixaDialeto::Molde.is_molde_family()),
            (
                CaixaDialeto::MoldePosicional,
                CaixaDialeto::MoldePosicional.is_molde_family(),
            ),
            (
                CaixaDialeto::Desconhecido,
                CaixaDialeto::Desconhecido.is_molde_family(),
            ),
        ];
        // Materialize the const-fold-evaluated table into a runtime slice
        // assertion — carries the same `bool = const fn call` shape a raw
        // `assert!(const_bool)` would, without tripping the
        // `assertions_on_constants` clippy lint that a per-arm
        // `assert!(CONST)` on a `const bool` triggers when the arm-count
        // is enumerated flat rather than compared as a whole-table shape.
        assert_eq!(
            ARMS,
            [
                (CaixaDialeto::Pacote, false),
                (CaixaDialeto::Molde, true),
                (CaixaDialeto::MoldePosicional, true),
                (CaixaDialeto::Desconhecido, false),
            ],
            "CaixaDialeto::is_molde_family() must evaluate in const context \
             for every arm and land on the {{false, true, true, false}} \
             partition — a future accidental downgrade to non-`const` \
             would trip the const-context array-initializer here"
        );
    }

    #[test]
    fn caixa_dialeto_as_str_is_const_fn() {
        // Const-context pin: [`CaixaDialeto::as_str`] must remain
        // `const fn` (its match arms return `pub const` byte-strings, so
        // no non-const operation exists on the resolution path).
        // Downstream consumers reaching for the accessor from a `const`
        // context (a future substrate-wide const-fold-driven audit table
        // that materializes every dialect's census label at build time,
        // a per-arm CR-admission-webhook message registration in a
        // `const` gate) rely on the const-ness. A future accidental
        // downgrade to non-`const` (an added runtime helper reachable
        // only from a non-`const` context, a manual hand-rolled `impl`
        // that shadows this method) trips at caixa-core build time
        // rather than surfacing as a downstream `const`-context
        // regression far from the accessor declaration. Peer of the
        // sibling [`crate::kind::tests::caixa_kind_wire_name_is_const_fn`]
        // pin on the paired [`crate::CaixaKind`] byte-string axis.
        const PACOTE: &str = CaixaDialeto::Pacote.as_str();
        const MOLDE: &str = CaixaDialeto::Molde.as_str();
        const MOLDE_POSICIONAL: &str = CaixaDialeto::MoldePosicional.as_str();
        const DESCONHECIDO: &str = CaixaDialeto::Desconhecido.as_str();
        assert_eq!(PACOTE, "Pacote");
        assert_eq!(MOLDE, "Molde");
        assert_eq!(MOLDE_POSICIONAL, "MoldePosicional");
        assert_eq!(DESCONHECIDO, "Desconhecido");
    }

    #[test]
    fn caixa_dialeto_is_variant_predicates_partition_the_arm_set() {
        // Fail-before-pass-after pin on the [`gen_platform::IsVariant`]
        // derive: for each of the four variants at [`CaixaDialeto::ALL`]`[idx]`
        // the observed four-slot predicate row must equal a one-hot row
        // with the `true` at exactly `idx`. Pre-derive the closed four-arm
        // dialect-classification partition lived only inside the paired
        // per-arm projections' four-arm match resolvers ([`Self::as_str`] /
        // [`Self::palavra_canonica`] / [`Self::consumidor`] /
        // [`Self::descricao`]) plus the two-arm [`Self::is_molde_family`]
        // hand-rolled `matches!` (now routed through the derived
        // predicates); a future rebrand (an accidental
        // `#[is_variant(name = "…")]` drift, a manual hand-rolled `impl`
        // that shadows the derive-generated method, an arm rename that
        // reroutes one arm through the wrong predicate lane) trips this
        // pin at caixa-core build time rather than surfacing far from the
        // derive declaration as a downstream [`Self::is_molde_family`]
        // consumer accepting the wrong arm-set. The expected row is
        // generated live from the [`Self::ALL`] declaration order rather
        // than transcribed by hand so a copy-paste flip reroutes at the
        // identity-diagonal assertion.
        //
        // Peer of the sibling
        // [`crate::kind::tests::caixa_kind_is_variant_predicates_partition_the_arm_set`]
        // / [`crate::supervisor::tests::restart_strategy_is_variant_predicates_partition_the_arm_set`]
        // / [`crate::aplicacao::tests::placement_strategy_is_variant_predicates_partition_the_arm_set`]
        // / [`crate::upgrade::tests::upgrade_instruction_is_variant_predicates_partition_the_arm_set`]
        // pins on the sibling closed-set typed-enum discriminator axes.
        for (idx, &variant) in CaixaDialeto::ALL.iter().enumerate() {
            let observed = [
                variant.is_pacote(),
                variant.is_molde(),
                variant.is_molde_posicional(),
                variant.is_desconhecido(),
            ];
            let mut expected = [false; 4];
            expected[idx] = true;
            assert_eq!(
                observed, expected,
                "CaixaDialeto::{variant:?} at ALL[{idx}] is_* predicates \
                 must fire only on their own arm lane (identity diagonal); \
                 got {observed:?}",
            );
        }
    }

    #[test]
    fn caixa_dialeto_is_variant_predicates_are_const_fn() {
        // The [`gen_platform::IsVariant`] derive emits `const fn`
        // predicates on the peer [`crate::CaixaKind`] +
        // [`crate::upgrade::UpgradeInstruction`] +
        // [`crate::supervisor::RestartStrategy`] +
        // [`crate::supervisor::RestartPolicy`] +
        // [`crate::aplicacao::PlacementStrategy`] +
        // [`crate::aplicacao::RateLimitUnit`] +
        // [`crate::dep::DepList`] closed-set typed enums — pin the same
        // posture on [`CaixaDialeto`] so a future accidental downgrade
        // to non-`const` (an added runtime helper reachable only from a
        // non-`const` context, a manual hand-rolled `impl` that shadows
        // the derive-generated method) trips at caixa-core build time
        // rather than surfacing as a downstream `const`-context
        // regression far from the derive declaration.
        // Use `const { assert!(…) }` (peer of the sibling
        // [`crate::render::PathShapeViolation`] +
        // [`crate::aplicacao::RateLimitUnit`] +
        // [`caixa_theme::style::Semantic`] const-fn pins) so the
        // const-context evaluation trips at const-fold time without
        // opening a per-`const bool` `assertions_on_constants` clippy
        // debt row this crate does not carry today for `dialeto.rs`.
        const { assert!(CaixaDialeto::Pacote.is_pacote()) };
        const { assert!(CaixaDialeto::Molde.is_molde()) };
        const { assert!(CaixaDialeto::MoldePosicional.is_molde_posicional()) };
        const { assert!(CaixaDialeto::Desconhecido.is_desconhecido()) };
    }

    #[test]
    fn caixa_dialeto_from_wire_accepts_every_as_str_output() {
        // Fail-before-pass-after per-arm accept pin on the newly lifted
        // [`CaixaDialeto::from_wire`] reverse projection: every arm in
        // [`CaixaDialeto::ALL`] must parse back through `from_wire` when
        // fed its own [`CaixaDialeto::as_str`] output, landing on
        // `Some(same_variant)` — a regression that hand-rolled either
        // side's per-arm match without threading through the shared
        // four-string closed set would silently disagree on any future
        // arm rename and this pin flags it at caixa-core build time.
        // Peer of the sibling
        // [`crate::kind::tests::caixa_kind_wire_round_trips_through_from_wire`]
        // (2aa6d23) /
        // `placement_strategy_from_wire_accepts_every_lifted_constant`
        // (18c7342) /
        // `dep_list_round_trips_through_as_str_and_from_wire` (45ee563)
        // shape on the sibling closed-set typed-enum reverse-projection
        // axes.
        for &variant in CaixaDialeto::ALL {
            let wire = variant.as_str();
            let parsed = CaixaDialeto::from_wire(wire).unwrap_or_else(|| {
                panic!(
                    "CaixaDialeto::from_wire({wire:?}) must accept every \
                     CaixaDialeto::as_str output — got None for the \
                     wire byte-string of {variant:?}"
                )
            });
            assert_eq!(
                parsed, variant,
                "CaixaDialeto::from_wire(CaixaDialeto::{variant:?}.as_str()) \
                 must return CaixaDialeto::{variant:?} — the (as_str, \
                 from_wire) pair must form a total round-trip on the \
                 closed four-arm CaixaDialeto arm-set"
            );
        }
    }

    #[test]
    fn caixa_dialeto_from_wire_rejects_unknown_byte_strings() {
        // Rejection pin on the parser's accept-set: any string outside
        // the four-arm [`CaixaDialeto::as_str`] output set must return
        // `None`. A future accidental widening of the accept-set (a
        // case-insensitive match that accepts `"pacote"` on the wire
        // axis, a hand-rolled Levenshtein-forgiving arm-lookup that
        // admits `"Pacotee"` typos, a silent acceptance of the sibling
        // [`Self::palavra_canonica`] `"defcaixa"` / `"defmolde"`
        // byte-shapes on this axis) would silently drift the parser's
        // accept-set from the emitter's — a downstream audit-report
        // re-loader that bound a prior audit's [`Self::as_str`] output
        // back to the typed enum through this parser would then bind a
        // malformed byte-string to a plausibly-wrong typed arm the
        // caller does not route through any fallback, silently
        // misclassifying the reloaded row. Also rejects the sibling
        // [`Self::palavra_canonica`] (`"defcaixa"` / `"defmolde"`) and
        // the sibling [`Self::consumidor`] (`"caixa-core / feira"`,
        // `"pleme-doc-gen"`, `"nobody known"`) byte-shapes, which are
        // the substrate's *distinct-axis* projections on the same enum
        // — the two-axis split the sibling
        // [`Self::palavra_canonica`] / [`Self::consumidor`] /
        // [`Self::descricao`] docstrings explicitly frame forbids
        // accepting one axis's byte-shapes as parseable on the other
        // axis. Peer of the sibling
        // [`crate::kind::tests::caixa_kind_from_wire_rejects_unknown_byte_strings`]
        // (2aa6d23) /
        // `placement_strategy_from_wire_rejects_unknown_byte_strings`
        // (18c7342) /
        // `dep_list_from_wire_returns_none_on_unknown_wire_scalar`
        // (45ee563) rejection pins on the sibling closed-set typed-enum
        // reverse-projection axes.
        for bad in [
            "",
            " ",
            "pacote",
            "PACOTE",
            "molde",
            "MoldePositional",
            "desconhecido",
            "Unknown",
            "defcaixa",
            "defmolde",
            "?",
            "caixa-core / feira",
            "pleme-doc-gen",
            "nobody known",
            "Pacote ",
            " Pacote",
        ] {
            assert!(
                CaixaDialeto::from_wire(bad).is_none(),
                "CaixaDialeto::from_wire({bad:?}) must return None — the \
                 parser's accept-set is exactly the four CaixaDialeto::as_str \
                 outputs; a widening would silently split the parser's \
                 accept-set from the emitter's arm-set"
            );
        }
    }

    #[test]
    fn cabeca_errada_ctor_matches_struct_literal_wrap() {
        // Fail-before-pass-after byte-identity pin: the lifted
        // [`DialetoError::cabeca_errada`] ctor MUST land on the exact
        // same struct-literal shape the pre-lift open-coded wire-up
        // block wrote by hand — `DialetoError::CabecaErrada {
        // encontrado: <head>.to_string() }`. A future accidental
        // divergence (`.into()` swap, per-arm constant substitution, an
        // added default field, an `.to_ascii_lowercase()` normalization
        // silently injected into the ctor body, a rebrand of the
        // `encontrado` field carrying a distinct byte-shape) trips this
        // pin at caixa-core build time rather than surfacing far from
        // the ctor declaration as a downstream `classify_form`
        // wrong-head consumer emitting one diagnostic shape while a
        // hand-written test peer opens another. Peer of the sibling
        // `unknown_byte_unit_ctor_matches_struct_literal_wrap`
        // (limits.rs; 29fac09) / `duplicate_from_ctor_matches_struct_
        // literal_wrap` (upgrade.rs; 7e52aec) shape on the sibling
        // single-slot `{ <field>: String }` envelope constructors.
        assert_eq!(
            DialetoError::cabeca_errada("defflake"),
            DialetoError::CabecaErrada {
                encontrado: "defflake".to_string(),
            },
            "DialetoError::cabeca_errada must byte-equal the pre-lift \
             open-coded struct-literal — a drift here means the ctor \
             stopped being a substrate primitive for the wrong-head \
             fallthrough site"
        );
    }

    #[test]
    fn cabeca_errada_routes_encontrado_verbatim_across_boundary_inputs() {
        // Fail-before-pass-after boundary-sweep pin: the lifted
        // [`DialetoError::cabeca_errada`] ctor MUST route its
        // `encontrado: &str` argument verbatim into the
        // [`DialetoError::CabecaErrada`] `encontrado: String` field
        // for every boundary-covering `&str` input — empty string, a
        // canonical `defcaixa`-adjacent head, a non-ASCII head, a
        // whitespace-carrying head, a Unicode-full-width head. Any
        // wrapper-side truncation, silent `.trim()`, accidental
        // `.to_ascii_lowercase()` normalization, or `.into()` divergence
        // on the ctor body surfaces here as a byte-mismatch against the
        // input rather than at a downstream
        // [`DialetoError::to_string()`] diagnostic-shape drift at a
        // wrong-head fallthrough consumer far from the ctor declaration.
        // Peer of the sibling `limits_codec_unit_only_ctors_route_unit_
        // verbatim_across_every_variant` (limits.rs; 29fac09) shape on
        // the sibling single-slot `{ <field>: String }` envelope
        // boundary-sweep discipline.
        for encontrado in [
            "",
            "defflake",
            "def-molde",
            "defcaixa ",
            " defcaixa",
            "μdefcaixa",
            "\u{00A0}defcaixa",
            "\u{3000}defcaixa",
            "def\u{2028}caixa",
        ] {
            let via_ctor = DialetoError::cabeca_errada(encontrado);
            let via_literal = DialetoError::CabecaErrada {
                encontrado: encontrado.to_string(),
            };
            assert_eq!(
                via_ctor, via_literal,
                "DialetoError::cabeca_errada({encontrado:?}) must byte- \
                 equal the open-coded struct-literal on the same input — \
                 a drift here would let the ctor silently normalize / \
                 truncate the head symbol before it reached the \
                 CabecaErrada envelope"
            );
            let DialetoError::CabecaErrada { encontrado: routed } = via_ctor else {
                panic!(
                    "DialetoError::cabeca_errada must construct the \
                     CabecaErrada arm — got a different variant on \
                     input {encontrado:?}"
                );
            };
            assert_eq!(
                routed, encontrado,
                "DialetoError::cabeca_errada must route the input \
                 {encontrado:?} verbatim into the encontrado field — \
                 any wrapper-side truncation / normalization surfaces \
                 here rather than at a downstream diagnostic shape drift"
            );
        }
    }

    #[test]
    fn classify_form_wrong_head_routes_through_cabeca_errada_ctor() {
        // Fail-before-pass-after routing pin: [`classify`]'s wrong-head
        // fallthrough site MUST construct its `Err(DialetoError::…)`
        // through the substrate-primitive [`DialetoError::cabeca_errada`]
        // ctor rather than through an open-coded struct-literal. Pre-
        // lift the wire-up hand-rolled a three-line
        // `Self::CabecaErrada { encontrado: other.to_string() }` block
        // with no compile-time link back to the substrate primitive; a
        // future accidental rebrand of the ctor body (an added
        // `.trim()` on `encontrado`, a per-arm constant prefix like
        // `"unknown-head:"`, a widening of the field into a
        // `(String, usize)` tuple carrying a caret offset) would then
        // silently split the two paths — the ctor consumers pick up
        // the new shape, the open-coded wire-up does not. Pinning
        // byte-equality between the observed `Err` and the ctor-
        // constructed `Err` refuses that split at caixa-core build
        // time rather than surfacing far from the wire-up commit as a
        // downstream diagnostic-consumer split.
        for head in ["defflake", "deffoobar", "defcaixaz", "let", "defmoldez"] {
            let src = format!("({head} :nome \"x\")");
            let observed = classify(&src);
            let via_ctor = Err(DialetoError::cabeca_errada(head));
            assert_eq!(
                observed, via_ctor,
                "classify({src:?}) must return the same Err shape as \
                 DialetoError::cabeca_errada({head:?}) — a drift here \
                 means the wire-up de-lifted its wrong-head fallthrough \
                 arm off the substrate primitive"
            );
        }
    }

    #[test]
    fn leitura_ctor_matches_tuple_literal_wrap_on_str_binding() {
        // Fail-before-pass-after byte-identity pin: the lifted
        // [`DialetoError::leitura`] ctor MUST land on the exact same
        // tuple-newtype wrap the pre-lift open-coded wire-up block wrote by
        // hand — `DialetoError::Leitura(<into-String-expr>)`. A future
        // accidental divergence (an added `.trim()` on the reader reason,
        // a per-arm constant prefix like `"tatara-lisp:"`, a widening of
        // the tuple carrying a caret offset, a rebrand of the payload
        // carrying a distinct byte-shape) trips this pin at caixa-core
        // build time rather than surfacing far from the ctor declaration
        // as a downstream [`classify`] tatara-lisp-reader consumer
        // emitting one diagnostic shape while a hand-written test peer
        // opens another. Peer of the sibling
        // `cabeca_errada_ctor_matches_struct_literal_wrap` pin above on
        // the same [`DialetoError`] envelope's wrong-head axis, and of
        // the peer `LimitsError::empty_byte_size` /
        // `LimitsError::empty_duration` (7a4b003 / 319216c) shape on the
        // sibling `(String)` single-slot tuple-newtype envelope
        // constructors.
        let reason: &str = "unclosed paren at 1:12";
        assert_eq!(
            DialetoError::leitura(reason),
            DialetoError::Leitura(reason.to_string()),
            "DialetoError::leitura must byte-equal the pre-lift open-coded \
             tuple-newtype wrap — a drift here means the ctor stopped \
             being a substrate primitive for the tatara-lisp-reader \
             fallthrough site"
        );
    }

    #[test]
    fn leitura_ctor_matches_tuple_literal_wrap_on_string_binding() {
        // Fail-before-pass-after byte-identity pin on the `String` wire-up
        // shape: the lifted [`DialetoError::leitura`] ctor MUST land on
        // the same tuple-newtype wrap when the caller passes an owned
        // `String` (the actual [`classify`] wire-up shape — `e.to_string()`
        // on a [`tatara_lisp::Error`]-carrying binding). Pins that the
        // `impl Into<String>` param covers the owned-`String` path with no
        // silent double-allocation or intermediate `&str` reslicing. Peer
        // of the sibling `_on_str_binding` pin above — together they close
        // the `impl Into<String>` bound's two authored wire-up shapes on
        // the ctor's substrate primitive.
        let reason: String = String::from("read: unexpected EOF at 3:1");
        let via_ctor = DialetoError::leitura(reason.clone());
        let via_literal = DialetoError::Leitura(reason.clone());
        assert_eq!(
            via_ctor, via_literal,
            "DialetoError::leitura must byte-equal the pre-lift open-coded \
             tuple-newtype wrap on the same owned-String fixture — a drift \
             here would let the ctor silently reshape the reader reason \
             before it reached the Leitura envelope"
        );
        let DialetoError::Leitura(routed) = via_ctor else {
            panic!(
                "DialetoError::leitura must construct the Leitura arm — \
                 got a different variant on input {reason:?}"
            );
        };
        assert_eq!(
            routed, reason,
            "DialetoError::leitura must route the input {reason:?} \
             verbatim into the tuple-newtype payload — any wrapper-side \
             truncation / normalization surfaces here rather than at a \
             downstream diagnostic shape drift"
        );
    }

    #[test]
    fn leitura_routes_reason_verbatim_across_boundary_inputs() {
        // Fail-before-pass-after boundary-sweep pin: the lifted
        // [`DialetoError::leitura`] ctor MUST route its
        // `reason: impl Into<String>` argument verbatim into the
        // [`DialetoError::Leitura`] tuple-newtype `String` payload for
        // every boundary-covering input — empty string, a canonical
        // tatara-lisp reader error, a non-ASCII reason, a
        // whitespace-carrying reason, a Unicode-full-width reason. Any
        // wrapper-side truncation, silent `.trim()`, accidental
        // `.to_ascii_lowercase()` normalization, or `.into()` divergence
        // on the ctor body surfaces here as a byte-mismatch against the
        // input rather than at a downstream [`DialetoError::to_string()`]
        // diagnostic-shape drift at a tatara-lisp-reader fallthrough
        // consumer far from the ctor declaration. Peer of the sibling
        // `cabeca_errada_routes_encontrado_verbatim_across_boundary_inputs`
        // pin above on the same [`DialetoError`] envelope's wrong-head
        // axis.
        for reason in [
            "",
            "unclosed paren at 1:12",
            "unexpected token ')'",
            "read: eof",
            " leading whitespace",
            "trailing whitespace ",
            "μnicode reason",
            "\u{00A0}NBSP-prefixed reason",
            "\u{3000}ideographic-space reason",
            "reason\u{2028}with-line-separator",
        ] {
            let via_ctor = DialetoError::leitura(reason);
            let via_literal = DialetoError::Leitura(reason.to_string());
            assert_eq!(
                via_ctor, via_literal,
                "DialetoError::leitura({reason:?}) must byte-equal the \
                 open-coded tuple-newtype wrap on the same input — a \
                 drift here would let the ctor silently normalize / \
                 truncate the reader reason before it reached the \
                 Leitura envelope"
            );
            let DialetoError::Leitura(routed) = via_ctor else {
                panic!(
                    "DialetoError::leitura must construct the Leitura \
                     arm — got a different variant on input {reason:?}"
                );
            };
            assert_eq!(
                routed, reason,
                "DialetoError::leitura must route the input {reason:?} \
                 verbatim into the tuple-newtype payload — any \
                 wrapper-side truncation / normalization surfaces here \
                 rather than at a downstream diagnostic shape drift"
            );
        }
    }

    #[test]
    fn classify_reader_error_routes_through_leitura_ctor() {
        // Fail-before-pass-after routing pin: [`classify`]'s
        // tatara-lisp-reader map-err site MUST construct its
        // `Err(DialetoError::…)` through the substrate-primitive
        // [`DialetoError::leitura`] ctor rather than through an
        // open-coded tuple-newtype wrap. Pre-lift the wire-up hand-rolled
        // a `Self::Leitura(e.to_string())` block with no compile-time
        // link back to the substrate primitive; a future accidental
        // rebrand of the ctor body (an added `.trim()` on the reader
        // reason, a per-arm constant prefix like `"tatara-lisp:"`, a
        // widening of the payload into a `(String, usize)` tuple
        // carrying a caret offset) would then silently split the two
        // paths — the ctor consumers pick up the new shape, the
        // open-coded wire-up does not. Pinning byte-equality between
        // the observed `Err` and the ctor-constructed `Err` refuses
        // that split at caixa-core build time rather than surfacing far
        // from the wire-up commit as a downstream diagnostic-consumer
        // split. Peer of the sibling
        // `classify_form_wrong_head_routes_through_cabeca_errada_ctor`
        // pin above on the same [`DialetoError`] envelope's wrong-head
        // fallthrough axis.
        //
        // The malformed sources below each name a distinct
        // tatara-lisp-reader failure shape (unclosed paren, stray close
        // paren, unterminated string), so together they sweep the
        // reader's rejection surface rather than pinning against one
        // specific error message the reader upstream is free to reword.
        for src in [
            "(defcaixa :nome \"x\"",
            "defcaixa :nome \"x\")",
            "(defcaixa :nome \"unterminated",
        ] {
            let observed = classify(src);
            let Err(DialetoError::Leitura(reason)) = observed.clone() else {
                panic!(
                    "classify({src:?}) must return the Leitura arm — got \
                     {observed:?}"
                );
            };
            let via_ctor: Result<CaixaDialeto, DialetoError> =
                Err(DialetoError::leitura(reason.clone()));
            assert_eq!(
                observed, via_ctor,
                "classify({src:?}) must return the same Err shape as \
                 DialetoError::leitura({reason:?}) — a drift here means \
                 the wire-up de-lifted its tatara-lisp-reader fallthrough \
                 arm off the substrate primitive"
            );
        }
    }

    #[test]
    fn caixa_dialeto_try_from_str_routes_through_from_wire_accessor() {
        // Fail-before-pass-after byte-parity pin on the lifted
        // `impl TryFrom<&str> for CaixaDialeto`: for every arm in
        // [`CaixaDialeto::ALL`], the `.try_into()` / `TryFrom::try_from`
        // path must resolve to the same variant the sibling
        // [`CaixaDialeto::from_wire`] resolver returns on the same
        // [`CaixaDialeto::as_str`] wire byte-string input. Pins the
        // three-path convergence discipline the [`CaixaDialeto`] closed-
        // set typed enum now carries on the `str → Self` reverse-
        // projection axis: `<CaixaDialeto as TryFrom<&str>>::try_from(s)`
        // (the newly lifted trait-idiomatic reverse projection),
        // `CaixaDialeto::from_wire(s)` (the substrate-primitive method-
        // named `Option<Self>` accessor the trait impl delegates through),
        // and the round-trip identity `variant.as_str() → variant`
        // (the four-arm closed accept-set shared between the emitter and
        // both reverse-projection consumers) must resolve to the same
        // typed [`CaixaDialeto`] discriminator on every arm.
        //
        // A future silent detour that routes the impl through a
        // divergent projection (a per-arm inline
        // `match s { "Pacote" => …, … }` re-inlining that opens a
        // compile-time link to the un-lifted arm-literal, a swap onto
        // the second-axis [`CaixaDialeto::palavra_canonica`] /
        // [`CaixaDialeto::consumidor`] / [`CaixaDialeto::descricao`]
        // accessors that carry distinct byte-shapes per axis, an accept-
        // set widening that silently accepts one axis's byte-shapes as
        // parseable on the other axis) trips at caixa-core test time
        // under `assert_eq!` rather than at a downstream
        // `TryFrom<&str>`-bound consumer's silent split. Peer of the
        // sibling
        // [`crate::kind::tests::caixa_kind_try_from_str_routes_through_from_wire_accessor`]
        // (3c83606) on the top-level [`crate::CaixaKind`] closed-set
        // discriminator's reverse-projection axis — extends the trait-
        // idiomatic reverse-projection axis onto the seventh closed-set
        // fieldless typed enum on the caixa surface (the second one to
        // carry the paired `TryFrom<&str>` impl).
        for &variant in CaixaDialeto::ALL {
            let wire = variant.as_str();
            let via_try_from: CaixaDialeto = <CaixaDialeto as TryFrom<&str>>::try_from(wire)
                .unwrap_or_else(|()| {
                    panic!(
                        "CaixaDialeto::try_from({wire:?}) must accept every \
                         CaixaDialeto::as_str output — got Err(()) for the \
                         wire byte-string of {variant:?}"
                    )
                });
            let via_from_wire: CaixaDialeto = CaixaDialeto::from_wire(wire).unwrap_or_else(|| {
                panic!(
                    "CaixaDialeto::from_wire({wire:?}) must accept every \
                     CaixaDialeto::as_str output — got None for the wire \
                     byte-string of {variant:?}"
                )
            });
            assert_eq!(
                via_try_from, variant,
                "CaixaDialeto::try_from(CaixaDialeto::{variant:?}.as_str()) \
                 must return CaixaDialeto::{variant:?} — the trait-idiomatic \
                 reverse projection must land on the same arm the method-named \
                 from_wire resolver does",
            );
            assert_eq!(
                via_try_from, via_from_wire,
                "CaixaDialeto::try_from({wire:?}) ({via_try_from:?}) must \
                 byte-equal CaixaDialeto::from_wire({wire:?}) ({via_from_wire:?}) \
                 on the same input — divergence signals a silent detour off the \
                 shared substrate-primitive resolver",
            );
            assert_eq!(
                <CaixaDialeto as TryFrom<&str>>::try_from(wire).ok(),
                CaixaDialeto::from_wire(wire),
                "the Result::ok() projection of TryFrom<&str> must byte-equal \
                 the sibling from_wire Option<Self> output on {wire:?} — the \
                 two accessors must share the same accept-set and typed \
                 outcome per arm",
            );
        }
    }

    #[test]
    fn caixa_dialeto_try_from_str_rejects_unknown_byte_strings() {
        // Rejection witness on the trait-idiomatic reverse-projection
        // axis: any string outside the four-arm [`CaixaDialeto::as_str`]
        // output set must resolve to `Err(())` through the lifted
        // [`impl TryFrom<&str> for CaixaDialeto`]. A future accidental
        // widening of the accept-set (a case-insensitive match that
        // accepts `"pacote"` on the wire axis, a hand-rolled Levenshtein-
        // forgiving arm-lookup that admits `"Pacotee"` typos, a silent
        // acceptance of the sibling [`CaixaDialeto::palavra_canonica`]
        // `"defcaixa"` / `"defmolde"` byte-shapes on this axis, a swap
        // onto the [`CaixaDialeto::consumidor`] `"pleme-doc-gen"` /
        // `"caixa-core / feira"` / `"nobody known"` byte-shapes) would
        // silently drift the trait-idiomatic parser's accept-set from
        // the sibling [`CaixaDialeto::from_wire`] resolver's — a
        // downstream `TryFrom<&str>`-bound consumer binding a malformed
        // byte-string through this impl would then bind a plausibly-
        // wrong typed arm the caller does not route through any fallback,
        // silently misclassifying the reloaded row.
        //
        // Sweeps the same rejection set the sibling
        // [`caixa_dialeto_from_wire_rejects_unknown_byte_strings`] pin
        // walks (the shared `from_wire` resolver both accessors delegate
        // through) so the trait-idiomatic axis and the method-named axis
        // stay locked to the same accept-set by construction. Peer of the
        // sibling
        // [`crate::kind::tests::caixa_kind_try_from_str_rejects_unknown_byte_strings`]
        // (3c83606) on the top-level [`crate::CaixaKind`] closed-set
        // discriminator's trait-idiomatic reverse-projection axis.
        for bad in [
            "",
            " ",
            "pacote",
            "PACOTE",
            "molde",
            "MoldePositional",
            "desconhecido",
            "Unknown",
            "defcaixa",
            "defmolde",
            "?",
            "caixa-core / feira",
            "pleme-doc-gen",
            "nobody known",
            "Pacote ",
            " Pacote",
        ] {
            assert_eq!(
                <CaixaDialeto as TryFrom<&str>>::try_from(bad),
                Err(()),
                "CaixaDialeto::try_from({bad:?}) must return Err(()) — the \
                 trait-idiomatic parser's accept-set is exactly the four \
                 CaixaDialeto::as_str outputs; a widening would silently \
                 split the trait-idiomatic reverse-projection axis from the \
                 sibling from_wire resolver's arm-set"
            );
        }
    }

    #[test]
    fn caixa_dialeto_from_str_routes_through_try_from_str_impl() {
        // Fail-before-pass-after byte-parity pin on the newly lifted
        // `impl std::str::FromStr for CaixaDialeto` — asserts the
        // standard-library `.parse()` parse-axis entry point and the
        // paired [`super::CaixaDialeto::try_from`] `TryFrom<&str>` impl
        // (which in turn routes through the substrate-primitive
        // [`super::CaixaDialeto::from_wire`] `Option<Self>` accessor)
        // resolve to the same four-arm accept-set across every arm the
        // exhaustive [`super::CaixaDialeto::ALL`] slice enumerates.
        // Extends the substrate-wide `FromStr` parse-axis campaign —
        // opened on [`crate::dep::DepList`] via 6167092 as first-
        // mover, extended onto the structurally most fundamental
        // closed-set typed enum via [`crate::CaixaKind`] (9867432),
        // then onto the first M3-mesh-primitive-defining slot enum
        // via [`crate::aplicacao::PlacementStrategy`] (62ef49a) —
        // onto the dialect-classification axis every [`crate::Caixa`]
        // carries through its parsed manifest form. The peer
        // method-named `from_wire` accessor and the paired
        // `TryFrom<&str>` trait impl fix the four-arm PascalCase
        // accept-set; this pin locks the `FromStr::from_str` trait
        // entry point onto the same set so any future divergence (a
        // stray per-arm `match s` re-inlining that opens a compile-
        // time link to an un-lifted arm-literal, a swap onto a hand-
        // rolled parser that widens the accept-set past the four
        // lifted [`crate::render::CAIXA_DIALETO_WIRE_*`] consts) trips
        // at caixa-core test time.
        use std::str::FromStr;
        for &variant in CaixaDialeto::ALL {
            let wire = variant.as_str();
            assert_eq!(
                <CaixaDialeto as FromStr>::from_str(wire),
                Ok(variant),
                "FromStr impl on CaixaDialeto must round-trip \
                 CaixaDialeto::{variant:?}.as_str() = {wire:?} back to \
                 Ok(CaixaDialeto::{variant:?}) — divergence from \
                 CaixaDialeto::try_from signals a silent detour off the \
                 paired reverse-projection trait impl"
            );
            assert_eq!(
                <CaixaDialeto as FromStr>::from_str(wire).ok(),
                CaixaDialeto::from_wire(wire),
                "FromStr ok()-projection on {wire:?} must byte-equal \
                 CaixaDialeto::from_wire on the same input — divergence \
                 signals the two reverse-projection trait paths have \
                 drifted off the substrate-primitive accessor"
            );
            // `.parse::<CaixaDialeto>()` short-form witness — the
            // stdlib consumer surface that reaches the enum through
            // the `T: FromStr` bound, not through `TryFrom<&str>`.
            let via_parse: Result<CaixaDialeto, ()> = wire.parse();
            assert_eq!(
                via_parse,
                Ok(variant),
                "`{wire:?}`.parse::<CaixaDialeto>() must resolve to \
                 Ok(CaixaDialeto::{variant:?}) — divergence signals \
                 the stdlib `.parse()` short-form has drifted from the \
                 lifted `FromStr::from_str` impl"
            );
        }
    }

    #[test]
    fn caixa_dialeto_from_str_rejects_unknown_byte_strings() {
        // Rejection witness on the `impl FromStr for CaixaDialeto` —
        // sweeps candidate byte-strings outside the four-arm
        // PascalCase accept-set the sibling
        // [`super::CaixaDialeto::as_str`] emits and asserts every one
        // lands on `Err(())`, so a future accidental widening of the
        // trait impl's accept-set (a stray case-fold path, a silent
        // acceptance of the sibling [`CaixaDialeto::palavra_canonica`]
        // `"defcaixa"` / `"defmolde"` byte-shapes on this axis, a
        // swap onto the [`CaixaDialeto::consumidor`] /
        // [`CaixaDialeto::descricao`] axes' byte-shapes) trips at
        // caixa-core test time. Peer of the sibling
        // [`caixa_dialeto_try_from_str_rejects_unknown_byte_strings`]
        // rejection witness — the two pins together bracket both
        // reverse-projection trait impls against the same rejected
        // set. Peer of the sibling
        // [`crate::kind::tests::caixa_kind_from_str_rejects_unknown_byte_strings`]
        // (9867432) rejection witness on the top-level
        // [`crate::CaixaKind`] closed-set discriminator's trait-
        // idiomatic `FromStr` parse axis.
        use std::str::FromStr;
        let rejected: &[&str] = &[
            "",
            " ",
            "pacote",
            "PACOTE",
            "molde",
            "MoldePositional",
            "desconhecido",
            "Unknown",
            "defcaixa",
            "defmolde",
            "?",
            "caixa-core / feira",
            "pleme-doc-gen",
            "nobody known",
            "Pacote ",
            " Pacote",
            "Pacote\n",
            "\"Pacote\"",
        ];
        for &input in rejected {
            assert_eq!(
                <CaixaDialeto as FromStr>::from_str(input),
                Err(()),
                "FromStr impl on CaixaDialeto must reject unknown \
                 byte-string {input:?} — divergence signals a silent \
                 accept-set widening past the four lifted \
                 crate::render::CAIXA_DIALETO_WIRE_* wire constants"
            );
            assert_eq!(
                <CaixaDialeto as FromStr>::from_str(input).ok(),
                CaixaDialeto::from_wire(input),
                "FromStr ok()-projection on {input:?} must byte-equal \
                 CaixaDialeto::from_wire on the same input — \
                 divergence signals the FromStr trait path has drifted \
                 off the substrate-primitive accessor"
            );
            let via_parse: Result<CaixaDialeto, ()> = input.parse();
            assert_eq!(
                via_parse,
                Err(()),
                "`{input:?}`.parse::<CaixaDialeto>() must reject the \
                 unknown byte-string — divergence signals the stdlib \
                 `.parse()` short-form has drifted from the lifted \
                 `FromStr::from_str` impl"
            );
        }
    }

    #[test]
    fn caixa_dialeto_from_into_static_str_routes_through_as_str_accessor() {
        // Fail-before-pass-after byte-parity pin on the newly lifted
        // `impl From<CaixaDialeto> for &'static str` — asserts the
        // standard-library trait impl and the substrate-primitive
        // [`CaixaDialeto::as_str`] `pub const fn` accessor resolve to
        // the same four-arm emit-set across every arm the exhaustive
        // [`CaixaDialeto::ALL`] slice enumerates. Any future silent
        // detour that routes the trait impl through a divergent
        // projection (a per-arm inline `match dialeto { Pacote =>
        // "Pacote", … }` re-inlining that opens a compile-time link to
        // the un-lifted arm-literal, an accidental swap onto the second-
        // axis [`CaixaDialeto::palavra_canonica`] /
        // [`CaixaDialeto::consumidor`] / [`CaixaDialeto::descricao`]
        // accessors that carry distinct byte-shapes per axis) trips at
        // caixa-core test time under `assert_eq!` rather than at a
        // downstream `impl Into<&'static str>`-bound consumer's silent
        // split. Sweeps every one of the four arms [`CaixaDialeto::ALL`]
        // carries so no arm's projection is covered only by the sibling
        // method-named `as_str` / [`std::fmt::Display`] / [`AsRef<str>`]
        // paths. Materializes the `<&'static str as
        // From<CaixaDialeto>>::from` output in a `const`-shape binding
        // to make the `'static` lifetime promise a build-time invariant
        // — a future accidental downgrade of any of the four arms'
        // returned literals to a non-`&'static str` (a `String::leak()`-
        // produced return, a `Box::leak`-cast, an intermediate lifetime-
        // erasing helper) trips at caixa-core build time rather than at
        // a downstream `'static`-bound consumer. Peer of the sibling
        // [`crate::supervisor::tests::restart_strategy_from_into_static_str_routes_through_as_str_accessor`]
        // (523157d) /
        // [`crate::supervisor::tests::restart_policy_from_into_static_str_routes_through_as_str_accessor`]
        // (9fb37d0) /
        // [`crate::kind::tests::caixa_kind_from_into_static_str_routes_through_as_str_accessor`]
        // (edb827b) pins on the sibling closed-set typed-enum forward-
        // projection axes — extends the trait-idiomatic forward-
        // projection axis onto the fourth closed-set fieldless typed
        // enum on the caixa surface (the dialect-classification axis,
        // second-of-two closed-set typed enums in caixa-core outside
        // the OTP-shape M2 slot).
        const PACOTE: &str = CaixaDialeto::Pacote.as_str();
        const MOLDE: &str = CaixaDialeto::Molde.as_str();
        const MOLDE_POSICIONAL: &str = CaixaDialeto::MoldePosicional.as_str();
        const DESCONHECIDO: &str = CaixaDialeto::Desconhecido.as_str();
        for &variant in CaixaDialeto::ALL {
            let via_trait: &'static str = <&'static str as From<CaixaDialeto>>::from(variant);
            let via_method: &'static str = variant.as_str();
            assert_eq!(
                via_trait, via_method,
                "From<CaixaDialeto> for &'static str impl must round-trip \
                 CaixaDialeto::{variant:?} to the same `PascalCase` byte-string \
                 CaixaDialeto::as_str returns — divergence signals a silent \
                 detour off the substrate-primitive accessor"
            );
            let via_into: &'static str = variant.into();
            assert_eq!(
                via_into, via_method,
                "Into<&'static str>::into on CaixaDialeto::{variant:?} must \
                 byte-equal CaixaDialeto::as_str on the same input — the \
                 blanket-derived Into shape must resolve to the same as_str \
                 dispatch as the explicit From impl"
            );
        }
        assert_eq!(
            [PACOTE, MOLDE, MOLDE_POSICIONAL, DESCONHECIDO],
            ["Pacote", "Molde", "MoldePosicional", "Desconhecido"],
            "const-context CaixaDialeto::as_str must resolve to the four \
             `PascalCase` variant-name byte-strings — a future accidental \
             downgrade of any arm to a non-const or non-static byte-string \
             breaks the `&'static str`-lifetime promise the paired \
             From<CaixaDialeto> for &'static str impl carries by \
             construction"
        );
    }

    #[test]
    fn caixa_dialeto_from_into_static_str_and_as_str_partition_the_emit_set() {
        // Cross-axis partition pin: the paired trait-idiomatic
        // `From<CaixaDialeto> for &'static str` forward projection and
        // the method-named [`CaixaDialeto::as_str`] forward projection
        // must resolve identically on *every* arm, not just the ones
        // named in the primary byte-parity pin above. Sweeps every
        // [`CaixaDialeto::ALL`] arm and asserts the trait's `From::from`
        // output byte-equals the method-named accessor's return-value on
        // each, locking the two forward-projection paths together by
        // construction so any future detour (a stray `From` special-case
        // that lands on a divergent per-arm literal outside the paired
        // `as_str` dispatch, a hypothetical rebrand touching one axis
        // without the other) trips at caixa-core test time. Peer of the
        // sibling forward-projection partition pins
        // [`crate::supervisor::tests::restart_strategy_from_into_static_str_and_as_str_partition_the_emit_set`]
        // (523157d) /
        // [`crate::supervisor::tests::restart_policy_from_into_static_str_and_as_str_partition_the_emit_set`]
        // (9fb37d0) /
        // [`crate::kind::tests::caixa_kind_from_into_static_str_and_as_str_partition_the_emit_set`]
        // (edb827b) — extends the round-trip discipline onto the fourth
        // closed-set typed enum on the caixa surface, closing the two-way
        // `Self ↔ &'static str` round-trip on the trait-idiomatic pair
        // (`From<Self> for &'static str` + `TryFrom<&str> for Self`) as
        // well as the pre-existing method-named pair (`as_str` +
        // `from_wire`).
        for &variant in CaixaDialeto::ALL {
            let via_trait: &'static str = <&'static str as From<CaixaDialeto>>::from(variant);
            let via_method: &'static str = variant.as_str();
            assert_eq!(
                via_trait, via_method,
                "From<CaixaDialeto> for &'static str and \
                 CaixaDialeto::as_str must resolve identically on \
                 CaixaDialeto::{variant:?} — divergence signals the \
                 two forward-projection paths have drifted onto different \
                 emit-sets"
            );
        }
        // Round-trip witness: every arm's forward `From` output re-parses
        // through the paired trait-idiomatic reverse `TryFrom<&str>` back
        // to the original variant. Closes the two-way `CaixaDialeto ↔
        // &'static str` round-trip on the trait-idiomatic axis pair
        // directly (no wire-vocab intermediate the peer [`CaixaKind`]
        // axis pair requires — the emit-side [`CaixaDialeto::as_str`]
        // and the parse-side [`CaixaDialeto::from_wire`] share the same
        // `PascalCase` byte-string vocabulary by construction), mirroring
        // the pre-existing method-named `as_str` + `from_wire` round-trip
        // on the substrate-primitive axis pair.
        for &variant in CaixaDialeto::ALL {
            let emitted: &'static str = variant.into();
            let re_parsed: Result<CaixaDialeto, ()> =
                <CaixaDialeto as TryFrom<&str>>::try_from(emitted);
            assert_eq!(
                re_parsed,
                Ok(variant),
                "trait-idiomatic axis pair must round-trip \
                 CaixaDialeto::{variant:?} through `.into::<&'static \
                 str>()` and back through `TryFrom<&str>` — a break signals \
                 the forward-emit and reverse-parse axes have drifted onto \
                 different vocabularies"
            );
        }
    }

    #[test]
    fn caixa_dialeto_is_molde_family_routes_through_is_variant_derived_predicates() {
        // Byte-parity pin on the post-lift [`CaixaDialeto::is_molde_family`]
        // convergence: for every arm in [`CaixaDialeto::ALL`], the typed
        // predicate must byte-equal the direct
        // `self.is_molde() || self.is_molde_posicional()` composition of
        // the two derived per-arm predicates. Pre-lift the predicate
        // hand-rolled `matches!(self, Self::Molde | Self::MoldePosicional)`
        // with no compile-time link back to the closed-set typed dispatch;
        // post-lift it routes through the derived predicates so a future
        // arm rename or `#[is_variant(name = "…")]` override lands at
        // exactly one dispatch on the substrate primitive. Pinning the
        // byte-equality here refuses a future accidental split between
        // the composed predicate and the paired derived predicates
        // (a hand-rolled shadow `impl` that overrides one path but not
        // the other, an accidental rebrand of `is_molde_family`'s body
        // back to the pre-lift `matches!` form) at caixa-core build time.
        for &d in CaixaDialeto::ALL {
            let via_derived = d.is_molde() || d.is_molde_posicional();
            let via_is_molde_family = d.is_molde_family();
            assert_eq!(
                via_is_molde_family, via_derived,
                "CaixaDialeto::{d:?}.is_molde_family() ({via_is_molde_family}) \
                 must byte-equal the composed derived predicates \
                 is_molde() || is_molde_posicional() ({via_derived}) — a \
                 split between the composed predicate and its derived \
                 building blocks would let a future arm rename land at one \
                 path and drift at the other, which is exactly the drift \
                 the IsVariant lift refuses"
            );
        }
    }

    #[test]
    fn caixa_dialeto_from_borrowed_into_static_str_routes_through_as_str_accessor() {
        // Fail-before-pass-after byte-parity pin on the newly lifted
        // `impl From<&CaixaDialeto> for &'static str` — asserts the
        // borrowed-input standard-library trait impl and the substrate-
        // primitive [`CaixaDialeto::as_str`] `pub const fn` accessor
        // resolve to the same four-arm emit-set across every arm the
        // exhaustive [`CaixaDialeto::ALL`] slice enumerates. Rust's
        // `From` trait does not auto-derive the borrowed-input sibling
        // from a paired owned-input impl (no `impl<T, U> From<&T> for U
        // where T: Copy, U: From<T>` blanket in `core`), so the
        // borrowed-input axis is a distinct trait-idiomatic surface that
        // a `.iter().map(Into::into)` shape over [`CaixaDialeto::ALL`]
        // (whose iterator yields `&CaixaDialeto`, not `CaixaDialeto`)
        // reaches through this impl and no other — the paired owned-
        // input [`From<CaixaDialeto>`] impl requires an explicit
        // `.copied()` / dereference before the trait fires.
        // Materializes the `<&'static str as From<&CaixaDialeto>>::from`
        // output in a `const`-shape binding to make the `'static`
        // lifetime promise a build-time invariant — a future accidental
        // downgrade of any of the four arms' returned literals to a
        // non-`&'static str` trips at caixa-core build time rather than
        // at a downstream `'static`-bound consumer. Peer of the sibling
        // [`crate::dep::tests::dep_list_from_borrowed_into_static_str_routes_through_as_str_accessor`]
        // (64aa742) /
        // [`crate::kind::tests::caixa_kind_from_borrowed_into_static_str_routes_through_as_str_accessor`]
        // (5ab993a) pins on the sibling closed-set typed-enum borrowed-
        // input forward-projection axes — extends the borrowed-input
        // axis discipline onto the third peer on the substrate-wide
        // campaign, the dialect-classification axis.
        const PACOTE: &str = CaixaDialeto::Pacote.as_str();
        const MOLDE: &str = CaixaDialeto::Molde.as_str();
        const MOLDE_POSICIONAL: &str = CaixaDialeto::MoldePosicional.as_str();
        const DESCONHECIDO: &str = CaixaDialeto::Desconhecido.as_str();
        for variant in CaixaDialeto::ALL {
            let via_trait: &'static str = <&'static str as From<&CaixaDialeto>>::from(variant);
            let via_method: &'static str = variant.as_str();
            assert_eq!(
                via_trait, via_method,
                "From<&CaixaDialeto> for &'static str impl must round-trip \
                 &CaixaDialeto::{variant:?} to the same `PascalCase` byte-\
                 string CaixaDialeto::as_str returns — divergence signals a \
                 silent detour off the substrate-primitive accessor"
            );
            let via_into: &'static str = variant.into();
            assert_eq!(
                via_into, via_method,
                "Into<&'static str>::into on &CaixaDialeto::{variant:?} must \
                 byte-equal CaixaDialeto::as_str on the same input — the \
                 blanket-derived Into shape must resolve to the same as_str \
                 dispatch as the explicit From impl"
            );
        }
        assert_eq!(
            [PACOTE, MOLDE, MOLDE_POSICIONAL, DESCONHECIDO],
            ["Pacote", "Molde", "MoldePosicional", "Desconhecido"],
            "const-context CaixaDialeto::as_str must resolve to the four \
             `PascalCase` variant-name byte-strings — the borrowed-input \
             From<&CaixaDialeto> for &'static str impl inherits its \
             `'static` lifetime promise from the same accessor the owned-\
             input sibling routes through"
        );
    }

    #[test]
    fn caixa_dialeto_from_owned_and_borrowed_into_static_str_agree_on_every_arm() {
        // Cross-axis partition pin: the paired trait-idiomatic
        // owned-input `From<CaixaDialeto> for &'static str` and
        // borrowed-input `From<&CaixaDialeto> for &'static str` (this
        // lift) forward projections must resolve identically on every
        // arm, locking the two input-shape paths together so any future
        // detour trips at caixa-core test time. Then a witness that a
        // `.iter().map(Into::into)` pipe over [`CaixaDialeto::ALL`]
        // (whose iterator yields `&CaixaDialeto`) materializes the four-
        // arm accept-set through the borrowed-input axis alone — the
        // exact shape a future M4 admission-webhook rejection body
        // composer, a future substrate-wide per-arm diagnostic column,
        // or a `HashMap::<&'static str, CaixaDialeto>::from_iter(
        //     CaixaDialeto::ALL.iter().map(|d| (d.into(), *d)))`-style
        // per-dialect lookup reaches through — closing the two-way
        // owned/borrowed input-shape symmetry on the forward-projection
        // trait-idiomatic axis. Peer of the sibling
        // [`crate::dep::tests::dep_list_from_owned_and_borrowed_into_static_str_agree_on_every_arm`]
        // (64aa742) /
        // [`crate::kind::tests::caixa_kind_from_owned_and_borrowed_into_static_str_agree_on_every_arm`]
        // (5ab993a) partition pins — extends the borrowed-input axis
        // discipline onto the third peer on the substrate-wide campaign.
        for &variant in CaixaDialeto::ALL {
            let owned: &'static str = <&'static str as From<CaixaDialeto>>::from(variant);
            let borrowed: &'static str = <&'static str as From<&CaixaDialeto>>::from(&variant);
            assert_eq!(
                owned, borrowed,
                "From<CaixaDialeto> and From<&CaixaDialeto> for &'static str \
                 must resolve identically on CaixaDialeto::{variant:?} — \
                 divergence signals the owned-input and borrowed-input \
                 forward-projection paths have drifted onto different \
                 emit-sets"
            );
        }
        let via_iter: Vec<&'static str> = CaixaDialeto::ALL.iter().map(Into::into).collect();
        let via_method: Vec<&'static str> = CaixaDialeto::ALL.iter().map(|d| d.as_str()).collect();
        assert_eq!(
            via_iter, via_method,
            "`.iter().map(Into::into)` over CaixaDialeto::ALL must byte-\
             equal `.iter().map(|d| d.as_str())` on every arm — the \
             borrowed-input `From<&CaixaDialeto> for &'static str` axis \
             is what makes the `.iter().map(Into::into)` shape route \
             through the substrate-primitive `CaixaDialeto::as_str` \
             accessor rather than through a per-call-site `.copied()` / \
             dereference detour"
        );
        // Direct round-trip witness on the borrowed-input axis: every
        // arm's borrowed `From` output re-parses through the paired
        // trait-idiomatic reverse `TryFrom<&str>` back to the original
        // variant. Unlike the peer [`crate::CaixaKind`] axis pair
        // (whose forward `From<Self> for &'static str` emits the
        // lowercase Portuguese `as_str` diagnostic vocabulary while
        // the reverse `TryFrom<&str>` parses the `PascalCase`
        // `wire_name` author-surface vocabulary, forcing the round-trip
        // through an intermediate wire-vocab hop), [`CaixaDialeto`]'s
        // [`CaixaDialeto::as_str`] emit and [`CaixaDialeto::from_wire`]
        // parse share the same `PascalCase` vocabulary by construction,
        // so the borrowed-input forward axis and the reverse axis
        // compose directly.
        for &variant in CaixaDialeto::ALL {
            let borrowed: &'static str = <&'static str as From<&CaixaDialeto>>::from(&variant);
            let re_parsed: Result<CaixaDialeto, ()> =
                <CaixaDialeto as TryFrom<&str>>::try_from(borrowed);
            assert_eq!(
                re_parsed,
                Ok(variant),
                "trait-idiomatic borrowed-input round-trip must project \
                 &CaixaDialeto::{variant:?} through \
                 `<&'static str>::from(&variant)` and back through \
                 `TryFrom<&str>` — a break signals the borrowed-input \
                 forward-emit axis and the reverse-parse axis have \
                 drifted onto different vocabularies"
            );
        }
    }

    #[test]
    fn caixa_dialeto_from_into_owned_string_routes_through_as_str_accessor() {
        // Fail-before-pass-after byte-parity pin on the newly lifted
        // `impl From<CaixaDialeto> for String` — asserts the owned-`String`
        // -returning standard-library trait impl and the substrate-
        // primitive [`CaixaDialeto::as_str`] `pub const fn` accessor
        // resolve to the same four-arm emit-set across every arm the
        // exhaustive [`CaixaDialeto::ALL`] slice enumerates. 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 the
        // owned-`String` forward-projection axis is a distinct trait-
        // idiomatic surface that a `let key: String = dialeto.into();`-
        // shaped call site reaches through this impl and no other — the
        // paired sibling `From<CaixaDialeto> for &'static str` impl
        // forces every owned-`String` call site through an explicit
        // `.to_owned()` / `String::from` restatement. Peer of the
        // first-mover
        // [`crate::supervisor::tests::restart_strategy_from_into_owned_string_routes_through_as_str_accessor`]
        // (7baa18a), the second-peer
        // [`crate::supervisor::tests::restart_policy_from_into_owned_string_routes_through_as_str_accessor`]
        // (7851725), and the third-peer
        // [`crate::kind::tests::caixa_kind_from_into_owned_string_routes_through_as_str_accessor`]
        // (231a18c) — extends the trait-idiomatic owned-`String`
        // forward-projection axis onto the fourth closed-set fieldless
        // typed enum on the caixa surface (the dialect-classification
        // axis, second peer outside the M2 OTP-shape sibling axis).
        for &variant in CaixaDialeto::ALL {
            let via_trait: String = <String as From<CaixaDialeto>>::from(variant);
            let via_method: &'static str = variant.as_str();
            assert_eq!(
                via_trait.as_str(),
                via_method,
                "From<CaixaDialeto> for String impl must round-trip \
                 CaixaDialeto::{variant:?} to the same `PascalCase` \
                 arm-string CaixaDialeto::as_str returns — divergence \
                 signals a silent detour off the substrate-primitive \
                 accessor"
            );
            let via_into: String = variant.into();
            assert_eq!(
                via_into.as_str(),
                via_method,
                "Into<String>::into on CaixaDialeto::{variant:?} must \
                 byte-equal CaixaDialeto::as_str on the same input — the \
                 blanket-derived Into shape must resolve to the same \
                 as_str dispatch as the explicit From impl"
            );
        }
    }

    #[test]
    fn caixa_dialeto_from_into_owned_string_and_static_str_agree_on_every_arm() {
        // Cross-axis partition pin: the paired trait-idiomatic
        // owned-`String` `From<CaixaDialeto> for String` (this lift) and
        // owned-`&'static str` `From<CaixaDialeto> for &'static str`
        // (c189a6f) forward projections must resolve identically on
        // every arm, locking the two return-type-shape paths together
        // so any future detour trips at caixa-core test time. Also
        // byte-parity witness against the sibling
        // [`ToString::to_string`] surface routed through
        // [`std::fmt::Display`] — the three owned-heap-string paths
        // (`.into::<String>()`, `String::from`, `.to_string()`) must
        // resolve identically on every arm so a future consumer that
        // picks any of the three lands on the same four-arm
        // `PascalCase` accept-set. Then a `.iter().copied()
        // .map(String::from)` pipe witness over [`CaixaDialeto::ALL`]
        // that materializes the four-arm accept-set through the
        // owned-`String` axis alone — the exact shape a future M4
        // admission-webhook rejection body composer or a
        // `HashMap::<String, CaixaDialeto>::from_iter(
        //     CaixaDialeto::ALL.iter().copied().map(|d| (d.into(), d)))`-
        // style owned-key per-dialect lookup reaches through — closing
        // the owned-`String` forward-projection axis's iterator-pipe
        // shape. Then a direct round-trip witness through the paired
        // trait-idiomatic reverse [`TryFrom<&str>`] axis on the
        // owned-`String`'s [`String::as_str`] borrow that closes the
        // two-way `Self → String → Self` round-trip on the trait-
        // idiomatic owned-`String` forward + reverse axis pair.
        //
        // Unlike the peer [`crate::CaixaKind`] axis pair (whose forward
        // `From` emit lands on the lowercase Portuguese `as_str`
        // diagnostic vocabulary while the reverse `TryFrom<&str>` parses
        // the `PascalCase` `wire_name` author-surface vocabulary,
        // forcing the round-trip through an intermediate
        // [`crate::CaixaKind::wire_name`] hop), [`CaixaDialeto`]'s
        // [`CaixaDialeto::as_str`] emit and [`CaixaDialeto::from_wire`]
        // parse share the same `PascalCase` vocabulary by construction
        // (there is no wire/diagnostic axis split on this enum), so
        // the owned-`String` forward axis and the reverse axis compose
        // directly — matching the peer
        // [`crate::supervisor::RestartStrategy`] /
        // [`crate::supervisor::RestartPolicy`] owned-`String` axis
        // pairs (whose forward emit and reverse parse also share one
        // `PascalCase` vocabulary by construction).
        for &variant in CaixaDialeto::ALL {
            let owned_string: String = <String as From<CaixaDialeto>>::from(variant);
            let owned_static: &'static str = <&'static str as From<CaixaDialeto>>::from(variant);
            assert_eq!(
                owned_string.as_str(),
                owned_static,
                "From<CaixaDialeto> for String and From<CaixaDialeto> for \
                 &'static str must resolve identically on \
                 CaixaDialeto::{variant:?} — divergence signals the \
                 owned-`String` and owned-`&'static str` forward-\
                 projection return-type-shape paths have drifted onto \
                 different emit-sets"
            );
            let via_to_string: String = variant.to_string();
            assert_eq!(
                owned_string, via_to_string,
                "From<CaixaDialeto> for String must byte-equal \
                 CaixaDialeto::to_string on CaixaDialeto::{variant:?} — \
                 divergence signals the trait-idiomatic owned-`String` \
                 forward-projection axis and the ToString-through-\
                 Display axis have drifted onto different emit-sets"
            );
        }
        let via_iter: Vec<String> = CaixaDialeto::ALL
            .iter()
            .copied()
            .map(String::from)
            .collect();
        let via_method: Vec<String> = CaixaDialeto::ALL
            .iter()
            .map(|d| d.as_str().to_owned())
            .collect();
        assert_eq!(
            via_iter, via_method,
            "`.iter().copied().map(String::from)` over CaixaDialeto::ALL \
             must byte-equal `.iter().map(|d| d.as_str().to_owned())` on \
             every arm — the owned-`String` `From<CaixaDialeto> for \
             String` axis is what makes the `String::from` composition \
             route through the substrate-primitive `CaixaDialeto::as_str` \
             accessor rather than through a per-call-site `.to_owned()` / \
             `String::from(dialeto.as_str())` detour"
        );
        for &variant in CaixaDialeto::ALL {
            let emitted: String = variant.into();
            let re_parsed: Result<CaixaDialeto, ()> =
                <CaixaDialeto as TryFrom<&str>>::try_from(emitted.as_str());
            assert_eq!(
                re_parsed,
                Ok(variant),
                "trait-idiomatic owned-`String` forward-projection + \
                 reverse-projection axis pair must round-trip \
                 CaixaDialeto::{variant:?} through `.into::<String>()` \
                 and back through `TryFrom<&str>` on the owned-`String`'s \
                 String::as_str borrow — a break signals the owned-\
                 `String` forward-emit and reverse-parse axes have \
                 drifted onto different vocabularies (unlike the peer \
                 CaixaKind axis pair, CaixaDialeto's forward emit and \
                 reverse parse share one PascalCase vocabulary by \
                 construction, so the round-trip composes directly)"
            );
        }
    }

    #[test]
    fn caixa_dialeto_from_into_borrowed_owned_string_routes_through_as_str_accessor() {
        // Fail-before-pass-after byte-parity pin on the newly lifted
        // `impl From<&CaixaDialeto> for String` — asserts the borrowed-
        // input owned-`String`-returning standard-library trait impl and
        // the substrate-primitive [`super::CaixaDialeto::as_str`]
        // `pub const fn` accessor resolve to the same four-arm emit-set
        // across every arm the exhaustive [`super::CaixaDialeto::ALL`]
        // slice enumerates. 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 the
        // borrowed-input owned-`String` forward-projection axis is a
        // distinct trait-idiomatic surface that a
        // `let key: String = (&dialeto).into();`-shaped call site
        // reaches through this impl and no other — the paired sibling
        // `From<CaixaDialeto> for String` impl forces every borrowed-
        // input call site through an explicit `Copy` deref
        // (`String::from(*dialeto)`) or an `.as_str().to_owned()` /
        // `.to_string()` detour. Peer of the first-mover
        // [`crate::supervisor::tests::restart_strategy_from_into_borrowed_owned_string_routes_through_as_str_accessor`]
        // (579385f), the second-peer
        // [`crate::supervisor::tests::restart_policy_from_into_borrowed_owned_string_routes_through_as_str_accessor`]
        // (8465740), the third-peer
        // [`crate::dep::tests::dep_list_from_into_borrowed_owned_string_routes_through_as_str_accessor`]
        // (e0cb617), and the fourth-peer
        // [`crate::kind::tests::caixa_kind_from_into_borrowed_owned_string_routes_through_as_str_accessor`]
        // (e76436d) — extends the trait-idiomatic borrowed-input owned-
        // `String` forward-projection axis onto the fourth closed-set
        // fieldless typed enum on the caixa surface (the dialect-
        // classification axis, second peer outside the M2 OTP-shape
        // sibling axis to reach the 2×2-completion corner).
        for &variant in CaixaDialeto::ALL {
            let via_trait: String = <String as From<&CaixaDialeto>>::from(&variant);
            let via_method: &'static str = variant.as_str();
            assert_eq!(
                via_trait.as_str(),
                via_method,
                "From<&CaixaDialeto> for String impl must round-trip \
                 &CaixaDialeto::{variant:?} to the same `PascalCase` \
                 arm-string CaixaDialeto::as_str returns — divergence \
                 signals a silent detour off the substrate-primitive \
                 accessor"
            );
            let via_into: String = (&variant).into();
            assert_eq!(
                via_into.as_str(),
                via_method,
                "Into<String>::into on &CaixaDialeto::{variant:?} must \
                 byte-equal CaixaDialeto::as_str on the same input — \
                 the blanket-derived Into shape must resolve to the \
                 same as_str dispatch as the explicit From impl"
            );
        }
    }

    #[test]
    fn caixa_dialeto_from_into_borrowed_owned_string_agrees_with_paired_axes_on_every_arm() {
        // Cross-axis partition pin: the newly lifted trait-idiomatic
        // borrowed-input owned-`String` `From<&CaixaDialeto> for String`
        // (this lift), the paired owned-input owned-`String`
        // `From<CaixaDialeto> for String` (88942cd), the paired
        // borrowed-input owned-`&'static str`
        // `From<&CaixaDialeto> for &'static str` (807b0b5), and the
        // paired owned-input owned-`&'static str`
        // `From<CaixaDialeto> for &'static str` (c189a6f) — every corner
        // of the `{Self, &Self} × {&'static str, String}` 2×2 trait-
        // idiomatic projection family — must resolve identically on
        // every arm, locking the four return-shape × input-shape paths
        // together so any future detour trips at caixa-core test time.
        // Also byte-parity witness against the sibling
        // [`ToString::to_string`] surface routed through
        // [`std::fmt::Display`] and a direct round-trip witness through
        // the paired trait-idiomatic reverse [`TryFrom<&str>`] axis 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. Peer of the first-mover
        // [`crate::supervisor::tests::restart_strategy_from_into_borrowed_owned_string_agrees_with_paired_axes_on_every_arm`]
        // (579385f), the second-peer
        // [`crate::supervisor::tests::restart_policy_from_into_borrowed_owned_string_agrees_with_paired_axes_on_every_arm`]
        // (8465740), the third-peer
        // [`crate::dep::tests::dep_list_from_into_borrowed_owned_string_agrees_with_paired_axes_on_every_arm`]
        // (e0cb617), and the fourth-peer
        // [`crate::kind::tests::caixa_kind_from_into_borrowed_owned_string_agrees_with_paired_axes_on_every_arm`]
        // (e76436d) — closes the whole `{Self, &Self} × {&'static str,
        // String}` 2×2 projection corner on the fifth substrate-wide
        // closed-set fieldless typed enum peer (the dialect-
        // classification axis, second peer outside the M2 OTP-shape
        // sibling pair).
        //
        // Unlike the peer [`crate::CaixaKind`] axis pair (whose forward
        // `From` emit lands on the lowercase Portuguese `as_str`
        // diagnostic vocabulary while the reverse `TryFrom<&str>`
        // parses the `PascalCase` `wire_name` author-surface vocabulary,
        // forcing the round-trip through an intermediate
        // [`crate::CaixaKind::wire_name`] hop), [`super::CaixaDialeto`]'s
        // [`super::CaixaDialeto::as_str`] emit and
        // [`super::CaixaDialeto::from_wire`] parse share the same
        // `PascalCase` vocabulary by construction (there is no
        // wire/diagnostic axis split on this enum), so the borrowed-
        // input owned-`String` forward axis and the reverse axis compose
        // directly — matching the peer
        // [`crate::supervisor::RestartStrategy`] /
        // [`crate::supervisor::RestartPolicy`] / [`crate::dep::DepList`]
        // borrowed-input owned-`String` axis pairs.
        for &dialeto in CaixaDialeto::ALL {
            let borrowed_string: String = <String as From<&CaixaDialeto>>::from(&dialeto);
            let owned_string: String = <String as From<CaixaDialeto>>::from(dialeto);
            let borrowed_static: &'static str =
                <&'static str as From<&CaixaDialeto>>::from(&dialeto);
            let owned_static: &'static str = <&'static str as From<CaixaDialeto>>::from(dialeto);
            assert_eq!(
                borrowed_string, owned_string,
                "From<&CaixaDialeto> for String and From<CaixaDialeto> \
                 for String must resolve identically on \
                 CaixaDialeto::{dialeto:?} — divergence signals the \
                 borrowed-input and owned-input owned-`String` forward-\
                 projection input-shape paths have drifted onto \
                 different emit-sets"
            );
            assert_eq!(
                borrowed_string.as_str(),
                borrowed_static,
                "From<&CaixaDialeto> for String and From<&CaixaDialeto> \
                 for &'static str must resolve identically on \
                 CaixaDialeto::{dialeto:?} — divergence signals the \
                 borrowed-input `&'static str` and owned-`String` \
                 return-shape paths have drifted onto different \
                 emit-sets"
            );
            assert_eq!(
                borrowed_string.as_str(),
                owned_static,
                "From<&CaixaDialeto> for String and From<CaixaDialeto> \
                 for &'static str must resolve identically on \
                 CaixaDialeto::{dialeto:?} — divergence signals a break \
                 in the diagonal corner of the {{Self, &Self}} × \
                 {{&'static str, String}} 2×2 trait-idiomatic \
                 projection family"
            );
            let via_to_string: String = dialeto.to_string();
            assert_eq!(
                borrowed_string, via_to_string,
                "From<&CaixaDialeto> for String must byte-equal \
                 CaixaDialeto::to_string on CaixaDialeto::{dialeto:?} — \
                 divergence signals the trait-idiomatic borrowed-input \
                 owned-`String` forward-projection axis and the \
                 ToString-through-Display axis have drifted onto \
                 different emit-sets"
            );
        }
        let via_iter: Vec<String> = CaixaDialeto::ALL.iter().map(String::from).collect();
        let via_method: Vec<String> = CaixaDialeto::ALL
            .iter()
            .map(|d| d.as_str().to_owned())
            .collect();
        assert_eq!(
            via_iter, via_method,
            "`.iter().map(String::from)` over CaixaDialeto::ALL — a \
             call site whose iteration axis holds `&CaixaDialeto` by \
             construction — must byte-equal `.iter().map(|d| \
             d.as_str().to_owned())` on every arm — the borrowed-input \
             owned-`String` `From<&CaixaDialeto> for String` axis is \
             what makes the `String::from` composition route through \
             the substrate-primitive `CaixaDialeto::as_str` accessor \
             without a spurious `Copy` deref (which would only be \
             reachable through the owned-input `From<CaixaDialeto> for \
             String` axis by first calling `.copied()` on the iterator)"
        );
        for &variant in CaixaDialeto::ALL {
            let emitted: String = (&variant).into();
            let re_parsed: Result<CaixaDialeto, ()> =
                <CaixaDialeto as TryFrom<&str>>::try_from(emitted.as_str());
            assert_eq!(
                re_parsed,
                Ok(variant),
                "trait-idiomatic borrowed-input owned-`String` \
                 forward-projection + reverse-projection axis pair \
                 must round-trip &CaixaDialeto::{variant:?} through \
                 `.into::<String>()` on the borrowed-input surface and \
                 back through `TryFrom<&str>` on the owned-`String`'s \
                 String::as_str borrow — a break signals the \
                 borrowed-input owned-`String` forward-emit and \
                 reverse-parse axes have drifted onto different \
                 vocabularies (unlike the peer CaixaKind axis pair, \
                 CaixaDialeto's forward emit and reverse parse share \
                 one PascalCase vocabulary by construction, so the \
                 round-trip composes directly)"
            );
        }
    }

    #[test]
    fn caixa_dialeto_from_into_static_cow_str_routes_through_as_str_accessor() {
        // Fail-before-pass-after byte-parity pin on the newly lifted
        // `impl From<CaixaDialeto> for std::borrow::Cow<'static, str>`
        // — asserts the standard-library trait impl and the
        // substrate-primitive [`super::CaixaDialeto::as_str`]
        // `pub const fn` accessor resolve to the same four-arm
        // emit-set across every arm the exhaustive
        // [`super::CaixaDialeto::ALL`] slice enumerates. Rust's
        // standard library does not carry a blanket
        // `impl<T: AsRef<str>> From<T> for std::borrow::Cow<'static,
        // str>` (nor an `impl<T: fmt::Display> From<T> for
        // std::borrow::Cow<'static, str>`), so the
        // [`std::borrow::Cow<'static, str>`] forward-projection axis
        // is a distinct trait-idiomatic surface that a
        // `let key: std::borrow::Cow<'static, str> = dialeto.into();`-
        // shaped call site reaches through this impl and no other —
        // the paired sibling `From<CaixaDialeto> for &'static str`
        // and `From<CaixaDialeto> for String` impls force every
        // [`std::borrow::Cow<'static, str>`]-parameterized call site
        // through a `std::borrow::Cow::Borrowed(dialeto.as_str())` /
        // `std::borrow::Cow::Owned(dialeto.to_string())` /
        // `String::from(dialeto).into()` composition whose type
        // bounds have no compile-time link back to the substrate
        // primitive.
        //
        // Also asserts the projection lands on the zero-alloc
        // [`std::borrow::Cow::Borrowed`] arm (not the
        // [`std::borrow::Cow::Owned`] arm) — the substrate-primitive
        // [`super::CaixaDialeto::as_str`] accessor's `&'static str`
        // return lifetime by construction makes the borrowed arm the
        // type-correct projection with no runtime allocation. Any
        // future silent detour that routes the impl through the
        // owned arm (an accidental
        // `std::borrow::Cow::Owned(dialeto.to_string())` rewrite that
        // would allocate on every call site where the `&'static str`
        // return of [`super::CaixaDialeto::as_str`] makes the
        // zero-alloc borrowed projection type-correct) trips at
        // caixa-core test time under the
        // [`std::borrow::Cow::Borrowed`] discriminator witness rather
        // than at a downstream
        // [`std::borrow::Cow<'static, str>`]-bound consumer's silent
        // allocation.
        //
        // Second peer on the outside-M3 caixa-core tier of the
        // substrate-wide trait-idiomatic
        // [`std::borrow::Cow<'static, str>`] forward-projection
        // family — extends the axis off the two-list dep-graph
        // [`crate::dep::DepList`] pair (6858bac / 702cdf4) that
        // opened + closed the tier onto the dialect-classification
        // [`super::CaixaDialeto`] enum (the sole remaining
        // internal-classification peer on the caixa-core surface).
        // Every future closed-set fieldless typed enum peer on the
        // substrate is a future target of the campaign.
        for &variant in CaixaDialeto::ALL {
            let via_trait: std::borrow::Cow<'static, str> =
                <std::borrow::Cow<'static, str> as From<CaixaDialeto>>::from(variant);
            let via_method: &'static str = variant.as_str();
            assert_eq!(
                via_trait.as_ref(),
                via_method,
                "From<CaixaDialeto> for Cow<'static, str> impl must \
                 round-trip CaixaDialeto::{variant:?} to the same \
                 PascalCase byte-string CaixaDialeto::as_str returns \
                 — divergence signals a silent detour off the \
                 substrate-primitive accessor"
            );
            assert!(
                matches!(via_trait, std::borrow::Cow::Borrowed(_)),
                "From<CaixaDialeto> for Cow<'static, str> impl must \
                 land on the zero-alloc Cow::Borrowed arm on \
                 CaixaDialeto::{variant:?} — a Cow::Owned outcome \
                 signals the projection has silently allocated where \
                 the substrate-primitive CaixaDialeto::as_str \
                 `&'static str` return makes the borrowed arm the \
                 type-correct projection"
            );
            let via_into: std::borrow::Cow<'static, str> = variant.into();
            assert_eq!(
                via_into.as_ref(),
                via_method,
                "Into<Cow<'static, str>>::into on \
                 CaixaDialeto::{variant:?} must byte-equal \
                 CaixaDialeto::as_str on the same input — the \
                 blanket-derived Into shape must resolve to the same \
                 as_str dispatch as the explicit From impl"
            );
            assert!(
                matches!(via_into, std::borrow::Cow::Borrowed(_)),
                "Into<Cow<'static, str>>::into on \
                 CaixaDialeto::{variant:?} must land on the zero-alloc \
                 Cow::Borrowed arm — the blanket-derived Into shape \
                 must resolve to the same Cow::Borrowed dispatch as \
                 the explicit From impl"
            );
        }
    }

    #[test]
    fn caixa_dialeto_from_into_static_cow_str_agrees_with_paired_axes_on_every_arm() {
        // Cross-axis partition pin: the newly lifted trait-idiomatic
        // `From<CaixaDialeto> for std::borrow::Cow<'static, str>`
        // (this lift), the paired owned-input
        // `From<CaixaDialeto> for &'static str`, and the paired
        // owned-input `From<CaixaDialeto> for String` forward
        // projections must resolve identically on every arm, locking
        // the three return-shape paths together by construction so
        // any future detour trips at caixa-core test time. Also
        // byte-parity witness against the sibling
        // [`ToString::to_string`] surface routed through
        // [`std::fmt::Display`] — every owned-heap-string path (the
        // [`std::borrow::Cow::Owned`] promotion of this axis's
        // `.into_owned()`, `From<CaixaDialeto> for String`, and
        // `.to_string()`) resolves to the same PascalCase byte-string
        // per arm.
        //
        // Then a `.iter().copied().map(std::borrow::Cow::from)` pipe
        // witness over [`super::CaixaDialeto::ALL`] that materializes
        // the four-arm accept-set through the
        // [`std::borrow::Cow<'static, str>`] axis alone — the exact
        // shape a future `axum::response::IntoResponse` per-arm
        // rejection-body composer, a future M4
        // `mesh.pleme.io/v1alpha1/Manifesto` CR materializer's
        // admission-webhook per-arm rejection-reason emitter whose
        // typing rules out the sibling [`AsRef<str>`] borrowed
        // return, or a future substrate-wide per-arm diagnostic
        // surface that binds through a
        // [`std::borrow::Cow<'static, str>`] boundary reaches through
        // — closing the composable-projection axis on the dialect-
        // classification closed-set fieldless typed enum peer. The
        // pipe witness also pins the zero-alloc discipline: every
        // element in the collected vector satisfies the
        // [`std::borrow::Cow::Borrowed`] arm predicate, so a future
        // accidental silent-allocation regression on the pipe's
        // iteration axis is a caixa-core-test-time failure.
        //
        // Then a direct round-trip witness through
        // [`TryFrom<&str>`] on the projection's
        // [`std::borrow::Cow::as_ref`] borrow — unlike the peer
        // [`crate::CaixaKind`] axis pair (whose forward emit lands
        // on the lowercase Portuguese diagnostic vocabulary while
        // the reverse parse lands on the `PascalCase` wire
        // vocabulary, forcing the round-trip through an intermediate
        // [`crate::CaixaKind::wire_name`] hop),
        // [`super::CaixaDialeto`]'s forward emit and reverse parse
        // share one `PascalCase` vocabulary by construction, so the
        // [`std::borrow::Cow<'static, str>`] projection composes
        // directly with the trait-idiomatic reverse [`TryFrom<&str>`]
        // axis without the wire-vocab intermediate hop.
        for &variant in CaixaDialeto::ALL {
            let via_cow: std::borrow::Cow<'static, str> =
                <std::borrow::Cow<'static, str> as From<CaixaDialeto>>::from(variant);
            let via_static: &'static str = <&'static str as From<CaixaDialeto>>::from(variant);
            let via_string: String = <String as From<CaixaDialeto>>::from(variant);
            assert_eq!(
                via_cow.as_ref(),
                via_static,
                "From<CaixaDialeto> for Cow<'static, str> and \
                 From<CaixaDialeto> for &'static str must resolve \
                 identically on CaixaDialeto::{variant:?} — \
                 divergence signals the Cow<'static, str> and \
                 &'static str return-shape paths have drifted onto \
                 different emit-sets"
            );
            assert_eq!(
                via_cow.as_ref(),
                via_string.as_str(),
                "From<CaixaDialeto> for Cow<'static, str> and \
                 From<CaixaDialeto> for String must resolve \
                 identically on CaixaDialeto::{variant:?} — \
                 divergence signals the Cow<'static, str> and String \
                 return-shape paths have drifted onto different \
                 emit-sets"
            );
            let via_to_string: String = variant.to_string();
            assert_eq!(
                via_cow.as_ref(),
                via_to_string.as_str(),
                "From<CaixaDialeto> for Cow<'static, str> must \
                 byte-equal CaixaDialeto::to_string on \
                 CaixaDialeto::{variant:?} — divergence signals the \
                 trait-idiomatic Cow<'static, str> forward-projection \
                 axis and the ToString-through-Display axis have \
                 drifted onto different emit-sets"
            );
        }
        let via_iter: Vec<std::borrow::Cow<'static, str>> = CaixaDialeto::ALL
            .iter()
            .copied()
            .map(std::borrow::Cow::from)
            .collect();
        let via_method: Vec<std::borrow::Cow<'static, str>> = CaixaDialeto::ALL
            .iter()
            .map(|d| std::borrow::Cow::Borrowed(d.as_str()))
            .collect();
        assert_eq!(
            via_iter, via_method,
            "`.iter().copied().map(Cow::from)` over \
             CaixaDialeto::ALL must byte-equal `.iter().map(|d| \
             Cow::Borrowed(d.as_str()))` on every arm — the \
             trait-idiomatic `From<CaixaDialeto> for Cow<'static, \
             str>` axis is what makes the `Cow::from` composition \
             route through the substrate-primitive \
             CaixaDialeto::as_str accessor rather than a per-call-\
             site open-code"
        );
        for cow in &via_iter {
            assert!(
                matches!(cow, std::borrow::Cow::Borrowed(_)),
                "`.iter().copied().map(Cow::from)` over \
                 CaixaDialeto::ALL must land on the zero-alloc \
                 Cow::Borrowed arm on every element — a Cow::Owned \
                 outcome signals the pipe has silently allocated \
                 where the substrate-primitive \
                 CaixaDialeto::as_str `&'static str` return makes \
                 the borrowed arm the type-correct projection"
            );
        }
        for &variant in CaixaDialeto::ALL {
            let via_cow: std::borrow::Cow<'static, str> =
                <std::borrow::Cow<'static, str> as From<CaixaDialeto>>::from(variant);
            let re_parsed: Result<CaixaDialeto, ()> =
                <CaixaDialeto as TryFrom<&str>>::try_from(via_cow.as_ref());
            assert_eq!(
                re_parsed,
                Ok(variant),
                "trait-idiomatic Cow<'static, str> forward-projection \
                 + reverse-projection axis pair must round-trip \
                 CaixaDialeto::{variant:?} through `.into::<Cow<\
                 'static, str>>()` on the owned-input surface and \
                 back through `TryFrom<&str>` on the projection's \
                 Cow::as_ref borrow — a break signals the \
                 Cow<'static, str> forward-emit and reverse-parse \
                 axes have drifted onto different vocabularies \
                 (unlike the peer CaixaKind axis pair, CaixaDialeto's \
                 forward emit and reverse parse share one PascalCase \
                 vocabulary by construction, so the round-trip \
                 composes directly)"
            );
        }
    }

    #[test]
    fn caixa_dialeto_from_borrowed_into_static_cow_str_routes_through_as_str_accessor() {
        // Fail-before-pass-after byte-parity pin on the newly lifted
        // `impl From<&CaixaDialeto> for std::borrow::Cow<'static,
        // str>` — asserts the borrowed-input standard-library trait
        // impl and the substrate-primitive
        // [`super::CaixaDialeto::as_str`] `pub const fn` accessor
        // resolve to the same four-arm PascalCase emit-set across
        // every arm the exhaustive [`super::CaixaDialeto::ALL`] slice
        // enumerates. Rust's standard library does not carry a blanket
        // `impl<T: AsRef<str>> From<&T> for Cow<'static, str>` (nor a
        // `Copy`-based `impl<T: Copy, U: From<T>> From<&T> for U`), so
        // the borrowed-input `Cow<'static, str>` forward-projection
        // axis is a distinct trait-idiomatic surface that a
        // `let key: Cow<'static, str> = (&dialeto).into();`-shaped
        // call site or a `CaixaDialeto::ALL.iter().map(Cow::from)`-
        // shaped pipe reaches through this impl and no other — the
        // paired owned-input `From<CaixaDialeto> for Cow<'static, str>`
        // impl (8322511) forces every borrowed-input call site
        // through an explicit `Copy` deref (`Cow::from(*dialeto)`) or
        // a `Cow::Borrowed(dialeto.as_str())` open-code whose type
        // bounds have no compile-time link back to the substrate
        // primitive.
        //
        // Also asserts the projection lands on the zero-alloc
        // [`std::borrow::Cow::Borrowed`] arm (not the
        // [`std::borrow::Cow::Owned`] arm) — the substrate-primitive
        // [`super::CaixaDialeto::as_str`] accessor's `&'static str`
        // return lifetime by construction makes the borrowed arm 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 dialect-classification
        // [`Cow<'static, str>`] axis on the second outside-M3
        // caixa-core closed-set fieldless typed enum peer on the
        // caixa surface, exactly as 702cdf4 closed it on the first
        // outside-M3 caixa-core peer ([`crate::dep::DepList`]) one
        // commit after the owning half (6858bac) landed, as afdf0f4
        // closed it on the second M3-mesh-primitive peer
        // ([`crate::aplicacao::PlacementStrategy`]) one commit after
        // the owning half (eee504d) landed, as 25690ef closed it on
        // the first M3-mesh-primitive peer
        // ([`crate::aplicacao::WitShape`]) one commit after the
        // owning half (8634dec) landed, as d45c409 closed it on the
        // top-level [`crate::CaixaKind`] one commit after the owning
        // half (99c1735) landed, and as 9b3e4b3 / ee577fd closed it
        // on the M2 OTP-shape [`crate::supervisor::RestartStrategy`]
        // / [`crate::supervisor::RestartPolicy`] sibling peers one
        // commit after (7dd28b3 / 0612398) landed.
        for &variant in CaixaDialeto::ALL {
            let via_trait: std::borrow::Cow<'static, str> =
                <std::borrow::Cow<'static, str> as From<&CaixaDialeto>>::from(&variant);
            let via_method: &'static str = variant.as_str();
            assert_eq!(
                via_trait.as_ref(),
                via_method,
                "From<&CaixaDialeto> for Cow<'static, str> impl must \
                 round-trip &CaixaDialeto::{variant:?} to the same \
                 PascalCase byte-string CaixaDialeto::as_str returns \
                 — divergence signals a silent detour off the \
                 substrate-primitive accessor"
            );
            assert!(
                matches!(via_trait, std::borrow::Cow::Borrowed(_)),
                "From<&CaixaDialeto> for Cow<'static, str> impl must \
                 land on the zero-alloc Cow::Borrowed arm on \
                 &CaixaDialeto::{variant:?} — a Cow::Owned outcome \
                 signals the projection has silently allocated where \
                 the substrate-primitive CaixaDialeto::as_str \
                 `&'static str` return makes the borrowed arm the \
                 type-correct projection"
            );
            let via_into: std::borrow::Cow<'static, str> = (&variant).into();
            assert_eq!(
                via_into.as_ref(),
                via_method,
                "Into<Cow<'static, str>>::into on \
                 &CaixaDialeto::{variant:?} must byte-equal \
                 CaixaDialeto::as_str on the same input — the \
                 blanket-derived Into shape on the borrowed-input \
                 surface must resolve to the same as_str dispatch as \
                 the explicit From impl"
            );
            assert!(
                matches!(via_into, std::borrow::Cow::Borrowed(_)),
                "Into<Cow<'static, str>>::into on \
                 &CaixaDialeto::{variant:?} must land on the \
                 zero-alloc Cow::Borrowed arm — the blanket-derived \
                 Into shape on the borrowed-input surface must \
                 resolve to the same Cow::Borrowed dispatch as the \
                 explicit From impl"
            );
        }
    }

    #[test]
    #[allow(
        clippy::too_many_lines,
        reason = "cross-axis partition pin folds four return-shape paths \
                  (borrowed-input Cow<'static, str>, owned-input Cow<'static, str>, \
                  borrowed-input &'static str, borrowed-input String) plus the \
                  ToString-through-Display witness plus a `.iter().map(Cow::from)` \
                  pipe witness with zero-alloc discriminator plus a direct \
                  round-trip witness through TryFrom<&str> over four typed \
                  variants; the linear per-axis repetition is exactly what the \
                  fold is pinning — a helper would hide the shape it locks"
    )]
    fn caixa_dialeto_from_borrowed_into_static_cow_str_agrees_with_paired_axes_on_every_arm() {
        // Cross-axis partition pin: the newly lifted trait-idiomatic
        // borrowed-input `From<&CaixaDialeto> for
        // std::borrow::Cow<'static, str>` (this lift), the paired
        // owned-input `From<CaixaDialeto> for
        // std::borrow::Cow<'static, str>`, the paired borrowed-input
        // `From<&CaixaDialeto> for &'static str`, and the paired
        // borrowed-input `From<&CaixaDialeto> for String` forward
        // projections must resolve identically on every arm, locking
        // the four return-shape paths together by construction so any
        // future detour trips at caixa-core test time. Also
        // byte-parity witness against the sibling
        // [`ToString::to_string`] surface routed through
        // [`std::fmt::Display`].
        //
        // Then a `.iter().map(std::borrow::Cow::from)` pipe witness
        // over [`super::CaixaDialeto::ALL`] — whose iterator yields
        // `&CaixaDialeto` by construction, so the borrowed-input
        // [`std::borrow::Cow<'static, str>`] axis is what routes the
        // pipe through the substrate-primitive
        // [`super::CaixaDialeto::as_str`] accessor with the zero-alloc
        // [`std::borrow::Cow::Borrowed`] arm and without a spurious
        // [`Copy`] deref. Every collected element satisfies the
        // [`std::borrow::Cow::Borrowed`]-arm predicate so a future
        // accidental silent-allocation regression on the pipe's
        // iteration axis is a caixa-core-test-time failure.
        //
        // Then a direct round-trip witness through [`TryFrom<&str>`]
        // on the projection's [`std::borrow::Cow::as_ref`] borrow —
        // unlike the peer [`crate::CaixaKind`] axis pair (whose
        // forward emit lands on the lowercase Portuguese diagnostic
        // vocabulary while the reverse parse lands on the
        // `PascalCase` wire vocabulary, forcing the round-trip
        // through an intermediate [`crate::CaixaKind::wire_name`]
        // hop), [`super::CaixaDialeto`]'s forward emit and reverse
        // parse share one `PascalCase` vocabulary by construction, so
        // the borrowed-input [`std::borrow::Cow<'static, str>`]
        // projection composes directly with the trait-idiomatic
        // reverse [`TryFrom<&str>`] axis without the wire-vocab
        // intermediate hop.
        for &variant in CaixaDialeto::ALL {
            let via_borrowed_cow: std::borrow::Cow<'static, str> =
                <std::borrow::Cow<'static, str> as From<&CaixaDialeto>>::from(&variant);
            let via_owned_cow: std::borrow::Cow<'static, str> =
                <std::borrow::Cow<'static, str> as From<CaixaDialeto>>::from(variant);
            let via_borrowed_static: &'static str =
                <&'static str as From<&CaixaDialeto>>::from(&variant);
            let via_borrowed_string: String = <String as From<&CaixaDialeto>>::from(&variant);
            assert_eq!(
                via_borrowed_cow.as_ref(),
                via_owned_cow.as_ref(),
                "From<&CaixaDialeto> for Cow<'static, str> and \
                 From<CaixaDialeto> for Cow<'static, str> must \
                 resolve identically on CaixaDialeto::{variant:?} — \
                 divergence signals the borrowed-input and \
                 owned-input Cow<'static, str> return-shape paths \
                 have drifted onto different emit-sets"
            );
            assert_eq!(
                via_borrowed_cow.as_ref(),
                via_borrowed_static,
                "From<&CaixaDialeto> for Cow<'static, str> and \
                 From<&CaixaDialeto> for &'static str must resolve \
                 identically on CaixaDialeto::{variant:?} — \
                 divergence signals the borrowed-input Cow<'static, \
                 str> and borrowed-input &'static str return-shape \
                 paths have drifted onto different emit-sets"
            );
            assert_eq!(
                via_borrowed_cow.as_ref(),
                via_borrowed_string.as_str(),
                "From<&CaixaDialeto> for Cow<'static, str> and \
                 From<&CaixaDialeto> for String must resolve \
                 identically on CaixaDialeto::{variant:?} — \
                 divergence signals the borrowed-input Cow<'static, \
                 str> and borrowed-input String return-shape paths \
                 have drifted onto different emit-sets"
            );
            let via_to_string: String = variant.to_string();
            assert_eq!(
                via_borrowed_cow.as_ref(),
                via_to_string.as_str(),
                "From<&CaixaDialeto> for Cow<'static, str> must \
                 byte-equal CaixaDialeto::to_string on \
                 CaixaDialeto::{variant:?} — divergence signals the \
                 borrowed-input Cow<'static, str> forward-projection \
                 axis and the ToString-through-Display axis have \
                 drifted onto different emit-sets"
            );
        }
        let via_iter: Vec<std::borrow::Cow<'static, str>> = CaixaDialeto::ALL
            .iter()
            .map(std::borrow::Cow::from)
            .collect();
        let via_method: Vec<std::borrow::Cow<'static, str>> = CaixaDialeto::ALL
            .iter()
            .map(|d| std::borrow::Cow::Borrowed(d.as_str()))
            .collect();
        assert_eq!(
            via_iter, via_method,
            "`.iter().map(Cow::from)` over CaixaDialeto::ALL must \
             byte-equal `.iter().map(|d| Cow::Borrowed(d.as_str()))` \
             on every arm — the trait-idiomatic `From<&CaixaDialeto> \
             for Cow<'static, str>` axis is what makes the \
             `Cow::from` composition on the borrowed-iteration axis \
             route through the substrate-primitive \
             CaixaDialeto::as_str accessor without a spurious Copy \
             deref"
        );
        for cow in &via_iter {
            assert!(
                matches!(cow, std::borrow::Cow::Borrowed(_)),
                "`.iter().map(Cow::from)` over CaixaDialeto::ALL \
                 must land on the zero-alloc Cow::Borrowed arm on \
                 every element — a Cow::Owned outcome signals the \
                 borrowed-iteration pipe has silently allocated \
                 where the substrate-primitive CaixaDialeto::as_str \
                 `&'static str` return makes the borrowed arm the \
                 type-correct projection"
            );
        }
        for &variant in CaixaDialeto::ALL {
            let via_cow: std::borrow::Cow<'static, str> =
                <std::borrow::Cow<'static, str> as From<&CaixaDialeto>>::from(&variant);
            let re_parsed: Result<CaixaDialeto, ()> =
                <CaixaDialeto as TryFrom<&str>>::try_from(via_cow.as_ref());
            assert_eq!(
                re_parsed,
                Ok(variant),
                "trait-idiomatic borrowed-input Cow<'static, str> \
                 forward-projection + reverse-projection axis pair \
                 must round-trip &CaixaDialeto::{variant:?} through \
                 `.into::<Cow<'static, str>>()` on the borrowed-input \
                 surface and back through `TryFrom<&str>` on the \
                 projection's Cow::as_ref borrow — a break signals \
                 the borrowed-input Cow<'static, str> forward-emit \
                 and reverse-parse axes have drifted onto different \
                 vocabularies (unlike the peer CaixaKind axis pair, \
                 CaixaDialeto's forward emit and reverse parse share \
                 one PascalCase vocabulary by construction, so the \
                 round-trip composes directly)"
            );
        }
    }

    #[test]
    fn caixa_dialeto_from_into_box_str_routes_through_as_str_accessor() {
        // Fail-before-pass-after byte-parity pin on the newly lifted
        // `impl From<CaixaDialeto> for Box<str>` — asserts the owned-
        // input standard-library trait impl and the substrate-primitive
        // [`super::CaixaDialeto::as_str`] `pub const fn` accessor
        // resolve to the same four-arm PascalCase emit-set across every
        // arm the exhaustive [`super::CaixaDialeto::ALL`] slice
        // enumerates. Extends the caixa-core-internal tier of the
        // substrate-wide [`Box<str>`] forward-projection campaign onto
        // the third caixa-core-internal peer, after the render-side
        // path-shape-diagnostic
        // [`super::super::render::PathShapeViolation`] pair (0d87a72,
        // both corners in one axis) opened the tier and the outside-M3
        // caixa-core two-list dep-graph [`super::super::dep::DepList`]
        // pair (4aada99, both corners in one axis) extended it. 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
        // `let key: Box<str> = dialeto.into();`-shaped call site reaches
        // through this impl and no other — a paired
        // `Box::from(dialeto.as_str())` open-code has no compile-time
        // link back to the substrate primitive.
        for &variant in CaixaDialeto::ALL {
            let via_trait: Box<str> = <Box<str> as From<CaixaDialeto>>::from(variant);
            let via_method: &'static str = variant.as_str();
            assert_eq!(
                via_trait.as_ref(),
                via_method,
                "From<CaixaDialeto> for Box<str> impl must round-trip \
                 CaixaDialeto::{variant:?} to the same PascalCase \
                 byte-string CaixaDialeto::as_str returns — divergence \
                 signals a silent detour off the substrate-primitive \
                 accessor"
            );
            let via_into: Box<str> = variant.into();
            assert_eq!(
                via_into.as_ref(),
                via_method,
                "Into<Box<str>>::into on CaixaDialeto::{variant:?} must \
                 byte-equal CaixaDialeto::as_str on the same input — \
                 the blanket-derived Into shape must resolve to the \
                 same as_str dispatch as the explicit From impl"
            );
        }
    }

    #[test]
    fn caixa_dialeto_from_borrowed_into_box_str_routes_through_as_str_accessor() {
        // Fail-before-pass-after byte-parity pin on the newly lifted
        // `impl From<&CaixaDialeto> for Box<str>` — asserts the
        // borrowed-input standard-library trait impl and the substrate-
        // primitive [`super::CaixaDialeto::as_str`] `pub const fn`
        // accessor resolve to the same four-arm PascalCase emit-set
        // across every arm the exhaustive [`super::CaixaDialeto::ALL`]
        // slice enumerates. 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 the
        // borrowed-input [`Box<str>`] forward-projection axis is a
        // distinct trait-idiomatic surface that a
        // `CaixaDialeto::ALL.iter().map(Box::<str>::from)`-shaped pipe
        // (whose iterator over `&'static [CaixaDialeto]` yields
        // `&CaixaDialeto` by construction) or a
        // `let key: Box<str> = (&dialeto).into();`-shaped call site
        // reaches through this impl and no other — the paired owned-
        // input `From<CaixaDialeto> for Box<str>` impl alone would
        // force every borrowed-input call site through an explicit
        // `Copy` deref (`Box::<str>::from(*dialeto)`) or a
        // `Box::<str>::from(dialeto.as_str())` open-code whose type
        // bounds have no compile-time link back to the substrate
        // primitive.
        //
        // Closes the `{Self, &Self}` input-shape corner on the third
        // caixa-core-internal closed-set fieldless typed enum peer of
        // the substrate-wide [`Box<str>`] forward-projection campaign,
        // matching the trajectory the paired render-side path-shape-
        // diagnostic [`super::super::render::PathShapeViolation`] pair
        // (0d87a72, both corners in one axis) and the paired outside-M3
        // caixa-core two-list dep-graph [`super::super::dep::DepList`]
        // pair (4aada99, both corners in one axis) walked before it.
        for &variant in CaixaDialeto::ALL {
            let via_trait: Box<str> = <Box<str> as From<&CaixaDialeto>>::from(&variant);
            let via_method: &'static str = variant.as_str();
            assert_eq!(
                via_trait.as_ref(),
                via_method,
                "From<&CaixaDialeto> for Box<str> impl must round-trip \
                 &CaixaDialeto::{variant:?} to the same PascalCase \
                 byte-string CaixaDialeto::as_str returns — divergence \
                 signals a silent detour off the substrate-primitive \
                 accessor"
            );
            let via_into: Box<str> = (&variant).into();
            assert_eq!(
                via_into.as_ref(),
                via_method,
                "Into<Box<str>>::into on &CaixaDialeto::{variant:?} \
                 must byte-equal CaixaDialeto::as_str on the same \
                 input — the blanket-derived Into shape on the \
                 borrowed-input surface must resolve to the same \
                 as_str dispatch as the explicit From impl"
            );
        }

        // Pipe witness — the distinguishing shape that forces the
        // borrowed-input axis to be independent of the owned-input
        // peer. `CaixaDialeto::ALL.iter()` yields `&CaixaDialeto` by
        // construction, so `.map(Box::<str>::from)` resolves through
        // the borrowed-input `From<&CaixaDialeto> for Box<str>` impl
        // and no other — without this axis, the same pipe would force
        // an explicit `.copied()` restatement whose type bounds bypass
        // the substrate primitive.
        let via_pipe: Vec<Box<str>> = CaixaDialeto::ALL.iter().map(Box::<str>::from).collect();
        let via_accessor: Vec<&'static str> =
            CaixaDialeto::ALL.iter().map(|d| d.as_str()).collect();
        assert_eq!(
            via_pipe.len(),
            via_accessor.len(),
            "CaixaDialeto::ALL.iter().map(Box::<str>::from) pipe must \
             preserve arity against the paired CaixaDialeto::as_str \
             accessor — a length divergence signals the borrowed-input \
             axis has silently rejected an arm"
        );
        for (pipe_arm, accessor_arm) in via_pipe.iter().zip(via_accessor.iter()) {
            assert_eq!(
                pipe_arm.as_ref(),
                *accessor_arm,
                "CaixaDialeto::ALL.iter().map(Box::<str>::from) pipe \
                 must byte-equal the paired \
                 CaixaDialeto::ALL.iter().map(|d| d.as_str()) pipe on \
                 every arm — divergence signals the borrowed-input \
                 `From<&CaixaDialeto> for Box<str>` axis has silently \
                 detoured off the substrate-primitive accessor"
            );
        }
    }

    #[test]
    fn caixa_dialeto_from_into_arc_str_routes_through_as_str_accessor() {
        // Fail-before-pass-after byte-parity pin on the newly lifted
        // `impl From<CaixaDialeto> for std::sync::Arc<str>` — asserts the
        // owned-input standard-library trait impl and the substrate-
        // primitive [`super::CaixaDialeto::as_str`] `pub const fn` accessor
        // resolve to the same four-arm PascalCase emit-set across every
        // arm the exhaustive [`super::CaixaDialeto::ALL`] slice enumerates.
        // Extends the caixa-core-internal tier of the substrate-wide
        // [`std::sync::Arc<str>`] forward-projection campaign onto the
        // third caixa-core-internal peer, after the structurally most
        // fundamental [`super::super::CaixaKind`] pair (c17be64, both
        // corners in one axis) opened the tier and the outside-M3 two-list
        // dep-graph [`super::super::dep::DepList`] pair (d8a4652, both
        // corners in one axis) extended it. 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> = dialeto.into();`-shaped call
        // site reaches through this impl and no other — a paired
        // `std::sync::Arc::<str>::from(dialeto.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(dialeto))`
        // composition through the owned-`String` axis allocates twice
        // where the single-step trait impl allocates once.
        //
        // Cross-axis byte-parity witness against the sibling owned-input
        // `{&'static str, String, Cow<'static, str>, Box<str>}` return-
        // shape axes — locking the five return-shape paths on the owned-
        // input surface together by construction so any future detour off
        // the substrate-primitive [`super::CaixaDialeto::as_str`] accessor
        // trips at caixa-core test time.
        for &variant in CaixaDialeto::ALL {
            let via_trait: std::sync::Arc<str> =
                <std::sync::Arc<str> as From<CaixaDialeto>>::from(variant);
            let via_method: &'static str = variant.as_str();
            assert_eq!(
                via_trait.as_ref(),
                via_method,
                "From<CaixaDialeto> for std::sync::Arc<str> impl must \
                 round-trip CaixaDialeto::{variant:?} to the same \
                 PascalCase byte-string CaixaDialeto::as_str returns — \
                 divergence signals a silent detour off the substrate-\
                 primitive accessor"
            );
            let via_into: std::sync::Arc<str> = variant.into();
            assert_eq!(
                via_into.as_ref(),
                via_method,
                "Into<std::sync::Arc<str>>::into on CaixaDialeto::\
                 {variant:?} must byte-equal CaixaDialeto::as_str on the \
                 same input — the blanket-derived Into shape must resolve \
                 to the same as_str dispatch as the explicit From impl"
            );
            let owned_static: &'static str = <&'static str as From<CaixaDialeto>>::from(variant);
            assert_eq!(
                via_trait.as_ref(),
                owned_static,
                "From<CaixaDialeto> for std::sync::Arc<str> and \
                 From<CaixaDialeto> for &'static str must resolve \
                 identically on CaixaDialeto::{variant:?} — divergence \
                 signals the owned-input std::sync::Arc<str> and \
                 &'static str return-shape paths have drifted onto \
                 different emit-sets"
            );
            let owned_string: String = <String as From<CaixaDialeto>>::from(variant);
            assert_eq!(
                via_trait.as_ref(),
                owned_string.as_str(),
                "From<CaixaDialeto> for std::sync::Arc<str> and \
                 From<CaixaDialeto> for String must resolve identically \
                 on CaixaDialeto::{variant:?} — divergence signals the \
                 owned-input std::sync::Arc<str> and owned-`String` \
                 return-shape paths have drifted onto different emit-sets"
            );
            let owned_cow: std::borrow::Cow<'static, str> =
                <std::borrow::Cow<'static, str> as From<CaixaDialeto>>::from(variant);
            assert_eq!(
                via_trait.as_ref(),
                owned_cow.as_ref(),
                "From<CaixaDialeto> for std::sync::Arc<str> and \
                 From<CaixaDialeto> for Cow<'static, str> must resolve \
                 identically on CaixaDialeto::{variant:?} — divergence \
                 signals the owned-input std::sync::Arc<str> and \
                 Cow<'static, str> return-shape paths have drifted onto \
                 different emit-sets"
            );
            let owned_box: Box<str> = <Box<str> as From<CaixaDialeto>>::from(variant);
            assert_eq!(
                via_trait.as_ref(),
                owned_box.as_ref(),
                "From<CaixaDialeto> for std::sync::Arc<str> and \
                 From<CaixaDialeto> for Box<str> must resolve identically \
                 on CaixaDialeto::{variant:?} — divergence signals the \
                 owned-input std::sync::Arc<str> and Box<str> return-\
                 shape paths have drifted onto different emit-sets"
            );
        }
    }

    #[test]
    #[allow(
        clippy::too_many_lines,
        reason = "cross-axis partition pin folds four borrowed-input \
                  return-shape paths (&'static str, String, Cow<'static, \
                  str>, Box<str>) plus the paired owned-input Arc<str> \
                  witness and the .iter().map(std::sync::Arc::<str>::from) \
                  pipe witness into one exhaustive round-trip over \
                  CaixaDialeto::ALL — the accepted line-count cost of \
                  keying the whole borrowed-input Arc<str> corner to the \
                  substrate-primitive as_str accessor at the same test-site"
    )]
    fn caixa_dialeto_from_borrowed_into_arc_str_routes_through_as_str_accessor() {
        // Fail-before-pass-after byte-parity pin on the newly lifted
        // `impl From<&CaixaDialeto> for std::sync::Arc<str>` — asserts the
        // borrowed-input standard-library trait impl and the substrate-
        // primitive [`super::CaixaDialeto::as_str`] `pub const fn` accessor
        // resolve to the same four-arm PascalCase emit-set across every
        // arm the exhaustive [`super::CaixaDialeto::ALL`] slice enumerates.
        // Rust's standard library does not carry a 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
        // the borrowed-input `std::sync::Arc<str>` forward-projection axis
        // is a distinct trait-idiomatic surface that a
        // `let key: std::sync::Arc<str> = (&dialeto).into();`-shaped call
        // site or a
        // `CaixaDialeto::ALL.iter().map(std::sync::Arc::<str>::from)`-shaped
        // pipe reaches through this impl and no other — the paired owned-
        // input `From<CaixaDialeto> for std::sync::Arc<str>` impl alone
        // forces every borrowed-input call site through a spurious `Copy`
        // deref (`std::sync::Arc::<str>::from((*dialeto).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 caixa-
        // core-internal tier of the substrate-wide trait-idiomatic
        // [`std::sync::Arc<str>`] forward-projection campaign for the
        // third caixa-core-internal enum peer, matching the
        // `{Self, &Self} × {&'static str, String, Cow<'static, str>,
        // Box<str>}` 2×4 forward-projection matrix the peer projection
        // surfaces already close on this same enum.
        //
        // Cross-axis partition pin against the paired owned-input
        // [`From<CaixaDialeto> for std::sync::Arc<str>`] and the sibling
        // borrowed-input `{&'static str, String, Cow<'static, str>,
        // Box<str>}` return-shape axes — locking the five return-shape ×
        // input-shape paths on the borrowed-input surface together by
        // construction so any future detour off the substrate-primitive
        // accessor trips at caixa-core test time. Then a
        // `.iter().map(std::sync::Arc::<str>::from)` pipe witness over
        // [`super::CaixaDialeto::ALL`] — whose iterator yields
        // `&CaixaDialeto` by construction, so the borrowed-input
        // [`std::sync::Arc<str>`] axis is what routes the pipe through the
        // substrate-primitive [`super::CaixaDialeto::as_str`] accessor
        // without a spurious [`Copy`] deref (which would only be reachable
        // through the owned-input
        // [`From<CaixaDialeto> for std::sync::Arc<str>`] axis by first
        // calling `.copied()` on the iterator).
        for &variant in CaixaDialeto::ALL {
            let via_trait: std::sync::Arc<str> =
                <std::sync::Arc<str> as From<&CaixaDialeto>>::from(&variant);
            let via_method: &'static str = variant.as_str();
            assert_eq!(
                via_trait.as_ref(),
                via_method,
                "From<&CaixaDialeto> for std::sync::Arc<str> impl must \
                 round-trip &CaixaDialeto::{variant:?} to the same \
                 PascalCase byte-string CaixaDialeto::as_str returns — \
                 divergence signals a silent detour off the substrate-\
                 primitive accessor"
            );
            let via_into: std::sync::Arc<str> = (&variant).into();
            assert_eq!(
                via_into.as_ref(),
                via_method,
                "Into<std::sync::Arc<str>>::into on &CaixaDialeto::\
                 {variant:?} must byte-equal CaixaDialeto::as_str on the \
                 same input — the blanket-derived Into shape on the \
                 borrowed-input surface must resolve to the same as_str \
                 dispatch as the explicit From impl"
            );
            let owned_arc: std::sync::Arc<str> =
                <std::sync::Arc<str> as From<CaixaDialeto>>::from(variant);
            assert_eq!(
                via_trait, owned_arc,
                "From<&CaixaDialeto> for std::sync::Arc<str> and \
                 From<CaixaDialeto> for std::sync::Arc<str> must resolve \
                 identically on CaixaDialeto::{variant:?} — divergence \
                 signals the borrowed-input and owned-input \
                 std::sync::Arc<str> forward-projection input-shape paths \
                 have drifted onto different emit-sets"
            );
            let borrowed_static: &'static str =
                <&'static str as From<&CaixaDialeto>>::from(&variant);
            assert_eq!(
                via_trait.as_ref(),
                borrowed_static,
                "From<&CaixaDialeto> for std::sync::Arc<str> and \
                 From<&CaixaDialeto> for &'static str must resolve \
                 identically on CaixaDialeto::{variant:?} — divergence \
                 signals the borrowed-input std::sync::Arc<str> and \
                 &'static str return-shape paths have drifted onto \
                 different emit-sets"
            );
            let borrowed_string: String = <String as From<&CaixaDialeto>>::from(&variant);
            assert_eq!(
                via_trait.as_ref(),
                borrowed_string.as_str(),
                "From<&CaixaDialeto> for std::sync::Arc<str> and \
                 From<&CaixaDialeto> for String must resolve identically \
                 on CaixaDialeto::{variant:?} — divergence signals the \
                 borrowed-input std::sync::Arc<str> and owned-`String` \
                 return-shape paths have drifted onto different emit-sets"
            );
            let borrowed_cow: std::borrow::Cow<'static, str> =
                <std::borrow::Cow<'static, str> as From<&CaixaDialeto>>::from(&variant);
            assert_eq!(
                via_trait.as_ref(),
                borrowed_cow.as_ref(),
                "From<&CaixaDialeto> for std::sync::Arc<str> and \
                 From<&CaixaDialeto> for Cow<'static, str> must resolve \
                 identically on CaixaDialeto::{variant:?} — divergence \
                 signals the borrowed-input std::sync::Arc<str> and \
                 Cow<'static, str> return-shape paths have drifted onto \
                 different emit-sets"
            );
            let borrowed_box: Box<str> = <Box<str> as From<&CaixaDialeto>>::from(&variant);
            assert_eq!(
                via_trait.as_ref(),
                borrowed_box.as_ref(),
                "From<&CaixaDialeto> for std::sync::Arc<str> and \
                 From<&CaixaDialeto> for Box<str> must resolve \
                 identically on CaixaDialeto::{variant:?} — divergence \
                 signals the borrowed-input std::sync::Arc<str> and \
                 Box<str> return-shape paths have drifted onto different \
                 emit-sets"
            );
        }
        let via_iter: Vec<std::sync::Arc<str>> = CaixaDialeto::ALL
            .iter()
            .map(std::sync::Arc::<str>::from)
            .collect();
        let via_method: Vec<std::sync::Arc<str>> = CaixaDialeto::ALL
            .iter()
            .map(|d| std::sync::Arc::<str>::from(d.as_str()))
            .collect();
        assert_eq!(
            via_iter, via_method,
            "`.iter().map(std::sync::Arc::<str>::from)` over \
             CaixaDialeto::ALL — a call site whose iteration axis holds \
             `&CaixaDialeto` by construction — must byte-equal \
             `.iter().map(|d| std::sync::Arc::<str>::from(d.as_str()))` \
             on every arm — the borrowed-input std::sync::Arc<str> \
             `From<&CaixaDialeto> for std::sync::Arc<str>` axis is what \
             makes the `std::sync::Arc::<str>::from` composition route \
             through the substrate-primitive `CaixaDialeto::as_str` \
             accessor without a spurious `Copy` deref (which would only \
             be reachable through the owned-input \
             `From<CaixaDialeto> for std::sync::Arc<str>` axis by first \
             calling `.copied()` on the iterator)"
        );
    }

    #[test]
    fn caixa_dialeto_from_into_rc_str_routes_through_as_str_accessor() {
        // Fail-before-pass-after byte-parity pin on the newly lifted
        // `impl From<CaixaDialeto> for std::rc::Rc<str>` — asserts the
        // owned-input standard-library trait impl and the substrate-
        // primitive [`super::CaixaDialeto::as_str`] `pub const fn` accessor
        // resolve to the same four-arm PascalCase emit-set across every
        // arm the exhaustive [`super::CaixaDialeto::ALL`] slice enumerates.
        // Extends the caixa-core-internal tier of the substrate-wide
        // [`std::rc::Rc<str>`] forward-projection campaign onto the second
        // caixa-core-internal peer, after the structurally most
        // fundamental [`super::super::CaixaKind`] pair (4fdfa37, both
        // corners in one axis) opened the campaign. 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>` (nor an
        // `impl<T: fmt::Display> From<T> for std::rc::Rc<str>`), and — the
        // `std::sync::Arc<str>` and `std::rc::Rc<str>` trait tables are
        // disjoint — so this axis is a distinct trait-idiomatic surface
        // that a `let key: std::rc::Rc<str> = dialeto.into();`-shaped
        // call site reaches through this impl and no other.
        //
        // Cross-axis byte-parity witness against the sibling owned-input
        // `{&'static str, String, Cow<'static, str>, Box<str>,
        // std::sync::Arc<str>}` return-shape axes — locking the six
        // return-shape paths on the owned-input surface together by
        // construction so any future detour off the substrate-primitive
        // [`super::CaixaDialeto::as_str`] accessor trips at caixa-core
        // test time.
        for &variant in CaixaDialeto::ALL {
            let via_trait: std::rc::Rc<str> =
                <std::rc::Rc<str> as From<CaixaDialeto>>::from(variant);
            let via_method: &'static str = variant.as_str();
            assert_eq!(
                via_trait.as_ref(),
                via_method,
                "From<CaixaDialeto> for std::rc::Rc<str> impl must \
                 round-trip CaixaDialeto::{variant:?} to the same \
                 PascalCase byte-string CaixaDialeto::as_str returns — \
                 divergence signals a silent detour off the substrate-\
                 primitive accessor"
            );
            let via_into: std::rc::Rc<str> = variant.into();
            assert_eq!(
                via_into.as_ref(),
                via_method,
                "Into<std::rc::Rc<str>>::into on CaixaDialeto::\
                 {variant:?} must byte-equal CaixaDialeto::as_str on the \
                 same input — the blanket-derived Into shape must resolve \
                 to the same as_str dispatch as the explicit From impl"
            );
            let owned_static: &'static str = <&'static str as From<CaixaDialeto>>::from(variant);
            assert_eq!(
                via_trait.as_ref(),
                owned_static,
                "From<CaixaDialeto> for std::rc::Rc<str> and \
                 From<CaixaDialeto> for &'static str must resolve \
                 identically on CaixaDialeto::{variant:?} — divergence \
                 signals the owned-input std::rc::Rc<str> and \
                 &'static str return-shape paths have drifted onto \
                 different emit-sets"
            );
            let owned_string: String = <String as From<CaixaDialeto>>::from(variant);
            assert_eq!(
                via_trait.as_ref(),
                owned_string.as_str(),
                "From<CaixaDialeto> for std::rc::Rc<str> and \
                 From<CaixaDialeto> for String must resolve identically \
                 on CaixaDialeto::{variant:?} — divergence signals the \
                 owned-input std::rc::Rc<str> and owned-`String` \
                 return-shape paths have drifted onto different emit-sets"
            );
            let owned_cow: std::borrow::Cow<'static, str> =
                <std::borrow::Cow<'static, str> as From<CaixaDialeto>>::from(variant);
            assert_eq!(
                via_trait.as_ref(),
                owned_cow.as_ref(),
                "From<CaixaDialeto> for std::rc::Rc<str> and \
                 From<CaixaDialeto> for Cow<'static, str> must resolve \
                 identically on CaixaDialeto::{variant:?} — divergence \
                 signals the owned-input std::rc::Rc<str> and \
                 Cow<'static, str> return-shape paths have drifted onto \
                 different emit-sets"
            );
            let owned_box: Box<str> = <Box<str> as From<CaixaDialeto>>::from(variant);
            assert_eq!(
                via_trait.as_ref(),
                owned_box.as_ref(),
                "From<CaixaDialeto> for std::rc::Rc<str> and \
                 From<CaixaDialeto> for Box<str> must resolve identically \
                 on CaixaDialeto::{variant:?} — divergence signals the \
                 owned-input std::rc::Rc<str> and Box<str> return-\
                 shape paths have drifted onto different emit-sets"
            );
            let owned_arc: std::sync::Arc<str> =
                <std::sync::Arc<str> as From<CaixaDialeto>>::from(variant);
            assert_eq!(
                via_trait.as_ref(),
                owned_arc.as_ref(),
                "From<CaixaDialeto> for std::rc::Rc<str> and \
                 From<CaixaDialeto> for std::sync::Arc<str> must resolve \
                 identically on CaixaDialeto::{variant:?} — divergence \
                 signals the owned-input std::rc::Rc<str> and \
                 std::sync::Arc<str> return-shape paths have drifted \
                 onto different emit-sets"
            );
        }
    }

    #[test]
    #[allow(
        clippy::too_many_lines,
        reason = "cross-axis partition pin folds five borrowed-input \
                  return-shape paths (&'static str, String, Cow<'static, \
                  str>, Box<str>, std::sync::Arc<str>) plus the paired \
                  owned-input Rc<str> witness and the \
                  .iter().map(std::rc::Rc::<str>::from) pipe witness into \
                  one exhaustive round-trip over CaixaDialeto::ALL — the \
                  accepted line-count cost of keying the whole borrowed-\
                  input Rc<str> corner to the substrate-primitive as_str \
                  accessor at the same test-site"
    )]
    fn caixa_dialeto_from_borrowed_into_rc_str_routes_through_as_str_accessor() {
        // Fail-before-pass-after byte-parity pin on the newly lifted
        // `impl From<&CaixaDialeto> for std::rc::Rc<str>` — asserts the
        // borrowed-input standard-library trait impl and the substrate-
        // primitive [`super::CaixaDialeto::as_str`] `pub const fn` accessor
        // resolve to the same four-arm PascalCase emit-set across every
        // arm the exhaustive [`super::CaixaDialeto::ALL`] slice enumerates.
        // Rust's standard library does not carry a 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
        // the borrowed-input `std::rc::Rc<str>` forward-projection axis is
        // a distinct trait-idiomatic surface that a
        // `let key: std::rc::Rc<str> = (&dialeto).into();`-shaped call
        // site or a
        // `CaixaDialeto::ALL.iter().map(std::rc::Rc::<str>::from)`-shaped
        // pipe reaches through this impl and no other.
        //
        // Cross-axis partition pin against the paired owned-input
        // [`From<CaixaDialeto> 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 — locking the
        // six return-shape × input-shape paths on the borrowed-input
        // surface together by construction so any future detour off the
        // substrate-primitive accessor trips at caixa-core test time.
        // Then a `.iter().map(std::rc::Rc::<str>::from)` pipe witness
        // over [`super::CaixaDialeto::ALL`] — whose iterator yields
        // `&CaixaDialeto` by construction, so the borrowed-input
        // [`std::rc::Rc<str>`] axis is what routes the pipe through the
        // substrate-primitive [`super::CaixaDialeto::as_str`] accessor
        // without a spurious [`Copy`] deref.
        for &variant in CaixaDialeto::ALL {
            let via_trait: std::rc::Rc<str> =
                <std::rc::Rc<str> as From<&CaixaDialeto>>::from(&variant);
            let via_method: &'static str = variant.as_str();
            assert_eq!(
                via_trait.as_ref(),
                via_method,
                "From<&CaixaDialeto> for std::rc::Rc<str> impl must \
                 round-trip &CaixaDialeto::{variant:?} to the same \
                 PascalCase byte-string CaixaDialeto::as_str returns — \
                 divergence signals a silent detour off the substrate-\
                 primitive accessor"
            );
            let via_into: std::rc::Rc<str> = (&variant).into();
            assert_eq!(
                via_into.as_ref(),
                via_method,
                "Into<std::rc::Rc<str>>::into on &CaixaDialeto::\
                 {variant:?} must byte-equal CaixaDialeto::as_str on the \
                 same input — the blanket-derived Into shape on the \
                 borrowed-input surface must resolve to the same as_str \
                 dispatch as the explicit From impl"
            );
            let owned_rc: std::rc::Rc<str> =
                <std::rc::Rc<str> as From<CaixaDialeto>>::from(variant);
            assert_eq!(
                via_trait, owned_rc,
                "From<&CaixaDialeto> for std::rc::Rc<str> and \
                 From<CaixaDialeto> for std::rc::Rc<str> must resolve \
                 identically on CaixaDialeto::{variant:?} — divergence \
                 signals the borrowed-input and owned-input \
                 std::rc::Rc<str> forward-projection input-shape paths \
                 have drifted onto different emit-sets"
            );
            let borrowed_static: &'static str =
                <&'static str as From<&CaixaDialeto>>::from(&variant);
            assert_eq!(
                via_trait.as_ref(),
                borrowed_static,
                "From<&CaixaDialeto> for std::rc::Rc<str> and \
                 From<&CaixaDialeto> for &'static str must resolve \
                 identically on CaixaDialeto::{variant:?} — divergence \
                 signals the borrowed-input std::rc::Rc<str> and \
                 &'static str return-shape paths have drifted onto \
                 different emit-sets"
            );
            let borrowed_string: String = <String as From<&CaixaDialeto>>::from(&variant);
            assert_eq!(
                via_trait.as_ref(),
                borrowed_string.as_str(),
                "From<&CaixaDialeto> for std::rc::Rc<str> and \
                 From<&CaixaDialeto> for String must resolve identically \
                 on CaixaDialeto::{variant:?} — divergence signals the \
                 borrowed-input std::rc::Rc<str> and owned-`String` \
                 return-shape paths have drifted onto different emit-sets"
            );
            let borrowed_cow: std::borrow::Cow<'static, str> =
                <std::borrow::Cow<'static, str> as From<&CaixaDialeto>>::from(&variant);
            assert_eq!(
                via_trait.as_ref(),
                borrowed_cow.as_ref(),
                "From<&CaixaDialeto> for std::rc::Rc<str> and \
                 From<&CaixaDialeto> for Cow<'static, str> must resolve \
                 identically on CaixaDialeto::{variant:?} — divergence \
                 signals the borrowed-input std::rc::Rc<str> and \
                 Cow<'static, str> return-shape paths have drifted onto \
                 different emit-sets"
            );
            let borrowed_box: Box<str> = <Box<str> as From<&CaixaDialeto>>::from(&variant);
            assert_eq!(
                via_trait.as_ref(),
                borrowed_box.as_ref(),
                "From<&CaixaDialeto> for std::rc::Rc<str> and \
                 From<&CaixaDialeto> for Box<str> must resolve \
                 identically on CaixaDialeto::{variant:?} — divergence \
                 signals the borrowed-input std::rc::Rc<str> and \
                 Box<str> return-shape paths have drifted onto different \
                 emit-sets"
            );
            let borrowed_arc: std::sync::Arc<str> =
                <std::sync::Arc<str> as From<&CaixaDialeto>>::from(&variant);
            assert_eq!(
                via_trait.as_ref(),
                borrowed_arc.as_ref(),
                "From<&CaixaDialeto> for std::rc::Rc<str> and \
                 From<&CaixaDialeto> for std::sync::Arc<str> must \
                 resolve identically on CaixaDialeto::{variant:?} — \
                 divergence signals the borrowed-input std::rc::Rc<str> \
                 and std::sync::Arc<str> return-shape paths have drifted \
                 onto different emit-sets"
            );
        }
        let via_iter: Vec<std::rc::Rc<str>> = CaixaDialeto::ALL
            .iter()
            .map(std::rc::Rc::<str>::from)
            .collect();
        let via_method: Vec<std::rc::Rc<str>> = CaixaDialeto::ALL
            .iter()
            .map(|d| std::rc::Rc::<str>::from(d.as_str()))
            .collect();
        assert_eq!(
            via_iter, via_method,
            "`.iter().map(std::rc::Rc::<str>::from)` over \
             CaixaDialeto::ALL — a call site whose iteration axis holds \
             `&CaixaDialeto` by construction — must byte-equal \
             `.iter().map(|d| std::rc::Rc::<str>::from(d.as_str()))` \
             on every arm — the borrowed-input std::rc::Rc<str> \
             `From<&CaixaDialeto> for std::rc::Rc<str>` axis is what \
             makes the `std::rc::Rc::<str>::from` composition route \
             through the substrate-primitive `CaixaDialeto::as_str` \
             accessor without a spurious `Copy` deref (which would only \
             be reachable through the owned-input \
             `From<CaixaDialeto> for std::rc::Rc<str>` axis by first \
             calling `.copied()` on the iterator)"
        );
    }

    #[test]
    #[allow(
        clippy::too_many_lines,
        reason = "cross-axis partition pin folds the substrate-primitive \
                  as_str accessor's `.as_bytes()` byte-tail plus the \
                  paired str-view (AsRef<str>, Display, as_str) and \
                  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 plus a <T: AsRef<[u8]>>-bound-consumer \
                  witness plus a blake3::Hasher::update-shape byte-\
                  input surface witness into one exhaustive round-trip \
                  over CaixaDialeto::ALL — the accepted line-count cost \
                  of opening the byte-view axis keyed to the substrate-\
                  primitive as_str accessor at the same test-site"
    )]
    #[allow(
        clippy::needless_borrows_for_generic_args,
        reason = "the borrowed-input surface (&variant) is exercised \
                  deliberately: the `<T: AsRef<[u8]>>`-bound consumer \
                  and the `blake3::Hasher::update`-shape byte-input \
                  surface both accept either owned or borrowed input \
                  through the standard-library blanket \
                  `impl<T: ?Sized + AsRef<[u8]>> AsRef<[u8]> for &T`, \
                  and this pin round-trips both input shapes to lock \
                  the borrowed-input path load-bearing against a \
                  future silent regression"
    )]
    fn caixa_dialeto_as_ref_bytes_routes_through_as_str_accessor() {
        // `<T: AsRef<[u8]>>`-bound-consumer witness helper: a generic
        // byte-input function accepts a [`super::CaixaDialeto`]
        // directly through the trait bound, without the caller open-
        // coding the two-hop `dialeto.as_str().as_bytes()`
        // composition. Lifted to the top of the function per
        // `clippy::items_after_statements`.
        fn generic_bytes_sink<T: AsRef<[u8]>>(t: T) -> Vec<u8> {
            t.as_ref().to_vec()
        }
        // `blake3::Hasher::update`-shape byte-input surface mock:
        // mirrors `blake3::Hasher::update` / `ring::digest::Context::
        // update` / `sha2::Sha256::update`'s `impl AsRef<[u8]>`-bound
        // `update` signature so a per-caixa BLAKE3 content-address
        // closure that composes `hasher.update(dialeto)` on the
        // [`crate::Lacre`] closure builder reaches the substrate-
        // primitive `as_str` accessor through the
        // [`super::CaixaDialeto`] `AsRef<[u8]>` axis and no other.
        // Lifted to the top of the function per
        // `clippy::items_after_statements`.
        struct MockHasher(Vec<u8>);
        impl MockHasher {
            fn new() -> Self {
                Self(Vec::new())
            }
            fn update(&mut self, bytes: impl AsRef<[u8]>) -> &mut Self {
                self.0.extend_from_slice(bytes.as_ref());
                self
            }
            fn finalize(self) -> Vec<u8> {
                self.0
            }
        }

        // Fail-before-pass-after byte-parity pin on the newly lifted
        // `impl AsRef<[u8]> for CaixaDialeto` — asserts the trait-
        // idiomatic byte-view standard-library impl and the substrate-
        // primitive [`super::CaixaDialeto::as_str`] `pub const fn`
        // accessor's `.as_bytes()` byte-tail resolve to the same
        // four-arm PascalCase-byte-string emit-set across every arm
        // the exhaustive [`super::CaixaDialeto::ALL`] slice enumerates.
        // Extends the substrate-wide trait-idiomatic byte-view axis
        // onto the second closed-set fieldless typed enum on the
        // caixa-core-internal tier — matching the trajectory the
        // sibling [`super::CaixaKind`] first-mover
        // [`AsRef<[u8]>`] impl (69d8d86) walked before it.
        for &variant in CaixaDialeto::ALL {
            let via_trait: &[u8] = <CaixaDialeto as AsRef<[u8]>>::as_ref(&variant);
            let via_method_bytes: &[u8] = variant.as_str().as_bytes();
            assert_eq!(
                via_trait, via_method_bytes,
                "AsRef<[u8]> for CaixaDialeto impl must byte-equal \
                 CaixaDialeto::as_str().as_bytes() on CaixaDialeto::\
                 {variant:?} — divergence signals a silent detour off \
                 the substrate-primitive accessor"
            );
            // Cross-axis witness against the paired str-view axes'
            // `.as_bytes()` byte-tails: [`AsRef<str>`] /
            // [`std::fmt::Display`] / [`super::CaixaDialeto::as_str`]
            // all resolve to the same lifted `CAIXA_DIALETO_WIRE_*`
            // const roster, and the byte-view axis must byte-equal
            // each of their `.as_bytes()` byte-tails by construction
            // — locking the str-view and byte-view axes together at
            // the substrate-primitive accessor.
            let str_view_ref: &str = <CaixaDialeto as AsRef<str>>::as_ref(&variant);
            assert_eq!(
                via_trait,
                str_view_ref.as_bytes(),
                "AsRef<[u8]> for CaixaDialeto and AsRef<str> for \
                 CaixaDialeto must resolve to byte-equal byte-tails \
                 on CaixaDialeto::{variant:?} — divergence signals \
                 the byte-view and str-view axes have drifted off the \
                 same substrate-primitive as_str accessor"
            );
            let display_bytes = variant.to_string();
            assert_eq!(
                via_trait,
                display_bytes.as_bytes(),
                "AsRef<[u8]> for CaixaDialeto and \
                 <CaixaDialeto as std::fmt::Display>::to_string must \
                 resolve to byte-equal byte-tails on CaixaDialeto::\
                 {variant:?} — divergence signals the byte-view axis \
                 and the Display formatter axis have drifted off the \
                 same substrate-primitive as_str accessor"
            );
            // Cross-axis witness against the paired reverse-
            // projection axes' `.as_bytes()` byte-tails: every one of
            // `{&'static str, String, Cow<'static, str>, Box<str>,
            // std::sync::Arc<str>, std::rc::Rc<str>}` allocates (or
            // borrows) the same PascalCase byte-string the substrate-
            // primitive accessor emits, so the byte-view axis must
            // byte-equal each of their `.as_bytes()` byte-tails by
            // construction.
            let owned_static: &'static str = <&'static str as From<CaixaDialeto>>::from(variant);
            assert_eq!(
                via_trait,
                owned_static.as_bytes(),
                "AsRef<[u8]> for CaixaDialeto and From<CaixaDialeto> \
                 for &'static str must resolve to byte-equal byte-\
                 tails on CaixaDialeto::{variant:?}"
            );
            let owned_string: String = <String as From<CaixaDialeto>>::from(variant);
            assert_eq!(
                via_trait,
                owned_string.as_bytes(),
                "AsRef<[u8]> for CaixaDialeto and From<CaixaDialeto> \
                 for String must resolve to byte-equal byte-tails on \
                 CaixaDialeto::{variant:?}"
            );
            let owned_cow: std::borrow::Cow<'static, str> =
                <std::borrow::Cow<'static, str> as From<CaixaDialeto>>::from(variant);
            assert_eq!(
                via_trait,
                owned_cow.as_bytes(),
                "AsRef<[u8]> for CaixaDialeto and From<CaixaDialeto> \
                 for Cow<'static, str> must resolve to byte-equal \
                 byte-tails on CaixaDialeto::{variant:?}"
            );
            let owned_box: Box<str> = <Box<str> as From<CaixaDialeto>>::from(variant);
            assert_eq!(
                via_trait,
                owned_box.as_bytes(),
                "AsRef<[u8]> for CaixaDialeto and From<CaixaDialeto> \
                 for Box<str> must resolve to byte-equal byte-tails \
                 on CaixaDialeto::{variant:?}"
            );
            let owned_arc: std::sync::Arc<str> =
                <std::sync::Arc<str> as From<CaixaDialeto>>::from(variant);
            assert_eq!(
                via_trait,
                owned_arc.as_bytes(),
                "AsRef<[u8]> for CaixaDialeto and From<CaixaDialeto> \
                 for std::sync::Arc<str> must resolve to byte-equal \
                 byte-tails on CaixaDialeto::{variant:?}"
            );
            let owned_rc_str: std::rc::Rc<str> =
                <std::rc::Rc<str> as From<CaixaDialeto>>::from(variant);
            assert_eq!(
                via_trait,
                owned_rc_str.as_bytes(),
                "AsRef<[u8]> for CaixaDialeto and From<CaixaDialeto> \
                 for std::rc::Rc<str> must resolve to byte-equal \
                 byte-tails on CaixaDialeto::{variant:?}"
            );
        }
        // `<T: AsRef<[u8]>>`-bound-consumer witness: the generic byte-
        // input function `generic_bytes_sink` (lifted above per
        // `clippy::items_after_statements`) accepts a
        // [`super::CaixaDialeto`] directly through the trait bound,
        // without the caller open-coding the two-hop
        // `dialeto.as_str().as_bytes()` composition. This is the
        // shape that reaches the caixa-lacre BLAKE3 content-address
        // closure's `blake3::Hasher::update(impl AsRef<[u8]>)` byte-
        // input surface through this impl and no other. Exercised on
        // both owned and borrowed input surfaces via the standard-
        // library blanket `impl<T: ?Sized + AsRef<[u8]>>
        // AsRef<[u8]> for &T`.
        for &variant in CaixaDialeto::ALL {
            let via_generic = generic_bytes_sink(variant);
            let via_borrowed_generic = generic_bytes_sink(&variant);
            let via_method_bytes = variant.as_str().as_bytes().to_vec();
            assert_eq!(
                via_generic, via_method_bytes,
                "generic `<T: AsRef<[u8]>>`-bound consumer on \
                 CaixaDialeto::{variant:?} must yield the same byte-\
                 tail CaixaDialeto::as_str().as_bytes() returns — \
                 divergence signals the byte-view axis fails to \
                 bridge a generic byte-input trait bound to the \
                 substrate-primitive accessor"
            );
            assert_eq!(
                via_borrowed_generic, via_method_bytes,
                "generic `<T: AsRef<[u8]>>`-bound consumer on \
                 &CaixaDialeto::{variant:?} must yield the same byte-\
                 tail CaixaDialeto::as_str().as_bytes() returns — the \
                 borrowed-input surface must resolve to the same \
                 as_str dispatch"
            );
        }
        // `blake3::Hasher::update`-shape byte-input surface witness
        // on the caixa-lacre compounding target: the `MockHasher`
        // (lifted above per `clippy::items_after_statements`) mirrors
        // `blake3::Hasher::update` / `ring::digest::Context::update` /
        // `sha2::Sha256::update`'s `impl AsRef<[u8]>`-bound update
        // signature and accepts a [`super::CaixaDialeto`] directly,
        // routing its byte-tail through the substrate-primitive
        // `as_str` accessor — the shape a future per-caixa BLAKE3
        // content-address closure composes to fold a `:dialect`
        // classification byte-tag into the [`crate::Lacre`] closure
        // body.
        for &variant in CaixaDialeto::ALL {
            let mut owned_hasher = MockHasher::new();
            owned_hasher.update(variant);
            let owned_folded = owned_hasher.finalize();
            assert_eq!(
                owned_folded,
                variant.as_str().as_bytes(),
                "`hasher.update(dialeto)`-shape composition on \
                 CaixaDialeto::{variant:?} must fold the same byte-\
                 tail CaixaDialeto::as_str().as_bytes() returns — the \
                 shape a future per-caixa BLAKE3 content-address \
                 closure composes to fold a `:dialect` classification \
                 byte-tag into the Lacre closure body"
            );
            let mut borrowed_hasher = MockHasher::new();
            borrowed_hasher.update(&variant);
            let borrowed_folded = borrowed_hasher.finalize();
            assert_eq!(
                borrowed_folded,
                variant.as_str().as_bytes(),
                "`hasher.update(&dialeto)`-shape composition on \
                 &CaixaDialeto::{variant:?} must fold the same byte-\
                 tail CaixaDialeto::as_str().as_bytes() returns — the \
                 borrowed-input surface must resolve to the same \
                 as_str dispatch"
            );
        }
    }

    #[test]
    #[expect(
        clippy::too_many_lines,
        reason = "the byte-owned reverse-projection axis is extended \
                  onto CaixaDialeto here as the second peer on the \
                  substrate-wide byte-owned Vec<u8>-output projection \
                  family (after the sibling first-mover CaixaKind, \
                  b245fd6), so the pin binds the new impl against every \
                  paired byte-view and str-view axis on the same enum \
                  plus a generic <T: Into<Vec<u8>>>-bound consumer \
                  witness and a std::io::Write::write_all-shape owned-\
                  byte-sink surface witness on both owned and borrowed \
                  input shapes to lock the whole family against a \
                  future silent regression"
    )]
    fn caixa_dialeto_from_into_owned_vec_bytes_routes_through_as_str_accessor() {
        // `<T: Into<Vec<u8>>>`-bound-consumer witness helper: a generic
        // owned-byte-input function accepts a [`super::CaixaDialeto`]
        // directly through the trait bound, without the caller open-
        // coding the three-hop `dialeto.as_str().as_bytes().to_vec()`
        // composition. Lifted to the top of the function per
        // `clippy::items_after_statements`.
        fn generic_owned_bytes_sink<T: Into<Vec<u8>>>(t: T) -> Vec<u8> {
            t.into()
        }
        // `std::io::Write::write_all`-shape owned-byte-sink surface
        // mock: mirrors `std::io::Write::write_all` /
        // `bytes::BytesMut::extend_from_slice` / any per-arm audit-log
        // byte-sink that consumes a `Vec<u8>` payload via
        // `Into<Vec<u8>>`, so a future per-caixa per-`:dialect` audit-
        // log emit reaches the substrate-primitive `as_str` accessor
        // through the byte-owned reverse-projection axis and no other.
        // Lifted to the top of the function per
        // `clippy::items_after_statements`.
        struct MockOwnedByteSink(Vec<u8>);
        impl MockOwnedByteSink {
            fn new() -> Self {
                Self(Vec::new())
            }
            fn write_all(&mut self, bytes: impl Into<Vec<u8>>) -> &mut Self {
                self.0.extend_from_slice(&bytes.into());
                self
            }
            fn finalize(self) -> Vec<u8> {
                self.0
            }
        }

        // Fail-before-pass-after byte-parity pin on the newly lifted
        // `impl From<CaixaDialeto> for Vec<u8>` and
        // `impl From<&CaixaDialeto> for Vec<u8>` — asserts the trait-
        // idiomatic byte-owned reverse-projection standard-library
        // impls and the substrate-primitive
        // [`super::CaixaDialeto::as_str`] `pub const fn` accessor's
        // `.as_bytes().to_vec()` byte-tail resolve to the same four-arm
        // `PascalCase`-byte-string emit-set across every arm the
        // exhaustive [`super::CaixaDialeto::ALL`] slice enumerates.
        // Extends the substrate-wide trait-idiomatic byte-owned
        // reverse-projection axis onto the second closed-set fieldless
        // typed enum on the caixa-core-internal tier — matching the
        // trajectory the sibling first-mover [`super::CaixaKind`]
        // `From<{Self, &Self}> for Vec<u8>` impls (b245fd6) walked
        // before it on the caixa-core tier of the byte-owned axis.
        for &variant in CaixaDialeto::ALL {
            let via_owned_from: Vec<u8> = <Vec<u8> as From<CaixaDialeto>>::from(variant);
            let via_borrowed_from: Vec<u8> = <Vec<u8> as From<&CaixaDialeto>>::from(&variant);
            let via_method_bytes: Vec<u8> = variant.as_str().as_bytes().to_vec();
            assert_eq!(
                via_owned_from, via_method_bytes,
                "From<CaixaDialeto> for Vec<u8> impl must byte-equal \
                 CaixaDialeto::as_str().as_bytes().to_vec() on \
                 CaixaDialeto::{variant:?} — divergence signals a \
                 silent detour off the substrate-primitive accessor"
            );
            assert_eq!(
                via_borrowed_from, via_method_bytes,
                "From<&CaixaDialeto> for Vec<u8> impl must byte-equal \
                 CaixaDialeto::as_str().as_bytes().to_vec() on \
                 CaixaDialeto::{variant:?} — divergence signals a \
                 silent detour off the substrate-primitive accessor"
            );
            assert_eq!(
                via_owned_from, via_borrowed_from,
                "From<CaixaDialeto> for Vec<u8> and From<&CaixaDialeto> \
                 for Vec<u8> must byte-equal each other on \
                 CaixaDialeto::{variant:?} — divergence signals the \
                 owned-input and borrowed-input paths have drifted off \
                 the same substrate-primitive as_str accessor"
            );
            // Cross-axis witness against the paired [`AsRef<[u8]>`]
            // borrowed byte-view axis: the byte-owned reverse-
            // projection axis must byte-equal the paired borrowed
            // byte-view axis by construction — locking the byte-view
            // and byte-owned axes together at the substrate-primitive
            // accessor.
            let borrowed_bytes: &[u8] = <CaixaDialeto as AsRef<[u8]>>::as_ref(&variant);
            assert_eq!(
                via_owned_from,
                borrowed_bytes.to_vec(),
                "From<CaixaDialeto> for Vec<u8> and AsRef<[u8]> for \
                 CaixaDialeto must resolve to byte-equal byte-tails on \
                 CaixaDialeto::{variant:?} — divergence signals the \
                 byte-owned and byte-view axes have drifted off the \
                 same substrate-primitive as_str accessor"
            );
            // Cross-axis witness against the str-owned reverse-
            // projection family's `.into_bytes()` / `.as_bytes().to_vec()`
            // byte-tails: every one of `{String, Cow<'static, str>,
            // Box<str>, std::sync::Arc<str>, std::rc::Rc<str>}`
            // allocates (or borrows) the same `PascalCase` byte-string
            // the substrate-primitive accessor emits, so the byte-
            // owned axis must byte-equal each of their owned byte-
            // tails by construction.
            let owned_string: String = <String as From<CaixaDialeto>>::from(variant);
            assert_eq!(
                via_owned_from,
                owned_string.into_bytes(),
                "From<CaixaDialeto> for Vec<u8> and \
                 String::from(dialeto).into_bytes() must resolve to \
                 byte-equal byte-tails on CaixaDialeto::{variant:?}"
            );
            let owned_cow: std::borrow::Cow<'static, str> =
                <std::borrow::Cow<'static, str> as From<CaixaDialeto>>::from(variant);
            assert_eq!(
                via_owned_from,
                owned_cow.as_bytes().to_vec(),
                "From<CaixaDialeto> for Vec<u8> and From<CaixaDialeto> \
                 for Cow<'static, str> must resolve to byte-equal \
                 byte-tails on CaixaDialeto::{variant:?}"
            );
            let owned_box: Box<str> = <Box<str> as From<CaixaDialeto>>::from(variant);
            assert_eq!(
                via_owned_from,
                owned_box.as_bytes().to_vec(),
                "From<CaixaDialeto> for Vec<u8> and From<CaixaDialeto> \
                 for Box<str> must resolve to byte-equal byte-tails on \
                 CaixaDialeto::{variant:?}"
            );
            let owned_arc: std::sync::Arc<str> =
                <std::sync::Arc<str> as From<CaixaDialeto>>::from(variant);
            assert_eq!(
                via_owned_from,
                owned_arc.as_bytes().to_vec(),
                "From<CaixaDialeto> for Vec<u8> and From<CaixaDialeto> \
                 for std::sync::Arc<str> must resolve to byte-equal \
                 byte-tails on CaixaDialeto::{variant:?}"
            );
            let owned_rc_str: std::rc::Rc<str> =
                <std::rc::Rc<str> as From<CaixaDialeto>>::from(variant);
            assert_eq!(
                via_owned_from,
                owned_rc_str.as_bytes().to_vec(),
                "From<CaixaDialeto> for Vec<u8> and From<CaixaDialeto> \
                 for std::rc::Rc<str> must resolve to byte-equal \
                 byte-tails on CaixaDialeto::{variant:?}"
            );
        }
        // `<T: Into<Vec<u8>>>`-bound-consumer witness on both owned
        // and borrowed input shapes: the generic owned-byte-input
        // function `generic_owned_bytes_sink` (lifted above per
        // `clippy::items_after_statements`) accepts a
        // [`super::CaixaDialeto`] and a `&CaixaDialeto` directly
        // through the trait bound, without the caller open-coding the
        // three-hop `dialeto.as_str().as_bytes().to_vec()` composition.
        for &variant in CaixaDialeto::ALL {
            let via_generic_owned = generic_owned_bytes_sink(variant);
            // Bind the borrowed-input path through an explicit
            // `&CaixaDialeto` local so the generic-consumer witness
            // routes through `From<&CaixaDialeto> for Vec<u8>` (T binds
            // to `&CaixaDialeto`) rather than clippy-collapsing the
            // borrow onto the owned-input `From<CaixaDialeto> for
            // Vec<u8>` peer.
            let variant_ref: &CaixaDialeto = &variant;
            let via_generic_borrowed = generic_owned_bytes_sink(variant_ref);
            let via_method_bytes = variant.as_str().as_bytes().to_vec();
            assert_eq!(
                via_generic_owned, via_method_bytes,
                "generic `<T: Into<Vec<u8>>>`-bound consumer on \
                 CaixaDialeto::{variant:?} must yield the same byte-\
                 tail CaixaDialeto::as_str().as_bytes().to_vec() \
                 returns — divergence signals the byte-owned axis \
                 fails to bridge a generic owned-byte-input trait \
                 bound to the substrate-primitive accessor"
            );
            assert_eq!(
                via_generic_borrowed, via_method_bytes,
                "generic `<T: Into<Vec<u8>>>`-bound consumer on \
                 &CaixaDialeto::{variant:?} must yield the same byte-\
                 tail CaixaDialeto::as_str().as_bytes().to_vec() \
                 returns — the borrowed-input surface must resolve to \
                 the same as_str dispatch"
            );
        }
        // `std::io::Write::write_all`-shape owned-byte-sink surface
        // witness: the `MockOwnedByteSink` (lifted above per
        // `clippy::items_after_statements`) mirrors
        // `std::io::Write::write_all` /
        // `bytes::BytesMut::extend_from_slice`'s `impl Into<Vec<u8>>`-
        // bound owned-byte input signature and accepts a
        // [`super::CaixaDialeto`] directly on both owned and borrowed
        // input shapes, routing its byte-tail through the substrate-
        // primitive `as_str` accessor — the shape a future per-caixa
        // per-`:dialect` audit-log emit composes to fold a `:dialect`
        // classification byte-tag into a downstream owned-byte-sink
        // surface.
        for &variant in CaixaDialeto::ALL {
            let mut owned_sink = MockOwnedByteSink::new();
            owned_sink.write_all(variant);
            let owned_folded = owned_sink.finalize();
            assert_eq!(
                owned_folded,
                variant.as_str().as_bytes(),
                "`sink.write_all(dialeto)`-shape composition on \
                 CaixaDialeto::{variant:?} must fold the same byte-\
                 tail CaixaDialeto::as_str().as_bytes() returns"
            );
            let mut borrowed_sink = MockOwnedByteSink::new();
            // Same explicit `&CaixaDialeto` binding as the generic-
            // consumer witness above: routes the owned-byte-sink
            // surface through `From<&CaixaDialeto> for Vec<u8>` (T
            // binds to `&CaixaDialeto`) rather than clippy-collapsing
            // the borrow onto the owned-input peer.
            let variant_ref: &CaixaDialeto = &variant;
            borrowed_sink.write_all(variant_ref);
            let borrowed_folded = borrowed_sink.finalize();
            assert_eq!(
                borrowed_folded,
                variant.as_str().as_bytes(),
                "`sink.write_all(&dialeto)`-shape composition on \
                 &CaixaDialeto::{variant:?} must fold the same byte-\
                 tail CaixaDialeto::as_str().as_bytes() returns — the \
                 borrowed-input surface must resolve to the same \
                 as_str dispatch"
            );
        }
    }

    #[test]
    fn caixa_dialeto_try_from_bytes_routes_through_from_wire_accessor() {
        // Fail-before-pass-after byte-parity pin on the newly lifted
        // `impl TryFrom<&[u8]> for CaixaDialeto` — asserts the trait-
        // idiomatic byte-view reverse-projection standard-library impl
        // and the substrate-primitive [`super::CaixaDialeto::from_wire`]
        // `Option<Self>` accessor resolve to the same four-arm
        // `PascalCase` wire accept-set across every arm the exhaustive
        // [`super::CaixaDialeto::ALL`] slice enumerates. Extends the
        // substrate-wide trait-idiomatic byte-view reverse-projection
        // axis onto the second caixa-core-internal closed-set fieldless
        // typed enum peer — mirror of the paired
        // [`TryFrom<&str> for CaixaDialeto`] str-view reverse-projection
        // axis on the same enum, and the byte-view companion of the
        // pre-existing byte-owned reverse-projection family
        // ([`AsRef<[u8]>`], [`From<CaixaDialeto> for Vec<u8>`],
        // [`From<&CaixaDialeto> for Vec<u8>`]) on this same enum. Peer
        // of the sibling
        // [`crate::kind::tests::caixa_kind_try_from_bytes_routes_through_from_wire_accessor`]
        // (18d1940) on the first-mover [`crate::CaixaKind`] closed-set
        // typed-enum peer — tracks 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 through the pre-
        // existing str-view reverse-projection axis alone. But that
        // two-hop shape has no compile-time link back to the byte-view
        // reverse-projection axis, forces every downstream
        // `<T: for<'a> TryFrom<&'a [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 byte-projection
        // axis whose parse arm-set carries no compile-time byte-view
        // surface. This impl closes the byte-view reverse-projection
        // axis at the substrate-primitive
        // [`super::CaixaDialeto::from_wire`] accessor so every future
        // `<T: for<'a> TryFrom<&'a [u8]>>`-bound consumer reaches the
        // same four-arm `PascalCase` wire accept-set through one trait
        // dispatch.
        for &variant in CaixaDialeto::ALL {
            let wire_bytes: &[u8] = variant.as_str().as_bytes();
            assert_eq!(
                <CaixaDialeto as TryFrom<&[u8]>>::try_from(wire_bytes),
                Ok(variant),
                "TryFrom<&[u8]> impl on CaixaDialeto must round-trip \
                 CaixaDialeto::{variant:?}.as_str().as_bytes() back to \
                 Ok(CaixaDialeto::{variant:?}) — divergence from \
                 CaixaDialeto::from_wire signals a silent detour off \
                 the substrate-primitive accessor"
            );
            assert_eq!(
                <CaixaDialeto as TryFrom<&[u8]>>::try_from(wire_bytes).ok(),
                CaixaDialeto::from_wire(variant.as_str()),
                "TryFrom<&[u8]> ok()-projection on \
                 CaixaDialeto::{variant:?}.as_str().as_bytes() must \
                 byte-equal CaixaDialeto::from_wire on the paired &str \
                 input"
            );
            // Cross-axis witness: the byte-view reverse-projection axis
            // must agree with the paired str-view reverse-projection
            // axis ([`TryFrom<&str>`]) on every accepted arm — the two
            // reverse paths share one `PascalCase` accept-set through
            // the substrate-primitive `from_wire` accessor.
            let via_str: Result<CaixaDialeto, ()> =
                <CaixaDialeto as TryFrom<&str>>::try_from(variant.as_str());
            let via_bytes: Result<CaixaDialeto, ()> =
                <CaixaDialeto as TryFrom<&[u8]>>::try_from(wire_bytes);
            assert_eq!(
                via_bytes, via_str,
                "TryFrom<&[u8]> and TryFrom<&str> reverse-projection \
                 axes on CaixaDialeto must agree on \
                 CaixaDialeto::{variant:?} — divergence signals the \
                 byte-view and str-view reverse paths have drifted off \
                 the same substrate-primitive from_wire accessor"
            );
        }
    }

    #[test]
    fn caixa_dialeto_try_from_bytes_rejects_unknown_and_non_utf8_bytes() {
        // Rejection witness on the `impl TryFrom<&[u8]> for CaixaDialeto`
        // — sweeps two rejection paths the byte-view reverse-projection
        // axis collapses onto the single unit-error `Err(())` return:
        // the invalid-UTF-8 rejection path ([`std::str::from_utf8`]
        // returns `Err` before [`super::CaixaDialeto::from_wire`] runs)
        // and the valid-UTF-8-but-unknown-wire rejection path
        // ([`super::CaixaDialeto::from_wire`] returns `None` on a byte-
        // string outside the four-arm `PascalCase` accept-set). Both
        // must reject, so a future accidental widening of the trait
        // impl's accept-set (a case-fold path, a silent acceptance of
        // the sibling [`super::CaixaDialeto::palavra_canonica`]
        // `"defcaixa"` / `"defmolde"` byte-shapes on this axis, a
        // `#[serde(rename_all = "…")]` attribute drift that widens the
        // parse arm-set silently, a stray fallback that maps invalid
        // UTF-8 onto a default arm rather than the trait-idiomatic
        // `Err(())`) trips at caixa-core test time. Peer of the sibling
        // [`crate::kind::tests::caixa_kind_try_from_bytes_rejects_unknown_and_non_utf8_bytes`]
        // (18d1940) on the first-mover [`crate::CaixaKind`] closed-set
        // typed-enum peer.
        //
        // Non-UTF-8 candidates:
        //   - a lone 0xFF byte (never valid as a UTF-8 leading byte)
        //   - a lone 0x80 continuation byte with no leading byte
        //   - a truncated multi-byte sequence (0xC3 without its continuation)
        //   - a UTF-16 BOM-style byte pair the UTF-8 validator rejects
        //   - a UTF-16 surrogate half rejected by UTF-8
        let non_utf8_rejected: &[&[u8]] = &[
            &[0xFF],
            &[0x80],
            &[0xC3],
            &[0xFF, 0xFE],
            &[0xED, 0xA0, 0x80],
        ];
        for &input in non_utf8_rejected {
            assert_eq!(
                <CaixaDialeto as TryFrom<&[u8]>>::try_from(input),
                Err(()),
                "TryFrom<&[u8]> impl on CaixaDialeto must reject the \
                 non-UTF-8 byte-sequence {input:?} with Err(()) — \
                 silent acceptance signals the UTF-8 validation path \
                 collapsed onto a default arm rather than the trait-\
                 idiomatic unit-error"
            );
        }
        // Valid-UTF-8-but-unknown-wire candidates: the empty byte-
        // string, case-folded variants of accepted arms, plausible
        // typos, the sibling [`super::CaixaDialeto::palavra_canonica`]
        // / [`super::CaixaDialeto::consumidor`] byte-shapes (a caller
        // who confuses those distinct axes with the census-facing wire
        // axis trips here), and whitespace-padded / quoted forms.
        let unknown_wire_rejected: &[&[u8]] = &[
            b"",
            b" ",
            b"pacote",
            b"PACOTE",
            b"molde",
            b"MoldePositional",
            b"desconhecido",
            b"Unknown",
            b"defcaixa",
            b"defmolde",
            b"?",
            b"caixa-core / feira",
            b"pleme-doc-gen",
            b"nobody known",
            b"Pacote ",
            b" Pacote",
            b"Pacote\n",
            b"\"Pacote\"",
        ];
        for &input in unknown_wire_rejected {
            assert_eq!(
                <CaixaDialeto as TryFrom<&[u8]>>::try_from(input),
                Err(()),
                "TryFrom<&[u8]> impl on CaixaDialeto must reject the \
                 valid-UTF-8-but-unknown-wire byte-string {input:?} \
                 with Err(()) — silent acceptance signals an accept-\
                 set widening off the paired CaixaDialeto::from_wire \
                 resolver"
            );
            // Cross-axis witness: on a byte-string that is valid UTF-8,
            // the byte-view reverse-projection axis must agree with the
            // paired str-view reverse-projection axis
            // ([`TryFrom<&str>`]) — both route through the same
            // [`super::CaixaDialeto::from_wire`] resolver, so the two
            // rejection paths align by construction.
            if let Ok(s) = std::str::from_utf8(input) {
                assert_eq!(
                    <CaixaDialeto as TryFrom<&[u8]>>::try_from(input),
                    <CaixaDialeto as TryFrom<&str>>::try_from(s),
                    "TryFrom<&[u8]> and TryFrom<&str> reverse-\
                     projection axes on CaixaDialeto must agree on the \
                     valid-UTF-8 input {input:?} — divergence signals \
                     the two reverse paths have drifted off the same \
                     substrate-primitive from_wire accessor"
                );
            }
        }
    }

    #[test]
    fn caixa_dialeto_try_from_vec_bytes_routes_through_borrowed_byte_view_axis() {
        // Fail-before-pass-after byte-parity pin on the newly lifted
        // `impl TryFrom<Vec<u8>> for CaixaDialeto` — asserts the trait-
        // idiomatic owned-byte-vec reverse-projection standard-library
        // impl and the sibling borrowed-input [`TryFrom<&[u8]>`] axis
        // resolve to the same four-arm `PascalCase` wire accept-set
        // across every arm the exhaustive [`super::CaixaDialeto::ALL`]
        // slice enumerates. Extends the substrate-wide trait-idiomatic
        // byte-owned reverse-projection axis onto the second caixa-
        // core-internal closed-set fieldless typed enum peer — owned-
        // input mirror of the paired [`TryFrom<&[u8]>`] byte-view
        // reverse-projection axis (d102cb8), and byte-owned reverse
        // companion of the pre-existing byte-owned *forward*-projection
        // pair ([`From<CaixaDialeto> for Vec<u8>`], [`From<&CaixaDialeto>
        // for Vec<u8>`]) on this same enum. Peer of the sibling
        // first-mover
        // [`crate::kind::tests::caixa_kind_try_from_vec_bytes_routes_through_borrowed_byte_view_axis`]
        // (99c2849) on the [`crate::CaixaKind`] closed-set typed-enum
        // peer — tracks the "delegate through `TryFrom<&[u8]>` on the
        // `Vec<u8>::as_slice` borrow" discipline the first-mover
        // established.
        //
        // Rust's standard library carries no blanket
        // `impl<T: for<'a> TryFrom<&'a [u8]>> TryFrom<Vec<u8>> for T`,
        // so an owned-byte-vec caller otherwise picks between an
        // open-coded `<T as TryFrom<&[u8]>>::try_from(bytes.as_slice())`
        // at every call site whose type bounds have no compile-time
        // link back to the byte-owned reverse-projection axis, or a
        // `String::from_utf8(bytes)` two-hop shape whose error surface
        // leaks the standard-library `FromUtf8Error` type. This impl
        // closes the byte-owned reverse-projection axis at the
        // substrate-primitive [`super::CaixaDialeto::from_wire`]
        // accessor so every future `<T: TryFrom<Vec<u8>>>`-bound owned-
        // byte-vec consumer reaches the same four-arm `PascalCase` wire
        // accept-set through one trait dispatch.
        for &variant in CaixaDialeto::ALL {
            let wire_bytes: Vec<u8> = variant.as_str().as_bytes().to_vec();
            assert_eq!(
                <CaixaDialeto as TryFrom<Vec<u8>>>::try_from(wire_bytes.clone()),
                Ok(variant),
                "TryFrom<Vec<u8>> impl on CaixaDialeto must round-trip \
                 CaixaDialeto::{variant:?}.as_str().as_bytes().to_vec() \
                 back to Ok(CaixaDialeto::{variant:?}) — divergence from \
                 the sibling TryFrom<&[u8]> axis signals a silent detour \
                 off the substrate-primitive from_wire accessor"
            );
            // Cross-axis witness: the owned-byte-vec reverse-projection
            // axis must agree with the borrowed byte-slice reverse-
            // projection axis on every accepted arm — the two axes
            // share one `PascalCase` wire vocabulary through the
            // substrate-primitive `from_wire` accessor, and the owned-
            // input axis delegates to the borrowed peer by design.
            let via_owned: Result<CaixaDialeto, ()> =
                <CaixaDialeto as TryFrom<Vec<u8>>>::try_from(wire_bytes.clone());
            let via_borrowed: Result<CaixaDialeto, ()> =
                <CaixaDialeto as TryFrom<&[u8]>>::try_from(wire_bytes.as_slice());
            assert_eq!(
                via_owned, via_borrowed,
                "TryFrom<Vec<u8>> and TryFrom<&[u8]> reverse-projection \
                 axes on CaixaDialeto must agree on \
                 CaixaDialeto::{variant:?} — divergence signals the \
                 owned-input and borrowed-input byte-view reverse \
                 paths have drifted off the same substrate-primitive \
                 from_wire accessor"
            );
            // Cross-axis witness against the paired str-view reverse
            // axis ([`TryFrom<&str>`]) — the three reverse paths (str-
            // view, byte-view borrowed, byte-view owned) share one
            // substrate primitive.
            let via_str: Result<CaixaDialeto, ()> =
                <CaixaDialeto as TryFrom<&str>>::try_from(variant.as_str());
            assert_eq!(
                via_owned, via_str,
                "TryFrom<Vec<u8>> and TryFrom<&str> reverse-projection \
                 axes on CaixaDialeto must agree on \
                 CaixaDialeto::{variant:?} — divergence signals the \
                 byte-owned and str-view reverse paths have drifted \
                 off the same substrate-primitive from_wire accessor"
            );
            // Four-corner witness: because [`CaixaDialeto`] carries no
            // wire-vs-diagnostic split (as_str and from_wire share one
            // `PascalCase` byte-vocabulary), the byte-owned reverse-
            // projection axis on this enum *does* round-trip against
            // the paired byte-owned forward-projection pair. Pin every
            // corner of the {owned-input, borrowed-input} ×
            // {From<Self> → Vec<u8>, From<&Self> → Vec<u8>} square onto
            // the same Ok(variant) return so a future accident that
            // drops one corner off the substrate-primitive accessor
            // trips here.
            let owned_forward: Vec<u8> = <Vec<u8> as From<CaixaDialeto>>::from(variant);
            let borrowed_forward: Vec<u8> = <Vec<u8> as From<&CaixaDialeto>>::from(&variant);
            assert_eq!(
                owned_forward, wire_bytes,
                "From<CaixaDialeto> for Vec<u8> forward projection on \
                 CaixaDialeto::{variant:?} must byte-equal \
                 variant.as_str().as_bytes().to_vec() — divergence \
                 signals the paired forward pair drifted off the \
                 substrate-primitive as_str accessor"
            );
            assert_eq!(
                borrowed_forward, wire_bytes,
                "From<&CaixaDialeto> for Vec<u8> forward projection on \
                 &CaixaDialeto::{variant:?} must byte-equal \
                 variant.as_str().as_bytes().to_vec() — divergence \
                 signals the paired forward pair drifted off the \
                 substrate-primitive as_str accessor"
            );
            assert_eq!(
                <CaixaDialeto as TryFrom<Vec<u8>>>::try_from(owned_forward.clone()),
                Ok(variant),
                "Four-corner round-trip on CaixaDialeto::{variant:?} \
                 through From<CaixaDialeto> for Vec<u8> then \
                 TryFrom<Vec<u8>> for CaixaDialeto must return \
                 Ok(variant) — divergence signals the byte-owned \
                 forward pair and the byte-owned reverse axis have \
                 drifted apart"
            );
            assert_eq!(
                <CaixaDialeto as TryFrom<Vec<u8>>>::try_from(borrowed_forward),
                Ok(variant),
                "Four-corner round-trip on CaixaDialeto::{variant:?} \
                 through From<&CaixaDialeto> for Vec<u8> then \
                 TryFrom<Vec<u8>> for CaixaDialeto must return \
                 Ok(variant) — divergence signals the borrowed-input \
                 forward corner and the owned-input reverse corner \
                 have drifted apart"
            );
        }
    }

    #[test]
    fn caixa_dialeto_try_from_vec_bytes_rejects_unknown_and_non_utf8_bytes() {
        // Rejection witness on the `impl TryFrom<Vec<u8>> for CaixaDialeto`
        // — sweeps the same two rejection paths the sibling borrowed
        // `TryFrom<&[u8]>` axis collapses onto the single unit-error
        // return: the invalid-UTF-8 rejection path (`std::str::from_utf8`
        // on the underlying byte-slice returns `Err` before
        // [`super::CaixaDialeto::from_wire`] runs) and the valid-UTF-8-
        // but-unknown-wire rejection path
        // ([`super::CaixaDialeto::from_wire`] returns `None` on a byte-
        // string outside the four-arm `PascalCase` accept-set). Both
        // must reject so a future accidental widening of the trait
        // impl's accept-set (a case-fold path, a silent acceptance of
        // the sibling [`super::CaixaDialeto::palavra_canonica`]
        // `"defcaixa"` / `"defmolde"` byte-shapes on this axis, a
        // `#[serde(rename_all = "…")]` attribute drift that widens the
        // parse arm-set silently, a stray `String::from_utf8_lossy`
        // detour that widens the input surface with the U+FFFD
        // replacement character, an `Option::unwrap_or_default`-shape
        // fallback that maps invalid UTF-8 onto a default arm rather
        // than the trait-idiomatic `Err(())`) trips at caixa-core test
        // time. Peer of the sibling first-mover
        // [`crate::kind::tests::caixa_kind_try_from_vec_bytes_rejects_unknown_and_non_utf8_bytes`]
        // (99c2849) on the [`crate::CaixaKind`] closed-set typed-enum
        // peer.
        let non_utf8_rejected: &[&[u8]] = &[
            &[0xFF],
            &[0x80],
            &[0xC3],
            &[0xFF, 0xFE],
            &[0xED, 0xA0, 0x80], // UTF-16 surrogate half — rejected by UTF-8
        ];
        for &input in non_utf8_rejected {
            let owned: Vec<u8> = input.to_vec();
            assert_eq!(
                <CaixaDialeto as TryFrom<Vec<u8>>>::try_from(owned),
                Err(()),
                "TryFrom<Vec<u8>> impl on CaixaDialeto must reject the \
                 non-UTF-8 byte-sequence {input:?} with Err(()) — \
                 silent acceptance signals the UTF-8 validation path \
                 collapsed onto a default arm rather than the trait-\
                 idiomatic unit-error"
            );
            // Cross-axis witness: the owned-input axis must agree with
            // the borrowed-input axis on every rejected input.
            assert_eq!(
                <CaixaDialeto as TryFrom<Vec<u8>>>::try_from(input.to_vec()),
                <CaixaDialeto as TryFrom<&[u8]>>::try_from(input),
                "TryFrom<Vec<u8>> and TryFrom<&[u8]> reverse-projection \
                 axes on CaixaDialeto must agree on the non-UTF-8 \
                 input {input:?} — divergence signals the owned-input \
                 and borrowed-input byte-view reverse paths have \
                 drifted off the same substrate-primitive from_wire \
                 accessor"
            );
        }
        // Valid-UTF-8-but-unknown-wire candidates: the empty byte-
        // string, case-folded variants of accepted arms, plausible
        // typos, the sibling [`super::CaixaDialeto::palavra_canonica`]
        // / [`super::CaixaDialeto::consumidor`] byte-shapes (a caller
        // who confuses those distinct axes with the census-facing wire
        // axis trips here), and whitespace-padded / quoted forms.
        let unknown_wire_rejected: &[&[u8]] = &[
            b"",
            b" ",
            b"pacote",
            b"PACOTE",
            b"molde",
            b"MoldePositional",
            b"desconhecido",
            b"Unknown",
            b"defcaixa",
            b"defmolde",
            b"?",
            b"caixa-core / feira",
            b"pleme-doc-gen",
            b"nobody known",
            b"Pacote ",
            b" Pacote",
            b"Pacote\n",
            b"\"Pacote\"",
        ];
        for &input in unknown_wire_rejected {
            let owned: Vec<u8> = input.to_vec();
            assert_eq!(
                <CaixaDialeto as TryFrom<Vec<u8>>>::try_from(owned),
                Err(()),
                "TryFrom<Vec<u8>> impl on CaixaDialeto must reject the \
                 valid-UTF-8-but-unknown-wire byte-string {input:?} \
                 with Err(()) — silent acceptance signals an accept-\
                 set widening off the paired CaixaDialeto::from_wire \
                 resolver"
            );
            // Cross-axis witness against the borrowed byte-view axis:
            // the two paths must agree by construction, since the owned
            // axis delegates to the borrowed peer.
            assert_eq!(
                <CaixaDialeto as TryFrom<Vec<u8>>>::try_from(input.to_vec()),
                <CaixaDialeto as TryFrom<&[u8]>>::try_from(input),
                "TryFrom<Vec<u8>> and TryFrom<&[u8]> reverse-projection \
                 axes on CaixaDialeto must agree on the valid-UTF-8-\
                 but-unknown-wire input {input:?} — divergence signals \
                 the owned-input and borrowed-input byte-view reverse \
                 paths have drifted off the same substrate-primitive \
                 from_wire accessor"
            );
        }
    }
}