Hojas tipadas, árbol sin tipos

El IaC moderno tipa cada recurso.
La composición — qué depende de qué, en qué orden, bajo qué condición — no tiene tipos.

Tres capas que yo confundía

• Rust me dio soltura en las dos primeras: newtypes, enums, TryFrom.
• De la tercera capa salieron todas las alertas de las 3 de la mañana que recuerdo.
• Esta charla es lo que pasó cuando convertí la capa tres en un contrato.

El stack, con honestidad

Un componente es un contrato

# schemas/lib/contracts.ncl  (extracto)
ComponentDef = {
  name       | String,
  mode       | [| 'taskserv, 'cluster, 'container |] | default = 'taskserv,
  depends_on | Array {
    name | String,
    kind | [| 'Requires, 'PrefersBefore, 'ConflictsWith |] | default = 'Requires,
  } | default = [],
  on_error   | [| 'Stop, 'Continue, 'Retry |] | default = 'Stop,
  requires   | {
    storage | { size | String, persistent | Bool } | optional,
    ports   | Array { port | Number, exposure | [| 'public, 'private, 'internal |] },
  } | default = {},
  provides   | {
    service   | String | optional,
    port      | Number | optional,
    endpoints | Array String | default = [],
  } | default = {},
  # mandatory — never omit
  concerns   | ServiceConcerns,
  ..
}

Concerns: tipar lo que nadie tipa

# schemas/lib/concerns.ncl
ConcernState = { kind | [| 'enabled, 'disabled, 'pending, 'inherited |], .. }

ServiceConcerns = {
  tls | ConcernState,  dns | ConcernState,  certs    | ConcernState,
  backup | ConcernState,  observability | ConcernState,  security | ConcernState,
}

# un componente honesto sobre sus carencias
concerns = {
  tls    = c.disabled "stateless service, no TLS termination",
  backup = c.pending  "policy to be defined" "BACKUP-001",
  ..
}

• No puedes omitir un concern. Solo puedes decir por qué está desactivado — o qué ticket lo cierra.
• "¿Qué componentes tienen backup = 'pending?" pasa a ser una consulta, no una auditoría.

El grafo es un valor — y se comprueba

# schemas/lib/formula.ncl (condensado) — se ejecuta en tiempo de configuración
let _Formula = std.contract.custom (fun label value =>
  let node_ids = value.nodes |> std.array.map (fun n => n.id) in
  let bad_deps = value.nodes |> std.array.flat_map (fun node =>
    node.depends_on
      |> std.array.filter (fun dep => !(std.array.elem dep.node_id node_ids))
      |> std.array.map (fun dep => "node '%{node.id}' depends_on unknown '%{dep.node_id}'")
  ) in
  if bad_deps != [] then
    std.contract.blame_with_message "invalid depends_on: %{std.string.join ", " bad_deps}" label
  else 'Ok value
)

• Ids de nodo duplicados, depends_on colgantes, extremos de arista inválidos → rechazados.
• Una fórmula = DAG de componentes en un servidor. max_parallel y on_error son política sobre el grafo.

Grafos de grafos: la composición

# workspaces/libre-wuji/infra/libre-wuji/dag.ncl
composition.formulas = [
  { formula_id = "libre-wuji-cp-formula",
    depends_on = [],
    health_gate = {
      check_cmd = "kubectl get nodes … | grep -v NotReady",
      retries   = 18,
    } },
  { formula_id = "libre-wuji-wrk-0-formula",
    depends_on = [{ formula_id = "libre-wuji-cp-formula",
                    condition  = 'Healthy }],
    parallel   = true },
  # wrk-1, wrk-2, strg-* …
]

Exactamente uno de — la lección que no había aplicado

 1  // lo que Rust quería desde el principio: dos estados, no cuatro
 2  pub enum NodeKind {
 3      TaskServ { taskserv: TaskServDef },
 4      Component { component: ComponentDef },
 5  }
 6  
 7  pub struct FormulaNode {
 8      pub id: String,
 9      pub kind: NodeKind,
10  }
11  
12  match &node.kind {
13      NodeKind::TaskServ { taskserv } => run_taskserv(taskserv),
14      NodeKind::Component { component } => run_component(component),
15  }

Los proveedores cumplen un contrato — el núcleo no se mueve

// platform/crates/provisioning-compute/src/trait_def.rs
#[async_trait]
pub trait ComputeProvider: Send + Sync + Debug + 'static {
    fn kind(&self) -> ProviderKind;
    async fn spawn(&self, spec: InstanceSpec) -> Result<Instance, ComputeError>;
    /// MUST be idempotent: destroying an unknown handle returns Ok(()).
    /// MUST NOT return NotFound — that case maps to Ok(()).
    async fn destroy(&self, handle: &InstanceHandle) -> Result<(), ComputeError>;
    async fn status(&self, handle: &InstanceHandle) -> Result<InstanceStatus, ComputeError>;
    async fn list(&self, label_selector: &str) -> Result<Vec<Instance>, ComputeError>;
    async fn health(&self) -> Result<ProviderHealth, ComputeError>;
}

Coordinación por eventos, no por llamadas

• Los payloads son structs de Rust serializados con serde (JSON en el cable), sobre JetStream.
• Cada mutación entra firmada y sale auditable como un historial git.

En vivo: romper el contrato

let f = import "schemas/lib/formula.ncl" in
let Acyclic = import "acyclic.ncl" in

f.make_formula {
  id          = "rustlab-live",
  description = "control plane, typed",
  provider    = "hetzner",
  server      = "libre-wuji-cp-0",
  nodes = [
    f.make_node { id = "os",         taskserv = { name = "os" } },
    f.make_node { id = "runc",       taskserv = { name = "runc" },       depends_on = [{ node_id = "os" }] },
    f.make_node { id = "crio",       taskserv = { name = "crio" },       depends_on = [{ node_id = "runc" }] },
    f.make_node { id = "kubernetes", taskserv = { name = "kubernetes" }, depends_on = [{ node_id = "crio" }] },
  ],
}

Ownership, trasladado — como analogía, no como mecanismo

Por qué el rollback no es Drop

{
    let plan = Plan::apply(&ctx)?;
    plan.verify()?;
    plan.commit();
} // se descarta sin commit → rollback

#[async_trait]
pub trait ProviderRollbackHandler: Send + Sync {
    async fn rollback_resource(&self, r: &ResourceSnapshot)
        -> Result<()>;
    async fn cleanup_resources_after(&self, cp: &Checkpoint)
        -> Result<Vec<String>>;
    async fn validate_rollback(&self, cp: &Checkpoint)
        -> Result<Vec<String>>;
}

El bug que encontré preparando esta charla

use std::collections::{HashMap, HashSet, VecDeque};

#[derive(Default)]
struct DependencyGraph {
    nodes: HashSet<String>,
    edges: HashMap<String, Vec<String>>,         // task -> its dependencies
    reverse_edges: HashMap<String, Vec<String>>, // dependency -> its dependents
}

impl DependencyGraph {
    fn add_dependency(&mut self, from: &str, depends_on: &str) {
        self.nodes.extend([from.to_string(), depends_on.to_string()]);
        self.edges.entry(from.into()).or_default().push(depends_on.into());
        self.reverse_edges.entry(depends_on.into()).or_default().push(from.into());
    }

    // same logic as orchestrator/src/workflow.rs:174
    fn topological_sort(&self) -> Result<Vec<String>, String> {
        let mut in_degree: HashMap<&str, usize> =
            self.nodes.iter().map(|n| (n.as_str(), 0)).collect();
        for deps in self.edges.values() {
            for dep in deps {
                *in_degree.entry(dep).or_default() += 1;
            }
        }
        let mut queue: VecDeque<&str> =
            in_degree.iter().filter(|(_, d)| **d == 0).map(|(n, _)| *n).collect();
        let mut result = Vec::new();
        while let Some(node) = queue.pop_front() {
            result.push(node.to_string());
            for dependent in self.reverse_edges.get(node).into_iter().flatten() {
                let d = in_degree.get_mut(dependent.as_str()).ok_or("unknown node")?;
                *d -= 1;
                if *d == 0 { queue.push_back(dependent); }
            }
        }
        if result.len() != self.nodes.len() {
            return Err("Circular dependency detected in workflow".into());
        }
        Ok(result)
    }
}

Los tipos comprueban forma. Los tests, significado.

• Result<Vec<String>> lo satisface el orden correcto, el incorrecto y un Err que miente.
• Los algoritmos de grafos necesitan propiedades, no ejemplos:

proptest! {
    #[test]
    fn topo_order_respects_every_edge(g in arb_dag(1..64)) {
        let order = g.topological_sort().unwrap();
        let pos: HashMap<_, _> = order.iter().enumerate().map(|(i, n)| (n, i)).collect();
        for (task, deps) in &g.edges {
            for dep in deps { prop_assert!(pos[dep] < pos[task]); }
        }
    }
}

La frontera es donde los tipos se filtran

mode     | [| 'taskserv, … |] | default = 'taskserv,
requires | { … },
provides | { … },
concerns | ServiceConcerns,   # obligatorio
..                             # record abierto

#[derive(Deserialize)]
pub struct ComponentDef {
    pub name: String,
    #[serde(default = "default_deploy_mode")] // ¡Cluster!
    pub mode: DeployMode,
    // requires, provides, concerns:
    // serde los descarta en silencio
}

• Dos sistemas de tipos, un concepto, dos valores por defecto.
• serde ignora los campos desconocidos salvo que digas #[serde(deny_unknown_fields)].
• Arreglo: una única fuente de verdad + un test de CI que exporta cada fixture de Nickel y la deserializa en modo estricto.

Un contrato solo protege donde se aplica

provides | {
  service   | String | optional,
  port      | Number | optional,
  # Added 2026-08-18: the surrealdb catalog component has always declared
  # provides.protocol = "http+ws" and this closed record rejected it, so the
  # component could be listed in settings.ncl (which does not apply
  # ComponentDef) but not used as a DAG component node, which does. The
  # incompatibility stayed invisible until a workspace first tried to
  # schedule it through the unified model.
  protocol  | String | optional,

El tipado gradual es una virtud — y un sitio donde los bugs esperan. Ten claro dónde se ejecutan tus contratos.

El estado externo no tipa

• condition = 'Healthy es un enum tipado. Lo que Healthy significa es kubectl get nodes | grep -v NotReady.
• Un 200 OK de un control plane a menudo significa encolado, no hecho.
• Consistencia eventual, límites de tasa, ventanas de idempotencia: nada de eso está en una firma.
• Puedo validar el plan. No puedo validar la nube.

Qué haría distinto

1. Tipos suma de extremo a extremo. Si el lenguaje de configuración no puede expresarlos, genera el lado de Rust — no copies a mano Option × Option.
2. Errores tipados en la capa de composición. Todavía devuelve anyhow. Los proveedores ya tienen enums #[non_exhaustive]; el grafo merece uno.
3. Un solo ejecutor. Nushell ejecuta el DAG en producción; a su lado había un motor en Rust sin tests en su ordenación. Dos motores = dos semánticas.
4. Tests de propiedades en cada algoritmo de grafos. Desde el primer día — un Result<Vec<String>> comprueba la forma de la respuesta, no su orden.
5. Comprobar la aciclicidad donde se declara el grafo. No donde se ejecuta — el ciclo pasó dag.ncl y solo Rust lo vio.

El mismo paradigma, otro ámbito

Qué cambia esto para los agentes de IA

La misma disciplina, un nivel más arriba

# un workspace → su dominio (libre-daoshi/.domains-ontoref/…)
{ id = "libre-daoshi-to-provisioning",
  from = "libre-daoshi", to = "provisioning",
  axis = 'Governance, state = 'Node, resolution = 'Merge }

# proyecto → gov, un sentido (provisioning/.domains-ontoref/…)
{ id = "provisioning-to-gov",
  from = "provisioning", to = "gov",
  axis = 'Dependency, state = 'Linked,
  dep_kind = 'Conformist, mutual = false }

Conclusiones

1. Tipa la composición, no solo los recursos. En las aristas viven los incidentes.
2. La ausencia tiene que ser explícita. 'pending "why" "TICKET-42" es mejor que un campo que falta.
3. La disciplina es recursiva. Componentes → fórmulas → infraestructura → proyectos y sus bonds.
4. Las costuras necesitan sus propios tests. Config ↔ Rust, plan ↔ nube, tipo ↔ significado.
5. Los agentes proponen; los contratos, los checks y las personas disponen. Ten claro dónde acaba cada garantía.

Cifras

¿Por qué no Terraform / Pulumi / CUE / KCL / Crossplane?

"Esto se puede hacer en cualquier lenguaje"

Federación (ADR-042)

• Los proyectos declaran Integration Modes; los contratos se distribuyen como artefactos OCI (application/vnd.ontoref.mode.v1) vía oras.
• Los workspaces los consumen como imports tipados.
• El impacto entre proyectos es un BFS acotado: impact_graph(slug, node, max_depth), profundidad ≤ 5.

Demo de respaldo — salidas reales

nickel: as written
✓ contracts satisfied — nothing touched a server
os ← ∅ · runc ← os · crio ← runc · kubernetes ← crio

nickel: runc → rnuc
✗ contract broken
Formula 'rustlab-live' has invalid depends_on:
  node 'crio' depends_on unknown 'rnuc'

nickel: os depends_on kubernetes
✓ contracts satisfied   ← the cycle passes

nickel: … } | Acyclic
✗ contract broken
Formula 'rustlab-live' has a dependency cycle
  through: os, runc, crio, kubernetes

rust: as in workflow.rs
error: Circular dependency detected in workflow
property FAILED — case 0: acyclic graph of
  4 nodes rejected: Circular dependency detected

rust: in-degree counted on the task
order: runc → crio → kubernetes → cilium
property: 1000 random DAGs, every edge respected ✓

Enlaces

Infraestructura

la plataforma de esta charlarepo.jesusperez.pro/provisioning/provisioning

vault de secretos post-cuántico · ML KEM-768 + DSA-65repo.jesusperez.pro/jesus/secretumvault

sustrato de build efímero · proveedores enchufables, caché direccionada por contenidorepo.jesusperez.pro/lian-build/lian-build

capas de builder · imágenes base + cachés de dependencias precocinadasrepo.jesusperez.pro/lamina/lamina-code

imágenes de servicio en ejecución · construidas con lian-buildprivado

framework web full-stack en Rust · Axum + HTMX · Leptos opcionalrustelo.dev

Comunidad

Rust Las Palmas · Gran Canaria · coorganizadorrust-laspalmas.dev

Feedback

encuesta de 1 minuto sobre la charla (en inglés) · graciasforms.librecloud.online/s/cmvsw4z3z000201t6sepedj1t

Protocolo · los dominios gov y custody, parte de ontoref

ontología + reflexión para proyectos · bondsrepo.jesusperez.pro/ontoref/ontoref-code

custody

el contrato al que se somete un proyecto custodiadorepo.jesusperez.pro/custody/custody

acotado, revisado, acordado por digestrepo.jesusperez.pro/specdossier/specdossier

la capacidad de firmarepo.jesusperez.pro/signatio/signatio-code

sesiones de agentes, observadasrepo.jesusperez.pro/wuwei-observer/wuwei-observer

iter

parte de isolation · trabajo en un store jj compartido, dueño + agenterepo.jesusperez.pro/custody/iter

Portada: Piazza Maggiore, Bolonia — foto de Max Nayman, vía Unsplash