Struct AplicacaoIntent 

pub struct AplicacaoIntent {
    pub chart_ref: String,
    pub version: String,
    pub profile: String,
    pub values_overlay: Value,
    pub release_name: Option<String>,
    pub target_namespace: Option<String>,
    pub install_timeout: Option<String>,
}

Aplicacao intent — emit a FluxCD HelmRelease for a pleme-io typed Aplicacao chart. The chart owns its own sub-chart DAG; the reconciler only watches HelmRelease.status.conditions[type=Ready].

This is the canonical handoff from caixa (defaplicacao …) declarations (which the typescape renders to this Intent) into in-cluster reconciliation. Closed-loop ephemeral test environments use this variant with :lifetime :ephemeral on the surrounding ProcessSpec.

Example (Lisp):

:intent (:aplicacao
          (:chart-ref "oci://ghcr.io/pleme-io/charts/lareira-demo-app"
           :version "0.5.5"
           :profile "all-in-one"
           :values-overlay (:cluster (:name "ephemeral-test-01")
                            :persistence false
                            :compliance (:overlays []))))

Fields

chart_ref: String

Helm chart reference. OCI (oci://…) or repo-relative (pleme-io/lareira-demo-app).

version: String

Chart version (Helm semver constraint; ">=0.5.5" allowed).

profile: String

Architecture profile from the chart’s values/*.yaml family (e.g. all-in-one, saas-internal). Leave empty to use chart defaults.

values_overlay: Value

Typed values overlay merged on top of the profile. Free-form JSON to keep tatara-process decoupled from chart schemas.

release_name: Option<String>

HelmRelease name override. Defaults to the Process’s PID-derived name.

target_namespace: Option<String>

Target namespace for the chart. Defaults to the Process’s namespace.

install_timeout: Option<String>

Install timeout (humantime duration). Empty = chart-controller default.

Implementations

impl AplicacaoIntent

pub fn chart_only( chart_ref: impl Into<String>, version: impl Into<String>, ) -> Self

Chart-pointer-only composer — the canonical minimal AplicacaoIntent every fixture and default-shape callsite restated pre-lift by binding only (chart_ref, version) and leaving every remaining slot at its K8s-schema-default value (profile = "", values_overlay = Value::Null, release_name = target_namespace = install_timeout = None).

Pre-lift the 7-slot struct-literal was hand-authored at 14 workspace-wide sites past the ★★ PRIME-DIRECTIVE ≥ 2 duplication threshold, each restating the SAME 5-slot default tail after a caller-varying (chart_ref, version) pair:

• tatara-process — 10 sites across lib.rs (3× empty_template in the ephemeral-spec / matrix / observer test blocks), lifetime_clock.rs (2× the ephemeral / permanent Process composer helpers), tagged_union.rs (1× the IntentKind::Aplicacao sample-intent arm), pool.rs (1× empty_template), and intent.rs (3× the helm_intent helper + the aplicacao_plus_flux_is_ambiguous fixture + the IntentKind::Aplicacao sample-intent-for arm).
• tatara-pool-reconciler — 4 sites across router.rs, pool_decide.rs, desired.rs, allocation_decide.rs (all empty_template fixtures seeding the pool + allocation convergence-decision test batteries).
• tatara-reconciler — 1 site in render.rs (helmrepository_chartref_for_non_oci production-shape fixture stamping the non-OCI chart-ref render path).

All 14 sites walked the SAME 5-slot default tail — differing only in the caller-varying chart_ref / version values ("oci://x" / "1" on the majority test-fixture slice, "oci://ghcr.io/x" / "0.1.0" on the IntentKind sample, "pleme-io/lareira-demo-app" / "0.5.5" on the non-OCI render pin). Post-lift each callsite reads AplicacaoIntent::chart_only(chart, version) and the 5-slot default tail lives at ONE substrate owner.

The impl Into<String> argument form matches the pre-lift call shape — every site that spelled "oci://x".into() + "1".into() in the struct-literal continues to compile unchanged, and callers with a live String (e.g. reading from a caller-supplied fixture parameter) pass it through without a .to_string() re-wrap.

Return-form axis: AplicacaoIntent — the owned typed value every consumer’s downstream Intent { aplicacao: Some(...), .. } / EphemeralSpec { aplicacao: ..., .. } binding stamps verbatim, matching the pre-lift 7-slot struct-literal’s return shape exactly. The five default-tail slots reify the K8s schema’s own defaults (profile empty ⇒ chart profile default; values_overlay = Null ⇒ pass-through; three None slots ⇒ server / chart-computed) so no consumer inherits a semantic change from the lift.

A future normalization of the “minimal AplicacaoIntent” default — an added struct field with its own K8s-schema default, a tightening of a None slot to a substrate-owned default value, a per-workspace-default install_timeout override — lands at THIS ONE substrate primitive and every downstream fixture / default-shape consumer inherits the upgrade mechanically — no per-site edit at any of the 14 listed callers or at future consumers (a new pool-shard-flavor fixture, a new intent-axis convergence probe, a per-tenant AplicacaoIntent minimal seed).

Peer to Self::helm_lifecycle_policy + Self::flux_reconcile_interval on the (COMPOSE, DERIVE) axis: chart_only is the WRITE-side composer (stamp a minimal AplicacaoIntent); the lifecycle + interval methods are the READ-side derivers (project a substrate-default Flux policy / cadence off an AplicacaoIntent). The three primitives partition the AplicacaoIntent compose × derive surface at the substrate.

Theory anchor: THEORY.md §VI.1 (generation over composition — the 5-slot default tail recurred at 14 hand-authored sites past the ★★ PRIME-DIRECTIVE ≥ 2 duplication trigger, spanning three workspace crates, and is lifted onto the ONE workspace- wide substrate owner here). THEORY.md §II.1 invariant 5 (composition preserves proofs — the pin block below binds the primitive at fail-before-pass-after granularity so a regression that drifted any of the five default-tail slots surfaces at THESE pins rather than as silent fixture skew across the 14 downstream consumers).

pub fn release_name_or(&self, fallback: &str) -> String

Effective HelmRelease name — the operator-supplied Self::release_name override when set, else the caller- supplied fallback (canonically the Process’s PID-derived name at the reconciler’s render_aplicacao site, and the enclosing matrix env’s NamedEphemeral.name at the matrix breathe_bands site — both are the Process’s own name).

Pre-lift the pattern was hand-authored at 2 workspace-wide sites past the ★★ PRIME-DIRECTIVE ≥ 2 duplication threshold, each restating the SAME Option::clone().unwrap_or_else(|| fallback.into()) chain differing only in the caller-varying fallback slot:

• tatara-reconciler::render::render_aplicacao — the HelmRelease.spec.releaseName slot on the Flux-owned release the reconciler emits per Helm-driven Process.
• tatara-process::matrix::EnvMatrixSpec::breathe_bands — the spec.targetRef.name slot on the breathe Band CRs the matrix sweep emits per generated env × dimension.

Post-lift both sites read a.release_name_or(fallback) and the fallback-composition shape lives at ONE substrate owner. A future tightening — a workspace-wide default seeded off the PID, a fallback shape derived off Self::chart_ref, a validation that the fallback is a DNS-1123 label — lands at THIS ONE primitive.

Peer to Self::target_namespace_or on the same (release, namespace) axis: both project one operator-optional override-or-fallback slot the reconciler + matrix consume in lock-step.

pub fn target_namespace_or(&self, fallback: &str) -> String

Effective HelmRelease target namespace — the operator-supplied Self::target_namespace override when set, else the caller- supplied fallback (canonically the Process’s own namespace at the reconciler’s render_aplicacao site, and the enclosing matrix env’s NamedEphemeral.name at the matrix breathe_bands site).

Peer to Self::release_name_or — same substrate-owner motivation, same 2-site collapse. Post-lift both consumers read a.target_namespace_or(fallback) and the Option::clone().unwrap_or_else(|| fallback.into()) shape lives at ONE primitive here.

pub fn helm_lifecycle_policy(&self) -> HelmLifecyclePolicy

Derive the Flux HelmRelease.spec.{install,upgrade} policy this intent publishes on BOTH slots. Pre-lift the reconciler’s render_aplicacao restated the shape by hand via two adjacent identical json! blocks (install and upgrade); post-lift both slots ride through this ONE composer. A future two-slot split (distinct install vs upgrade policies) lands as a two-method pair here, not at the render callsite.

pub fn flux_reconcile_interval(&self) -> String

Derive the Flux reconcile-loop cadence this intent publishes on BOTH OCIRepository.spec.interval (source-controller poll) and HelmRelease.spec.interval (helm-controller re-reconcile). Pre-lift the reconciler’s render_aplicacao restated the value via two adjacent hand-authored "5m" string literals past the ★★ PRIME-DIRECTIVE ≥ 2 duplication threshold; post-lift both slots ride through this ONE composer. A future divergence (distinct per-slot cadences, a per-intent override field, a two-slot method returning a FluxReconcileIntervals shape) lands at ONE method here, not at the render callsites.

Sibling composer to Self::helm_lifecycle_policy: both return the substrate-default shape a Helm-driven Process publishes on the Flux resources render_aplicacao emits, keyed off the same AplicacaoIntent.

Trait Implementations

impl Clone for AplicacaoIntent

fn clone(&self) -> AplicacaoIntent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AplicacaoIntent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AplicacaoIntent

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for AplicacaoIntent

fn schema_name() -> String

The name of the generated JSON Schema.

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

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

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

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

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

impl Serialize for AplicacaoIntent

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

where __S: Serializer,

Serialize this value into the given Serde serializer.