sergio/takana
> Una distribución Linux construida con un laboratorio funcional y hermético en el > sótano, y una terminal mutable, clásica y anárquica en el piso de arriba — diseñada > desde el suelo para que una IA programadora entienda, modifique y co…
⎇ a51d49a342ccbae8d8f4464bce62a000e0e829e8
crates/takana-core/src/recipe.rs
Historia
Quién tocó qué
crudo
servicios de paquete: la receta ya sabe declarar su demonio — y el card sale IGUAL al hardcodeado
1//! La `Recipe`: descripción pura de un build. Ver `docs/02-build-lab.md` §1.
2
3use std::path::{Path, PathBuf};
4
5use serde::{Deserialize, Serialize};
6
7use crate::hash::ArtifactHash;
8
9#[derive(Debug, Clone, Serialize, Deserialize)]
10pub struct Recipe {
11 pub name: String,
12 pub version: String,
13 pub source: Source,
14 pub build: Build,
15 #[serde(default)]
16 pub deps: Deps,
17 /// Evidencia de COMPORTAMIENTO que acompaña la receta (H1 — proof-carrying recipes, SDD 15).
18 /// Opcional. **No entra en `hash_inputs`**: certifica comportamiento, no identidad ⇒ agregar o
19 /// cambiar evidencia NO mueve el `artifact_hash` (el baseline de reproducibilidad no se toca).
20 #[serde(default, skip_serializing_if = "Evidence::is_empty")]
21 pub evidence: Evidence,
22 /// **Superficies del sistema** que este paquete reclama y requiere (H4b — configs
23 /// compatibles, SDD 15 §H4). Igual que `evidence`: **NO entra en `hash_inputs`** — declara
24 /// TOPOLOGÍA (qué toca / de qué depende), no identidad del artefacto; agregar o cambiar el
25 /// bloque no mueve el `artifact_hash`. Lo consume el gate de compatibilidad de `install`
26 /// (`crate::compat`) contra el estado instalado, no el build.
27 #[serde(default, skip_serializing_if = "Slots::is_empty")]
28 pub slots: Slots,
29 /// **Bajo qué términos se redistribuye este paquete.** Expresión SPDX (`"GPL-2.0-or-later"`,
30 /// `"MIT OR Apache-2.0"`, `"LGPL-2.1-only AND BSD-3-Clause"`).
31 ///
32 /// No es burocracia: al distribuir BINARIOS, la GPL y familia obligan a acompañarlos del texto
33 /// de la licencia y a poder entregar la fuente correspondiente. Una distro que no sabe bajo qué
34 /// términos redistribuye lo que empaqueta no puede cumplir ninguna de las dos cosas, y eso es
35 /// bloqueante para publicar (SDD 19 §2.1). Medido el 2026-08-07: **0 de 1141 recetas** lo
36 /// declaraban.
37 ///
38 /// Igual que `evidence` y `slots`, **NO entra en `hash_inputs`** — y acá esa propiedad es la que
39 /// hace la deuda pagable: describe términos legales, no identidad del build, así que se puede
40 /// poblar en las 1141 recetas YA SELLADAS sin mover un solo `ArtifactHash` ni invalidar el
41 /// baseline de reproducibilidad. Si entrara al hash, poner la licencia costaría reconstruir el
42 /// corpus entero y por eso no se habría hecho nunca.
43 ///
44 /// `None` = deuda declarada, no «sin licencia». `scripts/licencias.sh` mide la cobertura.
45 #[serde(default, skip_serializing_if = "Option::is_none")]
46 pub license: Option<String>,
47 /// La receta **sella bytes ajenos ya compilados**, no construye desde fuente (ADR 0015 D8).
48 ///
49 /// Hoy la usa una sola: el runtime *sniper* de Valve, que es la única imagen ajena que puede
50 /// entrar al store porque **no muta** — nadie le instala nada adentro, así que el mismo tarball
51 /// pineado da siempre el mismo árbol y sellarlo es una afirmación verdadera. Un rootfs mutable
52 /// (Arch, Ubuntu) no la cumple y por eso se queda fuera, en `/var/lib/hammer/qorpa`.
53 ///
54 /// **Lo que hace la marca es contable, no técnica.** El build no cambia en un solo byte: lo que
55 /// cambia es que `scripts/build-state.py` la clasifica como `ajeno`, la resta del denominador
56 /// de las imágenes y la deja fuera del recuento de recetas. Sin esto, sellar un prebuilt
57 /// inflaría la cifra que todo el mundo lee como «cuánto construimos» — el riesgo que el ADR
58 /// 0015 escribió antes de que existiera la primera instancia.
59 ///
60 /// **NO entra en `hash_inputs`**, igual que `license`: describe procedencia, no identidad del
61 /// build. Añadirla no mueve un solo `ArtifactHash`.
62 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
63 pub foreign: bool,
64 /// **Los servicios que este paquete TRAE** (`[[service]]`), como Cards de arje.
65 ///
66 /// Es la respuesta al hueco que la distro tenía abierto: un paquete con demonio no tenía dónde
67 /// declararlo, así que los dos servicios del producto vivían hardcodeados en constantes de Rust
68 /// y los ocho de una sesión GNOME se lanzaban con `&` desde un script, sin supervisión. Ver
69 /// [`crate::service`] para el porqué completo (incluido por qué `arje-absorb` no lo cubre).
70 ///
71 /// Declara **qué es** el servicio, no **si arranca**: lo segundo es del PERFIL, igual que
72 /// systemd separa `[Service]` de `[Install]`.
73 ///
74 /// **NO entra en `hash_inputs`**, como `license`, `slots` y `evidence`: describe cómo se
75 /// supervisa el artefacto, no qué bytes tiene ⇒ se puebla en recetas ya selladas sin mover un
76 /// solo `ArtifactHash`.
77 #[serde(default, rename = "service", skip_serializing_if = "Vec::is_empty")]
78 pub services: Vec<crate::service::Service>,
79 /// Directorio base contra el que se resuelven rutas relativas de la receta
80 /// (típicamente, `patches`). Lo fija `load_from_path`; al deserializar puro queda vacío.
81 #[serde(skip, default)]
82 pub base_dir: PathBuf,
83}
84
85/// `Source` admite dos modos, mutuamente excluyentes, validados en runtime:
86///
87/// 1. **Git** — `repo` + `commit` (SHA fijado, nunca HEAD; ADR 0006). Apropiado para
88/// upstreams cuyo árbol de git ya es buildable o cuando queremos pinear un parche que
89/// aún no salió en release.
90/// 2. **Tarball** — `tarball` (URL) + `sha256`. Apropiado para releases estables: la
91/// mayoría de proyectos GNU/autotools traen `configure` ya generado y embebidos los
92/// submódulos (gnulib, etc.), evitando la necesidad de `./bootstrap` en el sandbox.
93///
94/// El hash de entrada del artefacto usa `commit` o `sha256` según el modo, ambos
95/// identificadores inmutables del contenido fuente.
96#[derive(Debug, Clone, Default, Serialize, Deserialize)]
97pub struct Source {
98 // --- modo git ---
99 #[serde(default, skip_serializing_if = "Option::is_none")]
100 pub repo: Option<String>,
101 #[serde(default, skip_serializing_if = "Option::is_none")]
102 pub commit: Option<String>,
103 // --- modo tarball ---
104 #[serde(default, skip_serializing_if = "Option::is_none")]
105 pub tarball: Option<String>,
106 #[serde(default, skip_serializing_if = "Option::is_none")]
107 pub sha256: Option<String>,
108 /// Cuántos componentes recortar al extraer el tarball. Default 1 (los releases GNU
109 /// siempre tienen un único top-level `proyecto-version/`).
110 #[serde(default = "default_strip")]
111 pub strip_components: usize,
112 // --- modo directorio (recetas DERIVADAS) ---
113 /// Árbol fuente que vive en ESTE repo, relativo al directorio de la receta.
114 ///
115 /// Existe para las recetas cuyo contenido no viene de upstream sino de nosotros: un envoltorio
116 /// que se arma encima de otro artefacto (`atuq` sobre `firefox`, SDD 26), un tema, una
117 /// configuración. Antes de esto el `[source]` era obligatoriamente git o tarball, así que una
118 /// receta así no se podía ni escribir — y el rodeo (fetchear una fuente upstream que no se usa)
119 /// habría mentido sobre la identidad del artefacto.
120 ///
121 /// **Se hashea por CONTENIDO, no por ruta**: `ArtifactHash::of_tree` sobre el árbol entero, que
122 /// es lo mismo que ya se hace con los `patches` (bytes, no nombres). Editar un CSS del overlay
123 /// mueve el hash; renombrar el directorio sin tocar nada, no.
124 #[serde(default, skip_serializing_if = "Option::is_none")]
125 pub dir: Option<String>,
126 // --- común ---
127 /// Destino del vendoreo cargo (default `vendor`). Override per-receta para proyectos que
128 /// commitean su PROPIO `vendor/` (p.ej. mise → `vendor/aqua-registry`): `cargo vendor` borra
129 /// lo que no reconoce, así que se vendorea a un subdir aparte para no pisarlo. El fragmento
130 /// `.cargo/config.toml` que emite `cargo vendor` ya apunta al dir que se le pasa.
131 #[serde(default, skip_serializing_if = "Option::is_none")]
132 pub cargo_vendor_dir: Option<String>,
133 /// Fuerza el vendoreo cargo aunque el árbol NO se detecte como `BuildSys::Cargo`.
134 ///
135 /// Existe porque `detect_build_system` asume **un** sistema de build por árbol, y hay proyectos
136 /// que genuinamente tienen dos: C por fuera, Rust por dentro. El arquetipo es librsvg —trae
137 /// `configure.ac` Y `Cargo.toml`, y autotools gana por precedencia—, pero su `Makefile` invoca
138 /// `cargo build`. Sin vendoreo ese cargo intenta salir a la red DENTRO del sandbox hermético y
139 /// el build muere. Es un patrón, no una excepción: cada vez hay más GNOME así.
140 ///
141 /// No cambia qué se construye, sólo de dónde salen las deps —el `Cargo.lock` del source es el
142 /// que fija las versiones— así que **no entra al ArtifactHash**, igual que `cargo_vendor_dir`.
143 /// Es lo que permite prenderla en una receta ya sellada sin re-hashearla.
144 #[serde(default, skip_serializing_if = "Option::is_none")]
145 pub cargo_vendor: Option<bool>,
146 #[serde(default)]
147 pub patches: Vec<String>,
148}
149
150fn default_strip() -> usize {
151 1
152}
153
154/// Discriminante validado del `Source`. Se calcula bajo demanda; los campos de
155/// `Source` permanecen flat en TOML para que las recetas sean legibles.
156#[derive(Debug, Clone, PartialEq, Eq)]
157pub enum SourceKind<'a> {
158 Git { repo: &'a str, commit: &'a str },
159 Tarball { url: &'a str, sha256: &'a str },
160 /// Árbol del propio repo (recetas derivadas). Ver [`Source::dir`].
161 Dir { dir: &'a str },
162}
163
164impl Source {
165 pub fn kind(&self) -> crate::Result<SourceKind<'_>> {
166 // `dir` es EXCLUYENTE con los otros dos y se comprueba primero: declarar a la vez un
167 // árbol propio y una fuente upstream no es una receta ambigua, es un error de quien la
168 // escribió, y decirlo temprano evita un build que fetchea algo que después pisa.
169 if let Some(dir) = self.dir.as_deref() {
170 if self.repo.is_some() || self.tarball.is_some() {
171 return Err(crate::Error::Recipe(
172 "source: `dir` es excluyente con repo/tarball — una receta derivada no tiene fuente upstream".into(),
173 ));
174 }
175 return Ok(SourceKind::Dir { dir });
176 }
177 match (
178 self.repo.as_deref(),
179 self.commit.as_deref(),
180 self.tarball.as_deref(),
181 self.sha256.as_deref(),
182 ) {
183 (Some(repo), Some(commit), None, None) => Ok(SourceKind::Git { repo, commit }),
184 (None, None, Some(url), Some(sha256)) => Ok(SourceKind::Tarball { url, sha256 }),
185 (Some(_), Some(_), Some(_), _) | (Some(_), Some(_), _, Some(_)) => Err(
186 crate::Error::Recipe(
187 "source: usa repo+commit O tarball+sha256, no ambos".into(),
188 ),
189 ),
190 _ => Err(crate::Error::Recipe(
191 "source: faltan campos; necesito (repo+commit), (tarball+sha256) o (dir)".into(),
192 )),
193 }
194 }
195}
196
197#[derive(Debug, Clone, Serialize, Deserialize)]
198pub struct Build {
199 #[serde(default)]
200 pub compiler: Compiler,
201 #[serde(default = "default_target")]
202 pub target: String,
203 #[serde(default)]
204 pub link: LinkMode,
205 #[serde(default)]
206 pub flags: Vec<String>,
207 /// Versión de zig a usar para ESTA receta, distinta del zig por defecto del lab. Sirve de
208 /// escotilla por-receta para esquivar la regresión de zig 0.14 (que miscompila ciertos binarios
209 /// musl dinámicos: flex/cmake/python/binutils/…): `zig_version = "0.13.0"` los construye con el
210 /// zig bueno sin tocar el toolchain global ni el baseline de reproducibilidad (estas piezas son
211 /// herramientas, no inputs del of_tree del 4/4). `None` ⇒ el zig por defecto. Ver SDD 11 §7.2b.
212 #[serde(default, skip_serializing_if = "Option::is_none")]
213 pub zig_version: Option<String>,
214 /// **Separa la información de depuración del artefacto** (SDD 23). Con `true`, el lab pasa un
215 /// `zig objcopy --strip-debug` sobre los ELF de `/out` DESPUÉS de la fase install.
216 ///
217 /// POR QUÉ IMPORTA, medido: el **79%** del contenido binario del store son secciones `.debug_*`
218 /// ⇒ ~96 G de reserva de disco y un espejo público de ~30 G en vez de ~126 G. Y además **cierra
219 /// una fuga de reproducibilidad**: `takana why-differs` mostró que `appstream` y `bison`
220 /// divergen entre rebuilds ÚNICAMENTE en `.debug_*` (rutas internas del árbol de build), con el
221 /// código ejecutable idéntico. Sin esas secciones, el artefacto reproduce.
222 ///
223 /// ⚠ **ENTRA EN `hash_inputs`, y sólo si está fijado** — mismo diseño que `zig_version`. Las dos
224 /// mitades de esa frase importan:
225 /// · *entra*: si el lab pudiera cambiar lo que sale del build SIN mover el hash, el store
226 /// diría que todo está al día mientras los artefactos ya no corresponden. En un sistema
227 /// direccionado por contenido ése es el peor fallo posible: no falla, **miente**.
228 /// · *sólo si está fijado*: una receta sin el campo conserva su hash de antes de que existiera,
229 /// así que esto se puede desplegar receta a receta sin re-hashear el corpus de golpe.
230 ///
231 /// POR QUÉ ES UNA PERILLA DEL LAB Y NO UN PASO EN CADA RECETA: de las 1161 recetas, **383 no
232 /// tienen fase `install` explícita** (usan la heurística por defecto). Meter el strip receta a
233 /// receta obligaría a escribir a mano ese install por defecto en las 383, con el riesgo de no
234 /// clavarlo exacto. El lab lo hace una vez, igual para todas.
235 ///
236 /// Usa `zig objcopy`, que SIEMPRE está en el sandbox (`/opt/zig`), en vez del `strip` de
237 /// binutils: así no hay que añadir una dep de build a cada receta que lo active.
238 #[serde(default, skip_serializing_if = "Option::is_none")]
239 pub strip_debug: Option<bool>,
240 /// Habilita CGO en un build Go (`BuildSys::Go`). Por defecto el lab compila con `CGO_ENABLED=0`
241 /// (Go puro, estático, sin C). Algunos proyectos necesitan cgo para drivers con C bundled (p.ej.
242 /// el driver sqlite3 de mattn en usql/sq/dolt): con `cgo = true` el compile usa `CGO_ENABLED=1`
243 /// + `CC="zig cc"` (musl nativo del sandbox) y liga estático (`-linkmode=external -extldflags=
244 /// -static`). Sólo para C bundled; cgo contra libs C EXTERNAS (gpgme/libvirt) requiere además
245 /// esas recetas en el sandbox. No-op fuera de BuildSys::Go.
246 #[serde(default)]
247 pub cgo: bool,
248 /// Subdirectorio donde vive el módulo Go cuando NO está en la raíz del repo (p.ej. dolt → `go`,
249 /// csvtk → su subdir). El lab vendorea, detecta el main y compila DENTRO de `<src>/<subdir>`.
250 /// Vacío = raíz (lo normal). Sólo aplica a BuildSys::Go.
251 #[serde(default)]
252 pub subdir: String,
253 /// Overrides explícitos de las fases del build. Lo no especificado se decide por
254 /// heurística en el lab (ver `docs/02-build-lab.md` §4).
255 #[serde(default)]
256 pub phases: Phases,
257}
258
259/// Comandos shell que se ejecutan en el sandbox por cada fase. Cualquiera puede ser `None`:
260/// el lab lo deriva por heurística (autotools / cmake / meson / make).
261#[derive(Debug, Clone, Default, Serialize, Deserialize)]
262pub struct Phases {
263 #[serde(default, skip_serializing_if = "Option::is_none")]
264 pub configure: Option<String>,
265 #[serde(default, skip_serializing_if = "Option::is_none")]
266 pub compile: Option<String>,
267 #[serde(default, skip_serializing_if = "Option::is_none")]
268 pub install: Option<String>,
269}
270
271impl Phases {
272 /// `true` si ninguna fase está sobreescrita (todo se decide por heurística). Sirve a
273 /// serde (`skip_serializing_if`) para que un `.swm` sin fases custom no las emita.
274 pub fn is_empty(&self) -> bool {
275 self.configure.is_none() && self.compile.is_none() && self.install.is_none()
276 }
277}
278
279#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
280pub struct Deps {
281 #[serde(default)]
282 pub build: Vec<String>,
283 #[serde(default)]
284 pub runtime: Vec<String>,
285}
286
287impl Deps {
288 /// `true` si no hay ninguna dep (ni build ni runtime). Sirve a serde para no emitir el
289 /// bloque `deps` vacío en un `.swm`/receta.
290 pub fn is_empty(&self) -> bool {
291 self.build.is_empty() && self.runtime.is_empty()
292 }
293}
294
295/// Las **superficies del sistema** de una config/paquete (H4b — SDD 15 §H4). Una config del
296/// usuario = un conjunto de modificaciones direccionadas por contenido: cada modificación
297/// **reclama** una superficie (la escribe) y/o **requiere** otra (depende de ella a una versión
298/// exacta). El valor de cada slot es un hash `b3:…` del contenido — misma disciplina de "todo por
299/// hash" que el resto del stack.
300///
301/// El gate de compatibilidad (`crate::compat`) usa estos dos mapas contra el estado instalado:
302/// - un `requires` que no resuelve contra el estado ⇒ **incompatible** (el caso "modifiqué el
303/// protocolo de Wayland y bajo algo que depende del Wayland stock"); es el análogo, a nivel de
304/// sistema, de una referencia colgante.
305/// - un `claims` que pisa una superficie ya ocupada por otro contenido ⇒ **colisión = elección**
306/// (el caso "ya cambié el logo y bajo otra config que también lo cambia"), no un error.
307#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
308pub struct Slots {
309 /// Superficies que este paquete **escribe** → hash del contenido nuevo (`slot → b3:…`).
310 #[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
311 pub claims: std::collections::BTreeMap<String, String>,
312 /// Superficies de las que **depende** → versión exacta requerida (`slot → b3:…`).
313 #[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
314 pub requires: std::collections::BTreeMap<String, String>,
315}
316
317impl Slots {
318 /// `true` si no declara ninguna superficie (ni claims ni requires). Para serde: una receta
319 /// sin bloque `slots` no lo emite.
320 pub fn is_empty(&self) -> bool {
321 self.claims.is_empty() && self.requires.is_empty()
322 }
323
324 /// Valida la forma (schema, no compatibilidad): cada valor de slot debe ser un hash `b3:…`.
325 /// El gate de `install` corre esto antes de evaluar.
326 pub fn validate(&self) -> crate::Result<()> {
327 for (mapa, etiqueta) in [(&self.claims, "claims"), (&self.requires, "requires")] {
328 for (slot, hash) in mapa {
329 if !hash.starts_with("b3:") {
330 return Err(crate::Error::Recipe(format!(
331 "slots.{etiqueta}[{slot:?}]: el valor debe ser un hash `b3:…`, es {hash:?}"
332 )));
333 }
334 }
335 }
336 Ok(())
337 }
338}
339
340/// Evidencia de comportamiento de una receta (H1 — proof-carrying recipes, SDD 15 §H1). La IA
341/// entrega, junto al build, un conjunto de `checks` que el verificador (`takana swm-verify
342/// --evidence`) corre DENTRO del sandbox reproducible; la mutación sólo se propone si todos pasan.
343/// La confianza vive en el checker (pequeño, auditable), no en el generador: el sistema mejora solo
344/// sin poder corromperse solo. Deliberadamente FUERA de `Recipe::hash_inputs` (comportamiento ≠
345/// identidad). Frontera honesta: garantiza que *lo declarado pasa*, no que *lo declarado basta*.
346#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
347pub struct Evidence {
348 #[serde(default, skip_serializing_if = "Vec::is_empty")]
349 pub checks: Vec<EvidenceCheck>,
350}
351
352impl Evidence {
353 /// `true` si no hay ningún check. Sirve a serde (`skip_serializing_if`) para no emitir el
354 /// bloque `evidence` vacío en una receta/`.swm`.
355 pub fn is_empty(&self) -> bool {
356 self.checks.is_empty()
357 }
358
359 /// Valida la forma del bloque (schema, no ejecución): cada `cmd` no vacío y cada
360 /// `expected_output`, si está, con prefijo `b3:`. El checker de H1b corre esto antes de ejecutar.
361 pub fn validate(&self) -> crate::Result<()> {
362 for (i, c) in self.checks.iter().enumerate() {
363 if c.cmd.trim().is_empty() {
364 return Err(crate::Error::Recipe(format!(
365 "evidence.checks[{i}] ({}): `cmd` vacío",
366 c.kind.as_str()
367 )));
368 }
369 if let Some(h) = &c.expected_output {
370 if !h.starts_with("b3:") {
371 return Err(crate::Error::Recipe(format!(
372 "evidence.checks[{i}] ({}): `expected_output` debe ser un hash `b3:…`, es {h:?}",
373 c.kind.as_str()
374 )));
375 }
376 }
377 }
378 Ok(())
379 }
380}
381
382/// Un ítem de evidencia: un comando + el resultado exigido. `kind` estratifica la CONFIANZA
383/// (`cmd-exit` < `proptest` < `contract` < `kani`), que se reporta tal cual — H1 no finge que todo
384/// es prueba formal.
385#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
386pub struct EvidenceCheck {
387 pub kind: EvidenceKind,
388 /// Comando shell a correr en el sandbox reproducible tras el build (misma vía que las fases).
389 pub cmd: String,
390 /// Exit code exigido. Default 0.
391 #[serde(default)]
392 pub expected_exit: i32,
393 /// Hash BLAKE3 (`b3:…`) opcional del stdout, para checks deterministas cuyo OUTPUT también se
394 /// ancla (no sólo el exit). `None` ⇒ sólo se exige el exit code.
395 #[serde(default, skip_serializing_if = "Option::is_none")]
396 pub expected_output: Option<String>,
397}
398
399/// Estrato de confianza de un `EvidenceCheck`, en orden creciente (`Ord` = comparación de estratos).
400#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
401#[serde(rename_all = "kebab-case")]
402pub enum EvidenceKind {
403 /// El comando sale con `expected_exit`. La garantía más débil (un smoke test).
404 CmdExit,
405 /// Property tests (proptest/quickcheck): pasan sobre entradas generadas.
406 Proptest,
407 /// Contratos / aserciones de pre y post-condición.
408 Contract,
409 /// Prueba formal acotada (Kani/Creusot). La garantía más fuerte.
410 Kani,
411}
412
413impl EvidenceKind {
414 /// Nivel numérico de confianza (0 = más débil), para reportar/ordenar.
415 pub fn level(&self) -> u8 {
416 match self {
417 EvidenceKind::CmdExit => 0,
418 EvidenceKind::Proptest => 1,
419 EvidenceKind::Contract => 2,
420 EvidenceKind::Kani => 3,
421 }
422 }
423
424 pub fn as_str(&self) -> &'static str {
425 match self {
426 EvidenceKind::CmdExit => "cmd-exit",
427 EvidenceKind::Proptest => "proptest",
428 EvidenceKind::Contract => "contract",
429 EvidenceKind::Kani => "kani",
430 }
431 }
432}
433
434/// Veredicto de un `EvidenceCheck` tras ejecutarlo (H1b). Se computa comparando el resultado
435/// REAL (exit code + stdout) contra lo declarado — sin tocar el sandbox (eso lo hace el runner).
436#[derive(Debug, Clone, PartialEq, Eq)]
437pub struct CheckOutcome {
438 pub passed: bool,
439 /// Explicación legible de por qué pasó o falló (para el reporte al humano).
440 pub detail: String,
441}
442
443impl EvidenceCheck {
444 /// Evalúa el resultado real de correr `cmd` contra lo declarado: exige `expected_exit` y, si
445 /// hay `expected_output`, que `blake3(stdout)` coincida. **Función pura** — la ejecución en el
446 /// sandbox reproducible es H1b; acá vive la lógica auditable de "¿el resultado es el exigido?".
447 pub fn evaluate(&self, exit_code: i32, stdout: &[u8]) -> CheckOutcome {
448 if exit_code != self.expected_exit {
449 return CheckOutcome {
450 passed: false,
451 detail: format!("exit {exit_code} ≠ esperado {}", self.expected_exit),
452 };
453 }
454 if let Some(want) = &self.expected_output {
455 let got = ArtifactHash::of_bytes(stdout);
456 if got.as_str() != want {
457 return CheckOutcome {
458 passed: false,
459 detail: format!("stdout {got} ≠ esperado {want}"),
460 };
461 }
462 return CheckOutcome {
463 passed: true,
464 detail: format!("exit {exit_code} ok + stdout {want} ok"),
465 };
466 }
467 CheckOutcome {
468 passed: true,
469 detail: format!("exit {exit_code} ok"),
470 }
471 }
472}
473
474/// Compilador del lab, POR RECETA (no global). `zig-cc` por defecto; escotilla a clang/gcc
475/// para paquetes con gcc-ismos. Ver ADR 0003.
476#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
477#[serde(rename_all = "kebab-case")]
478pub enum Compiler {
479 #[default]
480 ZigCc,
481 Clang,
482 Gcc,
483}
484
485impl Compiler {
486 pub fn as_str(&self) -> &'static str {
487 match self {
488 Compiler::ZigCc => "zig-cc",
489 Compiler::Clang => "clang",
490 Compiler::Gcc => "gcc",
491 }
492 }
493}
494
495#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
496#[serde(rename_all = "lowercase")]
497pub enum LinkMode {
498 #[default]
499 Static,
500 Dynamic,
501}
502
503impl LinkMode {
504 pub fn as_str(&self) -> &'static str {
505 match self {
506 LinkMode::Static => "static",
507 LinkMode::Dynamic => "dynamic",
508 }
509 }
510}
511
512fn default_target() -> String {
513 "x86_64-linux-musl".to_string()
514}
515
516impl Recipe {
517 /// Parsea una receta desde su forma TOML. `base_dir` queda vacío: si la receta declara
518 /// `patches`, el caller debe fijar `base_dir` antes de hashear, o usar `load_from_path`.
519 pub fn from_toml(s: &str) -> crate::Result<Recipe> {
520 let r: Recipe = toml::from_str(s).map_err(|e| crate::Error::Recipe(e.to_string()))?;
521 // Los servicios se validan AL CARGAR, no al emitir la seed: un `id` mal puesto rompe la
522 // reproducibilidad del rootfs de producto, y eso hay que verlo en la receta —no tres pasos
523 // después, en un rootfs que ya no reproduce y no dice por qué. Recetas sin `[[service]]`
524 // pasan por una lista vacía, así que esto no toca a las 979 existentes.
525 crate::service::validate_all(&r.services)?;
526 Ok(r)
527 }
528
529 /// Serializa la receta a TOML. Útil para el sidecar de provenance que `takana-build`
530 /// escribe junto al artefacto en el store. `base_dir` no se serializa (es transient).
531 pub fn to_toml(&self) -> crate::Result<String> {
532 toml::to_string(self).map_err(|e| crate::Error::Recipe(e.to_string()))
533 }
534
535 /// Carga una receta desde el disco. `base_dir` se fija al directorio que contiene el
536 /// archivo, de modo que `source.patches` resuelve relativo a ahí (estilo Cargo).
537 pub fn load_from_path(path: impl AsRef<Path>) -> crate::Result<Recipe> {
538 let path = path.as_ref();
539 let text = std::fs::read_to_string(path)?;
540 let mut recipe = Recipe::from_toml(&text)?;
541 if let Some(parent) = path.parent() {
542 recipe.base_dir = parent.to_path_buf();
543 }
544 Ok(recipe)
545 }
546
547 /// Las entradas canónicas que alimentan el `ArtifactHash` de esta receta. Incluye el
548 /// **contenido** de cada patch (no su ruta), de modo que renombrar un archivo no cambia el
549 /// hash y editarlo sí lo hace. Ver `docs/02-build-lab.md` §2.
550 /// `lab` es la huella del toolchain que va a construir esto (ver [`crate::lab`]). Entra SIEMPRE
551 /// y es un parámetro obligatorio, no un `Option`: el 2026-08-10 se midió que dos labs con
552 /// distinto `rustc` producen bytes distintos, así que un hash calculado sin lab y otro con lab
553 /// son direcciones distintas para el mismo contenido. Un default silencioso aquí reintroduciría
554 /// exactamente la divergencia que esto cierra — quien no tiene lab usa
555 /// [`crate::lab::LabFingerprint::for_tests`] y lo dice.
556 pub fn hash_inputs(
557 &self,
558 dep_hashes: &[ArtifactHash],
559 lab: &crate::lab::LabFingerprint,
560 ) -> crate::Result<Vec<Vec<u8>>> {
561 // El identificador inmutable del contenido fuente: el commit en modo git, el
562 // sha256 del archivo en modo tarball. Cualquiera de los dos es un puntero al
563 // contenido exacto, lo que basta para reproducibilidad.
564 let source_id = match self.source.kind()? {
565 SourceKind::Git { commit, .. } => format!("git:{commit}"),
566 SourceKind::Tarball { sha256, .. } => format!("tarball:{sha256}"),
567 // El árbol vive en el repo y puede cambiar en cualquier commit ⇒ el puntero al
568 // contenido hay que CALCULARLO, no leerlo de la receta. `of_tree` es determinista
569 // (rutas ordenadas, bit de ejecución, contenido; no sigue symlinks).
570 SourceKind::Dir { dir } => {
571 let root = self.base_dir.join(dir);
572 let h = crate::ArtifactHash::of_tree(&root).map_err(|e| {
573 crate::Error::Recipe(format!(
574 "no pude hashear el árbol de source.dir {}: {e}",
575 root.display()
576 ))
577 })?;
578 format!("dir:{}", h.as_str())
579 }
580 };
581 let mut v: Vec<Vec<u8>> = vec![
582 source_id.into_bytes(),
583 self.build.compiler.as_str().as_bytes().to_vec(),
584 self.build.target.as_bytes().to_vec(),
585 self.build.link.as_str().as_bytes().to_vec(),
586 format!("lab:{}", lab.as_str()).into_bytes(),
587 ];
588 // Sólo entra al hash si está fijado: una receta sin `zig_version` mantiene su hash de antes
589 // de existir el campo (compatibilidad hacia atrás; el baseline 9adefb82 no se mueve).
590 if let Some(zv) = &self.build.zig_version {
591 v.push(format!("zig:{zv}").into_bytes());
592 }
593 // Ver la doc de `strip_debug`: cambia el CONTENIDO del artefacto, así que TIENE que entrar
594 // al hash. Sólo si está fijado, para no mover los hashes de las recetas que no lo usan.
595 if let Some(sd) = self.build.strip_debug {
596 v.push(format!("strip_debug:{sd}").into_bytes());
597 }
598 for p in &self.source.patches {
599 let resolved = self.base_dir.join(p);
600 let bytes = std::fs::read(&resolved).map_err(|e| {
601 crate::Error::Recipe(format!("no pude leer patch {}: {e}", resolved.display()))
602 })?;
603 v.push(bytes);
604 }
605 for f in &self.build.flags {
606 v.push(f.as_bytes().to_vec());
607 }
608 // Phases override: si alguien cambia el comando del compile, el artefacto cambia.
609 // Etiquetamos cada uno para que añadir un override luego no colisione con un flag.
610 for (label, val) in [
611 ("phase:configure", &self.build.phases.configure),
612 ("phase:compile", &self.build.phases.compile),
613 ("phase:install", &self.build.phases.install),
614 ] {
615 if let Some(cmd) = val {
616 v.push(format!("{label}={cmd}").into_bytes());
617 }
618 }
619 for d in dep_hashes {
620 v.push(d.as_str().as_bytes().to_vec());
621 }
622 Ok(v)
623 }
624}
625
626#[cfg(test)]
627mod tests {
628 use super::*;
629
630 const SAMPLE: &str = r#"
631name = "grep"
632version = "3.11"
633
634[source]
635repo = "git://git.savannah.gnu.org/grep.git"
636commit = "a1b2c3d4e5f6"
637
638[build]
639compiler = "zig-cc"
640target = "x86_64-linux-musl"
641link = "static"
642flags = ["--enable-perl-regexp"]
643
644[deps]
645build = ["pcre2"]
646"#;
647
648 #[test]
649 fn parse_full() {
650 let r = Recipe::from_toml(SAMPLE).expect("parse");
651 assert_eq!(r.name, "grep");
652 assert!(matches!(
653 r.source.kind().unwrap(),
654 SourceKind::Git { commit: "a1b2c3d4e5f6", .. }
655 ));
656 assert_eq!(r.build.compiler, Compiler::ZigCc);
657 assert_eq!(r.build.link, LinkMode::Static);
658 assert_eq!(r.deps.build, vec!["pcre2".to_string()]);
659 }
660
661 #[test]
662 fn to_toml_roundtrips_via_from_toml() {
663 let r1 = Recipe::from_toml(SAMPLE).unwrap();
664 let serialized = r1.to_toml().expect("to_toml");
665 let r2 = Recipe::from_toml(&serialized).expect("from_toml(roundtrip)");
666 assert_eq!(r2.name, r1.name);
667 assert_eq!(r2.version, r1.version);
668 assert_eq!(r2.build.compiler, r1.build.compiler);
669 assert_eq!(r2.build.link, r1.build.link);
670 assert_eq!(r2.build.flags, r1.build.flags);
671 assert_eq!(r2.deps.build, r1.deps.build);
672 // El kind del source también roundtripea.
673 match (r1.source.kind().unwrap(), r2.source.kind().unwrap()) {
674 (SourceKind::Git { commit: c1, .. }, SourceKind::Git { commit: c2, .. }) => {
675 assert_eq!(c1, c2);
676 }
677 _ => panic!("source kind cambió en el roundtrip"),
678 }
679 }
680
681 #[test]
682 fn parse_tarball_source() {
683 let s = r#"
684name = "grep"
685version = "3.11"
686[source]
687tarball = "https://ftp.gnu.org/gnu/grep/grep-3.11.tar.gz"
688sha256 = "1f31014953e71c3cddcedb97692ad7620cb9d6d04fbdc19e0d8dd836f87622bb"
689[build]
690"#;
691 let r = Recipe::from_toml(s).expect("parse");
692 assert!(matches!(r.source.kind().unwrap(), SourceKind::Tarball { .. }));
693 assert_eq!(r.source.strip_components, 1);
694 }
695
696 #[test]
697 fn source_mixed_modes_rejected() {
698 let s = r#"
699name = "x"
700version = "0"
701[source]
702repo = "git://x"
703commit = "deadbeef"
704tarball = "https://x/a.tar.gz"
705sha256 = "abc"
706[build]
707"#;
708 let r = Recipe::from_toml(s).unwrap();
709 let err = r.source.kind().unwrap_err().to_string();
710 assert!(err.contains("no ambos"), "msg = {err}");
711 }
712
713 #[test]
714 fn source_missing_fields_rejected() {
715 let s = r#"
716name = "x"
717version = "0"
718[source]
719repo = "git://x"
720[build]
721"#;
722 let r = Recipe::from_toml(s).unwrap();
723 let err = r.source.kind().unwrap_err().to_string();
724 assert!(err.contains("faltan campos"), "msg = {err}");
725 }
726
727 #[test]
728 fn tarball_and_git_hash_to_different_values() {
729 let git = Recipe::from_toml(SAMPLE).unwrap();
730 let tar_toml = r#"
731name = "grep"
732version = "3.11"
733[source]
734tarball = "https://ftp.gnu.org/gnu/grep/grep-3.11.tar.gz"
735sha256 = "1f31014953e71c3cddcedb97692ad7620cb9d6d04fbdc19e0d8dd836f87622bb"
736[build]
737flags = ["--enable-perl-regexp"]
738"#;
739 let tar = Recipe::from_toml(tar_toml).unwrap();
740 assert_ne!(git.hash_inputs(&[], &crate::lab::LabFingerprint::for_tests()).unwrap(), tar.hash_inputs(&[], &crate::lab::LabFingerprint::for_tests()).unwrap());
741 }
742
743 #[test]
744 fn parse_minimal_uses_defaults() {
745 let s = r#"
746name = "x"
747version = "0"
748[source]
749repo = "git://x"
750commit = "deadbeef"
751[build]
752"#;
753 let r = Recipe::from_toml(s).expect("parse");
754 assert_eq!(r.build.compiler, Compiler::ZigCc); // default
755 assert_eq!(r.build.target, "x86_64-linux-musl"); // default
756 assert_eq!(r.build.link, LinkMode::Static); // default
757 assert!(r.deps.build.is_empty());
758 }
759
760 #[test]
761 fn hash_no_patches_is_deterministic() {
762 let r = Recipe::from_toml(SAMPLE).unwrap();
763 let a = r.hash_inputs(&[], &crate::lab::LabFingerprint::for_tests()).unwrap();
764 let b = r.hash_inputs(&[], &crate::lab::LabFingerprint::for_tests()).unwrap();
765 assert_eq!(a, b);
766 }
767
768 #[test]
769 fn hash_uses_patch_contents_not_path() {
770 let dir1 = tempfile::tempdir().unwrap();
771 let dir2 = tempfile::tempdir().unwrap();
772 std::fs::write(dir1.path().join("p.patch"), b"diff --content").unwrap();
773 std::fs::write(dir2.path().join("otro-nombre.patch"), b"diff --content").unwrap();
774
775 let mut r1 = Recipe::from_toml(SAMPLE).unwrap();
776 r1.source.patches = vec!["p.patch".into()];
777 r1.base_dir = dir1.path().to_path_buf();
778
779 let mut r2 = Recipe::from_toml(SAMPLE).unwrap();
780 r2.source.patches = vec!["otro-nombre.patch".into()];
781 r2.base_dir = dir2.path().to_path_buf();
782
783 // Mismo CONTENIDO ⇒ misma entrada al hash, aunque las rutas sean distintas.
784 assert_eq!(r1.hash_inputs(&[], &crate::lab::LabFingerprint::for_tests()).unwrap(), r2.hash_inputs(&[], &crate::lab::LabFingerprint::for_tests()).unwrap());
785 }
786
787 /// `foreign` marca PROCEDENCIA, no identidad del build: una receta que sella bytes ajenos
788 /// produce exactamente el mismo artefacto con la marca puesta o quitada. Si entrara al hash,
789 /// marcar la primera receta ajena habría movido su `ArtifactHash` — y peor, habría invitado a
790 /// no marcarla para no re-sellar. La marca tiene que ser gratis para que se use.
791 #[test]
792 fn foreign_no_entra_al_hash() {
793 let sin = Recipe::from_toml(SAMPLE).unwrap();
794 let con = Recipe::from_toml(&format!("foreign = true\n{SAMPLE}")).unwrap();
795 assert!(con.foreign && !sin.foreign, "la marca no se parseó");
796 let lab = crate::lab::LabFingerprint::for_tests();
797 assert_eq!(sin.hash_inputs(&[], &lab).unwrap(), con.hash_inputs(&[], &lab).unwrap());
798 }
799
800 #[test]
801 fn hash_changes_when_patch_content_changes() {
802 let dir = tempfile::tempdir().unwrap();
803 let patch = dir.path().join("p.patch");
804 std::fs::write(&patch, b"version A").unwrap();
805
806 let mut r = Recipe::from_toml(SAMPLE).unwrap();
807 r.source.patches = vec!["p.patch".into()];
808 r.base_dir = dir.path().to_path_buf();
809 let h_a = r.hash_inputs(&[], &crate::lab::LabFingerprint::for_tests()).unwrap();
810
811 std::fs::write(&patch, b"version B").unwrap();
812 let h_b = r.hash_inputs(&[], &crate::lab::LabFingerprint::for_tests()).unwrap();
813 assert_ne!(h_a, h_b);
814 }
815
816 #[test]
817 fn missing_patch_reports_path() {
818 let mut r = Recipe::from_toml(SAMPLE).unwrap();
819 r.source.patches = vec!["no-existe.patch".into()];
820 r.base_dir = PathBuf::from("/tmp/seguro-que-no-existe-hammer");
821 let err = r.hash_inputs(&[], &crate::lab::LabFingerprint::for_tests()).unwrap_err().to_string();
822 assert!(err.contains("no-existe.patch"), "msg = {err}");
823 }
824
825 #[test]
826 fn load_from_path_sets_base_dir() {
827 let dir = tempfile::tempdir().unwrap();
828 let recipe_path = dir.path().join("foo.toml");
829 std::fs::write(&recipe_path, SAMPLE).unwrap();
830 let r = Recipe::load_from_path(&recipe_path).unwrap();
831 assert_eq!(r.base_dir, dir.path());
832 }
833
834 const WITH_EVIDENCE: &str = r#"
835name = "grep"
836version = "3.11"
837[source]
838repo = "git://git.savannah.gnu.org/grep.git"
839commit = "a1b2c3d4e5f6"
840[build]
841[deps]
842build = ["pcre2"]
843
844[[evidence.checks]]
845kind = "cmd-exit"
846cmd = "grep --version"
847
848[[evidence.checks]]
849kind = "proptest"
850cmd = "cd /src && cargo test --release proptest_"
851expected_exit = 0
852
853[[evidence.checks]]
854kind = "cmd-exit"
855cmd = "printf hola | grep -q hola"
856expected_output = "b3:deadbeef"
857"#;
858
859 #[test]
860 fn parse_evidence_block() {
861 let r = Recipe::from_toml(WITH_EVIDENCE).expect("parse");
862 assert_eq!(r.evidence.checks.len(), 3);
863 assert_eq!(r.evidence.checks[0].kind, EvidenceKind::CmdExit);
864 assert_eq!(r.evidence.checks[0].cmd, "grep --version");
865 assert_eq!(r.evidence.checks[0].expected_exit, 0); // default
866 assert_eq!(r.evidence.checks[1].kind, EvidenceKind::Proptest);
867 assert_eq!(r.evidence.checks[2].expected_output.as_deref(), Some("b3:deadbeef"));
868 r.evidence.validate().expect("schema válido");
869 }
870
871 #[test]
872 fn evidence_absent_is_empty_and_omitted() {
873 let r = Recipe::from_toml(SAMPLE).unwrap();
874 assert!(r.evidence.is_empty());
875 // `skip_serializing_if` ⇒ una receta sin evidencia no emite el bloque.
876 let toml = r.to_toml().unwrap();
877 assert!(!toml.contains("evidence"), "toml no debería traer `evidence`: {toml}");
878 }
879
880 #[test]
881 fn evidence_does_not_affect_artifact_hash() {
882 // La clave de H1a: la evidencia certifica COMPORTAMIENTO, no IDENTIDAD ⇒ el hash del
883 // artefacto es idéntico con y sin bloque evidence (el baseline de reproducibilidad no se mueve).
884 // Comparamos LA MISMA receta con y sin evidencia (clon + limpieza), no dos recetas distintas.
885 let con = Recipe::from_toml(WITH_EVIDENCE).unwrap();
886 let mut sin = con.clone();
887 sin.evidence = Evidence::default();
888 assert!(con.evidence.checks.len() == 3 && sin.evidence.is_empty());
889 assert_eq!(
890 sin.hash_inputs(&[], &crate::lab::LabFingerprint::for_tests()).unwrap(),
891 con.hash_inputs(&[], &crate::lab::LabFingerprint::for_tests()).unwrap(),
892 "la evidencia NO debe entrar en hash_inputs"
893 );
894 }
895
896 #[test]
897 fn cargo_vendor_roundtripea_y_no_afecta_el_hash() {
898 // `cargo_vendor` decide DE DÓNDE salen las deps de Cargo (registro vs. `vendor/` local), no
899 // CUÁLES: eso lo fija el `Cargo.lock` del source, que ya está bajo el hash de la fuente. Por
900 // eso no entra a `hash_inputs`, igual que `cargo_vendor_dir` — y por eso se puede prender en
901 // una receta YA SELLADA para destrabar su build offline sin re-hashear nada aguas abajo.
902 let sin = Recipe::from_toml(SAMPLE).unwrap();
903 let mut con = sin.clone();
904 con.source.cargo_vendor = Some(true);
905 assert_eq!(
906 sin.hash_inputs(&[], &crate::lab::LabFingerprint::for_tests()).unwrap(),
907 con.hash_inputs(&[], &crate::lab::LabFingerprint::for_tests()).unwrap(),
908 "cargo_vendor NO debe entrar en hash_inputs"
909 );
910 // Y roundtripea por TOML: si se perdiera al serializar, el forzado se apagaría solo en
911 // cualquier flujo que reescriba la receta.
912 let r = Recipe::from_toml(&con.to_toml().unwrap()).unwrap();
913 assert_eq!(r.source.cargo_vendor, Some(true));
914 // Ausente sigue siendo ausente (no `Some(false)`), que es lo que mantiene el TOML limpio.
915 assert_eq!(
916 Recipe::from_toml(&sin.to_toml().unwrap())
917 .unwrap()
918 .source
919 .cargo_vendor,
920 None
921 );
922 }
923
924 #[test]
925 fn slots_round_trip_y_no_afectan_el_hash() {
926 // H4b: el bloque `slots` declara TOPOLOGÍA (qué toca / de qué depende), no identidad ⇒
927 // como la evidencia, NO entra en hash_inputs. Y round-trippea por TOML.
928 let con_toml = format!(
929 "{SAMPLE}\n[slots.claims]\nlogo = \"b3:rojo\"\n[slots.requires]\n\"wayland-protocol\" = \"b3:stock\"\n"
930 );
931 let con = Recipe::from_toml(&con_toml).unwrap();
932 assert_eq!(con.slots.claims.get("logo").unwrap(), "b3:rojo");
933 assert_eq!(con.slots.requires.get("wayland-protocol").unwrap(), "b3:stock");
934 con.slots.validate().unwrap();
935
936 // Round-trip: serializa y vuelve a parsear ⇒ mismos slots.
937 let re = Recipe::from_toml(&con.to_toml().unwrap()).unwrap();
938 assert_eq!(re.slots, con.slots);
939
940 // Mismo hash con y sin slots.
941 let mut sin = con.clone();
942 sin.slots = Slots::default();
943 assert!(!con.slots.is_empty() && sin.slots.is_empty());
944 assert_eq!(
945 sin.hash_inputs(&[], &crate::lab::LabFingerprint::for_tests()).unwrap(),
946 con.hash_inputs(&[], &crate::lab::LabFingerprint::for_tests()).unwrap(),
947 "los slots NO deben entrar en hash_inputs"
948 );
949 }
950
951 #[test]
952 fn licencia_round_trip_y_no_afecta_el_hash() {
953 // ESTE TEST ES LA RAZÓN DE QUE LA DEUDA DE LICENCIAS SEA PAGABLE.
954 //
955 // El 2026-08-07 ninguna de las 1141 recetas declaraba licencia, y sin ese dato la distro no
956 // puede cumplir la GPL al redistribuir binarios (SDD 19 §2.1). Poblarlo sólo es viable si
957 // NO mueve el `ArtifactHash`: si lo moviera, poner la licencia significaría reconstruir el
958 // corpus entero y perder el baseline de reproducibilidad, y nadie lo haría nunca.
959 //
960 // `hash_inputs` es una lista blanca, así que la propiedad se cumple por construcción — pero
961 // se clava acá para que nadie la rompa por descuido metiendo el campo en el hash.
962 // La línea va DELANTE: en TOML una clave suelta después de un `[table]` pertenece a esa
963 // tabla, no a la raíz. Puesta al final, `license` acabaría dentro de `[deps]` y se perdería
964 // en silencio (serde ignora campos desconocidos). Es el mismo cuidado que hay que tener al
965 // poblar las recetas: el campo va arriba, junto a `name` y `version`.
966 let con_toml = format!("license = \"GPL-3.0-or-later\"\n{SAMPLE}");
967 let con = Recipe::from_toml(&con_toml).unwrap();
968 assert_eq!(con.license.as_deref(), Some("GPL-3.0-or-later"));
969
970 // Round-trip por TOML: serializa y vuelve a parsear ⇒ misma licencia.
971 let re = Recipe::from_toml(&con.to_toml().unwrap()).unwrap();
972 assert_eq!(re.license, con.license);
973
974 // Una receta sin el campo parsea igual (las 1141 existentes no se tocan para compilar).
975 let sin = Recipe::from_toml(SAMPLE).unwrap();
976 assert_eq!(sin.license, None);
977
978 // Y el hash es el MISMO con y sin licencia.
979 assert_eq!(
980 sin.hash_inputs(&[], &crate::lab::LabFingerprint::for_tests()).unwrap(),
981 con.hash_inputs(&[], &crate::lab::LabFingerprint::for_tests()).unwrap(),
982 "la licencia NO debe entrar en hash_inputs: si entrara, declararla re-hashearía las \
983 1141 recetas ya selladas y tiraría el baseline de reproducibilidad"
984 );
985 }
986
987 #[test]
988 fn strip_debug_entra_en_el_hash_solo_si_esta_fijado() {
989 // Las DOS mitades de la invariante, porque cada una evita un desastre distinto.
990 //
991 // (1) SIN el campo, el hash NO se mueve. Es lo que permite desplegar el split de debug
992 // receta a receta en vez de re-hashear las 1161 de golpe.
993 let sin = Recipe::from_toml(SAMPLE).unwrap();
994 assert_eq!(sin.build.strip_debug, None);
995
996 // (2) CON el campo, el hash SÍ cambia. `strip_debug` altera el CONTENIDO del artefacto
997 // (le quita las secciones .debug_*), así que si no entrara al hash el lab podría cambiar
998 // lo que sale del build sin que el store se enterara: diría que todo está al día
999 // mientras los artefactos ya no corresponden a su hash. En un sistema direccionado por
1000 // contenido ése es el peor fallo posible — no falla, MIENTE. Es exactamente lo contrario
1001 // de `license`, que describe términos legales y por eso NO debe entrar.
1002 let mut con = Recipe::from_toml(SAMPLE).unwrap();
1003 con.build.strip_debug = Some(true);
1004 assert_ne!(
1005 sin.hash_inputs(&[], &crate::lab::LabFingerprint::for_tests()).unwrap(),
1006 con.hash_inputs(&[], &crate::lab::LabFingerprint::for_tests()).unwrap(),
1007 "strip_debug DEBE entrar en hash_inputs: cambia el contenido del artefacto"
1008 );
1009
1010 // Y round-trippea por TOML, que es como se va a escribir en las recetas.
1011 let re = Recipe::from_toml(&con.to_toml().unwrap()).unwrap();
1012 assert_eq!(re.build.strip_debug, Some(true));
1013 }
1014
1015 #[test]
1016 fn slots_validate_rechaza_hash_sin_prefijo() {
1017 let mut s = Slots::default();
1018 s.claims.insert("logo".into(), "rojo".into()); // falta `b3:`
1019 assert!(s.validate().is_err());
1020 }
1021
1022 #[test]
1023 fn evidence_validate_rejects_empty_cmd_and_bad_hash() {
1024 let bad_cmd = r#"
1025name = "x"
1026version = "0"
1027[source]
1028repo = "git://x"
1029commit = "deadbeef"
1030[build]
1031[[evidence.checks]]
1032kind = "cmd-exit"
1033cmd = " "
1034"#;
1035 let r = Recipe::from_toml(bad_cmd).unwrap();
1036 assert!(r.evidence.validate().unwrap_err().to_string().contains("vacío"));
1037
1038 let bad_hash = r#"
1039name = "x"
1040version = "0"
1041[source]
1042repo = "git://x"
1043commit = "deadbeef"
1044[build]
1045[[evidence.checks]]
1046kind = "cmd-exit"
1047cmd = "true"
1048expected_output = "sha256:zzz"
1049"#;
1050 let r = Recipe::from_toml(bad_hash).unwrap();
1051 assert!(r.evidence.validate().unwrap_err().to_string().contains("b3:"));
1052 }
1053
1054 #[test]
1055 fn evidence_kind_levels_are_stratified() {
1056 assert!(EvidenceKind::CmdExit < EvidenceKind::Proptest);
1057 assert!(EvidenceKind::Proptest < EvidenceKind::Contract);
1058 assert!(EvidenceKind::Contract < EvidenceKind::Kani);
1059 assert_eq!(EvidenceKind::CmdExit.level(), 0);
1060 assert_eq!(EvidenceKind::Kani.level(), 3);
1061 }
1062
1063 fn check(expected_exit: i32, expected_output: Option<&str>) -> EvidenceCheck {
1064 EvidenceCheck {
1065 kind: EvidenceKind::CmdExit,
1066 cmd: "irrelevante".into(),
1067 expected_exit,
1068 expected_output: expected_output.map(|s| s.into()),
1069 }
1070 }
1071
1072 #[test]
1073 fn evaluate_exit_only_pass_and_fail() {
1074 let c = check(0, None);
1075 assert!(c.evaluate(0, b"lo que sea").passed);
1076 let bad = c.evaluate(1, b"");
1077 assert!(!bad.passed);
1078 assert!(bad.detail.contains("exit 1"), "{}", bad.detail);
1079 }
1080
1081 #[test]
1082 fn evaluate_non_zero_expected_exit() {
1083 // Un check puede exigir un exit != 0 (p.ej. "el binario rechaza input inválido con 2").
1084 let c = check(2, None);
1085 assert!(c.evaluate(2, b"").passed);
1086 assert!(!c.evaluate(0, b"").passed);
1087 }
1088
1089 #[test]
1090 fn evaluate_output_hash_pass_and_fail() {
1091 let want = ArtifactHash::of_bytes(b"hola\n");
1092 let c = check(0, Some(want.as_str()));
1093 // stdout correcto ⇒ pasa.
1094 let ok = c.evaluate(0, b"hola\n");
1095 assert!(ok.passed, "{}", ok.detail);
1096 assert!(ok.detail.contains("hash") || ok.detail.contains(want.as_str()));
1097 // stdout distinto ⇒ falla aunque el exit sea correcto.
1098 let bad = c.evaluate(0, b"chau\n");
1099 assert!(!bad.passed);
1100 assert!(bad.detail.contains("stdout"), "{}", bad.detail);
1101 // exit malo ⇒ falla antes de mirar el hash.
1102 assert!(!c.evaluate(1, b"hola\n").passed);
1103 }
1104
1105 // ── source.dir: recetas DERIVADAS (SDD 26) ─────────────────────────────────────────────────
1106 #[test]
1107 fn source_dir_es_su_propio_modo_y_excluye_a_los_otros() {
1108 let solo_dir: Source = toml::from_str("dir = \"atuq\"").unwrap();
1109 assert_eq!(
1110 solo_dir.kind().unwrap(),
1111 SourceKind::Dir { dir: "atuq" },
1112 "un `dir` solo tiene que resolver a modo directorio"
1113 );
1114
1115 // Declarar árbol propio Y fuente upstream no es ambigüedad que resolver por precedencia:
1116 // es un error de quien escribió la receta, y decirlo temprano evita un fetch que después
1117 // se pisa. Se comprueba con las dos formas de upstream.
1118 let con_git: Source =
1119 toml::from_str("dir = \"atuq\"\nrepo = \"git://x\"\ncommit = \"c0\"").unwrap();
1120 assert!(con_git.kind().is_err(), "dir + git debe fallar");
1121 let con_tar: Source =
1122 toml::from_str("dir = \"atuq\"\ntarball = \"http://x/t.tar\"\nsha256 = \"ab\"")
1123 .unwrap();
1124 assert!(con_tar.kind().is_err(), "dir + tarball debe fallar");
1125 }
1126
1127 #[test]
1128 fn el_error_de_source_vacio_nombra_los_tres_modos() {
1129 // El mensaje es la única guía que tiene quien escribe una receta a mano. Si sumamos un modo
1130 // y el error sigue nombrando dos, mandamos a la gente a buscar un campo que no existe.
1131 let vacio: Source = toml::from_str("").unwrap();
1132 let e = vacio.kind().unwrap_err().to_string();
1133 assert!(e.contains("repo"), "{e}");
1134 assert!(e.contains("tarball"), "{e}");
1135 assert!(e.contains("dir"), "{e}");
1136 }
1137}