From d0969f4d9c7f00965c6dbccfd372ac76f3fb3cef Mon Sep 17 00:00:00 2001 From: Alex Flom Date: Mon, 9 Nov 2026 19:05:22 -0700 Subject: [PATCH 1/2] test(bootstrap): avoid discarded BS-15 full-library runs Assemble the same ordered evaluator and native corpora directly. Keep the existing full accepted-package recipe assertions, bounded native inputs, all plants, counts and exported-package checks. Add an old/new assembly regression without changing compiler semantics or gate orchestration. Refs #457 --- VERIFICATION.md | 33 ++++ .../src/cases/bootstrap/rust_package.rs | 180 ++++++++++++++---- 2 files changed, 174 insertions(+), 39 deletions(-) diff --git a/VERIFICATION.md b/VERIFICATION.md index 7412633b08..c0e712e2e5 100644 --- a/VERIFICATION.md +++ b/VERIFICATION.md @@ -43,6 +43,38 @@ Outside `vv`: Each gate below was made to fail by planting a defect, running the gate's command, recording the failure, and removing the defect. The observed lines are verbatim gate output (paths abbreviated to the repository root). `cargo xtask release-check` requires a `### can fail` record for every gate and audit named in `repo_model::release::GATES`. +### BS-15 render corpus materialization + +Issue #457 changes only the construction of the two render vectors in +`crates/conformance/src/cases/bootstrap/rust_package.rs`. The previous code +encoded every full-library render, filtered the evaluator vector, then +replaced the large native inputs with their existing 4,096-byte prefixes. +The discarded full runs were inputs to neither differential. The direct +assembler retains the same order: accepted manifests, shaped inputs, then +seeded render mutants. At or below 16,384 bytes it uses the unchanged run and +expected files in both vectors; above that boundary it constructs only the +same native prefix and recipe outcome. The complete-library recipe assertion +against `package::package` in `accepted` is unchanged. + +No corpus generation, seed, count, negative fixture, planted defect, native +comparison, certificate limit, export check, host condition, timeout, or +compiler-semantics input changes. On the base tree's asserted counts, the +native render vector still contains 735 runs and the evaluator vector 241; +494 full-library argument encodings that neither vector consumed are no +longer materialized. This is a work-count deduction, not a measured CI speedup. + +The library unit regression `render_corpora_preserve_inputs_and_outcomes` +compares both vectors with the previous assembler on both profiles, distinct +supplied package outcomes, recipe outcomes, and libraries of 0, 4,096, +16,383, 16,384, 16,385 and 32,768 bytes. Local validation in the authoring +environment passed whitespace checks and an independent assembly model: +24 evaluator and 36 native results were identical in order and bytes across +27 empty/mixed collection cases, and changes to the boundary, prefix and +supplied-outcome routing were detected. That model does not execute Rust or +the package renderer. Rust formatting, Clippy, the library regression and the +complete release gate were not run locally because the environment has no +Rust toolchain; they remain required acceptance evidence on the final tree. + ### Intel host partition custody and complete evidence The three non-Intel auxiliary host legs keep their existing locked, @@ -13607,3 +13639,4 @@ Under separate root admission ca0818e03f221445d77bfab595b64e255f1eb5d0f5cb74df61 The reviewed physical ledger contains 12,551 entries and 10,900 present files, including 8 symlinks. Physical review393 remains detached at c613 with raw index f2a12ce1d4f383096de2ab9913efd25c55a5a3d01913a670429252ea4ee961eb and logical 0328 source tree; the external pre-documentation capture is 6dcf464632e277916cedfacb5656699c89872c47. Current frozen BOTH/probe artifacts, 905 inputs, closed errors, archived selected build metadata, helper ownership and all producer outputs passed entry and terminal preservation guards. The final additive VI is prepared externally, without changing that physical root. This is source/product readiness evidence, not complete combined-head acceptance. The historical281 draft run 41964177567 ran only plan/honesty/rest with seven required host/Atlas groups skipped; repro 41964177626 passed, and the prior ready run 41964083701 was cancelled. None accepts the new currentbase combination. One complete new-head hosted gate, same-run honesty, reproducibility, final review and eventual actual landing/tree equality remain mandatory. Existing d34/WSL PERFORMANCE rows and timing/host/comparison caveats retain their original scope; no new linearity measurement is claimed. Closure scope remains #373 only after its combined proof/BS02 and final gate requirements pass. + diff --git a/crates/conformance/src/cases/bootstrap/rust_package.rs b/crates/conformance/src/cases/bootstrap/rust_package.rs index b10d186835..ae64cebf46 100644 --- a/crates/conformance/src/cases/bootstrap/rust_package.rs +++ b/crates/conformance/src/cases/bootstrap/rust_package.rs @@ -311,6 +311,37 @@ fn render_run(render: &Render, expected: Files) -> Run { ) } +/// The ordered render corpora consumed by the evaluator and rustc. +fn render_corpora( + renders: &[(Render, Files)], + shaped: &[Render], + mutants: &[Render], +) -> (Vec, Vec) { + let mut within = Vec::new(); + let mut compiled = Vec::new(); + let inputs = renders + .iter() + .map(|(render, files)| (render, Some(files))) + .chain(shaped.iter().chain(mutants).map(|render| (render, None))); + for (render, files) in inputs { + if render.library.len() <= EVALUATOR_LIBRARY { + let expected = files.cloned().unwrap_or_else(|| files_of(render)); + let run = render_run(render, expected); + within.push(run.clone()); + compiled.push(run); + } else { + // rustc expands each argument byte into an array element, so + // the native corpus uses the existing 4,096-byte prefix. The + // full-library run feeds neither consumer; accepted() still + // holds its complete library to the package::package recipe. + let mut render = render.clone(); + render.library.truncate(4_096); + compiled.push(render_run(&render, files_of(&render))); + } + } + (within, compiled) +} + /// A manifest the oracle accepts, what `renderPackage` is given for it, and /// the two files `package::package` wrote. fn accepted(manifest: &Manifest) -> Option<(Render, Files)> { @@ -866,45 +897,7 @@ pub(super) fn case() { } render_mutants.push(render); } - let render_runs: Vec = renders - .iter() - .map(|(render, files)| render_run(render, files.clone())) - .chain( - shaped - .iter() - .chain(&render_mutants) - .map(|render| render_run(render, files_of(render))), - ) - .collect(); - let within: Vec = renders - .iter() - .map(|(render, _)| render) - .chain(&shaped) - .chain(&render_mutants) - .zip(&render_runs) - .filter(|(render, _)| render.library.len() <= EVALUATOR_LIBRARY) - .map(|(_, run)| run.clone()) - .collect(); - // rustc compiles each byte of an argument as one array element, and the - // libraries of the committed packages are megabytes together, so a render - // whose library is beyond the evaluator's bound runs under rustc on the - // first 4,096 bytes of it, held to the recipe, which reads it only as - // bytes to digest. - let compiled: Vec = renders - .iter() - .map(|(render, _)| render) - .chain(&shaped) - .chain(&render_mutants) - .zip(&render_runs) - .map(|(render, run)| { - if render.library.len() <= EVALUATOR_LIBRARY { - return run.clone(); - } - let mut render = render.clone(); - render.library.truncate(4_096); - render_run(&render, files_of(&render)) - }) - .collect(); + let (within, compiled) = render_corpora(&renders, &shaped, &render_mutants); eprintln!( "BS-15: {} manifests ({} accepted), {} and {} rule inputs, {} and {} mutants, {} renders under the evaluator ({:?})", manifests.len(), @@ -1034,3 +1027,112 @@ pub(super) fn case() { } eprintln!("BS-15: passed in {:?}", started.elapsed()); } + +#[cfg(test)] +mod tests { + use super::*; + + fn previous_corpora( + renders: &[(Render, Files)], + shaped: &[Render], + render_mutants: &[Render], + ) -> (Vec, Vec) { + let render_runs: Vec = renders + .iter() + .map(|(render, files)| render_run(render, files.clone())) + .chain( + shaped + .iter() + .chain(render_mutants) + .map(|render| render_run(render, files_of(render))), + ) + .collect(); + let within: Vec = renders + .iter() + .map(|(render, _)| render) + .chain(shaped) + .chain(render_mutants) + .zip(&render_runs) + .filter(|(render, _)| render.library.len() <= EVALUATOR_LIBRARY) + .map(|(_, run)| run.clone()) + .collect(); + // rustc compiles each byte of an argument as one array element, and the + // libraries of the committed packages are megabytes together, so a render + // whose library is beyond the evaluator's bound runs under rustc on the + // first 4,096 bytes of it, held to the recipe, which reads it only as + // bytes to digest. + let compiled: Vec = renders + .iter() + .map(|(render, _)| render) + .chain(shaped) + .chain(render_mutants) + .zip(&render_runs) + .map(|(render, run)| { + if render.library.len() <= EVALUATOR_LIBRARY { + return run.clone(); + } + let mut render = render.clone(); + render.library.truncate(4_096); + render_run(&render, files_of(&render)) + }) + .collect(); + (within, compiled) + } + + #[test] + fn render_corpora_preserve_inputs_and_outcomes() { + let mut renders = Vec::new(); + for std in [false, true] { + for length in [ + 0, + 4_096, + EVALUATOR_LIBRARY - 1, + EVALUATOR_LIBRARY, + EVALUATOR_LIBRARY + 1, + EVALUATOR_LIBRARY * 2, + ] { + let render = Render { + scaffold: scaffold::get().expect("the scaffold").clone(), + name: format!("render_{length}"), + version: "1.2.3".to_owned(), + std, + program: "f".repeat(64), + sources: vec!["a".repeat(64)], + effects: vec!["overflow".to_owned()], + exports: vec![("run".to_owned(), 0)], + library: (0u8..=255).cycle().take(length).collect(), + }; + // Distinct supplied files catch replacing the package's + // expected outcome with the recipe for a small library. + let files = ( + format!("package cargo: {std} {length}").into_bytes(), + format!("package provenance: {std} {length}").into_bytes(), + ); + renders.push((render, files)); + } + } + let shaped: Vec = renders + .iter() + .map(|(render, _)| { + let mut render = render.clone(); + render.name = "a\"b\\c".to_owned(); + render.scaffold.library = "A.rs".to_owned(); + render + }) + .collect(); + let mutants: Vec = shaped + .iter() + .map(|render| { + let mut render = render.clone(); + render.exports.reverse(); + render.sources.clear(); + render + }) + .collect(); + let expected = previous_corpora(&renders, &shaped, &mutants); + let observed = render_corpora(&renders, &shaped, &mutants); + assert_eq!(observed, expected, "both ordered vectors are byte-identical"); + assert_eq!(observed.0.len(), 24, "both profiles include the boundary"); + assert_eq!(observed.1.len(), 36, "rustc keeps every render"); + } +} From 5088c0f47d8a15abcb6a2567c857cfa79fd01b39 Mon Sep 17 00:00:00 2001 From: Alex Flom Date: Mon, 9 Nov 2026 19:09:07 -0700 Subject: [PATCH 2/2] style(bootstrap): apply pinned rustfmt to assembly regression --- crates/conformance/src/cases/bootstrap/rust_package.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/crates/conformance/src/cases/bootstrap/rust_package.rs b/crates/conformance/src/cases/bootstrap/rust_package.rs index ae64cebf46..745fcae696 100644 --- a/crates/conformance/src/cases/bootstrap/rust_package.rs +++ b/crates/conformance/src/cases/bootstrap/rust_package.rs @@ -1131,7 +1131,10 @@ mod tests { .collect(); let expected = previous_corpora(&renders, &shaped, &mutants); let observed = render_corpora(&renders, &shaped, &mutants); - assert_eq!(observed, expected, "both ordered vectors are byte-identical"); + assert_eq!( + observed, expected, + "both ordered vectors are byte-identical" + ); assert_eq!(observed.0.len(), 24, "both profiles include the boundary"); assert_eq!(observed.1.len(), 36, "rustc keeps every render"); }