From 53a854d053334160d5ec40fef48ff0bcb7152a58 Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Wed, 11 Nov 2026 13:16:03 +0000 Subject: [PATCH 1/9] =?UTF-8?q?ci:=20regenerate.yml,=20the=20write=20recip?= =?UTF-8?q?es=20on=20runners=20(SPEC.md=20=C2=A79.4)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A dispatch on a ref runs the production export, the verification records and the other oracle writers as three jobs from clean checkouts of that commit, and a final job combines their patches into one, refusing two that write one path. It reads the repository and writes nothing to it; the patch is reviewed and committed like any other written output (§28.3). Co-Authored-By: Claude Opus 5.5 --- .github/workflows/regenerate.yml | 146 +++++++++++++++++++++++++++++++ CHANGELOG.md | 4 + SPEC.md | 2 + 3 files changed, 152 insertions(+) create mode 100755 .github/workflows/regenerate.yml diff --git a/.github/workflows/regenerate.yml b/.github/workflows/regenerate.yml new file mode 100755 index 0000000000..0da30be75b --- /dev/null +++ b/.github/workflows/regenerate.yml @@ -0,0 +1,146 @@ +# The write recipes of SPEC.md §9.2 on a runner (§9.4): every file the gate +# compares with a committed oracle, regenerated from a clean checkout of the +# dispatched ref and returned as one binary patch. Not part of the gate. It +# reads the repository and writes nothing to it; the patch is reviewed and +# committed like any other written output (§28.3). +# +# gh workflow run regenerate.yml --ref [-f atlas=true] +# gh run download --name regenerated- +# git apply --index regenerated.patch +name: regenerate + +on: + workflow_dispatch: + inputs: + atlas: + description: Rewrite UOR Atlas's verification records too (its whole proof, in the records job) + type: boolean + default: false + +permissions: + contents: read + +concurrency: + group: regenerate-${{ github.ref }} + cancel-in-progress: true + +jobs: + # Each writer runs from its own clean checkout, so the three run at once; + # the paths they write are disjoint, which `combine` checks. + writer: + name: write (${{ matrix.writer }}) + if: github.repository == 'UOR-Foundation/LexLean' + strategy: + fail-fast: false + matrix: + writer: [production-export, records, oracles] + runs-on: ubuntu-24.04 + timeout-minutes: 360 + env: + # The profile of the `examples` leg (§22.11): a schedule, never a byte + # of what is written, which is that of width 1. + LEXLEAN_VERIFY_WIDTH: "2" + LEXLEAN_VERIFY_MEMORY_KIB: "12582912" + LEXLEAN_VERIFY_HINTS: ${{ github.workspace }}/.github/verify-hints.json + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + - name: Install the pinned Rust toolchain + run: rustup toolchain install + - uses: taiki-e/install-action@b6b84cf49ebfe0176417bdce007c624f0db37f20 # v2.86.2 + with: + tool: just + - name: Install elan and the pinned Lean toolchain + run: | + set -euo pipefail + curl https://elan.lean-lang.org/elan-init.sh -sSf | sh -s -- -y --default-toolchain none + echo "$HOME/.elan/bin" >> "$GITHUB_PATH" + "$HOME/.elan/bin/elan" toolchain install "$(cat lean-toolchain)" + - name: Reserve bounded overflow memory for the proofs + run: | + set -euo pipefail + sudo fallocate -l 4G "$RUNNER_TEMP/lexlean-regenerate.swap" + sudo chmod 600 "$RUNNER_TEMP/lexlean-regenerate.swap" + sudo mkswap "$RUNNER_TEMP/lexlean-regenerate.swap" + sudo swapon "$RUNNER_TEMP/lexlean-regenerate.swap" + sudo sysctl vm.swappiness=10 + - name: Run the write recipes + shell: bash + env: + ATLAS: ${{ inputs.atlas }} + run: | + set -euo pipefail + case "${{ matrix.writer }}" in + production-export) recipes="production-export-write" ;; + records) + recipes="verify-write" + if [ "$ATLAS" != "true" ]; then + export LEXLEAN_EXAMPLES_PART=without:uor-atlas + fi + ;; + oracles) recipes="golden-write fixtures-write calculus-write model-write" ;; + esac + just --timestamp --timestamp-format '%s%.3f' $recipes + - name: Capture what the recipes wrote + shell: bash + run: | + set -euo pipefail + mkdir -p "$RUNNER_TEMP/part" + git add --all + git diff --cached --binary > "$RUNNER_TEMP/part/${{ matrix.writer }}.patch" + git diff --cached --name-only | tee "$RUNNER_TEMP/part/${{ matrix.writer }}.files" + echo "${{ matrix.writer }}: $(wc -l < "$RUNNER_TEMP/part/${{ matrix.writer }}.files") paths" >> "$GITHUB_STEP_SUMMARY" + - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + with: + name: regenerate-part-${{ matrix.writer }} + path: ${{ runner.temp }}/part + if-no-files-found: error + retention-days: 7 + + # The parts applied in turn to a clean checkout of the same commit: two parts + # that write one path fail here, rather than one silently replacing the other. + combine: + name: combine + needs: [writer] + runs-on: ubuntu-24.04 + timeout-minutes: 30 + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + - uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2 + with: + pattern: regenerate-part-* + path: ${{ runner.temp }}/parts + merge-multiple: true + - name: Apply every part + shell: bash + run: | + set -euo pipefail + out="$RUNNER_TEMP/regenerated" + mkdir -p "$out" + for part in production-export records oracles; do + # A writer that changed nothing returns an empty patch. + if [ -s "$RUNNER_TEMP/parts/$part.patch" ]; then + git apply --index "$RUNNER_TEMP/parts/$part.patch" + fi + done + git diff --cached --binary > "$out/regenerated.patch" + git diff --cached --name-only > "$out/regenerated-files.txt" + echo "$GITHUB_SHA" > "$out/base-commit.txt" + (cd "$out" && sha256sum regenerated.patch regenerated-files.txt base-commit.txt > SHA256SUMS) + { + echo "### Regenerated $(wc -l < "$out/regenerated-files.txt") paths on $GITHUB_SHA" + echo + echo '```bash' + echo "gh run download $GITHUB_RUN_ID --repo $GITHUB_REPOSITORY --name regenerated-$GITHUB_SHA" + echo "git apply --index regenerated.patch" + echo '```' + } >> "$GITHUB_STEP_SUMMARY" + - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + with: + name: regenerated-${{ github.sha }} + path: ${{ runner.temp }}/regenerated + if-no-files-found: error + retention-days: 7 diff --git a/CHANGELOG.md b/CHANGELOG.md index 350fe95844..e0da37861c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,6 +17,10 @@ workspace carried at those versions without a tag. ## Unreleased +- `regenerate.yml` (SPEC.md §9.4): a dispatch on a ref runs the write recipes on runners, the production + export, the verification records and the other oracles as three parallel jobs, and returns one + reviewed patch, so that a change which moves committed output is no longer regenerated on a + workstation. - The generic notation as language-1.2 source, fourth slice of the front end (SPEC.md §17.23, §17.21, `BS-24`, #269; no new diagnostic code, no change to the language-1.2 identity). `parseGeneric` and `printGeneric` of diff --git a/SPEC.md b/SPEC.md index 6e1c370fbe..ed64dd823d 100644 --- a/SPEC.md +++ b/SPEC.md @@ -707,6 +707,8 @@ The Intel host factory is separate from the normative BDD and Atlas partitions a `reproducibility.yml` MUST perform two builds in distinct absolute directories and compare every platform-independent artifact byte-for-byte after path normalization. +`regenerate.yml` is not part of the gate: it runs the write recipes of §9.2 on runners, so that a change which moves committed output is regenerated from a clean checkout rather than on a workstation. A `workflow_dispatch` on a ref starts three jobs at once, each from its own clean checkout of that commit: `production-export-write`; `verify-write` over every example but UOR Atlas, or over every example when its `atlas` input is set; and `golden-write fixtures-write calculus-write model-write`. They verify with the profile of the `examples` leg, which changes no byte of what is written (§22.11). Each returns what its recipes wrote as a binary patch, and the job `combine` applies the patches in turn to a clean checkout of the same commit, failing when two write one path, and returns the result as one patch with the list of its paths and the commit it applies to. The workflow reads the repository and writes nothing to it (`contents: read`, no persisted credentials); its patch is reviewed and committed like any other written output (§28.3), and the gate then verifies the tree that carries it. + --- ## 10. Project files From a66bd0ce49067976453262f0e7d2dbc86110b33e Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Wed, 11 Nov 2026 13:17:29 +0000 Subject: [PATCH 2/9] ci: regenerate.yml starts on a push to regenerate/** GitHub dispatches only a workflow its default branch carries, so a push to a branch under regenerate/ starts it from any commit; regenerate/atlas/ includes UOR Atlas's records. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/regenerate.yml | 10 ++++++++-- CHANGELOG.md | 2 +- SPEC.md | 2 +- 3 files changed, 10 insertions(+), 4 deletions(-) diff --git a/.github/workflows/regenerate.yml b/.github/workflows/regenerate.yml index 0da30be75b..65c3deb032 100755 --- a/.github/workflows/regenerate.yml +++ b/.github/workflows/regenerate.yml @@ -4,12 +4,18 @@ # reads the repository and writes nothing to it; the patch is reviewed and # committed like any other written output (§28.3). # -# gh workflow run regenerate.yml --ref [-f atlas=true] +# git push origin :refs/heads/regenerate/ # or regenerate/atlas/ +# gh workflow run regenerate.yml --ref [-f atlas=true] # once on the default branch # gh run download --name regenerated- # git apply --index regenerated.patch +# +# A push to `regenerate/**` starts it from any commit, because GitHub +# dispatches only a workflow its default branch carries. name: regenerate on: + push: + branches: ['regenerate/**'] workflow_dispatch: inputs: atlas: @@ -68,7 +74,7 @@ jobs: - name: Run the write recipes shell: bash env: - ATLAS: ${{ inputs.atlas }} + ATLAS: ${{ inputs.atlas || startsWith(github.ref_name, 'regenerate/atlas/') }} run: | set -euo pipefail case "${{ matrix.writer }}" in diff --git a/CHANGELOG.md b/CHANGELOG.md index e0da37861c..dd06a9b783 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,7 +17,7 @@ workspace carried at those versions without a tag. ## Unreleased -- `regenerate.yml` (SPEC.md §9.4): a dispatch on a ref runs the write recipes on runners, the production +- `regenerate.yml` (SPEC.md §9.4): a push to `regenerate/`, or a dispatch, runs the write recipes on runners, the production export, the verification records and the other oracles as three parallel jobs, and returns one reviewed patch, so that a change which moves committed output is no longer regenerated on a workstation. diff --git a/SPEC.md b/SPEC.md index ed64dd823d..e27e7ca350 100644 --- a/SPEC.md +++ b/SPEC.md @@ -707,7 +707,7 @@ The Intel host factory is separate from the normative BDD and Atlas partitions a `reproducibility.yml` MUST perform two builds in distinct absolute directories and compare every platform-independent artifact byte-for-byte after path normalization. -`regenerate.yml` is not part of the gate: it runs the write recipes of §9.2 on runners, so that a change which moves committed output is regenerated from a clean checkout rather than on a workstation. A `workflow_dispatch` on a ref starts three jobs at once, each from its own clean checkout of that commit: `production-export-write`; `verify-write` over every example but UOR Atlas, or over every example when its `atlas` input is set; and `golden-write fixtures-write calculus-write model-write`. They verify with the profile of the `examples` leg, which changes no byte of what is written (§22.11). Each returns what its recipes wrote as a binary patch, and the job `combine` applies the patches in turn to a clean checkout of the same commit, failing when two write one path, and returns the result as one patch with the list of its paths and the commit it applies to. The workflow reads the repository and writes nothing to it (`contents: read`, no persisted credentials); its patch is reviewed and committed like any other written output (§28.3), and the gate then verifies the tree that carries it. +`regenerate.yml` is not part of the gate: it runs the write recipes of §9.2 on runners, so that a change which moves committed output is regenerated from a clean checkout rather than on a workstation. A push to a branch under `regenerate/`, or a `workflow_dispatch` on a ref, starts three jobs at once, each from its own clean checkout of that commit: `production-export-write`; `verify-write` over every example but UOR Atlas, or over every example when the branch is under `regenerate/atlas/` or the `atlas` input is set; and `golden-write fixtures-write calculus-write model-write`. They verify with the profile of the `examples` leg, which changes no byte of what is written (§22.11). Each returns what its recipes wrote as a binary patch, and the job `combine` applies the patches in turn to a clean checkout of the same commit, failing when two write one path, and returns the result as one patch with the list of its paths and the commit it applies to. The workflow reads the repository and writes nothing to it (`contents: read`, no persisted credentials); its patch is reviewed and committed like any other written output (§28.3), and the gate then verifies the tree that carries it. --- From 79ec16402a408f324ab03e377c23b8727e0fdde8 Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Wed, 11 Nov 2026 15:17:45 +0000 Subject: [PATCH 3/9] conformance: the BS evaluator differential runs on every processor Each bdd-bootstrap-* part of the gate is a single case, and its evaluator differential ran its corpus on one thread of a four-processor runner. The runs are independent, so the calling thread and helpers from one budget the process shares each take the next run. The verdict and the disagreements reported are the sequential ones; PD-08's stack measurement keeps every run on the measured thread. Co-Authored-By: Claude Opus 5.5 --- CHANGELOG.md | 4 + crates/conformance/src/cases/bootstrap.rs | 105 ++++++++++++++++++++-- 2 files changed, 101 insertions(+), 8 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 350fe95844..dd86a7e031 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,6 +17,10 @@ workspace carried at those versions without a tag. ## Unreleased +- The evaluator differential of the `BS` cases runs its corpus on every processor of the host: + the calling thread and helpers from one budget the process shares, each taking the next run. + The verdict and the disagreements it reports are the sequential ones; each `bdd-bootstrap-*` + part of the gate is a single case, so three of a runner's four processors were idle. - The generic notation as language-1.2 source, fourth slice of the front end (SPEC.md §17.23, §17.21, `BS-24`, #269; no new diagnostic code, no change to the language-1.2 identity). `parseGeneric` and `printGeneric` of diff --git a/crates/conformance/src/cases/bootstrap.rs b/crates/conformance/src/cases/bootstrap.rs index 7bb1aff05c..5b9633e2ba 100644 --- a/crates/conformance/src/cases/bootstrap.rs +++ b/crates/conformance/src/cases/bootstrap.rs @@ -970,30 +970,119 @@ fn readable(value: &Json) -> String { } /// Every run of `corpus` on which the evaluator and the oracle disagree, up -/// to `limit`, each as the input and the two outcomes. +/// to `limit`, each as the input and the two outcomes: the first `limit` in +/// the corpus's order, whichever thread ran them. +/// +/// The runs are independent, so they run on the calling thread and on as +/// many helpers as the shared budget of [`helpers`] allows, each taking the +/// next run in order. When one has found `limit` disagreements no run is +/// taken after it; every run before the last one taken still finishes, so +/// the first `limit` disagreements are among those run and the answer is the +/// sequential one. When the cases measure the evaluator's stack (`PD-08`) +/// every run is on the calling thread, whose stack is the one measured. fn evaluate(lowered: &Lowered, corpus: &[Run], limit: usize) -> Vec { - let mut out = Vec::new(); - for (run, (arguments, expected)) in corpus.iter().enumerate() { + use std::sync::atomic::{AtomicUsize, Ordering}; + + let disagreement = |run: usize| -> Option { + let (arguments, expected) = &corpus[run]; let outcome = interp::run(&lowered.program, FUEL, lowered.entry(), arguments); let observed = rust::observable(&outcome) .unwrap_or_else(|| panic!("run {run} on {arguments:?}: {outcome:?}")); - if &observed != expected { + (&observed != expected).then(|| { let input: Vec = arguments .iter() .map(|argument| readable(&serde_json::to_value(argument).expect("JSON"))) .collect(); - out.push(format!( + format!( "run {run} on {}: the program gives {}, the oracle {}", input.join(" "), readable(&observed), readable(expected) - )); - if out.len() >= limit { + ) + }) + }; + let next = AtomicUsize::new(0); + let found = AtomicUsize::new(0); + let work = || { + let mut out = Vec::new(); + while found.load(Ordering::SeqCst) < limit { + let run = next.fetch_add(1, Ordering::SeqCst); + if run >= corpus.len() { break; } + if let Some(text) = disagreement(run) { + found.fetch_add(1, Ordering::SeqCst); + out.push((run, text)); + } + } + out + }; + let wanted = if crate::stack_bounds::measuring().is_some() { + 0 + } else { + corpus.len().saturating_sub(1) + }; + let permits = helpers::take(wanted); + let mut out = std::thread::scope(|scope| { + let spawned: Vec<_> = (0..permits.0) + .map(|_| { + std::thread::Builder::new() + .stack_size(EVALUATOR_STACK) + .spawn_scoped(scope, work) + .expect("an evaluator thread") + }) + .collect(); + let mut out = work(); + for helper in spawned { + match helper.join() { + Ok(more) => out.extend(more), + Err(failure) => std::panic::resume_unwind(failure), + } } + out + }); + drop(permits); + out.sort_by_key(|(run, _)| *run); + out.truncate(limit); + out.into_iter().map(|(_, text)| text).collect() +} + +/// The helper threads every [`evaluate`] of this process shares: one fewer +/// than the host's processors, because the threads that call it, the test +/// harness's, already run, and a part of the `bdd` recipe may run several +/// cases at once. Taking never waits: a call takes what is free, and the +/// calling thread alone runs every run when nothing is. +mod helpers { + use std::sync::Mutex; + + static FREE: Mutex> = Mutex::new(None); + + fn budget() -> usize { + std::thread::available_parallelism().map_or(1, std::num::NonZeroUsize::get) - 1 + } + + /// Helpers taken from the budget, returned when dropped, on a panic too. + pub(super) struct Taken(pub(super) usize); + + impl Drop for Taken { + fn drop(&mut self) { + let mut free = FREE + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner); + *free.get_or_insert_with(budget) += self.0; + } + } + + /// Up to `wanted` helpers, as many as are free. + pub(super) fn take(wanted: usize) -> Taken { + let mut free = FREE + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner); + let available = free.get_or_insert_with(budget); + let taken = wanted.min(*available); + *available -= taken; + Taken(taken) } - out } /// What the lowered root returns for `arguments`, as the oracle's values are From f952ed5642bb5c9b79fa677c98658b04de4457a9 Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Wed, 11 Nov 2026 21:41:06 +0000 Subject: [PATCH 4/9] ci: regenerate.yml also writes the counts, model documents and stack bounds A fourth job, after combine, applies the regenerated tree, runs the parts that hold a crate::counts! check under LEXLEAN_COUNTS=fast, writes the moved counts (cargo xtask counts --write) and the model documents, and measures the stack bound of each recursive package the record lacks with a whole run of the case that names its root. The patch it returns is the whole landing. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/regenerate.yml | 151 ++++++++++++++++++++++++++++++- CHANGELOG.md | 2 + SPEC.md | 2 +- 3 files changed, 152 insertions(+), 3 deletions(-) diff --git a/.github/workflows/regenerate.yml b/.github/workflows/regenerate.yml index 65c3deb032..e639c89868 100755 --- a/.github/workflows/regenerate.yml +++ b/.github/workflows/regenerate.yml @@ -124,14 +124,154 @@ jobs: shell: bash run: | set -euo pipefail - out="$RUNNER_TEMP/regenerated" - mkdir -p "$out" for part in production-export records oracles; do # A writer that changed nothing returns an empty patch. if [ -s "$RUNNER_TEMP/parts/$part.patch" ]; then git apply --index "$RUNNER_TEMP/parts/$part.patch" fi done + mkdir -p "$RUNNER_TEMP/combined" + git diff --cached --binary > "$RUNNER_TEMP/combined/combined.patch" + echo "combined: $(git diff --cached --name-only | wc -l) paths" >> "$GITHUB_STEP_SUMMARY" + - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + with: + name: regenerate-combined + path: ${{ runner.temp }}/combined + if-no-files-found: error + retention-days: 7 + + # What follows from the regenerated tree: the counts the bootstrap count + # cases assert (`cargo xtask counts`, from runs of their parts under + # `LEXLEAN_COUNTS=fast`), the model documents, and the stack bound of each + # recursive package the record lacks (PD-08), measured by the cases that run + # it. A measuring run is a whole run of its case, so it also checks the + # counts just written. + finish: + name: counts and stack bounds + needs: [combine] + runs-on: ubuntu-24.04 + timeout-minutes: 360 + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + - name: Install the pinned Rust toolchain + run: rustup toolchain install + - name: Install elan and the pinned Lean toolchain + run: | + set -euo pipefail + curl https://elan.lean-lang.org/elan-init.sh -sSf | sh -s -- -y --default-toolchain none + echo "$HOME/.elan/bin" >> "$GITHUB_PATH" + "$HOME/.elan/bin/elan" toolchain install "$(cat lean-toolchain)" + - name: Reserve bounded overflow memory for the proofs + run: | + set -euo pipefail + sudo fallocate -l 4G "$RUNNER_TEMP/lexlean-regenerate.swap" + sudo chmod 600 "$RUNNER_TEMP/lexlean-regenerate.swap" + sudo mkswap "$RUNNER_TEMP/lexlean-regenerate.swap" + sudo swapon "$RUNNER_TEMP/lexlean-regenerate.swap" + sudo sysctl vm.swappiness=10 + - uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2 + with: + name: regenerate-combined + path: ${{ runner.temp }}/combined + - name: Apply the regenerated tree + shell: bash + run: | + set -euo pipefail + if [ -s "$RUNNER_TEMP/combined/combined.patch" ]; then + git apply --index "$RUNNER_TEMP/combined/combined.patch" + fi + - name: Write the moved counts + shell: bash + run: | + set -uo pipefail + mkdir -p "$RUNNER_TEMP/regenerated" + # The parts of `.github/bdd-parts.json` that hold a case with a + # `crate::counts!` check; each runs only up to its counts. + parts=$(python3 - <<'PY' + import json, pathlib, re + ids = set() + for path in pathlib.Path("crates/conformance/src").rglob("*.rs"): + ids |= set(re.findall(r'counts!\(\s*"([A-Z]+-[0-9]+)"', path.read_text())) + plan = json.loads(pathlib.Path(".github/bdd-parts.json").read_text()) + parts = plan["parts"] if "parts" in plan else plan + print(" ".join(sorted(name for name, members in parts.items() + if isinstance(members, list) and ids & set(members)))) + PY + ) + if [ -z "$parts" ]; then + echo "no case of this tree has a \`crate::counts!\` check: no counts written" | tee -a "$GITHUB_STEP_SUMMARY" + exit 0 + fi + echo "parts with counts: $parts" + for part in $parts; do + LEXLEAN_COUNTS=fast LEXLEAN_BDD_PART="$part" cargo xtask bdd > "$RUNNER_TEMP/fast-$part.log" 2>&1 + echo "$part: exit $?" + done + cargo xtask counts --write 2>&1 | grep -v -E '^\s*(Finished|Running|Compiling)' | tee "$RUNNER_TEMP/regenerated/counts.txt" + test "${PIPESTATUS[0]}" -eq 0 + - name: Write the model documents + run: cargo xtask validate-model --write + - name: Measure the stack bound of each recursive package the record lacks + shell: bash + env: + LEXLEAN_VERIFY_WIDTH: "2" + LEXLEAN_VERIFY_MEMORY_KIB: "12582912" + run: | + set -euo pipefail + # Rows for packages no longer in the exports are dropped; for each + # recursive package without a row, the case whose source names its + # root runs whole and measures it (`LEXLEAN_MEASURE_STACK=all`). + cases=$(python3 - <<'PY' + import json, pathlib, re + record_path = pathlib.Path("tests/stack-bounds.json") + record = json.loads(record_path.read_text()) + recursive = set() + for corpus in ("bootstrap", "stdlib"): + for provenance in pathlib.Path("tests/production-export", corpus, "packages").rglob("provenance.json"): + if "recursion" in json.loads(provenance.read_text()).get("effects", []): + recursive.add(f"{corpus}/{provenance.parent.name}") + rows = {key for key in record["rows"] if key != "bootstrap/evaluator"} + for stale in sorted(rows - recursive): + print(f"dropping the row of {stale}", file=__import__("sys").stderr) + del record["rows"][stale] + if rows - recursive: + record_path.write_text(json.dumps(record, indent=2) + "\n") + sources = list(pathlib.Path("crates/conformance/src/cases").rglob("*.rs")) + cases = set() + for package in sorted(recursive - rows): + name = package.split("/", 1)[1] + root = name.split("_")[0] + "".join(part.title() for part in name.split("_")[1:]) + owners = set() + for source in sources: + text = source.read_text() + # The file's first line names its own case. + own = re.match(r'//! `([A-Z]+-[0-9]+)`', text) + if f'"{root}"' in text and own: + owners.add(own.group(1)) + if not owners: + raise SystemExit(f"{package}: no case names the root `{root}`; measure it by hand") + print(f"{package}: measured by {', '.join(sorted(owners))}", file=__import__("sys").stderr) + cases |= owners + print(" ".join("conformance_" + case.lower().replace("-", "_") for case in sorted(cases))) + PY + ) + if [ -z "$cases" ]; then + echo "every recursive package has its row" | tee -a "$GITHUB_STEP_SUMMARY" + exit 0 + fi + echo "measuring: $cases" | tee -a "$GITHUB_STEP_SUMMARY" + LEXLEAN_MEASURE_STACK=all cargo test -p repo-conformance --all-features --test conformance -- $cases --nocapture 2>&1 \ + | grep -E --line-buffered 'debug [0-9]+ bytes|test result|panicked|^test ' + - name: Return the regenerated tree + if: ${{ !cancelled() }} + shell: bash + run: | + set -euo pipefail + out="$RUNNER_TEMP/regenerated" + mkdir -p "$out" + git add --all git diff --cached --binary > "$out/regenerated.patch" git diff --cached --name-only > "$out/regenerated-files.txt" echo "$GITHUB_SHA" > "$out/base-commit.txt" @@ -139,12 +279,19 @@ jobs: { echo "### Regenerated $(wc -l < "$out/regenerated-files.txt") paths on $GITHUB_SHA" echo + if [ -s "$out/counts.txt" ]; then + echo '#### Counts (the writer lists here anything it could not place)' + echo '```text' + cat "$out/counts.txt" + echo '```' + fi echo '```bash' echo "gh run download $GITHUB_RUN_ID --repo $GITHUB_REPOSITORY --name regenerated-$GITHUB_SHA" echo "git apply --index regenerated.patch" echo '```' } >> "$GITHUB_STEP_SUMMARY" - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + if: ${{ !cancelled() }} with: name: regenerated-${{ github.sha }} path: ${{ runner.temp }}/regenerated diff --git a/CHANGELOG.md b/CHANGELOG.md index 50ab3af991..39f2c77eaf 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -21,6 +21,8 @@ workspace carried at those versions without a tag. export, the verification records and the other oracles as three parallel jobs, and returns one reviewed patch, so that a change which moves committed output is no longer regenerated on a workstation. + A fourth job then writes the moved counts of the bootstrap count cases, the model documents, + and the stack bound of each recursive package that lacks one, so the patch is the whole landing. - `rustix` 1.1.6 (RUSTSEC-2026-0486: the extended-attribute functions marked unwritten bytes as initialized for a zero-length buffer), so `cargo deny` passes; `errno` and `tempfile` resolve `windows-sys` 0.59, the version `fs4` 0.13 and `rustix` 1.1.6 both accept. diff --git a/SPEC.md b/SPEC.md index e27e7ca350..0a19772ddc 100644 --- a/SPEC.md +++ b/SPEC.md @@ -707,7 +707,7 @@ The Intel host factory is separate from the normative BDD and Atlas partitions a `reproducibility.yml` MUST perform two builds in distinct absolute directories and compare every platform-independent artifact byte-for-byte after path normalization. -`regenerate.yml` is not part of the gate: it runs the write recipes of §9.2 on runners, so that a change which moves committed output is regenerated from a clean checkout rather than on a workstation. A push to a branch under `regenerate/`, or a `workflow_dispatch` on a ref, starts three jobs at once, each from its own clean checkout of that commit: `production-export-write`; `verify-write` over every example but UOR Atlas, or over every example when the branch is under `regenerate/atlas/` or the `atlas` input is set; and `golden-write fixtures-write calculus-write model-write`. They verify with the profile of the `examples` leg, which changes no byte of what is written (§22.11). Each returns what its recipes wrote as a binary patch, and the job `combine` applies the patches in turn to a clean checkout of the same commit, failing when two write one path, and returns the result as one patch with the list of its paths and the commit it applies to. The workflow reads the repository and writes nothing to it (`contents: read`, no persisted credentials); its patch is reviewed and committed like any other written output (§28.3), and the gate then verifies the tree that carries it. +`regenerate.yml` is not part of the gate: it runs the write recipes of §9.2 on runners, so that a change which moves committed output is regenerated from a clean checkout rather than on a workstation. A push to a branch under `regenerate/`, or a `workflow_dispatch` on a ref, starts three jobs at once, each from its own clean checkout of that commit: `production-export-write`; `verify-write` over every example but UOR Atlas, or over every example when the branch is under `regenerate/atlas/` or the `atlas` input is set; and `golden-write fixtures-write calculus-write model-write`. They verify with the profile of the `examples` leg, which changes no byte of what is written (§22.11). Each returns what its recipes wrote as a binary patch, and the job `combine` applies the patches in turn to a clean checkout of the same commit, failing when two write one path. The job `finish` then applies that tree and writes what follows from it: the counts the bootstrap count cases assert, by `cargo xtask counts --write` over runs of the parts of `.github/bdd-parts.json` that hold a `crate::counts!` check under `LEXLEAN_COUNTS=fast`; the model documents, by `validate-model --write`; and the row of `tests/stack-bounds.json` of each recursive package of the bootstrap and stdlib exports that has none (`PD-08`), measured by a whole run under `LEXLEAN_MEASURE_STACK=all` of the case whose source names the package's root, which also checks the counts just written, while a row of a package no longer exported is dropped. It returns the result as one patch with the list of its paths, the counts the writer reported, and the commit it applies to. The workflow reads the repository and writes nothing to it (`contents: read`, no persisted credentials); its patch is reviewed and committed like any other written output (§28.3), and the gate then verifies the tree that carries it. --- From 3da2bd3aafeca2474e4048940c729481ae554c75 Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Thu, 12 Nov 2026 00:31:07 +0000 Subject: [PATCH 5/9] =?UTF-8?q?ci:=20export=20the=20bootstrap=20project=20?= =?UTF-8?q?once=20per=20run=20(SPEC.md=20=C2=A79.4)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Every bdd part that runs a bootstrap case exported the bootstrap project itself, a whole verification of 1,173-2,205 s per part (19 jobs, about 569 runner-minutes per gate in run 43046966603). The new `bootstrap export` job runs it once after honesty at the examples leg's profile (`cargo xtask export-bootstrap`), requires the committed packages, and uploads the bundle with a custody record binding repository, run, attempt, commit, tree, pins, toolchains and the bundle digest. Each leg starts a fetcher that takes the artifact when a case first needs it; `exported("bootstrap")` checks the record against its own run and checkout and replays the bundle, and exports as before when LEXLEAN_BOOTSTRAP_EXPORT is unset. RP-14 checks the job, the fetcher and the record against planted changes. Co-Authored-By: Claude Opus 5.5 --- .github/scripts/take-bootstrap-export.sh | 51 +++ .github/workflows/ci.yml | 102 ++++- CHANGELOG.md | 5 + SPEC.md | 6 +- crates/conformance/src/cases/repository.rs | 293 +++++++++++++- crates/conformance/src/export_custody.rs | 418 ++++++++++++++++++++ crates/conformance/src/lib.rs | 1 + crates/conformance/src/production_export.rs | 51 ++- xtask/Cargo.toml | 2 +- xtask/src/main.rs | 21 + 10 files changed, 927 insertions(+), 23 deletions(-) create mode 100755 .github/scripts/take-bootstrap-export.sh create mode 100644 crates/conformance/src/export_custody.rs diff --git a/.github/scripts/take-bootstrap-export.sh b/.github/scripts/take-bootstrap-export.sh new file mode 100755 index 0000000000..79990117a0 --- /dev/null +++ b/.github/scripts/take-bootstrap-export.sh @@ -0,0 +1,51 @@ +#!/usr/bin/env bash +# The fetcher of the run's bootstrap export (SPEC.md §9.4), started beside a +# leg's gate command in a run that is the whole gate. It waits until a case +# of the leg asks for the export (the harness writes `/wanted`), then +# waits for the artifact `bootstrap-export` of THIS run, unpacks it into +# `/artifact`, and writes `/ready`; the harness checks the custody +# record against its own run and checkout before any case reads the bundle. +# When the `bootstrap export` job ends without the artifact it writes the +# reason to `/failed`, and the case fails with it. It reads the run's +# artifacts and jobs through `gh` with the job's token (`actions: read`), +# and nothing of another run. +set -uo pipefail +dir=${1:?the directory the harness waits in} +repo=${GITHUB_REPOSITORY:?} +run=${GITHUB_RUN_ID:?} +mkdir -p "$dir" +fail() { + printf '%s\n' "$1" > "$dir/failed.tmp" && mv "$dir/failed.tmp" "$dir/failed" + echo "take-bootstrap-export: $1" >&2 + exit 1 +} +# No API call until a case needs the export: most legs never ask. +until [ -e "$dir/wanted" ]; do sleep 5; done +echo "take-bootstrap-export: wanted at $(date -u +%H:%M:%SZ)" +polls=0 +while :; do + id=$(gh api "repos/$repo/actions/runs/$run/artifacts?name=bootstrap-export" \ + --jq '[.artifacts[] | select(.expired | not)] | max_by(.created_at) | .id // empty' 2>/dev/null) || id= + if [ -n "$id" ]; then + rm -rf "$dir/artifact" "$dir/artifact.zip" + gh api "repos/$repo/actions/artifacts/$id/zip" > "$dir/artifact.zip" \ + || fail "the artifact $id of run $run did not download" + mkdir -p "$dir/artifact" && unzip -q "$dir/artifact.zip" -d "$dir/artifact" \ + || fail "the artifact $id of run $run did not unpack" + rm -f "$dir/artifact.zip" + echo "take-bootstrap-export: artifact $id of run $run at $(date -u +%H:%M:%SZ)" + touch "$dir/ready" + exit 0 + fi + # Every fourth poll, whether the export job ended without its artifact. + if [ $((polls % 4)) -eq 0 ]; then + state=$(gh api "repos/$repo/actions/runs/$run/jobs?filter=latest&per_page=100" --paginate \ + --jq '.jobs[] | select(.name == "bootstrap export") | "\(.status) \(.conclusion)"' 2>/dev/null) || state= + case "$state" in + "completed success") ;; # uploaded: the next listing shows it + completed*) fail "the bootstrap export job of run $run ended: $state" ;; + esac + fi + polls=$((polls + 1)) + sleep 30 +done diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 812c99c315..4cdbbcefac 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -169,6 +169,87 @@ jobs: if-no-files-found: error retention-days: 14 + # The bootstrap production export, once for the run (SPEC.md §9.4). Every + # bootstrap case compares the packages of that export with the committed + # packages, and exporting verifies the whole bootstrap project, which took + # 20 to 37 minutes of every part that ran it. This job runs it once, at the + # profile of the `examples` leg, requires its packages to equal the + # committed ones, and uploads the bundle with a custody record that binds it + # to the repository, the run and its attempt, the commit and its tree, the + # toolchain pins and the toolchains that ran, and the bundle's digest. A leg + # takes it through `.github/scripts/take-bootstrap-export.sh` when one of + # its cases first needs it, and the harness checks the record against the + # leg's own run and checkout and replays the bundle before the case reads + # it. The legs start when honesty passes, as before, and wait only at that + # point; the artifact is read by this run alone. + bootstrap-export: + name: bootstrap export + needs: [plan, honesty] + if: ${{ needs.plan.outputs.full == 'true' }} + runs-on: ubuntu-24.04 + timeout-minutes: 360 + env: + LEXLEAN_CI_TELEMETRY: ${{ github.workspace }}/ci-evidence + # The resource profile of the examples leg (§22.11); operational only. + LEXLEAN_VERIFY_WIDTH: "2" + LEXLEAN_VERIFY_MEMORY_KIB: "12582912" + LEXLEAN_VERIFY_HINTS: ${{ github.workspace }}/.github/verify-hints.json + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + - name: Install the pinned Rust toolchain + run: rustup toolchain install + - name: Install elan and the pinned Lean toolchain + run: | + set -euo pipefail + curl https://elan.lean-lang.org/elan-init.sh -sSf | sh -s -- -y --default-toolchain none + echo "$HOME/.elan/bin" >> "$GITHUB_PATH" + "$HOME/.elan/bin/elan" toolchain install "$(cat lean-toolchain)" + - name: Reserve bounded overflow memory for the export + run: | + set -euo pipefail + sudo fallocate -l 4G "$RUNNER_TEMP/lexlean-atlas.swap" + sudo chmod 600 "$RUNNER_TEMP/lexlean-atlas.swap" + sudo mkswap "$RUNNER_TEMP/lexlean-atlas.swap" + sudo swapon "$RUNNER_TEMP/lexlean-atlas.swap" + sudo sysctl vm.swappiness=10 + swapon --show + - name: Export the bootstrap project once for the run + shell: bash + run: | + set -euo pipefail + mkdir -p ci-evidence + sample_resources() { + set +e + while true; do + avail=$(awk '/^MemAvailable:/ {print $2}' /proc/meminfo) + swap=$(awk '/^SwapTotal:/ {t=$2} /^SwapFree:/ {f=$2} END {print t-f}' /proc/meminfo) + top=$( (ps -eo rss= --sort=-rss || true) | awk 'NR==1 {print $1}') + printf '%s\t%s\t%s\t%s\n' "$(date +%s.%N | cut -c1-14)" "$avail" "$swap" "${top:-0}" + sleep 5 + done + } + sample_resources > ci-evidence/resources.tsv & + sample_pid=$! + trap 'kill "$sample_pid" 2>/dev/null || true; wait "$sample_pid" 2>/dev/null || true' EXIT + cargo xtask export-bootstrap --output "$RUNNER_TEMP/bootstrap-export" 2>&1 | tee ci-evidence/vv.txt + - name: Summarize the run's timing and memory + if: ${{ !cancelled() }} + run: cargo xtask ci-summary --evidence ci-evidence + - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + with: + name: bootstrap-export + path: ${{ runner.temp }}/bootstrap-export + if-no-files-found: error + include-hidden-files: true + retention-days: 1 + - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + if: ${{ !cancelled() }} + with: + name: acceptance-gate-evidence-bootstrap-export + path: ci-evidence + if-no-files-found: error + retention-days: 14 + vv: name: just vv (${{ matrix.part }}) needs: [plan, honesty] @@ -181,6 +262,11 @@ jobs: matrix: include: ${{ fromJSON(needs.plan.outputs.fanout) }} runs-on: ubuntu-24.04 + # `actions: read` lets a leg list and download this run's artifacts: the + # bootstrap export, which its fetcher takes when a case needs it. + permissions: + contents: read + actions: read # Complete proof coverage is intentionally the long pole. GitHub-hosted # jobs permit six hours; a shorter local-style timeout would turn complete # proof coverage into a CI failure mode. @@ -227,9 +313,23 @@ jobs: swapon --show - name: Run the normative acceptance gate shell: bash + env: + # In a run that is the whole gate, the `bootstrap export` job exports + # the bootstrap project for every leg (§9.4): the fetcher takes the + # run's artifact when a case first asks for it, and the harness + # checks its custody record before any case reads it. Otherwise no + # job exports it once, and a case exports it itself. + FULL_GATE: ${{ needs.plan.outputs.full }} + GH_TOKEN: ${{ github.token }} run: | set -euo pipefail mkdir -p ci-evidence + take_pid= + if [ "$FULL_GATE" = true ]; then + export LEXLEAN_BOOTSTRAP_EXPORT="$RUNNER_TEMP/bootstrap-export" + .github/scripts/take-bootstrap-export.sh "$LEXLEAN_BOOTSTRAP_EXPORT" > ci-evidence/take-bootstrap-export.txt 2>&1 & + take_pid=$! + fi monitor_resources() { while true; do date -u +'%Y-%m-%dT%H:%M:%SZ' @@ -255,7 +355,7 @@ jobs: monitor_pid=$! sample_resources > ci-evidence/resources.tsv & sample_pid=$! - trap 'kill "$monitor_pid" "$sample_pid" 2>/dev/null || true; wait "$monitor_pid" "$sample_pid" 2>/dev/null || true' EXIT + trap 'kill "$monitor_pid" "$sample_pid" $take_pid 2>/dev/null || true; wait "$monitor_pid" "$sample_pid" $take_pid 2>/dev/null || true' EXIT just --timestamp --timestamp-format '%s%.3f' ${{ matrix.recipes }} 2>&1 | tee ci-evidence/vv.txt # The end of the leg's last recipe, as `vv` prints its own at the end # of the whole gate (`repo_conformance::evidence::PART_PASSED_LINE`). diff --git a/CHANGELOG.md b/CHANGELOG.md index 17a425bd30..3b99ea4d45 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,6 +17,11 @@ workspace carried at those versions without a tag. ## Unreleased +- CI exports the bootstrap project once per run (SPEC.md §9.4): the `bootstrap export` job + runs `cargo xtask export-bootstrap` at the `examples` leg's profile, requires the committed + packages, and uploads the bundle with a custody record (`lexlean/ci-bootstrap-export/1`); a + leg takes it when a case first needs it, and the harness checks the record against its own + run and checkout and replays the bundle. No bootstrap part verifies the bootstrap project. - `rustix` 1.1.6 (RUSTSEC-2026-0486: the extended-attribute functions marked unwritten bytes as initialized for a zero-length buffer), so `cargo deny` passes; `errno` and `tempfile` resolve `windows-sys` 0.59, the version `fs4` 0.13 and `rustix` 1.1.6 both accept. diff --git a/SPEC.md b/SPEC.md index 6e1c370fbe..978f4861c6 100644 --- a/SPEC.md +++ b/SPEC.md @@ -693,7 +693,7 @@ Its image MUST install the pinned Rust and Lean toolchains at build, so that not **The release's evidence.** `release.yml` runs no recipe of the gate. The CI evidence a release attaches (§30.3) is a run of `ci.yml` that was the whole gate and passed every job, on the tagged commit or, when the tagged commit is a merge whose tree is the tree of its second parent, on that parent; `.github/release-gate.sh` finds it under the rule `plan` applies to a push, and refuses, naming the commits it looked at, when no such run exists. The evidence names the run, every job of it with its conclusion, and the transcript of every leg the run still retains. The gate run whole on one hosted runner exceeds the six-hour job limit (the `bdd` recipe alone takes over four hours there, and Atlas follows it), so a release gate that re-ran it would never conclude, and the run of the line has already verified the tree. -In a run that is the whole gate, the jobs run the recipes as the rows of `.github/vv-rows.json`, each from its own clean checkout: `examples`, which verifies every example but UOR Atlas; `honesty`, which runs `fmt-check model spec-links bdd` before any expensive root; `rest`, the other recipes in the order of `vv`; and one `bdd-` row for each named part of the `bdd` plan below, which runs `bdd` alone. Each leg runs `just` with its recipes, which stops at the first that fails, as `vv` does. The part of `examples` a job runs is named by its matrix row through `LEXLEAN_EXAMPLES_PART` and by nothing else: `without:uor-atlas` on the leg, `shard:uor-atlas:` and `join:uor-atlas` on the Atlas jobs below; unset or empty, which is what `just vv` runs, the recipe verifies every example whole. After honesty succeeds, the remaining rows run as one matrix and the supported-host matrix, Intel construction and Atlas prefix may start; a failed or skipped honesty part starts none of these expensive roots. Together the legs and the Atlas jobs run every recipe of `vv`, every example, and every test of `bdd` exactly once, and the run passes only when every job passes, so it proves what one run of `just vv` proves; no recipe depends on another having run, and every recipe owns the files it builds. Its wall time is the longest path through the jobs rather than the sum. `just vv` remains the acceptance recipe of §9.2 for every other run, and release acceptance requires the complete same-tree run. +In a run that is the whole gate, the jobs run the recipes as the rows of `.github/vv-rows.json`, each from its own clean checkout: `examples`, which verifies every example but UOR Atlas; `honesty`, which runs `fmt-check model spec-links bdd` before any expensive root; `rest`, the other recipes in the order of `vv`; and one `bdd-` row for each named part of the `bdd` plan below, which runs `bdd` alone. Each leg runs `just` with its recipes, which stops at the first that fails, as `vv` does. The part of `examples` a job runs is named by its matrix row through `LEXLEAN_EXAMPLES_PART` and by nothing else: `without:uor-atlas` on the leg, `shard:uor-atlas:` and `join:uor-atlas` on the Atlas jobs below; unset or empty, which is what `just vv` runs, the recipe verifies every example whole. After honesty succeeds, the remaining rows run as one matrix and the supported-host matrix, Intel construction, the bootstrap export and Atlas prefix may start; a failed or skipped honesty part starts none of these expensive roots. Together the legs and the Atlas jobs run every recipe of `vv`, every example, and every test of `bdd` exactly once, and the run passes only when every job passes, so it proves what one run of `just vv` proves; no recipe depends on another having run, and every recipe owns the files it builds. Its wall time is the longest path through the jobs rather than the sum. `just vv` remains the acceptance recipe of §9.2 for every other run, and release acceptance requires the complete same-tree run. UOR Atlas is verified as the parts of one run. `.github/verify-shards.json` partitions its verification into shards, each naming the shards it needs, the modules it elaborates, and the modules it replays and audits, one of them named `join`; `cargo xtask ci-shards` checks, as the verifier would when a part ran, that every module is elaborated by exactly one shard and replayed by exactly one, that every import of a module a shard elaborates or replays is elaborated by that shard or by one it needs, directly or through another, and that `join` needs every other shard. Each shard is a job of its own clean checkout that runs the verifier's prelude whole (certificate generation, the preflights, staging, the generated-source audit, the probe), then elaborates, replays, and audits only the modules of its plan, reading the `.olean` files of the modules it imports from the output the jobs of the shards it needs uploaded in the same run, and uploads its own `.olean` files and process records as its output. The join runs the modules of its plan, reads every shard's records, requires each to name the executable the join itself hashed for the tool that produced it (`lean` for an elaboration or an audit member, `leanchecker` for a replay), judges each as the stage that produced it judges its own, and continues through policy, the attestation over every record in the canonical order of §22.11, publication, and the comparison of every normalized record with `expected/verify` (§29.5): what it publishes is what the whole verification publishes, record for record and attestation identity included (`VR-23`). A module without a record from any part, a record of a process no module owns, a record whose `executable_sha256` is not the join's digest of its tool (`LLI9001`, naming the record and both digests), or a shard whose plan leaves a module without the `.olean` it imports fails the run. Every process of the verification runs exactly once per run. The executable the Atlas jobs run is the one the `prefix` job built from its clean checkout, carried to the other jobs of the run as an artifact beside the shards' output; it, the output, and the records cross no run, and a job reads the artifacts of its own run only. The Atlas jobs run after the jobs of the shards they need, at the profile of the `examples` leg, and only in a run that is the whole gate. @@ -701,9 +701,11 @@ The `bdd` recipe runs as the parts of one run as well. `.github/bdd-parts.json` Every normative gate job runs on the standard GitHub-hosted runner, `ubuntu-24.04`; no larger runner is part of the gate. The supported-host execution jobs run on their named hosts (§8.3); the Intel aggregate runs on `ubuntu-24.04` and executes no host test. The verification resource profile (§22.11) of a job is named by its matrix row, or on an Atlas job by the job itself, and by nothing else, no repository or workflow variable and no input: the `examples` leg and every Atlas job verify at width 2, with the scheduling hints committed in `.github/verify-hints.json` (derived from a run's telemetry by `cargo xtask ci-hints`) and a memory budget of 12 GiB (12582912 KiB) for the summed expected peaks of the proof processes running at once; the other legs name no profile and run at the default. A profile is a schedule and never a verdict: every elaboration, replay, and audit member still runs on the pinned toolchain, the directory each project publishes is byte for byte the one of width 1 without hints or a budget (§22.11), and the leg and the join still require every example's normalized verification records to equal `expected/verify` (§29.5), so a profile that changed a byte would fail the gate rather than pass a different one. A stale hint reorders processes and never skips one. Local `just vv` verifies UOR Atlas whole at width 1 with no profile. The budget is below the runner's 16 GB, with the 4 GiB swap file of the job as overflow, so two processes run together only when their expected peaks fit, and a process whose expected peak alone passes the budget runs alone. The gate has no path filter, no cache of a build directory, object, verification tree, attestation, or proof result, and no condition that skips a recipe of `just vv` but the plan's, which decides only what a run is, as above; the artifacts the jobs of one run exchange are read by that run alone, and every job starts from a clean checkout with the exact pinned toolchains. Each proof or fan-out job writes its performance telemetry (§22.12) to `ci-evidence/` and uploads that directory as the artifact named after it, `acceptance-gate-evidence-` or `acceptance-gate-evidence-atlas-`: the gate log (`just --timestamp` stamps each recipe's first command on a leg, which is how a recipe is timed without changing it; an Atlas job's log is the recipe's own output), the host's memory and swap sampled every five seconds, the verifier's telemetry, and a summary of the wall time of each recipe and verification stage, the slowest modules and audit members, and the peak resident set and swap of the proof processes. The summary step also prints that summary to the job log and appends it to the step summary, and runs when the job failed, because an uploaded artifact cannot be read from the log; each table lists only its slowest rows and the part appended to the step summary is cut at 512 KiB, half of what GitHub accepts. The initial honesty job retains its recipe timing and summary in the same evidence format, without Lean processes or proof-resource samples. None of it is an input of any recipe, and a timing is never a claim about a semantic property. +The bootstrap production export (§24.7) is made once per run. Every bootstrap case compares the packages of the bootstrap project's export with the committed packages, and a test process that needs the export exports the project, which verifies it whole; each part that ran a bootstrap case ran that verification. In a run that is the whole gate, the job `bootstrap-export` runs `cargo xtask export-bootstrap` from its clean checkout after honesty, at the profile of the `examples` leg, requires every exported package to equal the committed package, and uploads the bundle as the artifact `bootstrap-export` with a custody record (`lexlean/ci-bootstrap-export/1`) that names the repository, the run and its attempt, the commit and its tree, the SHA-256 of `rust-toolchain.toml`, `lean-toolchain` and `Cargo.lock`, what `rustc -vV` and `lean --version` report, the bundle's project-relative path, and the digest of its files. The legs do not wait for that job to start: each leg of such a run starts `.github/scripts/take-bootstrap-export.sh`, which asks nothing until a case of the leg needs the export, then downloads that artifact of its own run, or records that the export job ended without it, and the case fails with that reason. The harness names the directory it waits in through `LEXLEAN_BOOTSTRAP_EXPORT`; before any case reads the bundle it requires the record to name the leg's own repository, run, commit, tree, pins and toolchains, an attempt at most the leg's (a rerun of failed jobs keeps the export that passed, on the same commit), the digest of the files it received, and a path below the project, and it replays the bundle (§24.7). A record that differs in any of these fails the case. Unset or empty, as in `just vv` and in a run that is not the whole gate, each process that needs the export runs it itself. The export crosses no run, as the Atlas parts do not; `RP-14` checks the job, the legs' fetcher, and the record against planted changes. + The Intel host factory is separate from the normative BDD and Atlas partitions above: it transfers only the same-run host test construction and dependency data of §8.3. Construction requires successful honesty; consumers require construction; the aggregate requires all of them and cannot skip an incomplete result. The factory's behavioral tests run in the initial honesty job, before the expensive roots, and exercise inventory completeness, custody and fail-closed result joins without needing an Intel runner. These tests do not substitute for execution of the complete workload on Intel macOS. -`ci.yml` MUST expose the initial `honesty` job (retaining the previous check context) separately so claim drift is distinguishable from code failure. It runs the existing format, model and specification-link recipes and the complete BDD meta-gate target, without Lean. The remaining rows, supported hosts and Atlas prefix MUST require its success; these recipes and meta tests run once in the normative gate. Both the plan's previous-run evidence and release evidence MUST require the honesty row, including its successful conclusion; missing, failed or skipped honesty never establishes full acceptance. The separate `honesty.yml` workflow is subsumed by this same-run job. +`ci.yml` MUST expose the initial `honesty` job (retaining the previous check context) separately so claim drift is distinguishable from code failure. It runs the existing format, model and specification-link recipes and the complete BDD meta-gate target, without Lean. The remaining rows, supported hosts, the bootstrap export and Atlas prefix MUST require its success; these recipes and meta tests run once in the normative gate. Both the plan's previous-run evidence and release evidence MUST require the honesty row, including its successful conclusion; missing, failed or skipped honesty never establishes full acceptance. The separate `honesty.yml` workflow is subsumed by this same-run job. `reproducibility.yml` MUST perform two builds in distinct absolute directories and compare every platform-independent artifact byte-for-byte after path normalization. diff --git a/crates/conformance/src/cases/repository.rs b/crates/conformance/src/cases/repository.rs index 09a8125bb8..3dc75c71e1 100644 --- a/crates/conformance/src/cases/repository.rs +++ b/crates/conformance/src/cases/repository.rs @@ -2093,13 +2093,13 @@ pub(crate) fn run(id: &str) { } assert_eq!( step_conditions, - 4 + 2 * atlas_jobs.len(), + 6 + 2 * atlas_jobs.len(), "the summary step and the evidence upload of every gate job carry it" ); assert_eq!( full_conditions, - atlas_jobs.len() + 1, - "every Atlas job and the host matrix, and no other job, wait for the plan to name the whole gate" + atlas_jobs.len() + 2, + "every Atlas job, the bootstrap export, and the host matrix, and no other job, wait for the plan to name the whole gate" ); assert_eq!(rows_conditions, 1, "the legs run when the plan names a leg"); assert_eq!(honesty_conditions, 1, "honesty runs when the plan names it"); @@ -2145,13 +2145,91 @@ pub(crate) fn run(id: &str) { "the Intel graph must refuse `{from}` replaced by `{to}`" ); } + let take = root_file(TAKE_EXPORT); + bootstrap_export_workflow(&ci, &take) + .expect("§9.4: the run's one bootstrap export and its same-run custody"); + let export_job = workflow_job(&ci, "bootstrap-export").expect("the export job"); + for (from, to) in [ + (" needs: [plan, honesty]", " needs: [plan]"), + ( + "cargo xtask export-bootstrap --output \"$RUNNER_TEMP/bootstrap-export\"", + "echo exported", + ), + ( + " LEXLEAN_VERIFY_WIDTH: \"2\"", + " LEXLEAN_VERIFY_WIDTH: \"4\"", + ), + ( + " name: bootstrap-export\n", + " name: bootstrap-bundle\n", + ), + (" name: bootstrap export\n", " name: export\n"), + ] { + assert!( + export_job.contains(from), + "the plant must change the export job: {from}" + ); + let planted = ci.replacen(&export_job, &export_job.replacen(from, to, 1), 1); + assert!( + bootstrap_export_workflow(&planted, &take).is_err(), + "the bootstrap export's custody must refuse `{from}` replaced by `{to}`" + ); + } + for (from, to) in [ + ( + " FULL_GATE: ${{ needs.plan.outputs.full }}\n", + " FULL_GATE: true\n", + ), + ( + " permissions:\n contents: read\n actions: read\n # Complete proof", + " permissions:\n contents: read\n # Complete proof", + ), + ( + " export LEXLEAN_BOOTSTRAP_EXPORT=\"$RUNNER_TEMP/bootstrap-export\"\n", + " export LEXLEAN_BOOTSTRAP_EXPORT=\"$RUNNER_TEMP/elsewhere\"\n", + ), + ] { + assert!(ci.contains(from), "the plant must change the workflow: {from}"); + assert!( + bootstrap_export_workflow(&ci.replacen(from, to, 1), &take).is_err(), + "the bootstrap export's custody must refuse `{from}` replaced by `{to}`" + ); + } + for (from, to) in [ + ("run=${GITHUB_RUN_ID:?}", "run=${OTHER_RUN_ID:?}"), + ( + "artifacts?name=bootstrap-export", + "artifacts?name=bootstrap-bundle", + ), + ( + "select(.name == \"bootstrap export\")", + "select(.name == \"export\")", + ), + ("until [ -e \"$dir/wanted\" ]", "until true"), + ] { + assert!( + take.contains(from), + "the plant must change the fetcher: {from}" + ); + assert!( + bootstrap_export_workflow(&ci, &take.replacen(from, to, 1)).is_err(), + "the fetcher's custody must refuse `{from}` replaced by `{to}`" + ); + } + bootstrap_custody_decisions(); honesty_dependencies(&ci).expect("expensive roots require successful same-run honesty"); assert!( honesty_dependencies(&ci.replacen("name: ${{ matrix.part }}", "name: honesty", 1)) .is_err(), "a static matrix name acquires a suffix instead of the exact honesty context" ); - for root in ["vv", "atlas-prefix", "host-matrix", "intel-construction"] { + for root in [ + "bootstrap-export", + "vv", + "atlas-prefix", + "host-matrix", + "intel-construction", + ] { let original = format!(" {root}:\n"); let pos = ci.find(&original).expect("the root"); let end = ci[pos + original.len()..] @@ -3256,6 +3334,205 @@ fn intel_host_workflow(ci: &str) -> Result<(), String> { Ok(()) } +/// The fetcher a leg runs beside its gate command to take the run's +/// bootstrap export (§9.4). +const TAKE_EXPORT: &str = ".github/scripts/take-bootstrap-export.sh"; + +/// §9.4: one bootstrap export per run, carried to the legs of the same run. +/// The export job follows honesty and the plan's whole-gate decision, runs +/// the export at the profile of the `examples` leg, and uploads it under the +/// one name the fetcher reads; a leg reads the artifacts of its own run only, +/// takes the export only in a run that is the whole gate, and only into the +/// directory its harness waits in; the fetcher names this run and the export +/// job, and asks nothing before a case wants the export. +fn bootstrap_export_workflow(ci: &str, take: &str) -> Result<(), String> { + let job = workflow_job(ci, "bootstrap-export")?; + let legs = workflow_job(ci, "vv")?; + let require = |body: &str, text: &str, rule: &str| -> Result<(), String> { + if body.contains(text) { + Ok(()) + } else { + Err(format!("RP-14: {rule}: missing `{text}`")) + } + }; + for (text, rule) in [ + (" name: bootstrap export\n", "the job the fetcher watches"), + (" needs: [plan, honesty]\n", "the export follows honesty"), + ( + " if: ${{ needs.plan.outputs.full == 'true' }}\n", + "the export runs in a run that is the whole gate", + ), + (" LEXLEAN_VERIFY_WIDTH: \"2\"\n", "the examples leg's width"), + ( + " LEXLEAN_VERIFY_MEMORY_KIB: \"12582912\"\n", + "the examples leg's budget", + ), + ( + " LEXLEAN_VERIFY_HINTS: ${{ github.workspace }}/.github/verify-hints.json\n", + "the committed hints", + ), + ( + "cargo xtask export-bootstrap --output \"$RUNNER_TEMP/bootstrap-export\" 2>&1 | tee ci-evidence/vv.txt\n", + "the export, with the comparison and the custody record", + ), + (" name: bootstrap-export\n", "the artifact the fetcher reads"), + ( + " path: ${{ runner.temp }}/bootstrap-export\n", + "the directory the export wrote", + ), + ( + "name: acceptance-gate-evidence-bootstrap-export\n", + "the job's evidence", + ), + ] { + require(&job, text, rule)?; + } + for (text, rule) in [ + (" actions: read\n", "a leg lists the run's artifacts"), + ( + " FULL_GATE: ${{ needs.plan.outputs.full }}\n", + "a leg takes the export only in a run that is the whole gate", + ), + ( + " if [ \"$FULL_GATE\" = true ]; then\n export LEXLEAN_BOOTSTRAP_EXPORT=\"$RUNNER_TEMP/bootstrap-export\"\n .github/scripts/take-bootstrap-export.sh \"$LEXLEAN_BOOTSTRAP_EXPORT\"", + "the fetcher fills the directory the harness waits in", + ), + ] { + require(&legs, text, rule)?; + } + for body in [&job, &legs] { + for forbidden in [ + "run-id:", + "github-token:", + "actions/cache", + "continue-on-error", + ] { + if body.contains(forbidden) { + return Err(format!("RP-14: the export's custody admits `{forbidden}`")); + } + } + } + for (text, rule) in [ + ("run=${GITHUB_RUN_ID:?}", "the fetcher reads this run"), + ( + "repos/$repo/actions/runs/$run/artifacts?name=bootstrap-export", + "the fetcher reads the export job's artifact", + ), + ( + "select(.name == \"bootstrap export\")", + "the fetcher watches the export job", + ), + ( + "until [ -e \"$dir/wanted\" ]", + "the fetcher asks nothing before a case wants the export", + ), + ] { + require(take, text, rule)?; + } + if take.matches("actions/runs/").count() != 2 || take.contains("GITHUB_RUN_ID=") { + return Err("RP-14: the fetcher reads the run it is in and no other".to_owned()); + } + Ok(()) +} + +/// §9.4: a custody record names the run and checkout that take the export, +/// and every way it can differ is refused. +fn bootstrap_custody_decisions() { + use crate::export_custody::{check, Custody, Identity, SPEC}; + use std::collections::BTreeMap; + let pins: BTreeMap = [ + ("Cargo.lock", "a".repeat(64)), + ("lean-toolchain", "b".repeat(64)), + ("rust-toolchain.toml", "c".repeat(64)), + ] + .into_iter() + .map(|(name, digest)| (name.to_owned(), digest)) + .collect(); + let toolchains: BTreeMap = + [("lean", "Lean (version 4.32.1)"), ("rustc", "rustc 1.97.1")] + .into_iter() + .map(|(name, text)| (name.to_owned(), text.to_owned())) + .collect(); + let here = Identity { + repository: "UOR-Foundation/LexLean".to_owned(), + run_id: "100".to_owned(), + run_attempt: "2".to_owned(), + commit: "1".repeat(40), + tree: "2".repeat(40), + pins: pins.clone(), + toolchains: toolchains.clone(), + }; + let bundle = ("d".repeat(64), 162); + let record = Custody { + spec: SPEC.to_owned(), + repository: here.repository.clone(), + run_id: here.run_id.clone(), + run_attempt: "1".to_owned(), + commit: here.commit.clone(), + tree: here.tree.clone(), + pins, + toolchains, + bundle_path: ".lexlean/production/bundle".to_owned(), + bundle_sha256: bundle.0.clone(), + bundle_files: bundle.1, + }; + check(&record, &here, &bundle).expect("§9.4: the run's own export, from an earlier attempt"); + type Plant = Box; + let plants: Vec<(&str, Plant)> = vec![ + ("spec", Box::new(|record| record.spec.push('2'))), + ( + "repository", + Box::new(|record| record.repository = "fork/LexLean".to_owned()), + ), + ("run", Box::new(|record| record.run_id = "99".to_owned())), + ( + "attempt", + Box::new(|record| record.run_attempt = "3".to_owned()), + ), + ("commit", Box::new(|record| record.commit = "3".repeat(40))), + ("tree", Box::new(|record| record.tree = "4".repeat(40))), + ( + "pins", + Box::new(|record| { + record + .pins + .insert("lean-toolchain".to_owned(), "e".repeat(64)); + }), + ), + ( + "toolchains", + Box::new(|record| { + record + .toolchains + .insert("rustc".to_owned(), "rustc 1.97.0".to_owned()); + }), + ), + ( + "bundle", + Box::new(|record| record.bundle_sha256 = "f".repeat(64)), + ), + ("bundle", Box::new(|record| record.bundle_files += 1)), + ( + "bundle path", + Box::new(|record| record.bundle_path = "../outside".to_owned()), + ), + ( + "bundle path", + Box::new(|record| record.bundle_path = "/abs/bundle".to_owned()), + ), + ]; + for (field, plant) in plants { + let mut planted = record.clone(); + plant(&mut planted); + let refusal = check(&planted, &here, &bundle) + .expect_err("§9.4: a custody record that names another run, tree, pin, or bundle"); + assert!( + refusal.starts_with(field) && refusal.lines().count() == 1, + "the refusal names the field `{field}` alone: {refusal}" + ); + } +} + /// Claim drift must finish successfully before a costly root can start. fn honesty_dependencies(ci: &str) -> Result<(), String> { let initial = workflow_job(ci, "honesty")?; @@ -3267,7 +3544,13 @@ fn honesty_dependencies(ci: &str) -> Result<(), String> { "RP-14: honesty must expose its matrix-resolved context and follow the plan".to_owned(), ); } - for root in ["vv", "atlas-prefix", "host-matrix", "intel-construction"] { + for root in [ + "bootstrap-export", + "vv", + "atlas-prefix", + "host-matrix", + "intel-construction", + ] { let body = workflow_job(ci, root)?; if !body.contains("needs: [plan, honesty]\n") || body diff --git a/crates/conformance/src/export_custody.rs b/crates/conformance/src/export_custody.rs new file mode 100644 index 0000000000..0f6c5fff54 --- /dev/null +++ b/crates/conformance/src/export_custody.rs @@ -0,0 +1,418 @@ +//! The bootstrap production export carried between the jobs of one CI run +//! (SPEC.md §9.4). The `bootstrap-export` job exports the bootstrap project +//! once, requires its packages to equal the committed packages, and uploads +//! the bundle with a custody record that binds it to the repository, the +//! run and its attempt, the commit and its tree, the toolchain pins and the +//! toolchains that ran, and the bundle's bytes. A conformance case of the same +//! run that needs the export takes it from there instead of exporting the +//! project again: the harness names the directory it waits in through +//! [`VARIABLE`], checks the record against its own run and checkout, replays +//! the bundle, and only then hands it to the case. Unset, as in `just vv`, +//! every process that needs the export runs it as before. + +use std::collections::BTreeMap; +use std::process::Command; +use std::time::{Duration, Instant}; + +use camino::{Utf8Path, Utf8PathBuf}; +use lexlean::api::production::{self, ProductionOutput, ProductionResult}; +use serde::{Deserialize, Serialize}; +use sha2::{Digest, Sha256}; + +use crate::production_export::{self as harness, Exported, BOOTSTRAP}; +use crate::support::{self, P}; + +/// The variable naming the directory a job takes the run's export in. +pub const VARIABLE: &str = "LEXLEAN_BOOTSTRAP_EXPORT"; + +/// The custody record's format. +pub const SPEC: &str = "lexlean/ci-bootstrap-export/1"; + +/// The custody record, beside the bundle in the uploaded directory. +pub const CUSTODY_FILE: &str = "custody.json"; + +/// The exported bundle, beside the custody record. +pub const BUNDLE_DIR: &str = "bundle"; + +/// Written by the harness when a case first needs the export. +pub const WANTED: &str = "wanted"; + +/// Written by the job's fetcher once the artifact is in [`ARTIFACT_DIR`]. +pub const READY: &str = "ready"; + +/// Written by the job's fetcher, with the reason, when the run has no export. +pub const FAILED: &str = "failed"; + +/// Where the fetcher unpacks the uploaded directory. +pub const ARTIFACT_DIR: &str = "artifact"; + +/// The repository files whose bytes pin the toolchains and the dependencies. +pub const PINS: [&str; 3] = ["rust-toolchain.toml", "lean-toolchain", "Cargo.lock"]; + +/// The longest a case waits for the run's export: the export job's own +/// limit, after which the job has failed and the fetcher says so. +const WAIT: Duration = Duration::from_secs(6 * 60 * 60); + +/// What binds an uploaded export to the run and the tree that made it. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct Custody { + /// Exactly [`SPEC`]. + pub spec: String, + /// `owner/name` of the repository whose run exported it. + pub repository: String, + /// The run that exported it. + pub run_id: String, + /// The attempt of that run. + pub run_attempt: String, + /// The commit checked out. + pub commit: String, + /// The tree of that commit. + pub tree: String, + /// The SHA-256 of each file of [`PINS`]. + pub pins: BTreeMap, + /// What the toolchains report: `rustc -vV` and `lean --version`. + pub toolchains: BTreeMap, + /// The project-relative bundle directory of the export. + pub bundle_path: String, + /// [`bundle_digest`] of the bundle. + pub bundle_sha256: String, + /// The number of files in the bundle. + pub bundle_files: u64, +} + +/// The run and checkout a job is in: what a custody record must name. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Identity { + /// `GITHUB_REPOSITORY`. + pub repository: String, + /// `GITHUB_RUN_ID`. + pub run_id: String, + /// `GITHUB_RUN_ATTEMPT`. + pub run_attempt: String, + /// `HEAD`. + pub commit: String, + /// `HEAD^{tree}`. + pub tree: String, + /// The SHA-256 of each file of [`PINS`]. + pub pins: BTreeMap, + /// What the toolchains report. + pub toolchains: BTreeMap, +} + +fn sha256_hex(bytes: &[u8]) -> String { + Sha256::digest(bytes) + .iter() + .map(|byte| format!("{byte:02x}")) + .collect() +} + +fn run(root: &Utf8Path, program: &str, arguments: &[&str]) -> Result { + let output = Command::new(program) + .args(arguments) + .current_dir(root.as_std_path()) + .output() + .map_err(|error| format!("`{program} {}`: {error}", arguments.join(" ")))?; + if !output.status.success() { + return Err(format!( + "`{program} {}` failed: {}", + arguments.join(" "), + String::from_utf8_lossy(&output.stderr).trim() + )); + } + String::from_utf8(output.stdout) + .map(|text| text.trim().to_owned()) + .map_err(|_| format!("`{program} {}` printed no UTF-8", arguments.join(" "))) +} + +/// The run and checkout this process is in. +/// +/// # Errors +/// +/// When the run is not named by GitHub's variables, the checkout's tracked +/// files differ from its commit, or a toolchain cannot be asked its version. +pub fn identity(root: &Utf8Path) -> Result { + let variable = |name: &str| -> Result { + std::env::var(name) + .ok() + .filter(|value| !value.is_empty()) + .ok_or_else(|| format!("`{name}` is unset: the export crosses jobs of a CI run only")) + }; + let repository = variable("GITHUB_REPOSITORY")?; + let run_id = variable("GITHUB_RUN_ID")?; + let run_attempt = variable("GITHUB_RUN_ATTEMPT")?; + for (name, value) in [ + ("GITHUB_RUN_ID", &run_id), + ("GITHUB_RUN_ATTEMPT", &run_attempt), + ] { + if !value.bytes().all(|byte| byte.is_ascii_digit()) { + return Err(format!("`{name}` is not a number: {value}")); + } + } + let changed = run( + root, + "git", + &["status", "--porcelain", "--untracked-files=no"], + )?; + if !changed.is_empty() { + return Err(format!( + "the checkout's tracked files differ from its commit:\n{changed}" + )); + } + let mut pins = BTreeMap::new(); + for name in PINS { + let bytes = std::fs::read(root.join(name).as_std_path()) + .map_err(|error| format!("{name}: {error}"))?; + pins.insert(name.to_owned(), sha256_hex(&bytes)); + } + let toolchains = BTreeMap::from([ + ("lean".to_owned(), run(root, "lean", &["--version"])?), + ("rustc".to_owned(), run(root, "rustc", &["-vV"])?), + ]); + Ok(Identity { + repository, + run_id, + run_attempt, + commit: run(root, "git", &["rev-parse", "HEAD"])?, + tree: run(root, "git", &["rev-parse", "HEAD^{tree}"])?, + pins, + toolchains, + }) +} + +/// The digest of a bundle directory: the SHA-256 of one line +/// ` ` per file, in path order, and the +/// number of files. +#[must_use] +pub fn bundle_digest(bundle: &Utf8Path) -> (String, u64) { + let files = harness::tree(bundle); + let mut listing = String::new(); + for (relative, bytes) in &files { + listing.push_str(&sha256_hex(bytes)); + listing.push_str(" "); + listing.push_str(relative); + listing.push('\n'); + } + (sha256_hex(listing.as_bytes()), files.len() as u64) +} + +/// Whether `custody` names the run and checkout `current` is in and the +/// bundle whose digest is `bundle`. Any attempt of the same run may take +/// an export an attempt before it made: a rerun of failed jobs reruns the +/// consumers and keeps the export that passed, on the same commit. +/// +/// # Errors +/// +/// Every field that does not match, one per line. +pub fn check(custody: &Custody, current: &Identity, bundle: &(String, u64)) -> Result<(), String> { + let mut unmet = Vec::new(); + let mut same = + |what: &str, recorded: &dyn std::fmt::Debug, here: &dyn std::fmt::Debug, equal: bool| { + if !equal { + unmet.push(format!( + "{what}: the record names {recorded:?}, this job has {here:?}" + )); + } + }; + same("spec", &custody.spec, &SPEC, custody.spec == SPEC); + same( + "repository", + &custody.repository, + ¤t.repository, + custody.repository == current.repository, + ); + same( + "run", + &custody.run_id, + ¤t.run_id, + custody.run_id == current.run_id, + ); + let attempt = |value: &str| value.parse::().ok(); + same( + "attempt (at most this job's)", + &custody.run_attempt, + ¤t.run_attempt, + matches!( + (attempt(&custody.run_attempt), attempt(¤t.run_attempt)), + (Some(recorded), Some(here)) if recorded <= here + ), + ); + same( + "commit", + &custody.commit, + ¤t.commit, + custody.commit == current.commit, + ); + same( + "tree", + &custody.tree, + ¤t.tree, + custody.tree == current.tree, + ); + same( + "pins", + &custody.pins, + ¤t.pins, + custody.pins == current.pins, + ); + same( + "toolchains", + &custody.toolchains, + ¤t.toolchains, + custody.toolchains == current.toolchains, + ); + same( + "bundle", + &(&custody.bundle_sha256, custody.bundle_files), + &(&bundle.0, bundle.1), + custody.bundle_sha256 == bundle.0 && custody.bundle_files == bundle.1, + ); + let path = Utf8Path::new(&custody.bundle_path); + same( + "bundle path (relative, below the project)", + &custody.bundle_path, + &"a relative path", + !custody.bundle_path.is_empty() + && path + .components() + .all(|part| matches!(part, camino::Utf8Component::Normal(_))), + ); + if unmet.is_empty() { + Ok(()) + } else { + Err(unmet.join("\n")) + } +} + +fn copy_files(from: &Utf8Path, to: &Utf8Path) -> Result<(), String> { + for (relative, bytes) in harness::tree(from) { + let path = to.join(&relative); + std::fs::create_dir_all(path.parent().expect("a file has a parent").as_std_path()) + .map_err(|error| format!("{path}: {error}"))?; + std::fs::write(path.as_std_path(), bytes).map_err(|error| format!("{path}: {error}"))?; + } + Ok(()) +} + +/// Export the bootstrap project once for the run, require its packages to +/// equal the committed packages, and write the bundle and its custody record +/// to `output`. Returns the record. +/// +/// # Errors +/// +/// When the run or checkout cannot be named, the export fails, a package +/// differs from the committed one, or `output` cannot be written. +pub fn publish(output: &Utf8Path) -> Result { + let root = support::repo_root(); + let before = identity(&root)?; + let exported = harness::export(BOOTSTRAP)?; + let unmet = harness::differences(BOOTSTRAP, &exported); + if !unmet.is_empty() { + return Err(unmet.join("\n")); + } + // The export ran from this checkout: it changed no tracked file. + let after = identity(&root)?; + if after != before { + return Err("the checkout changed while the bootstrap project exported".to_owned()); + } + if output.as_std_path().exists() { + return Err(format!("{output} exists: the export is written once")); + } + let bundle = output.join(BUNDLE_DIR); + copy_files(&exported.bundle(), &bundle)?; + let (bundle_sha256, bundle_files) = bundle_digest(&bundle); + let custody = Custody { + spec: SPEC.to_owned(), + repository: before.repository, + run_id: before.run_id, + run_attempt: before.run_attempt, + commit: before.commit, + tree: before.tree, + pins: before.pins, + toolchains: before.toolchains, + bundle_path: exported.output.bundle.to_string(), + bundle_sha256, + bundle_files, + }; + std::fs::write( + output.join(CUSTODY_FILE).as_std_path(), + harness::canonical(&custody), + ) + .map_err(|error| format!("{output}/{CUSTODY_FILE}: {error}"))?; + Ok(custody) +} + +/// Wait in `directory` for the run's export, check its custody record +/// against this job's run and checkout, place the bundle in a fresh copy of +/// the bootstrap project, and replay it. +/// +/// # Errors +/// +/// When the run has no export, the record names another run, commit, tree, +/// pin, toolchain, or bundle, or the bundle does not replay. +pub fn take(directory: &Utf8Path) -> Result { + std::fs::create_dir_all(directory.as_std_path()) + .and_then(|()| std::fs::write(directory.join(WANTED).as_std_path(), b"")) + .map_err(|error| format!("{directory}: {error}"))?; + let started = Instant::now(); + eprintln!("bootstrap export: waiting in {directory} for the run's export"); + loop { + if directory.join(READY).as_std_path().exists() { + break; + } + if let Ok(reason) = std::fs::read_to_string(directory.join(FAILED).as_std_path()) { + return Err(format!( + "the run has no bootstrap export: {}", + reason.trim() + )); + } + if started.elapsed() > WAIT { + return Err(format!("no export reached {directory} in {WAIT:?}")); + } + std::thread::sleep(Duration::from_secs(5)); + } + let artifact = directory.join(ARTIFACT_DIR); + let custody: Custody = serde_json::from_slice( + &std::fs::read(artifact.join(CUSTODY_FILE).as_std_path()) + .map_err(|error| format!("{CUSTODY_FILE}: {error}"))?, + ) + .map_err(|error| format!("{CUSTODY_FILE}: {error}"))?; + let source = artifact.join(BUNDLE_DIR); + let digest = bundle_digest(&source); + let root = support::repo_root(); + check(&custody, &identity(&root)?, &digest)?; + let project = P::bootstrap(); + let bundle = project.root.join(&custody.bundle_path); + copy_files(&source, &bundle)?; + let result: ProductionResult = serde_json::from_slice( + &std::fs::read(bundle.join("result.json").as_std_path()) + .map_err(|error| format!("result.json: {error}"))?, + ) + .map_err(|error| format!("result.json: {error}"))?; + let report = production::verify_artifact(&bundle) + .map_err(|error| format!("the bundle does not replay: {:?}", error.diagnostics))?; + if report.result_id != result.result_id { + return Err(format!( + "the replay names result {}, result.json {}", + report.result_id, result.result_id + )); + } + eprintln!( + "bootstrap export: taken from run {} attempt {} after {:?} (commit {}, bundle sha256 {}, {} files), replayed", + custody.run_id, + custody.run_attempt, + started.elapsed(), + custody.commit, + custody.bundle_sha256, + custody.bundle_files + ); + Ok(Exported { + project, + output: ProductionOutput { + result, + bundle: Utf8PathBuf::from(&custody.bundle_path), + }, + report, + gnaf: None, + }) +} diff --git a/crates/conformance/src/lib.rs b/crates/conformance/src/lib.rs index 3a974e2dcb..7147f94e86 100644 --- a/crates/conformance/src/lib.rs +++ b/crates/conformance/src/lib.rs @@ -15,6 +15,7 @@ pub mod certification; pub mod certification_library; pub mod differential; pub mod evidence; +pub mod export_custody; pub mod fixtures; pub mod gnaf; pub mod inventory; diff --git a/crates/conformance/src/production_export.rs b/crates/conformance/src/production_export.rs index 06d90d00d8..3daaa00d16 100644 --- a/crates/conformance/src/production_export.rs +++ b/crates/conformance/src/production_export.rs @@ -321,7 +321,20 @@ pub fn exported(example: &str) -> &'static Exported { HELPDESK => &DESK, other => panic!("`{other}` is not an exported example"), }; - cell.get_or_init(|| export(example).unwrap_or_else(|reason| panic!("{reason}"))) + cell.get_or_init(|| { + // In a CI run that exports the bootstrap project once (SPEC.md §9.4), + // the job's harness takes that export instead of running it again. + if example == BOOTSTRAP { + if let Some(directory) = std::env::var(crate::export_custody::VARIABLE) + .ok() + .filter(|value| !value.is_empty()) + { + return crate::export_custody::take(Utf8Path::new(&directory)) + .unwrap_or_else(|reason| panic!("§9.4: the run's bootstrap export: {reason}")); + } + } + export(example).unwrap_or_else(|reason| panic!("{reason}")) + }) } /// Every file under `root`, by `/`-separated relative path. @@ -345,6 +358,28 @@ pub fn tree(root: &Utf8Path) -> BTreeMap> { out } +/// Every difference between one export's packages and the committed expected +/// packages of `example`, one line each. +#[must_use] +pub fn differences(example: &str, exported: &Exported) -> Vec { + let packages = tree(&exported.bundle().join("packages")); + let expected = tree(&fixture_dir(example).join("packages")); + let mut unmet = Vec::new(); + for (relative, bytes) in &packages { + match expected.get(relative) { + Some(committed) if committed == bytes => {} + Some(_) => unmet.push(format!("{example}: packages/{relative} differs")), + None => unmet.push(format!("{example}: packages/{relative} is not committed")), + } + } + for relative in expected.keys() { + if !packages.contains_key(relative) { + unmet.push(format!("{example}: packages/{relative} was not exported")); + } + } + unmet +} + /// Compare every exported package with the committed expected packages, or /// with `write`, replace the expected packages with the exported ones. /// @@ -367,19 +402,7 @@ pub fn check(write: bool) -> Result<(), String> { } continue; } - let expected = tree(&expected_root); - for (relative, bytes) in &packages { - match expected.get(relative) { - Some(committed) if committed == bytes => {} - Some(_) => unmet.push(format!("{example}: packages/{relative} differs")), - None => unmet.push(format!("{example}: packages/{relative} is not committed")), - } - } - for relative in expected.keys() { - if !packages.contains_key(relative) { - unmet.push(format!("{example}: packages/{relative} was not exported")); - } - } + unmet.extend(differences(example, &exported)); } if unmet.is_empty() { Ok(()) diff --git a/xtask/Cargo.toml b/xtask/Cargo.toml index f6090f3784..c642339e1b 100644 --- a/xtask/Cargo.toml +++ b/xtask/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "xtask" -description = "Repository gates: validate-model, validate-spec-links, verify-examples, check-golden, check-reproducibility, check-fixtures, check-calculus, check-production-export, check-package, check-test-inventory, bdd, ci-summary, ci-hints, ci-shards, release-artifacts, release-check, validate." +description = "Repository gates: validate-model, validate-spec-links, verify-examples, check-golden, check-reproducibility, check-fixtures, check-calculus, check-production-export, export-bootstrap, check-package, check-test-inventory, bdd, ci-summary, ci-hints, ci-shards, release-artifacts, release-check, validate." version.workspace = true edition.workspace = true rust-version.workspace = true diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 9887022ba5..d2a7cbbbf0 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -35,6 +35,7 @@ fn main() -> ExitCode { "check-fixtures" => check_fixtures(&root, write), "check-calculus" => check_calculus(&root, write), "check-production-export" => check_production_export(write), + "export-bootstrap" => export_bootstrap(&std::env::args().skip(2).collect::>()), "check-package" => check_package(&root), "check-test-inventory" => ci::check_test_inventory(&root), "bdd" => ci::bdd(&root), @@ -60,6 +61,9 @@ fn main() -> ExitCode { their generator\n\ check-production-export §24.7: the consumer's exported packages equal the committed\n\ packages under tests/production-export\n\ + export-bootstrap §9.4: export the bootstrap project once for a CI run, require + its committed packages, and write the bundle with its custody + record (--output DIR) check-package §30.3, RP-12: package lexlean crate, verify offline build & identity\n\ check-test-inventory RP-13: the `test` and `bdd` recipes partition the workspace tests,\n\ and the parts of .github/bdd-parts.json partition `bdd`\n\ @@ -124,6 +128,23 @@ fn check_production_export(write: bool) -> Result<(), Fail> { Ok(()) } +/// §9.4: the bootstrap production export, run once for a CI run by the +/// `bootstrap-export` job, which uploads what this writes for the run's other +/// jobs (`repo_conformance::export_custody`). +fn export_bootstrap(arguments: &[String]) -> Result<(), Fail> { + let output = arguments + .iter() + .position(|argument| argument == "--output") + .and_then(|index| arguments.get(index + 1)) + .ok_or("export-bootstrap --output DIR")?; + let custody = repo_conformance::export_custody::publish(camino::Utf8Path::new(output))?; + println!( + "export-bootstrap: the bootstrap project exported once for run {} attempt {} (commit {}); its packages equal the committed packages (§24.7); bundle sha256 {} ({} files) in {output}", + custody.run_id, custody.run_attempt, custody.commit, custody.bundle_sha256, custody.bundle_files + ); + Ok(()) +} + fn example_dirs(root: &Path) -> Result, Fail> { let mut dirs = Vec::new(); for entry in std::fs::read_dir(root.join("examples"))? { From 34aca6213e3d96c9e3d25eef466c39114a24587a Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Thu, 12 Nov 2026 00:47:37 +0000 Subject: [PATCH 6/9] =?UTF-8?q?ci:=20run=20the=20Windows=20host's=20tests?= =?UTF-8?q?=20as=20five=20lanes=20(SPEC.md=20=C2=A78.3)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The Windows job ran the whole workspace in one `cargo test` and took 106-126 minutes, the longest job of the gate; 115 minutes of it were the conformance harness (482 cases, 6,924 s). It now runs as five jobs on windows-2022: the four conformance lanes of .github/intel-host-lanes.json (the partition honesty already proves complete) and a producer lane with every other test and doctest. Each lane builds from its own checkout and records the host's listing and what it executed; the join on ubuntu keeps the context `build and non-Lean tests (x86_64-pc-windows-msvc)` and passes only when the lanes are this run's and commit's, disjoint, and together equal the host's whole listing. RP-14 checks the lanes and the join against plants; test_host_lanes.py runs the join's refusals in honesty. Co-Authored-By: Claude Opus 5.5 --- .../__pycache__/host_lanes.cpython-314.pyc | Bin 0 -> 14993 bytes .../intel_host_tests.cpython-314.pyc | Bin 0 -> 83172 bytes .../test_host_lanes.cpython-314.pyc | Bin 0 -> 5662 bytes .../test_intel_host_tests.cpython-314.pyc | Bin 0 -> 63079 bytes .github/scripts/host_lanes.py | 199 ++++++++++++++++++ .github/scripts/test_host_lanes.py | 88 ++++++++ .github/workflows/ci.yml | 81 ++++++- CHANGELOG.md | 5 + SPEC.md | 6 +- crates/conformance/src/cases/repository.rs | 186 +++++++++++++++- 10 files changed, 553 insertions(+), 12 deletions(-) create mode 100644 .github/scripts/__pycache__/host_lanes.cpython-314.pyc create mode 100644 .github/scripts/__pycache__/intel_host_tests.cpython-314.pyc create mode 100644 .github/scripts/__pycache__/test_host_lanes.cpython-314.pyc create mode 100644 .github/scripts/__pycache__/test_intel_host_tests.cpython-314.pyc create mode 100755 .github/scripts/host_lanes.py create mode 100755 .github/scripts/test_host_lanes.py diff --git a/.github/scripts/__pycache__/host_lanes.cpython-314.pyc b/.github/scripts/__pycache__/host_lanes.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..50c062ca44f1cec761d741e5e13b8508c7db2603 GIT binary patch literal 14993 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 literal 0 HcmV?d00001 diff --git a/.github/scripts/__pycache__/intel_host_tests.cpython-314.pyc b/.github/scripts/__pycache__/intel_host_tests.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..871f0727b650303ba012e19cf5849ca06b040b40 GIT binary patch literal 83172 zcmd44d3ambl_!Xm1PPD;NpKNKQINPu6gTbrMsblSu6m?E%ceww1h`mSpa)P3oP|ks zby2aqM8!^tZo6Wt?3Af0r^9rT3f*xgbShO*QmM*=0SXLS{Z*zbJ=4|m&9rT~DrNV4 z-Sa#5t$<+J)$_;9lX&r#d+)pNF6W-}yXTx+lbw~R!_lAd56}Fk@9A`ZM;G#8mQEfX zFz9r%I!+hVUDR>4f|k=6!3-&0 zW-yaIw+5~3*A}#~->hI3`^^q!vtN7A&VC(12m8$l=CI$~U@m70=3UeWot!zC&!q(m zxZT0RdL6f?TOTaK?_T_FxM1zsBY%eayIIGj@6n6b!IFF(t}TT+F5^P!9;0-3BbQmI z3zl(Kgqyg1oUKqdp%1#aEL?BqvJr0K>A%22uobxcRFf!l~DJGe50JGo5=cX2L+ySdE> z_izWeEiC`NI4fso`?v}`+0RuXJit{UJcyESWzP!0?#QJ2NppHCpSMnhv@=u3?nK=bGm6!7k54(8o`Cg5y{4{lmjPe~=Y^)D!g8 zyLzq%$MA;T^#^O}GrR8U--)*7^r_HFg+F8DBmBaO0J_yuAA^s4Y9|? zPkHJ>JL(QzsM&V>P@Qs7y?x-xVQqU$!$jP2+L;;GlPU7$^CIgLqGHe0b0k z4D#bc=yHLH)w%WZKpI2smh0~7yQ=l`P;+4=LMk?b*1Hy;P^m(3Rn1&>i$4r+3Cb zF+Pl{b)D($?s8r7T|eZ)S5e{6Tg-kB+A*HS`vNl)!MG8R<7V`q8DGGJ7*#HpOZ>b{ z>aK$%Q%7ZKAEBQkC@u=m*dO^ut z;5qC2W?fOItJk`6h(9D6%etS+%)2dM9|qlZn}@|F0znR3obyhm4Z&Th3N$fp#< znKSH{zPnsEkS(Xw-mNxczChtKvc#@Jj205E_BOy&h*eTzTu$QBp4sl zm#Qs1wHa&Lc=~t%Lv+Fy&%{aK`Xol`rMQV2F>aoi_ILyF4BqGQVoY5NvIZq;=O=1s z1O-dz*11}_IcBDhi01}n5=WnH#=^0Jl7So?GbEy7Wcey{Lb-6 z`JU*eJ;H%=g8NC~+*887fvD-i1FQY!p|2d8_uihmH5DnS`f2$}MbzpROzvMC5`Q1< z9MlA?b6jEXP1QMil&*m&(lJ2w!HympVMzy?PJhwB8bnIV8L3;#hurNjtC}#D%zsbK z)`xmZ8=vy}rh@T|z%(Bm#E=QZ^_gAOCRY9N%&Yu(&?i=`3n}7e@64n>P;KDLam5n> zPpDogKC9n4JUmPhXe7_-9+)h1&fhr`Gi?Z)HoQ{t>h^!VeevA#&Q(*ixaFQ{t+?a9 zNg7F7VnY3#Rn`IA^%!S$1Gpg`J=zf`-BZ~JzkWa&Q|hQoHEuX%Odi$`>Sqiy#zCdW zPa6j^XJA-1;7?98djq8`NrV$JixO#u@3K%q(Io>mN7b z%5^SXjY{M3#ihD&!zSHEPyzba_bI6l8#n64^`MOgerQ-Nm{_NIxbcu0=ZJn**Q@K% z*1Hs!Q)Us&Ack=r`rx<@#2lQ3iH010)4-JZJd*)RJuA{z%aIAsIq!4DH#gnbwBU?oltnYj7ONiQZ-^Ej zT4}nUe`2m>-IjIp^o`T==YGE%Q(-}){9}=2qb%|6 z#{udsZ&f!QGQV@kdU8WX!UU=ih<}YbMUPk7MLT1t5%6Qbw<*>wO4%WfHDsq z)}J+=(Rpj6(ijUrVK(AS@~Cns5{!HcQpNT4AwzvVV?Xa2;)ePialK!pz7k)Pab(mt z<-6wRkHuY7qCws_!2|`(_>*I_BgX(yfWJpkgzXo8Hh53J+8}PqdPt+?%Q<=a zxW1vauR2|vg)#Y#LjogdBW}c?=ZU_?t(cNMLxJfDFvoGDXJR654uDAu(iBV#HXDrz zrOZkw8sCRpPT?=`Is%#|tk0jB55CeHv2Bjo+=9)$=oNpLf-8H%4adcc)mDLXhnwB& z*%ga@cTNkox(|(dbHi_}MGMY|wT#W;^QM@?6?V8HjxAB!mYD5=V7u@};I%+_`-OXb zzkKp%PYO>w^^3vCcHDd;@JEl{j%>YM)*_SyDFXLK6O)W8ofq9L^dRx?=sKVkPc zy*hmjP$}7=iU!&){q^*cG!0EVJ?^yJEC>hGtqm_3+IlMlI+ z4UBUMITP7QVhj(tM51pBjE8*uL1Yj&LE7_GTU9QSFT-tq69wHAP``_tNWP1wLmp!( zPtd*e-oduc?&cPDo8=;LJD^yJ+)f6)dvKf(1Y%2i==qlspcj8eX0qd6-@R60UvJdZ zw{FXQvFVkpMQ^02CgQAJ8d>&!fBf6y-?+zm z=Z`kLwc!UPv4b7qgB_9D&i9OZTeto_o!;E7f3%Mh&&c}d_M|?lnN%Ps))Gr69df

FFRi9O_uq>BP>R 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 X@A_QV^TS_o-?yei9Nn73+U5TN26bwA literal 0 HcmV?d00001 diff --git a/.github/scripts/__pycache__/test_host_lanes.cpython-314.pyc b/.github/scripts/__pycache__/test_host_lanes.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..787ddf817c4434e4e0982a510ac917e5d08c4b22 GIT binary patch literal 5662 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 CC%6j$ literal 0 HcmV?d00001 diff --git a/.github/scripts/__pycache__/test_intel_host_tests.cpython-314.pyc b/.github/scripts/__pycache__/test_intel_host_tests.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..59bc583602a94a14b8cbc97dcdf6292860c8a904 GIT binary patch literal 63079 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 L6Et-$YZLzu_^BV~ literal 0 HcmV?d00001 diff --git a/.github/scripts/host_lanes.py b/.github/scripts/host_lanes.py new file mode 100755 index 0000000000..bbe3c9b8a1 --- /dev/null +++ b/.github/scripts/host_lanes.py @@ -0,0 +1,199 @@ +#!/usr/bin/env python3 +"""Run one supported host's tests as lanes of one run, and join them (SPEC §8.3/§9.4). + +A host whose one `cargo test --workspace` was the longest job of the gate runs +it as lanes instead, each a job of its own clean checkout and build: the +conformance harness's cases, partitioned exactly as the Intel lanes partition +them (`.github/intel-host-lanes.json`, whose completeness honesty checks), and +the `producer` lane, every other test of the workspace and every doctest. Each +lane records what the host listed and what it executed; the join requires a +receipt from every lane of the same run and commit, lanes that are disjoint, +and an execution whose union is the host's whole listing, test for test, +before the host's context passes. Nothing crosses runs. Python 3.9+. +""" + +import argparse +from collections import Counter +import json +import os +from pathlib import Path +import re +import subprocess +import sys + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import intel_host_tests as factory # noqa: E402 (the shared partition) + +SCHEMA = 1 +PRODUCER = "producer" +CARGO = ["cargo", "test", "--locked", "--all-features", "--no-fail-fast"] +HARNESS = [*CARGO, "-p", "repo-conformance", "--test", "conformance"] +RESULT = re.compile(r"test (.+?) \.\.\. (ok|ignored|FAILED)(?:, .*)?") +SUFFIXES = (" - should panic", " - compile fail", " - no_run") + +require = factory.require +Invalid = factory.Invalid + + +def lanes(root): + """The lanes of a host: the producer, then the conformance lanes.""" + bdd, plan = factory.plan(root) + return bdd, plan, [PRODUCER, *plan["lanes"]] + + +def listing(output): + """Every `name: test` line of a (multi-binary) `--list` transcript.""" + return [line[: -len(": test")] for line in output.splitlines() if line.endswith(": test")] + + +def executed(output): + names = [] + for line in output.splitlines(): + match = RESULT.fullmatch(line.strip()) + if match: + name = match.group(1) + for suffix in SUFFIXES: + name = name.removesuffix(suffix) + names.append(name) + return names + + +def run(command, root, capture=True): + print("+ " + " ".join(command), flush=True) + process = subprocess.Popen(command, cwd=root, stdout=subprocess.PIPE, text=True, + encoding="utf-8", errors="replace") + lines = [] + for line in process.stdout: + sys.stdout.write(line) + lines.append(line) + sys.stdout.flush() + return process.wait(), "".join(lines) + + +def metadata_targets(root): + """The test-carrying targets of repo-conformance other than the harness.""" + output = subprocess.run(["cargo", "metadata", "--locked", "--format-version", "1", "--no-deps"], + cwd=root, check=True, stdout=subprocess.PIPE, text=True).stdout + package = next(p for p in json.loads(output)["packages"] if p["name"] == "repo-conformance") + selectors = [] + for target in package["targets"]: + kinds = set(target["kind"]) + if "test" in kinds and target["name"] != "conformance": + selectors += ["--test", target["name"]] + elif kinds & {"lib", "rlib"}: + selectors.append("--lib") + elif "bin" in kinds: + selectors += ["--bin", target["name"]] + return selectors + + +def identity(root): + git = lambda *args: subprocess.run(["git", *args], cwd=root, check=True, # noqa: E731 + stdout=subprocess.PIPE, text=True).stdout.strip() + return {"commit": git("rev-parse", "HEAD"), "tree": git("rev-parse", "HEAD^{tree}"), + "run": os.environ.get("GITHUB_RUN_ID", ""), "attempt": os.environ.get("GITHUB_RUN_ATTEMPT", "")} + + +def execute(root, target, lane, output): + host = subprocess.run(["rustc", "-vV"], cwd=root, check=True, stdout=subprocess.PIPE, + text=True).stdout + require(f"host: {target}\n" in host, f"this runner is not {target}") + bdd, plan, names = lanes(root) + require(lane in names, f"`{lane}` is no lane of {factory.LANES}") + status, out = run([*HARNESS, "--", "--list"], root) + require(status == 0, "the conformance harness does not list") + conformance = factory.parse_list(out) + receipt = {"schema": SCHEMA, "target": target, "lane": lane, **identity(root), + "conformance": conformance, "whole": None, "executed": []} + failed = False + if lane == PRODUCER: + status, out = run(["cargo", "test", "--locked", "--workspace", "--all-features", "--", "--list"], root) + require(status == 0, "the workspace does not list") + receipt["whole"] = sorted(listing(out)) + commands = [ + [*CARGO, "--workspace", "--exclude", "repo-conformance"], + [*CARGO, "-p", "repo-conformance", *metadata_targets(root)], + [*CARGO, "-p", "repo-conformance", "--doc"], + ] + else: + commands = [[*HARNESS, "--", *factory.lane_filters(bdd, plan)[lane]]] + for command in commands: + status, out = run(command, root) + failed |= status != 0 + receipt["executed"] += executed(out) + receipt["executed"].sort() + receipt["passed"] = not failed + output.mkdir(parents=True, exist_ok=True) + (output / "receipt.json").write_text(json.dumps(receipt, indent=1, sort_keys=True) + "\n") + require(not failed, f"lane `{lane}` has a failing test") + print(f"host-lanes: {target} lane {lane}: {len(receipt['executed'])} tests passed") + + +def join(root, target, artifacts): + bdd, plan, names = lanes(root) + receipts = {} + for path in sorted(Path(artifacts).glob("*/receipt.json")): + receipt = json.loads(path.read_text()) + require(receipt.get("schema") == SCHEMA and receipt.get("target") == target, + f"{path}: a receipt of another host or format") + require(receipt["lane"] not in receipts, f"two receipts of lane `{receipt['lane']}`") + receipts[receipt["lane"]] = receipt + return check_join(receipts, names, plan, bdd, identity(root)) + + +def check_join(receipts, names, plan, bdd, here): + """The lanes are this run's and commit's, complete, disjoint, and passed.""" + require(sorted(receipts) == sorted(names), f"lanes {sorted(names)}, receipts {sorted(receipts)}") + for lane, receipt in receipts.items(): + for field in ("commit", "tree", "run", "attempt"): + if field == "attempt": + require(str(receipt[field]).isdigit() and int(receipt[field]) <= int(here[field] or 0), + f"lane `{lane}` ran in another attempt") + else: + require(receipt[field] == here[field], f"lane `{lane}` ran on another {field}") + require(receipt.get("passed") is True, f"lane `{lane}` did not pass") + conformance = receipts[PRODUCER]["conformance"] + require(conformance and all(r["conformance"] == conformance for r in receipts.values()), + "the lanes listed different conformance harnesses") + named = {factory.test_name(i) for ids in bdd["parts"].values() for i in ids} + require(named <= set(conformance), f"named tests absent: {sorted(named - set(conformance))}") + whole = Counter(receipts[PRODUCER]["whole"] or []) + ran = Counter(name for r in receipts.values() for name in r["executed"]) + require(whole, "the producer listed no workspace") + missing, extra = whole - ran, ran - whole + require(not missing and not extra, + f"executed is not the host's listing: missing {sorted(missing)[:20]}, extra {sorted(extra)[:20]}") + for lane in names: + if lane == PRODUCER: + continue + require(set(receipts[lane]["executed"]) <= set(conformance), + f"lane `{lane}` ran a test outside the conformance harness") + print(f"host-lanes: {len(ran)} tests of {len(names)} lanes equal the host's listing, each once") + return sum(ran.values()) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + sub = parser.add_subparsers(dest="command", required=True) + one = sub.add_parser("execute") + one.add_argument("--target", required=True) + one.add_argument("--lane", required=True) + one.add_argument("--output", required=True, type=Path) + both = sub.add_parser("join") + both.add_argument("--target", required=True) + both.add_argument("--artifacts", required=True) + arguments = parser.parse_args() + root = Path(__file__).resolve().parents[2] + try: + if arguments.command == "execute": + execute(root, arguments.target, arguments.lane, arguments.output) + else: + join(root, arguments.target, arguments.artifacts) + except Invalid as error: + print(f"::error::{error}", file=sys.stderr) + return 1 + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/.github/scripts/test_host_lanes.py b/.github/scripts/test_host_lanes.py new file mode 100755 index 0000000000..32318b3109 --- /dev/null +++ b/.github/scripts/test_host_lanes.py @@ -0,0 +1,88 @@ +"""Behavioral tests of the host lanes' join (SPEC §8.3), run in honesty.""" + +import copy +from pathlib import Path +import sys +import unittest + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import host_lanes # noqa: E402 + +BDD = {"parts": {"one": ["AA-01"], "two": ["AA-02"]}, "targets": {"honesty": ["bdd"]}, "remainder": "rest"} +PLAN = {"producer": ["honesty"], "lanes": {"a": ["one"], "b": ["two", "rest"]}} +NAMES = ["producer", "a", "b"] +HERE = {"commit": "c" * 40, "tree": "t" * 40, "run": "7", "attempt": "1"} +HARNESS = ["conformance_aa_01", "conformance_aa_02", "conformance_aa_03"] + + +def receipts(): + base = {"schema": 1, "target": "x86_64-pc-windows-msvc", "passed": True, "conformance": HARNESS, + "whole": None, **HERE} + return { + "producer": {**base, "lane": "producer", "executed": ["meta", "unit"], + "whole": sorted(["meta", "unit", *HARNESS])}, + "a": {**base, "lane": "a", "executed": ["conformance_aa_01"]}, + "b": {**base, "lane": "b", "executed": ["conformance_aa_02", "conformance_aa_03"]}, + } + + +class Join(unittest.TestCase): + def check(self, value): + return host_lanes.check_join(value, NAMES, PLAN, BDD, HERE) + + def refuse(self, value): + with self.assertRaises(host_lanes.Invalid): + self.check(value) + + def test_complete_lanes_pass(self): + self.assertEqual(self.check(receipts()), 5) + + def test_missing_lane(self): + value = receipts() + del value["b"] + self.refuse(value) + + def test_test_run_twice(self): + value = receipts() + value["a"]["executed"].append("conformance_aa_02") + self.refuse(value) + + def test_test_lost(self): + value = receipts() + value["b"]["executed"] = ["conformance_aa_02"] + self.refuse(value) + + def test_failed_lane(self): + value = receipts() + value["a"]["passed"] = False + self.refuse(value) + + def test_other_commit_or_run(self): + for field in ("commit", "tree", "run"): + value = receipts() + value["a"][field] = "x" + self.refuse(value) + + def test_different_harness(self): + value = receipts() + value["b"] = copy.deepcopy(value["b"]) + value["b"]["conformance"] = HARNESS[:2] + self.refuse(value) + + def test_conformance_lane_outside_harness(self): + value = receipts() + value["a"]["executed"] = ["meta"] + value["producer"]["executed"] = ["conformance_aa_01", "unit"] + self.refuse(value) + + def test_named_test_absent(self): + value = receipts() + for receipt in value.values(): + receipt["conformance"] = ["conformance_aa_02", "conformance_aa_03"] + value["producer"]["whole"] = sorted(["meta", "unit", "conformance_aa_02", "conformance_aa_03"]) + value["a"]["executed"] = [] + self.refuse(value) + + +if __name__ == "__main__": + unittest.main() diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 812c99c315..c18f13e9ac 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -150,7 +150,9 @@ jobs: - name: Test the Intel construction and inventory checks env: PYTHONDONTWRITEBYTECODE: "1" - run: python3 -m unittest discover -s .github/scripts -p 'test_intel_host_tests.py' + run: | + python3 -m unittest discover -s .github/scripts -p 'test_intel_host_tests.py' + python3 -m unittest discover -s .github/scripts -p 'test_host_lanes.py' - name: Run the honesty part of the acceptance gate shell: bash run: | @@ -1021,9 +1023,10 @@ jobs: # reports which ones it skipped; on Linux x86-64 the same gate makes the # toolchain mandatory, so nothing passes vacuously where it matters. # - # The three hosts below keep their original single invocation. Intel's - # conformance execution is partitioned below after one construction; its - # final aggregate retains the fourth supported-host status (issue #449). + # The two hosts below keep their original single invocation. Windows runs + # as lanes below, each building for itself, and Intel's conformance + # execution is partitioned below after one construction; each aggregate + # retains its supported-host status (issue #449). # There is no separate build step here: `cargo test` with the same `--locked # --workspace --all-features` builds, in the same profile, the library and the # binary of `lexlean` (its integration tests run the binary) before it runs a @@ -1040,7 +1043,6 @@ jobs: include: - { os: ubuntu-24.04-arm, target: aarch64-unknown-linux-gnu } - { os: macos-15, target: aarch64-apple-darwin } - - { os: windows-2022, target: x86_64-pc-windows-msvc } runs-on: ${{ matrix.os }} # Keep the existing bound; scheduling changes do not extend it. timeout-minutes: 240 @@ -1161,3 +1163,72 @@ jobs: path: ${{ runner.temp }}/intel-evidence if-no-files-found: error retention-days: 14 + + # Windows x86-64 as lanes of one run (§8.3): its one `cargo test` took 106 + # to 126 minutes, the longest job of the gate, almost all of it the + # conformance harness. Each lane is its own clean checkout and build; the + # conformance lanes run the cases of the Intel lanes' partition + # (`.github/intel-host-lanes.json`), and `producer` runs every other test + # and doctest of the workspace. Each lane records what the host listed and + # what ran, and the join requires every lane of this run and commit, lanes + # that are disjoint, and an execution equal to the host's whole listing, + # before the host's context passes. + windows-part: + name: Windows tests (${{ matrix.lane }}) + needs: [plan, honesty] + if: ${{ needs.plan.outputs.full == 'true' }} + strategy: + fail-fast: false + matrix: + lane: [producer, lower, print, validate, moves] + runs-on: windows-2022 + timeout-minutes: 240 + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + - name: Install the pinned Rust toolchain + run: rustup toolchain install + - name: The runner is the host this leg claims + shell: bash + run: | + set -euo pipefail + host="$(rustc -vV | sed -n 's/^host: //p')" + if [ "$host" != x86_64-pc-windows-msvc ]; then + echo "::error::windows-2022 is $host, not x86_64-pc-windows-msvc (SPEC.md §8.3)" + exit 1 + fi + echo "$host" + - name: Execute this lane and record its inventory + shell: bash + run: python .github/scripts/host_lanes.py execute --target x86_64-pc-windows-msvc --lane ${{ matrix.lane }} --output "$RUNNER_TEMP/host-lane" + - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + if: ${{ always() }} + with: + name: host-x86_64-pc-windows-msvc-${{ matrix.lane }} + path: ${{ runner.temp }}/host-lane + if-no-files-found: error + retention-days: 14 + + # The Windows host status: every lane's receipt, joined. It runs even after + # a failure, so a missing lane reads as a failure and never as success. + windows-join: + name: build and non-Lean tests (x86_64-pc-windows-msvc) + needs: [plan, windows-part] + if: ${{ always() && needs.plan.outputs.full == 'true' }} + runs-on: ubuntu-24.04 + timeout-minutes: 15 + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + - uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2 + with: + pattern: host-x86_64-pc-windows-msvc-* + path: ${{ runner.temp }}/host-lanes + - name: Verify every lane and the complete Windows inventory + run: python3 .github/scripts/host_lanes.py join --target x86_64-pc-windows-msvc --artifacts "$RUNNER_TEMP/host-lanes" + - name: All Windows lanes succeeded + if: ${{ always() }} + shell: bash + env: + PART_RESULT: ${{ needs.windows-part.result }} + run: | + set -euo pipefail + test "$PART_RESULT" = success diff --git a/CHANGELOG.md b/CHANGELOG.md index 17a425bd30..e81d80f8d5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,6 +17,11 @@ workspace carried at those versions without a tag. ## Unreleased +- CI runs the Windows x86-64 host's tests as five lanes of one run (SPEC.md §8.3): the four + conformance lanes of `.github/intel-host-lanes.json` and a `producer` lane with every other test + and doctest. A join on `ubuntu-24.04` keeps the context `build and non-Lean tests + (x86_64-pc-windows-msvc)` and passes only when the lanes' executed tests equal the host's + listing, each once. The single Windows job took 106-126 minutes. - `rustix` 1.1.6 (RUSTSEC-2026-0486: the extended-attribute functions marked unwritten bytes as initialized for a zero-length buffer), so `cargo deny` passes; `errno` and `tempfile` resolve `windows-sys` 0.59, the version `fs4` 0.13 and `rustix` 1.1.6 both accept. diff --git a/SPEC.md b/SPEC.md index 6e1c370fbe..ce1bacd247 100644 --- a/SPEC.md +++ b/SPEC.md @@ -557,7 +557,7 @@ The Rust crate MUST build and its non-Lean tests MUST pass on: - macOS AArch64; - Windows x86-64. -`ci.yml` checks these hosts in every run that is the whole gate (§9.4). The normative full verification and reproducibility gate runs on Linux x86-64. The Linux AArch64, macOS AArch64 and Windows x86-64 legs each run one `cargo test --locked --workspace --all-features --no-fail-fast`, which builds the library and binary in the same locked, all-features test profile and reports every failing test binary rather than stopping at the first. These three legs are unchanged by the Intel macOS partition below. Each execution job MUST check the actual Rust host triple against the host it claims. Other hosts produce platform-bound attestations and MUST obey the same source, manifest, and policy formats. +`ci.yml` checks these hosts in every run that is the whole gate (§9.4). The normative full verification and reproducibility gate runs on Linux x86-64. The Linux AArch64 and macOS AArch64 legs each run one `cargo test --locked --workspace --all-features --no-fail-fast`, which builds the library and binary in the same locked, all-features test profile and reports every failing test binary rather than stopping at the first. These two legs are unchanged by the partitions below. Each execution job MUST check the actual Rust host triple against the host it claims. Other hosts produce platform-bound attestations and MUST obey the same source, manifest, and policy formats. On macOS x86-64, one construction job and one conformance execution job per committed lane partition that same complete workspace test workload. Construction MUST compile all workspace test targets once from a clean checkout with the pinned Rust toolchain, locked dependencies, all features and the default test profile, and discover the executable test targets from Cargo's machine-readable output. It MUST execute every non-conformance test target, including the `repo-conformance` library, complete `bdd` meta target and other integration targets, and all workspace doctests. It MUST record each execution's outcome and continue independent executions after a test failure. A local test or doctest failure MUST NOT prevent the conformance jobs from running after successful construction; it remains a failure of the host aggregate. @@ -565,6 +565,8 @@ All conformance execution jobs MUST run the same constructed `repo-conformance` The aggregate MUST require the construction result and exactly one successful receipt for each committed lane, reject missing, duplicate, foreign, changed, failed or incomplete evidence, and run even when a prerequisite failed or was cancelled so absence cannot become success. Its check context MUST remain exactly `build and non-Lean tests (x86_64-apple-darwin)`. The other auxiliary contexts remain exactly `build and non-Lean tests (aarch64-unknown-linux-gnu)`, `build and non-Lean tests (aarch64-apple-darwin)` and `build and non-Lean tests (x86_64-pc-windows-msvc)`. Previous-run and release evidence MUST require each of these four exact contexts once, not infer complete coverage from the number of matrix rows or accept a partition context in place of a host. The partition changes scheduling and custody only: it reduces no test, changes no assertion or corpus, and raises no host timeout. +On Windows x86-64 that same complete workspace test workload runs as lanes of one run (`.github/scripts/host_lanes.py`): the conformance lanes of `.github/intel-host-lanes.json`, each running the conformance harness with that lane's filters, and a `producer` lane running every other test target of the workspace, the `repo-conformance` library, `bdd` meta target and other integration targets among them, and every doctest. Each lane is a job of its own clean checkout that builds with the pinned toolchain, locked dependencies, all features and the default test profile, checks its host triple, and records the commit, tree, run and attempt, the harness's listing, the producer's listing of the whole workspace, and every test it executed. The aggregate, whose check context remains exactly `build and non-Lean tests (x86_64-pc-windows-msvc)`, runs even when a lane failed or was cancelled, and passes only with exactly one passing receipt for each lane of the run and commit, lanes that listed the same harness, and executed tests whose union is the whole listing with each test once. It reduces no test, changes no assertion, and raises no host timeout. + Non-UTF-8 project paths are outside language 1.0 and produce a registered environment diagnostic. ### 8.4 Cargo dependency rules @@ -699,7 +701,7 @@ UOR Atlas is verified as the parts of one run. `.github/verify-shards.json` part The `bdd` recipe runs as the parts of one run as well. `.github/bdd-parts.json` names parts by conformance ID, complete integration-test targets in `targets`, and a remainder, `rest`. Cases that share a fixture built once per test process belong to one part. The `honesty` part owns the complete `bdd` meta-gate target, including any tests added to that target; no copied test-name list selects it. `cargo xtask bdd` runs `cargo test -p repo-conformance --all-features` with the Cargo target selectors and harness filters of `LEXLEAN_BDD_PART`. A target part selects its targets through `--test`; an ID part uses `--exact` and the test of each ID. The remainder discovers all integration-test targets from Cargo metadata, selects every target no target part owns, and keeps the library and binary tests and doctests; Cargo requires doctests in a separate invocation when target selectors are present. Its `--exact` and `--skip` filters omit every conformance test an ID part owns. A new test in a target belongs to that target's part; a new integration target and a new conformance ID belong to the remainder until assigned. No case decides whether it runs. `inventory` lists the tests using the same selectors and filters, proves disjointness and equality with the whole `bdd` suite, and requires a target part to own every test of its target (§9.2). Exactly one row runs every part, the remainder included. The initial honesty row names its part; each later `bdd-` row and the `rest` row name theirs. Unset or empty, as in local `just vv`, the recipe runs the whole suite unchanged. Each row builds from its own clean checkout; no build or evidence crosses runs. -Every normative gate job runs on the standard GitHub-hosted runner, `ubuntu-24.04`; no larger runner is part of the gate. The supported-host execution jobs run on their named hosts (§8.3); the Intel aggregate runs on `ubuntu-24.04` and executes no host test. The verification resource profile (§22.11) of a job is named by its matrix row, or on an Atlas job by the job itself, and by nothing else, no repository or workflow variable and no input: the `examples` leg and every Atlas job verify at width 2, with the scheduling hints committed in `.github/verify-hints.json` (derived from a run's telemetry by `cargo xtask ci-hints`) and a memory budget of 12 GiB (12582912 KiB) for the summed expected peaks of the proof processes running at once; the other legs name no profile and run at the default. A profile is a schedule and never a verdict: every elaboration, replay, and audit member still runs on the pinned toolchain, the directory each project publishes is byte for byte the one of width 1 without hints or a budget (§22.11), and the leg and the join still require every example's normalized verification records to equal `expected/verify` (§29.5), so a profile that changed a byte would fail the gate rather than pass a different one. A stale hint reorders processes and never skips one. Local `just vv` verifies UOR Atlas whole at width 1 with no profile. The budget is below the runner's 16 GB, with the 4 GiB swap file of the job as overflow, so two processes run together only when their expected peaks fit, and a process whose expected peak alone passes the budget runs alone. The gate has no path filter, no cache of a build directory, object, verification tree, attestation, or proof result, and no condition that skips a recipe of `just vv` but the plan's, which decides only what a run is, as above; the artifacts the jobs of one run exchange are read by that run alone, and every job starts from a clean checkout with the exact pinned toolchains. Each proof or fan-out job writes its performance telemetry (§22.12) to `ci-evidence/` and uploads that directory as the artifact named after it, `acceptance-gate-evidence-` or `acceptance-gate-evidence-atlas-`: the gate log (`just --timestamp` stamps each recipe's first command on a leg, which is how a recipe is timed without changing it; an Atlas job's log is the recipe's own output), the host's memory and swap sampled every five seconds, the verifier's telemetry, and a summary of the wall time of each recipe and verification stage, the slowest modules and audit members, and the peak resident set and swap of the proof processes. The summary step also prints that summary to the job log and appends it to the step summary, and runs when the job failed, because an uploaded artifact cannot be read from the log; each table lists only its slowest rows and the part appended to the step summary is cut at 512 KiB, half of what GitHub accepts. The initial honesty job retains its recipe timing and summary in the same evidence format, without Lean processes or proof-resource samples. None of it is an input of any recipe, and a timing is never a claim about a semantic property. +Every normative gate job runs on the standard GitHub-hosted runner, `ubuntu-24.04`; no larger runner is part of the gate. The supported-host execution jobs run on their named hosts (§8.3); the Intel and Windows aggregates run on `ubuntu-24.04` and execute no host test. The verification resource profile (§22.11) of a job is named by its matrix row, or on an Atlas job by the job itself, and by nothing else, no repository or workflow variable and no input: the `examples` leg and every Atlas job verify at width 2, with the scheduling hints committed in `.github/verify-hints.json` (derived from a run's telemetry by `cargo xtask ci-hints`) and a memory budget of 12 GiB (12582912 KiB) for the summed expected peaks of the proof processes running at once; the other legs name no profile and run at the default. A profile is a schedule and never a verdict: every elaboration, replay, and audit member still runs on the pinned toolchain, the directory each project publishes is byte for byte the one of width 1 without hints or a budget (§22.11), and the leg and the join still require every example's normalized verification records to equal `expected/verify` (§29.5), so a profile that changed a byte would fail the gate rather than pass a different one. A stale hint reorders processes and never skips one. Local `just vv` verifies UOR Atlas whole at width 1 with no profile. The budget is below the runner's 16 GB, with the 4 GiB swap file of the job as overflow, so two processes run together only when their expected peaks fit, and a process whose expected peak alone passes the budget runs alone. The gate has no path filter, no cache of a build directory, object, verification tree, attestation, or proof result, and no condition that skips a recipe of `just vv` but the plan's, which decides only what a run is, as above; the artifacts the jobs of one run exchange are read by that run alone, and every job starts from a clean checkout with the exact pinned toolchains. Each proof or fan-out job writes its performance telemetry (§22.12) to `ci-evidence/` and uploads that directory as the artifact named after it, `acceptance-gate-evidence-` or `acceptance-gate-evidence-atlas-`: the gate log (`just --timestamp` stamps each recipe's first command on a leg, which is how a recipe is timed without changing it; an Atlas job's log is the recipe's own output), the host's memory and swap sampled every five seconds, the verifier's telemetry, and a summary of the wall time of each recipe and verification stage, the slowest modules and audit members, and the peak resident set and swap of the proof processes. The summary step also prints that summary to the job log and appends it to the step summary, and runs when the job failed, because an uploaded artifact cannot be read from the log; each table lists only its slowest rows and the part appended to the step summary is cut at 512 KiB, half of what GitHub accepts. The initial honesty job retains its recipe timing and summary in the same evidence format, without Lean processes or proof-resource samples. None of it is an input of any recipe, and a timing is never a claim about a semantic property. The Intel host factory is separate from the normative BDD and Atlas partitions above: it transfers only the same-run host test construction and dependency data of §8.3. Construction requires successful honesty; consumers require construction; the aggregate requires all of them and cannot skip an incomplete result. The factory's behavioral tests run in the initial honesty job, before the expensive roots, and exercise inventory completeness, custody and fail-closed result joins without needing an Intel runner. These tests do not substitute for execution of the complete workload on Intel macOS. diff --git a/crates/conformance/src/cases/repository.rs b/crates/conformance/src/cases/repository.rs index 09a8125bb8..ba16bd4222 100644 --- a/crates/conformance/src/cases/repository.rs +++ b/crates/conformance/src/cases/repository.rs @@ -1552,7 +1552,7 @@ pub(crate) fn run(id: &str) { for (key, body) in &jobs { if matches!( key.as_str(), - "host-matrix" | "intel-construction" | "intel-part" + "host-matrix" | "intel-construction" | "intel-part" | "windows-part" ) { continue; } @@ -1562,7 +1562,7 @@ pub(crate) fn run(id: &str) { ); // The plan decides what the run is and runs no recipe: it has // ten minutes, not the six hours of the proof jobs. - if key == "intel-join" { + if key == "intel-join" || key == "windows-join" { let limit = body .lines() .find_map(|line| line.trim().strip_prefix("timeout-minutes: ")) @@ -2074,7 +2074,7 @@ pub(crate) fn run(id: &str) { let mut honesty_conditions = 0; for (index, line) in jobs .iter() - .filter(|(key, _)| !key.starts_with("intel-")) + .filter(|(key, _)| !key.starts_with("intel-") && !key.starts_with("windows-")) .flat_map(|(_, body)| body.lines()) .enumerate() { @@ -2104,6 +2104,31 @@ pub(crate) fn run(id: &str) { assert_eq!(rows_conditions, 1, "the legs run when the plan names a leg"); assert_eq!(honesty_conditions, 1, "honesty runs when the plan names it"); intel_host_workflow(&ci).expect("§8.3: the host inventory and Intel custody graph"); + windows_host_workflow(&ci).expect("§8.3: the Windows lanes and their join"); + for (from, to) in [ + ("lane: [producer, lower, print, validate, moves]", "lane: [producer, lower, print, validate]"), + (" needs: [plan, windows-part]", " needs: [plan]"), + ( + " if: ${{ always() && needs.plan.outputs.full == 'true' }}\n runs-on: ubuntu-24.04\n timeout-minutes: 15\n steps:\n - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1\n - uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2\n with:\n pattern: host-x86_64", + " if: ${{ needs.plan.outputs.full == 'true' }}\n runs-on: ubuntu-24.04\n timeout-minutes: 15\n steps:\n - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1\n - uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2\n with:\n pattern: host-x86_64", + ), + ("host_lanes.py join --target", "host_lanes.py execute --target"), + ( + "windows-part.result }}\n run: |\n set -euo pipefail\n test \"$PART_RESULT\" = success", + "windows-part.result }}\n run: |\n set -euo pipefail\n test \"$PART_RESULT\" != cancelled", + ), + (" runs-on: windows-2022\n", " runs-on: windows-2025\n"), + ( + "python3 -m unittest discover -s .github/scripts -p 'test_host_lanes.py'", + "echo lane checks", + ), + ] { + assert!(ci.contains(from), "the plant must change the workflow: {from}"); + assert!( + windows_host_workflow(&ci.replacen(from, to, 1)).is_err(), + "the Windows lanes must refuse `{from}` replaced by `{to}`" + ); + } for (from, to) in [ ( "name: build and non-Lean tests (x86_64-apple-darwin)", @@ -2151,7 +2176,13 @@ pub(crate) fn run(id: &str) { .is_err(), "a static matrix name acquires a suffix instead of the exact honesty context" ); - for root in ["vv", "atlas-prefix", "host-matrix", "intel-construction"] { + for root in [ + "vv", + "atlas-prefix", + "host-matrix", + "intel-construction", + "windows-part", + ] { let original = format!(" {root}:\n"); let pos = ci.find(&original).expect("the root"); let end = ci[pos + original.len()..] @@ -3115,6 +3146,14 @@ fn intel_host_workflow(ci: &str) -> Result<(), String> { .find_map(|line| line.strip_prefix(" name: ")) .ok_or("RP-14: the Intel aggregate has no context")?; contexts.push(aggregate_name.to_owned()); + let windows = workflow_job(ci, "windows-join")?; + contexts.push( + windows + .lines() + .find_map(|line| line.strip_prefix(" name: ")) + .ok_or("RP-14: the Windows aggregate has no context")? + .to_owned(), + ); contexts.sort(); let mut expected = supported_host_contexts(); expected.sort(); @@ -3256,6 +3295,137 @@ fn intel_host_workflow(ci: &str) -> Result<(), String> { Ok(()) } +/// §8.3: Windows runs as the lanes of one run, the conformance lanes of the +/// Intel partition and the producer, after honesty and only in a run that is +/// the whole gate; its aggregate keeps the host's context, runs after any +/// lane's failure, joins every lane's receipt, and fails on a missing one. +fn windows_host_workflow(ci: &str) -> Result<(), String> { + let part = workflow_job(ci, "windows-part")?; + let join = workflow_job(ci, "windows-join")?; + let honesty = workflow_job(ci, "honesty")?; + let require = |body: &str, text: &str, rule: &str| -> Result<(), String> { + if body.contains(text) { + Ok(()) + } else { + Err(format!("RP-14: {rule}: missing `{text}`")) + } + }; + let plan: serde_json::Value = serde_json::from_str(&root_file(".github/intel-host-lanes.json")) + .map_err(|error| format!("RP-14: the lanes file: {error}"))?; + let mut lanes = vec!["producer".to_owned()]; + lanes.extend( + plan["lanes"] + .as_object() + .ok_or("RP-14: the lanes file names its lanes")? + .keys() + .cloned(), + ); + lanes.sort(); + let mut matrix: Vec = part + .lines() + .find_map(|line| line.strip_prefix(" lane: [")) + .and_then(|rest| rest.strip_suffix(']')) + .ok_or("RP-14: the Windows matrix names its lanes")? + .split(',') + .map(|lane| lane.trim().to_owned()) + .collect(); + matrix.sort(); + if matrix != lanes { + return Err(format!( + "RP-14: the Windows matrix runs {matrix:?}, the producer and the lanes of the partition are {lanes:?}" + )); + } + for (body, text, rule) in [ + (&part, " needs: [plan, honesty]\n", "the lanes follow honesty"), + ( + &part, + " if: ${{ needs.plan.outputs.full == 'true' }}\n", + "the lanes run in a run that is the whole gate", + ), + (&part, " fail-fast: false\n", "a failing lane stops no other"), + (&part, " runs-on: windows-2022\n", "the lanes run on the host"), + (&part, " run: rustup toolchain install\n", "the Rust pin"), + ( + &part, + "if [ \"$host\" != x86_64-pc-windows-msvc ]; then", + "a lane checks its host triple", + ), + ( + &part, + "python .github/scripts/host_lanes.py execute --target x86_64-pc-windows-msvc --lane ${{ matrix.lane }} --output \"$RUNNER_TEMP/host-lane\"", + "a lane executes and records its part", + ), + ( + &part, + " name: host-x86_64-pc-windows-msvc-${{ matrix.lane }}\n", + "a lane uploads its receipt", + ), + ( + &join, + " name: build and non-Lean tests (x86_64-pc-windows-msvc)\n", + "the aggregate keeps the host's context", + ), + (&join, " needs: [plan, windows-part]\n", "the aggregate follows the lanes"), + ( + &join, + " if: ${{ always() && needs.plan.outputs.full == 'true' }}\n", + "the aggregate runs after a failed or cancelled lane", + ), + ( + &join, + " pattern: host-x86_64-pc-windows-msvc-*\n", + "the aggregate reads every lane's receipt", + ), + ( + &join, + "python3 .github/scripts/host_lanes.py join --target x86_64-pc-windows-msvc --artifacts \"$RUNNER_TEMP/host-lanes\"", + "the aggregate joins the receipts", + ), + ( + &join, + "PART_RESULT: ${{ needs.windows-part.result }}", + "the aggregate reads the lanes' result", + ), + ( + &honesty, + "python3 -m unittest discover -s .github/scripts -p 'test_host_lanes.py'", + "the join's behavioral tests run before expensive roots", + ), + ] { + require(body, text, rule)?; + } + let result_step = join + .split("\n - ") + .find(|step| step.contains("test \"$PART_RESULT\" = success")) + .ok_or("RP-14: the Windows aggregate does not check its lanes' result")?; + require( + result_step, + "if: ${{ always() }}", + "the aggregate cannot hide a failed or cancelled lane", + )?; + let timeout = part + .lines() + .find_map(|line| line.trim().strip_prefix("timeout-minutes: ")) + .and_then(|value| value.parse::().ok()) + .ok_or("RP-14: a Windows lane has no timeout")?; + if timeout == 0 || timeout > 240 { + return Err("RP-14: a Windows lane cannot raise the 240-minute bound".to_owned()); + } + for body in [&part, &join] { + for forbidden in [ + "run-id:", + "github-token:", + "continue-on-error", + "actions/cache", + ] { + if body.contains(forbidden) { + return Err(format!("RP-14: the Windows lanes admit `{forbidden}`")); + } + } + } + Ok(()) +} + /// Claim drift must finish successfully before a costly root can start. fn honesty_dependencies(ci: &str) -> Result<(), String> { let initial = workflow_job(ci, "honesty")?; @@ -3267,7 +3437,13 @@ fn honesty_dependencies(ci: &str) -> Result<(), String> { "RP-14: honesty must expose its matrix-resolved context and follow the plan".to_owned(), ); } - for root in ["vv", "atlas-prefix", "host-matrix", "intel-construction"] { + for root in [ + "vv", + "atlas-prefix", + "host-matrix", + "intel-construction", + "windows-part", + ] { let body = workflow_job(ci, root)?; if !body.contains("needs: [plan, honesty]\n") || body From 2636707b30e9a946fcef4a331b2413af2ab5eef4 Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Thu, 12 Nov 2026 00:48:01 +0000 Subject: [PATCH 7/9] ci: drop the Python bytecode committed with the Windows lanes Co-Authored-By: Claude Opus 5.5 --- .../__pycache__/host_lanes.cpython-314.pyc | Bin 14993 -> 0 bytes .../intel_host_tests.cpython-314.pyc | Bin 83172 -> 0 bytes .../__pycache__/test_host_lanes.cpython-314.pyc | Bin 5662 -> 0 bytes .../test_intel_host_tests.cpython-314.pyc | Bin 63079 -> 0 bytes 4 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 .github/scripts/__pycache__/host_lanes.cpython-314.pyc delete mode 100644 .github/scripts/__pycache__/intel_host_tests.cpython-314.pyc delete mode 100644 .github/scripts/__pycache__/test_host_lanes.cpython-314.pyc delete mode 100644 .github/scripts/__pycache__/test_intel_host_tests.cpython-314.pyc diff --git a/.github/scripts/__pycache__/host_lanes.cpython-314.pyc b/.github/scripts/__pycache__/host_lanes.cpython-314.pyc deleted file mode 100644 index 50c062ca44f1cec761d741e5e13b8508c7db2603..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 14993 zcmbVzYj7Lam1Z~4c!MPPrbvoxO4I`q0ZO7?resPo9}-21rkWHeTNFu%03}Ey0e3g_ zKwh+GYfU+>6&1@dk|DjWUx=l-=3dh5?G$wo+E@IrqG{v#`L63{C_>&KxR7rWiji*?N{}}SrO3CO z-ztFce>Np7Y;cU9D2WEdej&4;IhycCT@!lE1u z@R!1pyiMZepd?GYU*aeI(?N+3Ptay!bh?T6PY3wR;m|ZMUkXm~+XwnP+xdU`*+Fkh z^FRIU8Sh@V*KR*XhvBbbupsR?HtrWMhUuuh$8#+#UXddH@!%ML4O3toelk3L5mRE| z3uH1%#IrDf6RL^BwvbNXbzD^9s)lP1)BG=6rLVy%0OW}JQbM?%0V(Gpo52e zLtCfhrZ6SL@naD&9Egqw#W6Y?c6l`@-r&Qi6E)~%fRhCw-J;ei5FRJT=H)v98ar77 zF9yfMVnD(g{4(7MSsp(b0t^GRC#?W{gV%%OQ4}7ct?2QJ!Iz>T5r^-$W0+tlBJ&es zcq+3bI(%j^l7EVx6de&8oeIfK8EDC5V!s&V10jiwDmU55nc$4H83FDLfTGjnJ){9V zgM~n#N#F*S8=Ah@qyYd2NMD-l7lL>XX17I7GK@30F5@UA9I2P@1K`k;9~Z-K$4W7v7E-@Ghd-8DSbF;@oAgwy` z3S(YU#BcZRJmThuz2qOiJ$&Wsp^MX4W#H>w$GUqvJKWokv^MeH9quFJ8NNno*MuD8 z$UXJpWri8f5_Ertdu0po(!lr_ouaRyUMv|Z8RqmBUe;$2*e37>Jw4C17&kL+L#%C( zP?}EAeoCa2FnE2xfbpdurECJrEUnN!Ue!dOZlh|M0C|MP8!8t;k!tN1p6@u*-YKAp z6T@LyHC_k=L?;#?VOPvno>vbyUkXnJn=eJDqU6`o(%c)o-V0*&5IWz}tW%LRE&|ge zw3g&iZQjTYk=$1_+e*fCBb#CV;HrGf`5k9`FzMR#a`#Mo+EIAtx>B)gzH$EAPd#{1 z9J>^5*HbiRRsow_aTM6!rQ`UR{`{jL&5?B0>0-{XQG=I>8oG8c%uB`nWJ7C`!0N}b zEmLz5t!kN`8iw()f?=2(FHO0YZiZ$03_VQ@V`J(tdIXF)YN)4gA;xWt9qpu~KQ;~G z!XW{-z!O5CX%L;C-#!(cltZ2ip=rN(!_AL*JcLTdcv40<%JWDlB2B+Ny)eKGj}bb>CIn6h!j+wc|Qe>;nCPN6!(-JCvc$o4blbd_N>CLh;dptsCDeWvV8Tn|Jc za`Ha5zbMy2fAevA%X+3q)LVjx**_9obz8+!JXEvLIdG$Os7>yH5g84wEcf<&^=73gNw8=FF z0<{nX8Yaw>ruAB_i!xc{s%L4*h^s`!uBbig^f@tw}o3U>0M4`I<_6>h*$U zU3g~^yTt%>w#E!Qd6ne{arK%eCZp1&m?0OG}72gh(jX{ zBScp5S@a`6NxNbma<pm>3i(mVo`XB3m zQGZ`fZ*N|*eQIQj+S!@ok2Gqke5>$IAqdIpxMja-U$IsttX1){l(jBxEx6^p>6{yU zV6A>)Vv6fOH8Upbt0!MRxx$qtxUv*ik#>~aI(+l+x7*@--ahcX1M~ZS(55)t3g^~{ zCrcn$Z1!IK9~$wXNK5MrAyA)O&x1P)Y@WE16+`sC&@pfW9?05yfcD(8$8`0m{zyz`UXgh8_x1wA19deTV(s21dGq~ z3?>h3CigkoS@YWowu9GD2O>b7QLwMA_Zph=Zh?rgrwzA>NpJ|xU52JS$m@4b0Cxu& zX+7c<3iMThcrO5|h1$w8lExKsPYFd|xq@$H?h+yp7RNe?KuAOj5A-wf1`(BIC~85X zOie&}SS|MIYRDx>?+_Dp4az(C4kzvekW>@ZyC{K)9u%y)*$G<)Yh#{vAlt;$JCJWxgLjw8 zMkKk+X{-8>bP{Q~3`f5M7qE&eON-z*}c|24k zmpu>-C8$d(yE|s{c&5XiKrkY?Z6X0MWj-SKJEO5W4*Mre5!xsu_^>}9f%^qz%Jv`t z5EiFN0hY`@RGSo>3=#ofQq9_qR1?{d^aVM>&8z?AcK%zPgsOc>D7AFXQU3+qGEzpzd(8WGq=Y zHgi1fDw*j{mu!f;S4tX{lEzu{Ls#isSA74QeMyKIrnIAY?#$~);#cPxtUBM1gf0RU@n|gW?ek>o%>2?&3yL zWl%ZrF^M8KYK(%yUWL+`=&!taFdbpVMsoMb;f+5fw(E2n*l)4t^CvyV~s0!z_EHEX7j zm`w~`^}uW-1y$}u=dlj(1u+tNJ1k)a)k0ZCbU?$&t3_2-6)F-Q?DW@1*19^+Sh$T19 z&^FrJ;xk}0Yn}*Ac3j8Yj*flj(TIn#6>}ksF?)g8{R@i`1jFEy<+rM}+d2rsO zkC=Nx0rcrR@)`0a8O+5-3Va1n>VPnj!W^uI9_c+aC=K1m>0X45C3{9_@5H`K4jB%u z8gqDyK64IE`BG-o7&Q=B^&HAbdKe>rP5rvCsSksv&S0U^IrZut3}&w;BS9V|%F&vH zOU)qEVdmv=b8@q944w4P3t>We2x+53c|(%8JvRLu6Mvw#|B_cR$s_p zuTV$nv3^hXvPDZ`nxIMGDeX7VHk*ctphOdaaXx(XSwPvF_gM5VI8KUj{cKT9VpNjH zV@A(apLPqy%*0aJ3MJMaD}}Y08kwhIt;gGRSVs9+%r&NcQQIq#tYKF65F;`%uf?_y zSvud^n(<8VfiO(gWDL>_3NWPWDZh9Y%Z8~AR$P(X(@eSQ2@fSwD7*-&nHtaoxJDrpinu0;)$lr2F&e%SgC&W21E_z4 zm=7Ttq6wr%c#uY~1aC;6o5}L{u~^v{lms{s_z8aqDl@bT2*jT|3B)uXNh=>SYfy<9 z@LoV0NSggV;I@dwvn8G+SwG2SWSNXibQ<_CjSNSF>WfMCOr-C+gMP97Vh2cen?c!L4enlW2QBDtR=GQd_OYPZue zO%$+XtasuqwD6OrFF{h6VIDflZ?(PF7C$iGsZ{S++QGwrj{ zhiKh#^HltFT#ipDjeFl8`up=gKfn0AQqz&*IvK6t<5 zpWC$ebWv^m%EE!gj-?&p{iYF?Sx>d=D~ZcRTX5 z^EfF#J~xO=sqr9B?K*m|EV-)-uW9E2QhR{Z9-y@c7Ovs-v4tzM-?TnfT(k933^s=dTh1;Isw!d5UUiDvBFCM>lOgVif<@PBroL_dI zPjMqSoH_IBC*xb^%jV6>)>ftJP>MTDtX;kFinw*&JTK2rEIjwFw0K~tb-AT0*?e5_ zp15D2*nJPUp)WDt{#vs@Wo;z6`4w;cmWz zyVf#Hm?=%`8C)StS=O`Y>o=!9TEv=XRkE&Y$H`i+hO;sok?Rhz`pv7^lW-TW-#@!Q zA4~fAEV!wRt7KS0_cZyet1Vj2bk{QRYT>RUes043czAg=TLQ`!w9PGdB;Q)BI~kdcY#pmG-{!xt#a6$i;TG%$Za@2#v)OaB_fq%*)8R?;vO;)$^IQ_a32}C z>?+=vE-Icm0T;;~Io|!ow^k~5CMtI-O^1_}&pvRq!RA|1@z##-?1&G(J@UPg?v3DR{S~<5>sd`p% zwSj@#j%v#i{`JRlhV?Cf14tl{jbeR_lwGl=ak*UDeL)kzm`1#rgT}rXhIlgoeeUUm8MjIiRJ<(t<_I-M z$a!U1lAsC>yIu`Y)R0%6CF9lV6Sr((J8#O5zK^<IUGdEvLe-7fF||@Lw^K-~+OYp3T}bVvkrcLhdx}!x&Rb z14a6pDNYsTQQEq#nh33DlHL>8lW$1LD)zoVcj~Tuc;wDm$8&EM&m)eUnSeyY{iWxt zuPoxs+cng^+^GzGkiV0m|C0YD{?EK#1v;MW$iJu|GEmGb%+(5|d9cg6Y=pA>y@FoL z^IByi9M`tWr$!$O9C!{mVDg!AR7ClfhPj}M+th&h^aVupw-fe~ZK zVpU^2B5Qa=J?c_Q#x5Hx)@l$?rq_s3^caj4j$x_*Rp7}aRA*b?Bi4%chuN%83`e=v zCpKUptUBWdgWO2j6Pxja8R*b`BG3aCaev6%?W@Ap`$+LXxUb4Gr zA`#mC6ZL@ApG$PVc<ZH?S)ilwK089KnvLE4>^9dIBCiva)-S_POIJGpj7`W5; zi>cd_voY!%)g$WkV9V)n&Jq)A(!*zTD-i)B5qp8Q1dcG3wDMCSNg_6r z*1kWMVF`UPE5boxN$~U3)DUaZ5YJD6$ipfi!NO1HUdNauehov!>=}SV*pBVUoEwZI z{z=WByJ`WM2-`4XW!;?UM|W|YWY3a}5Qe*0q{8$ocvnpbq?jU(MOjoWAt?}on?^Mv z8bgz{sU5`#vyE!L>Yt3lYD4WXHewGNC8!{tA;TI-mbH#xwCI%ECB8{YH<1h%HbX^m zm4l*y$Pe;OWN!qIgo2X+%n0u$8`1)r0u-NABM4WuWT2^C%z#Rul4=r0Qvzjg0QN;s>$;7Q(V}_61RADX+&x6ePBHWk7xA`csxsM?jBr*rRDr`Ny|(RF~sz&IL|50b8ol* zpgmQ8?tT?94yC$ZOxC05?e_1lElk#)OFN0?VLHk_^6Xly{M+Fb&(VbEXv*_k%Gsar zJU2i7pWE-f^!m_BLEVQ1b@7)T6g2#)oD9?^6+s0Cy|Dm&V?!?`*%Vk^VuPv7~uaxam%J#us<=j8h z`OsdRDDIuN{;cRnMJaxFvbZ;C@11F<<13~6Qr!M@dG(v;<~RRz=j<6`*08*e&2CYg zTjou7yVHfOAMC%k?UzUHw=5reUTN)D`p>3b7*)oC$rmP+i}uVMDz zT;;P|+EH}pV9HVR-<@U9*X|hSPQ2MS-@07pO}d)jZ(00WvZX!YYEPFSk|%Cf>P{-I z9-O7^6bpMzamA;0#$=!Ey;~X|_(4_NKELDLfyMH_d2yjvIe0;_kEgi6Lr3APbSri< z_U*4H9kmKq``OctOu=cE`sn{<)3#oZnb2!Cfjw%D>M95fP|mUy>qqzGLfQo8Kt^bc z5Ya2E7G(#Z5k9$qIYex->nTS@X=IhB zC}OH1fq*2yb4?OBDmYTrG$;HG4fa>BX^2mZP`hqv))SYj-Ae=mB%-8lW^$t4pBEriPBfGsBHq3B#C~094*uV)@f0ZYXPmW}J3a#2sdQ2?1(4k0CTii;r=$ z;?FT>jQDgQi;@a0s2c8gQURC$jYyDMf?{ydWbH~ZTWc!~U~FwAe|!K}La@(Wp;{5V zKwT1Q;W6=IbPCc@KZzf}-8wo72hHfHTIdf1MoEYxEtga~`PM#ECwa#Zw4-Jb%Xm0Q zP=sn7B|eKF27w1b3Qr=K=qlDow@UX#&2u?_gl5IML$+b*p2qzh3TT(~eo{mNGqDA? zg?NqV8gXqSs0n}KqH-5t(NkeY)0U#eW8ey=A)ADeWLy)PTY{VN!wUBs6u*a`bP`+# z*0O?f#Or)m(D;63s^A&e?d`4=dws%QKmWo~nPRU`+S?HNZ!fszz3Gi_NZL2!i?e9q zk8>|BG$Lpx#Wm-O&Mt7Y$dfBVtM>Gu)FvFY^R|@3O)jmDmFgXd>KzN+@AbXYx759IxHoaQH|0F_1ctYQPi;&=@m$$T z<+eoSwuKEV?!yW9;brHuPpqi?)29~3S^6nsFcm+v7R=e=TjG^UVZ*z|_w4W3m#rz8(K_MoKxxEg>b*8owkh13y*6TeFu!08Bbkj1x2 z$uCLv0WAg!5?`c?{xQ}l5vgJJ#hhNHCYckjS$jE)E`3nJQ(}R;uB+_3#w_z-uzt zCMsx6?p5hCWC)#M*(aQX<(^hEtn2qo{YQ-BBgXc7rV9B-Oz}sI{Sjk))%vpa)uNY+ z=GfaUx8?YWH@>-2=}A<2l9kOXmHQKw`;(;yQp~}Rm`#st_8D{9Q9ff;t=%)Gw7qk- zQ?Yl>?M0?+*ol1MEV9LKAe*tIZH`;juT?8$ok?34>DM-6ePl1b)qJxVmHNvkW+S`% z6Q_Y4Wk0do*y2yCZ0wFtstVciPd0Jv6#Gdb&z@yJ>0)i{bL=Nowd}@E+RE61$6khW e&c;&44IsH!PrP#C=HR#C{wYIfKUYmb^M3)wL_N>| diff --git a/.github/scripts/__pycache__/intel_host_tests.cpython-314.pyc b/.github/scripts/__pycache__/intel_host_tests.cpython-314.pyc deleted file mode 100644 index 871f0727b650303ba012e19cf5849ca06b040b40..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 83172 zcmd44d3ambl_!Xm1PPD;NpKNKQINPu6gTbrMsblSu6m?E%ceww1h`mSpa)P3oP|ks zby2aqM8!^tZo6Wt?3Af0r^9rT3f*xgbShO*QmM*=0SXLS{Z*zbJ=4|m&9rT~DrNV4 z-Sa#5t$<+J)$_;9lX&r#d+)pNF6W-}yXTx+lbw~R!_lAd56}Fk@9A`ZM;G#8mQEfX zFz9r%I!+hVUDR>4f|k=6!3-&0 zW-yaIw+5~3*A}#~->hI3`^^q!vtN7A&VC(12m8$l=CI$~U@m70=3UeWot!zC&!q(m zxZT0RdL6f?TOTaK?_T_FxM1zsBY%eayIIGj@6n6b!IFF(t}TT+F5^P!9;0-3BbQmI z3zl(Kgqyg1oUKqdp%1#aEL?BqvJr0K>A%22uobxcRFf!l~DJGe50JGo5=cX2L+ySdE> z_izWeEiC`NI4fso`?v}`+0RuXJit{UJcyESWzP!0?#QJ2NppHCpSMnhv@=u3?nK=bGm6!7k54(8o`Cg5y{4{lmjPe~=Y^)D!g8 zyLzq%$MA;T^#^O}GrR8U--)*7^r_HFg+F8DBmBaO0J_yuAA^s4Y9|? zPkHJ>JL(QzsM&V>P@Qs7y?x-xVQqU$!$jP2+L;;GlPU7$^CIgLqGHe0b0k z4D#bc=yHLH)w%WZKpI2smh0~7yQ=l`P;+4=LMk?b*1Hy;P^m(3Rn1&>i$4r+3Cb zF+Pl{b)D($?s8r7T|eZ)S5e{6Tg-kB+A*HS`vNl)!MG8R<7V`q8DGGJ7*#HpOZ>b{ z>aK$%Q%7ZKAEBQkC@u=m*dO^ut z;5qC2W?fOItJk`6h(9D6%etS+%)2dM9|qlZn}@|F0znR3obyhm4Z&Th3N$fp#< znKSH{zPnsEkS(Xw-mNxczChtKvc#@Jj205E_BOy&h*eTzTu$QBp4sl zm#Qs1wHa&Lc=~t%Lv+Fy&%{aK`Xol`rMQV2F>aoi_ILyF4BqGQVoY5NvIZq;=O=1s z1O-dz*11}_IcBDhi01}n5=WnH#=^0Jl7So?GbEy7Wcey{Lb-6 z`JU*eJ;H%=g8NC~+*887fvD-i1FQY!p|2d8_uihmH5DnS`f2$}MbzpROzvMC5`Q1< z9MlA?b6jEXP1QMil&*m&(lJ2w!HympVMzy?PJhwB8bnIV8L3;#hurNjtC}#D%zsbK z)`xmZ8=vy}rh@T|z%(Bm#E=QZ^_gAOCRY9N%&Yu(&?i=`3n}7e@64n>P;KDLam5n> zPpDogKC9n4JUmPhXe7_-9+)h1&fhr`Gi?Z)HoQ{t>h^!VeevA#&Q(*ixaFQ{t+?a9 zNg7F7VnY3#Rn`IA^%!S$1Gpg`J=zf`-BZ~JzkWa&Q|hQoHEuX%Odi$`>Sqiy#zCdW zPa6j^XJA-1;7?98djq8`NrV$JixO#u@3K%q(Io>mN7b z%5^SXjY{M3#ihD&!zSHEPyzba_bI6l8#n64^`MOgerQ-Nm{_NIxbcu0=ZJn**Q@K% z*1Hs!Q)Us&Ack=r`rx<@#2lQ3iH010)4-JZJd*)RJuA{z%aIAsIq!4DH#gnbwBU?oltnYj7ONiQZ-^Ej zT4}nUe`2m>-IjIp^o`T==YGE%Q(-}){9}=2qb%|6 z#{udsZ&f!QGQV@kdU8WX!UU=ih<}YbMUPk7MLT1t5%6Qbw<*>wO4%WfHDsq z)}J+=(Rpj6(ijUrVK(AS@~Cns5{!HcQpNT4AwzvVV?Xa2;)ePialK!pz7k)Pab(mt z<-6wRkHuY7qCws_!2|`(_>*I_BgX(yfWJpkgzXo8Hh53J+8}PqdPt+?%Q<=a zxW1vauR2|vg)#Y#LjogdBW}c?=ZU_?t(cNMLxJfDFvoGDXJR654uDAu(iBV#HXDrz zrOZkw8sCRpPT?=`Is%#|tk0jB55CeHv2Bjo+=9)$=oNpLf-8H%4adcc)mDLXhnwB& z*%ga@cTNkox(|(dbHi_}MGMY|wT#W;^QM@?6?V8HjxAB!mYD5=V7u@};I%+_`-OXb zzkKp%PYO>w^^3vCcHDd;@JEl{j%>YM)*_SyDFXLK6O)W8ofq9L^dRx?=sKVkPc zy*hmjP$}7=iU!&){q^*cG!0EVJ?^yJEC>hGtqm_3+IlMlI+ z4UBUMITP7QVhj(tM51pBjE8*uL1Yj&LE7_GTU9QSFT-tq69wHAP``_tNWP1wLmp!( zPtd*e-oduc?&cPDo8=;LJD^yJ+)f6)dvKf(1Y%2i==qlspcj8eX0qd6-@R60UvJdZ zw{FXQvFVkpMQ^02CgQAJ8d>&!fBf6y-?+zm z=Z`kLwc!UPv4b7qgB_9D&i9OZTeto_o!;E7f3%Mh&&c}d_M|?lnN%Ps))Gr69df

FFRi9O_uq>BP>R zCdDVRTcr_Z0SygbV)79`gh&1O3;at2)C;qp|NKJVV$~lGMC{um)*6sSv12Zn)~uzo z&FguELhjauidSo2s*U7sol9G{=DgUqQ1QZ(QR}8(*>Xq%ZjCuB!_LZxb8FPGRj6rM z^{%>w>W=%C&iB)GdD}j;=*+g~+vdHX*Nc5&TeVQvBb+@a^tgqZ{`;mU9_@)V;j^B& z3!%rHKra<`6Mc>1utU>V6oy)JPf5dCQ755$7K(+sdQcXYb{H#u=8tsFaTR%>toB9(Z6bu@u>1aW6I zWrm<;CPB?@NX;USGAbjnh-sZp#&V^1Ixst>Oe=p4XGyN*7JWNvj?oyUzxMB9Juzco zgIvD;@>+$>MH_waqTe3Ml?j#nxf(W9ZPT9=x~(XQ$&Fu=Z`$QBzXd{ZJpH}j(t(?g7s z16BzP;uVbP09)+!#;r0lJ{X*iTRee5KY{RgHgz5HEx;F_w>pg`VzTJJRJL0U2Ix2 zZl1XT_C8j)HC(uL$rLH9ixut*7w(G`9=LBi`0M-)vHZ$#ekHh|{F+$)o^bx2NdCT+ zytVuzbFB|-dAFNhXo^yUM+#eRH{EXfs&W-^wg_!w!uX^xHYJ>zj@kV0+jTirA388S z&9#PYWx|%mpH$r|`s+=RljnuTCxs_Rqlh^@vo`&O$k-R()9J?ajRyQ|K56(zozC23 z_{5pZ^pFP-Gpnly@Iy1Uc%+7-+yF^6acGbw9RN!u%JC@tlrUdCR>YQR3OKCqOE`Or z%JKL2$uz{DrgA{;G+=}peh-vZqD)l8i#kTd%*hnbZAdk*xYOhkVBS@}u*adCDkq?^ ziU99VM;X$zWk@d5Mcs_ioj#?23piIODb5wnQ>CMBvs{u?D5|=8o1(TYmK$3u7R_W{B%c<%A>`jC?Z<7I?S_Y)qAMMNxLf;wO^ zWIX7Sfptc_4!fp&SFlj&!Gai;rf7Y0eAESqjxnXu6xH^CKxxfZ;Gdb zPv*x#5{-DXGv-B&a^CJr*Z}!LPj)&`x$1+Z=Wt>=TdQiG$aqk<4?;L*Z=>5{2H#+8; zALNxTxFdPnac0Y#Z(b<)TF2tPHD~qG*|4)-*d-FZ9UW0y=ejNLX4j3bg*{Q5>p@=e z?c-lPzPKlnw{5O@yo-5Q(zjam!-0D{1zYW0Gx+D=i`N$`Uf=#8Cx3qAh0<8g zmT=CN#XYf{ZPA=O%bV@`tr<^{ zM9A6p@o(+);C{vl>DkAD3VigxJ-NTR(){Puxy?D&KR;~4`A>4J&0Fk0Db1ksN^A4J zjA4b5K>`xyacz1S1S;uqcyh4j2r=%QamG-un=!Ov0AAkB>9s?+%g_$SmRKUc2?R_b zDJtWp5&-p{hM`x;gFKK$@k||ratRu!1Yr8KWKtFN+*nQ4mP^h}{&gFN4DFl6lFk_X z#%YJ9tO}7yVl5qDErB9VSb80wfweSAtfiT;mMPQ9rI8tOtlFh%zSQ7*j+j~v(N?%F zOg>88rY6cVGp@-SEOC-RqU4c)#1cDQEwa;G29Q_-gnC0Na!x|M{2na|o4{h5I?EV~ zZSE`v3j3M!OHntOYTXPd@KP$!h=3-}D#uPi?9Fa-4>;E3L;e;_lxoc=BSM|#)Slbx zkju&XsZD+-CPEU`*`ef$36BYsUqY|7sKThG*IIgta%UvAxjQ}8H0REcbKj)vb+|LMW5=JVzRzvx!TLh-A%CGNxOy>NFmcS%L#SKQ zA;(wyrY0p?R!ZqgN`^}{1(%)tWeKI+@@QIjCTG`v7qyt?y;v%e-b=(X=|Eb?W7488 zeR5hZCk1Pjn_PPINcrP5?{-_{cA3r@*d{;d*)E@{znaxg>p-1+-<<=R1;sL~TRP>w z2{zG*9%yr0duUQmI@~t-jS$}pL<*^?S!)kKgXBYQPt;O=axHNM$zKYw`Co|nx(&V` zQO$w6ko1{!a3-#Bzcdc9R*JFH`o}bK`nRPTB?&-emOCqz0^cXR#l#iKnhbc)r?kVP z)a3I2nF?$b|G&zu1-3Jt{;6zd@-@DdmfDjJjMNnU zSS}OVc1di5&(&r-W1PJI*i-X=9P7b@g(@bR!i_H^Ykb^t~XPnlHAns-@Zo*hX==e>I zk6?vb$~gfMA?nQ#k!v{7AR-tsiEE#7jiwR-(PIIkB|zuO4Bl%b`YfR*z*%UHY{%GQ zbEOtV0d7Kt;V)9qjR33Mpj;x5!h7f}h(KQD)?z7Jux3Zt$DqUnr@&J%5_N$c2t+(3 z@6ubAWz#P{FI@0Mx`$%j&qTYQS#`hIw2<~f`{IH7&YE!dGht`V4=fVMvi}f)EI?Mo z8YPasK|xobpEm(LJ!qPBg(~DIUR3xvsW3uS5vT_A2uPY4hqmS?t(u-d=@di?lq)qN zCDS0OMkUHc+HVRT1#K~!jQCRsw5yT~c;df;yEo_wO~E3#)EC~-yR`FF+e@}rvlp@> zJ9@>h{&H!VK2#=SZBkF8@6mi)$izd&3dt}MEef!RN>xd{IkZjfmx!YxO-T`fRFzIm zPu0oto?M+`HnNaLVikWKL8wfQka|gC7;%(?I2`oTe~vx~PqP5Oivp^6jRFWylr6sb zlY5?|1o9Fkla)Y5-new<(sE6->KFrF#DK;}s7U?}afwA;RJp5XBjT=s{SaP;J~TLe zDQ>tnR9z;nt6V}3{4*5LxM8b){AD^bA&94m-A)`>A-XM!w4=VD)Hvb-%oK|}9-z)0 zw*VHzT1)_Eq>08>x!shONwh%X7}=qyJP~%b9?27V=8sTt6anPkO9T(n&?W7bnc(3m;JMN}0%*^k*d13Ct-SpWO!L~z$9nH_3d8Pc7;l;|ApLw}~7K&=RqNeU& zwRT4AUGI#poO{vuV&`JzQrb7_BF-HV$Ij)w?>Y{=Ga9ycG2rsH@daa)Xj3Hb(rx2y z<5!idh~rY!c4^&KPbvUAex08CZhF~+g5rh4k%FyrRst#8W6r9uvnt};7IkbBYOz2y zAoN@iwqJ}|2JxIw#c*NYa*42`cjejGaW0JiJ9;C9eImw~`dP%;7j^Ur?kiEtRT)L_ zF0{rn%A*La;Z=F;(w7mf3$Ua-AxTs-|+R@hM|G@OlEH~_QH%>ZL9 z*a&npui(YcFS_4&>dsSlk2L+S;+qbJ9MdvTl7?rMk>e)or`@- z+rDuz?A$Hv?-qLc?p+b~x?{Hf_e*qzW$%^hY=!Syx2)R=W44W9+r~w&VA~kA)%^S7 z>vN8!Fy-_Rh0w8+PH`QE)r!7J%yVu%mpbd1a5_D33Z$tjpz#<<~~@YnRi0WPQuJ z+8jI37Cq2*ulIqo7=7nmXVv1BsB<^amV;;Xi1}+|X1iruaKHN0OHbW*RKIW4m2CNK zwJx(FoKgPK2YI@zoge*2d)IG|u=oesK1Le+|M<5Jh=Lv>WR!m#puzupIog4X8D)YVKQVRDUM)4=oqX0lt>`;)K{lJ=vj+ zE%QPA=9H4HvQWE2#}!ZN4?u$9%qowYGL6D3acNxo4nvZ>h8c@wE*0o@8@P0>^dXlB zkgfE6q;bg^v~f~vU~ttK8S_91D_m5O413wjiY5%+^1!zjC z)UaDIKpRl*X=+`0D!-Z4dXD;bEL&w_LH;oq4r)CJnI%K>_Rm`5;4j1)*R;Z3so#H6 zJ;U_vf1;j~QpsP-<*8rl&ipi-tNqGj>N!)+Gi5z1PvuxivQ!CXG9)g9$+>D;R>8$tixz0|+aQkt(7%M`G&vW)HJLJg%BcI2H0pk)DJv<^v7=|R ze5U@Yn31OCv6#l_^Jncn>Ub^Ge4R>p)Y?+8%2f5E#oD$?MFg&1q~;0S3uQ|_vy2o%H{ZOt6Z-G>OFhVB%Zc)YaJ863-Z!nV6XL1c%39h(b6>TtD@QFdr|Z%1Hrt{2L?) z)F5C2zWww&l`Cgo%v{*{$}kj#V~zuY)JSY({QVkcoztOcoVLk_VO#k$^P=Q?6T2tM&=1`Fenj}6+=*!gqcH{412Lh#bq4a>- z#U1fTr6}-7-vo#CXx}vOe~K(veemDLS?a1-p(g}8v8p(HG2DMa;CkO~{!!OkUH5jz zj&uq~IwSoTBxGqzg+5d$e>8O(QCf#p0UsocKrvVj?bP-+AV*in0JdFsd7!m4It67X zOj8x($Zba(1 zxudbGrB?)e2YKW!p+~M^ohk_08HFC4jV*R9P&Z_ZOYjuRtvK|hC%8ieUlgOBhpPupQOF3 z9HL2*iKrF-V?3l!4Eznm6)0}y6ff*~z5EXkE$xZs?D%f=O7lF+kL2+Hh;Uw+)U%Sc| zPkqC-H2kg6yQ9nFtGSW-=GEbQHEXTz`L@{>%InPh%qvjrEsxn61zY2rnalg%ZjNkg z6q?*oQ~$cHdd?@=$EL=yx65VWit|?4ZHDW(~v*~8jSCp#=igLyiH4Q1nOu~am z6>UA!HrupbwDDEzOV+Pv-LNqYG?3?gukVRCw#6K~1;_3sx3K@zJ<}?HfUc;en-Cm; zLt#c^B6%JW9a1hM4v#SWY}E3(b&K_8=8eqxefKTJ&|Th8CF(9W&7&4yF}~8YXngtf z%UNMtrLeUzYC5@|mp|LFp1Xlioclm=(g?*-3vy9#TwHR;9Q6Am;}48sHm)Owaq%PL zzf&(G2QCUvUyoWs>lSCsQWCb5EVSOYl*52Hul&O_Ql4&_w?%9lU(b8Jcd0Z|xi7ML zf7rHPG*?;a6wY1lT$`rb*|)M6f)PhW%+Vn@I^HZ^ZbidZ zH;R|5BSP1usAYn_m!bZzmoJXKR=eh`k2>mw9sN$`Qaw+`3`mOsupvTv{6`t&f%N3zzO&4y-gqN>8j=PY9+HkE#w5 z=gPj-!Ui^U6B0}<9{1hQwlP58#<+vDUBFje-U9h78#9-zvl19+X!CHV(;K}^w&Y-PqRJ`#ZK)Kg@dcUZtTRTYwFG&@pUIir znY*DN-U=S!@(;Rd)-f_q(g`ruG{^s}kO$N()Mym&KHBv$TF{ z^c(%Knq_OLbZ$}3k@GlAJ;d3B%_}sih0^Ql*u)n~tE&rK8ux?qq6vj{K%OQoreRlY z)67Rd#ND`lJf4AdPS#t!JV7G-I~1_V>VKg#wouSZag6}~12&v#QGRg}ve67hde^Y6 z4e-B29P0Ujj}f5PSJy7}f3q}JeI#6cBwBqe>gWhpA6qQ{xp8&piyIbp{z2)_jJHa0 zYql-y=wOZ%)(cA)`oH#tSYb`Lu;zYY-3{xU=~vquq7Luf%EgM6-I$V&gm<5Mu~azQ zC!8BtJ9|O6I21cOESw#_*C^&0K0AD?^ls&xIqdKfDS39yTCy+`wN|W`RthElw+mJ? z)=r#_9^|6iro#uhWv4JW3N7Hs#VMix$v?>pU!1y|hx_ktn?~%p*5^8YP3iW%nYJ|Z zr&&0mTR?A%>ff_5XAU1d%+cj^>OXpzrpxi^Kl;0E(*e>FdbzY|SK2!p?M(+P@9eBX z_~T>wO~*15cukTK*ce}CV;ndO460xop3<^frfTSaAJSL`4n}E{4%G}rmSeq4&jgqy zQO~3U8gI~f(kliASmDRA?kD7|AgfBw=o8R1OP4c+l{!&F9Ao-V^BaM&WR&T!lHU-^ zkN6#S0D;h*Nkn{ATp*2gK@YUa>2Bp=2-laKES9eFf)l) zLeDp3sC9)5J6xeWC87GVP}$5BY&WJyr(kL4P0j?1lU`|l|!yd7Mu&i3;e={`?m7+tel${Zd_P68q2DFH>>(V z?gpW_E0WtS*t#EN*>4VfWk4uCuu>7rI{t3faZ+P$S?HVZ6v|IUZKoeN3l~hUX1%6!ErRk~V>m@yLg#>dyzxwLcX8ZLQ6;xf}UtAongND405;!pFZ zt7UduG;~@mAzF{i7*OY}l(ACrpNXqaT&BVyLPuWV3e){*;0mpw5)o+8$S*4SOJF&u zbM408!;=UUcnfqYwStuD>PCY9FsZN(q?h48{wK(&iyuKKVXI7oOb0L-j zV*M{j9stNDL98d=YFTc+ZNFt-%ogp$e$XOeT^lzs1HGx~1gvVSoB^zC)-02 zALL1N;D15)n8l$tKvJrr{3A|L8A?0zzs6JWH@ZMNo1uW>%(V!4JEEqYI2B&h+Do#V5o!}eA}l1|N^CitXqDgU)H0A9k*p{Qwiy>i=9;Wq|i zl?TF=2cngSFu8>*4=oJ;xM}6`^XKO;|Ng)`O*aN`Yqlkfd5=CtnVN+1?kLRH`v;;I zo)$bKkqe`1{iBhdF`;{0*!;|W)1{9drt2K1ARO3EGePRd2Xb3Brv1cH+ESjDU_B#A z{icV1gog4MJPu|w2pJSE5I#*R_yb4{aAv zN?D4G$CY0$3#6O{am1?>TcyyP3G=K`olE6ZY7CVNX7i6ypZG3CzRb>e{lV95l;l=0Qykz<B%z>rMC#06YLA9fS?gE_jYH^sWpuGH_@_)_$SGAOGjaj>9tyEp5 zR_qHja!Z!{HqE_k`QC0bXVbKSBIBs{)Ed>!z87_=VqDbiHnXQ;n{= zI-;8}neMzft*d@}_3@D1Rp$zfP0vhtvCcC!J{-cL1PUR# zvOJ_oTTMAZq^d?dc&YUsmaaxTP#jgRq!-8!Cw-m(+`cN0MT7^l4|G2dV~KeRo>Xy# z8MnSBVX~$9g-y2Tk?Ld%g29MKu3IlnxgZvwFy(42{`tQ|CX%_oi_I>gx&Ic?gNd?A zor0nG@01d_qO_O@71Njc7y7=|{HN(3@g2AwI-sP6da#$-007{HH0tufcdjeon-J~) zS*>cKeiet7|9~NG`(Cr8310)0etLPDg7W@SpI` zxP?3&&490xM9|q;wFUUULkt5*JF^iLtpMy#hx-Tb1?Mdb&aY)Jn^w}lYrk`FweP;; zOr&38hkj>ErM|T7+JuHZh-&a@S4yzSrC_M6eb&B z_QQj#n6fC@pP=0(sCjk zSg;WY6KXd000jWC1%@DxHrC(y{~d_~fRw>ljVNn=bRsKNC-r{*L&W`n5`7UZ@{wew zyza=IZA(M~9yoGu+rDZOHg?{_QcmBT`ERX`^%B>sM_xMe@-ebjmTi!mW2JTB(mJ93 zI2I^YtAvuasO`*yT<7iDuhzb&)484^w+9yt9>YV}01O%C(*M?)dt?8)Ek9-}4cma= zzIySci;<0W_igp$Q=x+SRCxYWI1j@xlD7jI-`_p8ayqgHoKy>PI;}rxz&F5y0&!?qmw#=b|RJ#3in=4j8dNEi#D8 zWyJP0-Z8B2Wbf!QtnWI!()hjFu&H78)VzC?2x>1n;%|iZB=0FN_buhP_42I@qCPv24;HZhd z!j_7qzLjRdQW3Q@t`}~YGyT4e!9!icS{#L>b5>_Zz?&r0S<2dxc?^F#mqY7Zl4W~2 zB+A)T{4Ca?G_~nY=Zsl!s!RH%oOzc?`wW)wl_IgGH7qX8O_uYSQvS4pm#L!dZbhFE zsT^V|*xzMx>6$nS&&^r-jHb~{8Hrq8N@+mh;vThby!^8y#9dQkXdQNNk4f*(D$!{i38Jo&kIlOCxeYp1e>#=3 z!6tp`T58g3@^&WY3~eoVkF1dTaUSw;_;cNPK-cn+r_=51!AMCy_DDA%n?dFwb_HL9v5%ae@O?ZwJGTqE@gVuvp2;v>6R?>qh$^#w4#8Ra@3@b)uffvv)`07 zuV??Gd8?8d#y=d5NfyBJnl)&Vgj1UQxzr2BbuQfi$p!34(|J*nQk_4)FRQ0czN`MK zRID#w`N9VExqK$Kk{kz{zI?Gy>Kz+lso>8)p5O6P@poK5{+V3pbi_W3&2h(n6k|!> zT>vCDm;Wy)7h@ZJJkS3VT^M)l@$#)W``A>E2{E3I%{{>2dgI37s|b8kSK_8i(B|y| z+89JMp7EK6t3z1rCmx$OBA{g>NR2Feo`jnO*a(AFG{%hLWR@m%BuPG0EcdY9Z=UAj zknCX*>MziPq*zx2qo%IxTt!mGFr4lxr!FmtQVD% zB3i=JQd%JUy6yc8UCBPieW0Q5uo9ADMLYv0rNO~rxJ|liP}{e1b|ocb)6#z&0*zJuPCtGzP8*Snr8v z1jnczfkVX8`q(M;Fj5#bUG}i37;FkxAk_(t&)W+YdMum`YL`7L>C4ww zO~SU8SWb(O(}GBIX2J2ydTzmzqZ!yEUlnBNYp?*75Gd-+07 zZ>;CMfdBpHg{Po%I4b0fkxSLQcdeVq^IhkS&cy@Yzp#8^)iBo?wKc70<<9T?S5L6j z+C8x>S2WAD*tB%{n?>K+cz5G+5Q;X@>LaVh_YBUg?GK78V#V9vE#AJgUueAelaoI^ z^UfKZ2)*uD?|^{+PY&Sn!Op|6olW7LO}{wv%kH0bN4--qZy@XqKzFcYMn9kafytax z`ChiJtdc~!rQYwBe}DV8w+p35SJQu*{Z2N%AbReJ*tx;*xk2Ih)8P`&KOo_-{#PX) z7-c@GpU?~E2L+E$7`^n$!B|PnyCpTtdsox$neKUovt zb=_HfyW>{JA9NvyO;x|Hs(WMN&ctg|^J(+X!VdG_%TZwH`3Ie16fzOLg@vMuu%jaC zs9I0D{%xghJJz;c@7L;P^dWtuE)))47bg5~j<1+jys=|l;bUF*g1>zBXU|5CJrz6V z4IlGHj*Z-}A4Rk*_NbP48qn&umHi@nKg-n)%O5 z^zFMd{(R%fEobU2e{p=sTVOFm>(<;hj7B?7yKq4{kdA0 zH&IKWOM4Sm*9vOKuaS}1Foj3z)k%~}Lb+R3$7|j&x5>y(_RG^LS zQ0h^-Lm35VenlPTLEm<7>%9%a_TH$aZ{403 zvu_I9H!Y?`>{|uPR(VeR60+iHzN9E9?2mgXk5>q2Cm2(0n{Ncm7epi01n zlYja>eA@>Gqq+FQ%rbMqhbQ!UbFcolX-4z54|E7v$yt&F5FG2tI>Hwo{v`t72?)g_ z71lylHt?0Eht2M%y8hJUWRmk#f8iKZ>MhVAOwEp^ShKcv7hwJPess@KfI~r}mG{vP_mYHSP1S(pKu+-E# z_y(2(?Lld*1A~#yAYaiF#Q`XEL6nvoNJ9bG0ZGxi+XQ(Ky9qHLg-+5=P&Hoq^;!Zd zOFHmI2(*D@W#B&g2JC<*Ng|MPs%<2M5P%=D*41HM1N|RNZz#X64!ULVa)c3GN3KHx zN1+BB%4f|9`bdg-1g#HGU{kty8WEE5UybzzdpAw=_1#P2?XmWTo?q&(itl z`7h&3KF(|cOFIoQXZX^`c{~h;>VmMV0iQQMRUe$5oB-XSB~7uhzei_(M!^XLpk%Cj z^x|BrYZ14LjynfMrTgG@z8M|l2z8Rnh>A{PvcgwJ^TM{pPGR?%h@(AfYZp4bQIn6h zKp0-AShOy=BXBY?^7im*#XYNVZYXkW7+Ck)y+5hES1R;RgpW){@~03kH^0)lxaS*( zBc%=R7Bt{SIDd+EN$~4wmjpj1_xvg5N%@_O;>NAn!+5`P(4c4CY63;`=w|_~p+V6k ztU=4spr1krQj&UfLs@i3b5|;u&W)VH|4fc@-UV=j%osdC2Jy7?C4F}&4Dwr zB~PuAni5x4@0FI7H<1)cQljihoy%00(6wrE35&{!p43yORm!Y!$k3}-x;l23s=h|)VCW4Moa^T5TA_i7eWG9iD{s&k%9Yh~)XWmd3bj2!HV-)j8s}et-27OdOI)!_ zC7;W!B(2&3c6(%n6w?>Bwu4tAY?mXglYSF#WBU8jI_WH%wZ(PPO^|PtVWUd8%BDZ9 zG>FhMB|l#FbK$zaB|RqY%U{b7HAvz71YS=fb$y~f)9+Mlr3F02!V>wr+L{}rdPI>Z z$9R_98t1wO+nVFKn#;z%zLw4&Y$L~?K}^0K0eqM{={%o;75W-RA=oP1+qgtrA_?L* zLNe3I>tHtR*YO=leiDCy=Md$eW_7^?US6q%C5Aw#Mjv`_K@H;R^en0v@=0EMj7 z@iMr~gm~$x<6%jrgxE+qzf>*@kf` z14DHeCG=?^u>C0hwrpe8>oo)QiNDob@UVh!LS=>a$@?p??W37eh>IhuXyi*C3rQa) z1=9n_5|M^KHr8EngK;Jf>0?8k8wvtITXV(-AI0W6DKMxdqwg`U92#dUS+meh51VE*dlXVCuy z-{$l7Ra@d2+_~Pq){e$gy#UB?+T7hFUS*3LRkw6CVaKcH!MJqY!*#bpQwduoOB-3A zYwN(%Eb*!jn_IW^VNYesYOt>bLEPMY9x;v)OA$BI{ib-j^rm%mG!eWy8ap}p~3?Tf`1#tWrJOVlo!>=aEZ9SQ-p1aZDCRm80PNY zKG6qf2IFw!77^q`U!;jGp5Z0+7wD-#6GZBh0p3mNsf;{F0hLcuwv}K^Q8>4Y13{VO z`74M>Q)}Qk1dKO+{`Af6uXID<72uVvI%ew-Y#nco#p;i}TYoH4e`57?xV}T^nu(gO zJlIn4#`Ztj{!pjSxnQ`neWBv}_HWzY)9D)ZA;WKVx}DD&pk;z^-C2aY8wU*U>vZ`8 z2KYG3Etq%S**@C_E*VK-ay*~$e5bInX|-+juu#$+HT68O=iCf^B_tG|SufcnY}vn7 zvOiXQGF*HzQr!HLp`Uu+@jf)_9Uc1F)1tvLwj5bFOPg@Go`{;xuV)hQSpz$7n^V#; z8C{$aHr6c#Bep$c_M+YnE(|Wg1bsK|W*5Y=%fi`Z?`}G_YKmmH#IoDN+3k_+PI&Rh z3_tQ>-+b%B7Px;~%n#eDVzyI)?bOow<-oFUWtUKMY_&36b4qAqGrBGJ#pZ>|#k|GQ zrJ3c?m6_FX;p`LZwt`oT3(YTQEFQ$}YtINLVYodeJd-Fgd{9Vr!qk4>$=}p!GQD#! z4PgTBsBi<@!Qc>>ln4){;ubmmMMW~ee%bn@<#)7x@}Vl@`VH8NPnzAZJZ+X^;=KuO z%cv96k!oc}e#V)TQ$cM3%BTrgAaqv}zX1pgctx)pzQ-kC*Mq`9qZ)`dp&wn(l9toco`9mwaAkA?3s0&>-F;2y-WL-kFV7$dXm?q0t7og=F|qr00I`ra2O>3xV>OLJP2&pxuDubFp)QA1?^!7ytSeywEANe> zJ4H)dzg2U$hWQlP-W=K7vU*kM>3`qOV(HS&=k*_bkVy$e>xsHu&5pD`ccmjtSO!-h zm>{diWTFENls}=tkD-s}$%kq=P1{Y5z{UW!%?go(rF6p9NAj=)Yj2Q+9d8a3cFd`O z9EI&RtAGo<#w+AZEsaXpRKnr~7{K6_Pe=i>tKH;~>D+YP#u}Go4@L)|Quh(nFfyfd75^(BGwW7Ma*eo37F7v&gRHs$V=P79zmE zgmh#03;bK8#o&ie-ZQbhtwP?`xpWM9w%Ysz20Pnp^DD<56qYQUTI^mc-4iL?J9qkT z?ZxXQgFwEeS10vpX<(=rRIopXUsVyIEPlY#SWbfA3BRYkcIP}HO><` zG!)%8v|e!L-hQF?{9hjz&O9YJ2cW~6bx{u|Gg;30R-x=%*a>&Pd%^FFd~aIV+qyb* zui&0VaGs@jz50iFI;VuMQ|-wIiPAJ~9!8kU=cC9xxwP8Iap6x&a~1^Xf>qeD)m zqqP9(O`Pcf=*4I~8~>@}Dt4^$sFeINK+99hup}~0a$KnffRAe!AZ#F}P3bmMU1`0+ z_CJvrBO$hh%hX=;cikDBReJ|wzKzRD#Ux?Jj%;mAxfUn|o+ah7%j~zRrSAVT=G)Tl zwkA>_jV+J`01hn=Nr#-fU(5X2QZiEpd{YWKsG*}SiH>SOCiSVZajGrV=B9EF()wkE zHJueuM^ep!aZRcPu$xJB#+fy?Uy5EUU=pG{>`=YMaCvH6O+96B&Q$f3N&{7{!-n+! zOF-SQL2WxI71Odbrvj$rZ>6z%E=#hJ{v2Sx=ES{PFr!XlEYZ#>sm6ygf|B|%z@`D! zr$koj-UOe|8z=R&o+uwlxg2NoAgQ-~VxRqlx3E5&^=O}ky*E^wsD|3VApZKZ;TI`O z?aA(J%{M51Lzs{1f&u7Ki%05MT8lHeZ4$==EHR01Ogc2}k|lw$d(kTY0lNihMhsU- z0+B>BAX>VUzMV_2*K1;wvlt2W$Q5ax@22N~Yxhg_VAs}y2G+C7Um^jb8jq%GeQ?FF zuKbifCx4}!pWmUTe|)`gC51Y!RMtXv+ml4h#JR($ zvMfd_8`CpotlA&rJ)vz%2}C0;F{QLJEGwG$yx^c5BvsXE{0{Knr3`8lkW$TKK%_z6 zDEKsjOH*0vgJ%$z(f%_|6tlN6^zxiU2m!R`JX?rB`I8TomrtS@pgJ0!-jK*^$o&nJ zC;hRM=NLu=AQbJGOU3hJFDk`0SX$J3N}?&xh`(H#WRhoLek$YX-f3()3`Un}OcLuW z%JqMVvo7Y;GH!%59QJ!h_;DtwM%DqFke3JBa30qOrNu!>)#41@ zbPdhGZP%dGv?*2x{}n1W0HV)KC;|B8jvB)IPcLs4`Yyz{ivoA?-r3mDXn1H;7`q%B z;-k5B(W@ch+0P;B7xc}Bf6(bZr*9z>v1|HPLJr#uBLpK}(~l5vNIyt2zj?m(Yt^yb z@^EfBbQ$wvxphKrU6{KV&aI2=$F|H46yVF{jl1-JQikB2tV)Cl*cq{LdH8$iL@@gZ zb_StD&%aE4oTNjXzd@fxeMZz36Stn(^huQ=Z9GHFJ#*`#zhw2>u59s-q=mvN~9eI+UendWOUMeWj)_bU!W?7nctfrZN}-XES? zy(aVwubuLSk9c3qoY&7+d@X$;=c}1`K6_fQ`_^egRmDgVi_LJ}32nU0uVya5d8cd6 zOqx9hZycO|B4WjU%zLBOy({N_bpEaLtDlP(#aot2*UI;;74L^<(`!H6G+#h~O2OAQ369N+Ig7jB zIB@5{QtR@*Z+1n1nQS?-(zr6R>i*#r;1eOcYtBfy8pDn)LRI5x`D(sUaVly#{UCqC zLgk`ut++0dUq6>gaWZ3$>ae4Fsbab4n+*}ip_pS#aEz_C|HK|UF)HAH?}b>eFWl>k z^p0YvT+*K-!$jbrP#s?w29i9wJo3%yl`E@P?v4D#7uJi)7Sk55d?S0=2JMyYKbXEZ z6Lk*@-b)ep1iW>=5_o;jQu?xeZQF@Rd1I{nbh!LdyT5jDzGmUYP@cLJ}PJ^em=E5Q9ZxK3R-^|CE&s}Q#JM9=mMPdpv}?#51|} z#AM{`l+ZIRRQaQ(%j?iPo_c92T2>D-lGkkrm(?%iEVq5HRyf%g-qrWwPT@R2EYI5c zAz^e<7?}#6pTfOBP?&jkEkJ~*5$nt#HbH%t;r7n?ok&01j@!seT==&}Y^96(ux+zY zel}|2;6w_sLFksRegBK!{$h0hX}lMg2yLT=*=BMwwN=`rC%o-o)Ou*8{ht1ZUHA5^ z9qA$2+Ugce?vFlb&^bon5pWAt^hY10(fb0#)jVI&=`g*Kjo_!{6`lEM_iSYpHta+A z^Ll${iRrHlHVX5s6qctUOi&vj>4wSHq$oEFP<;S5#3Pk%VX9e4gY!VSD3!dF5F^2M zQJx{y7#e;U``l`0L^*CEHl^+vt9^6glD(W#^A@7r?C4P}?c_TNN(~81|8hRG6HL9r zp*QF;C0OFcZ27UZv7_T;V^jNJN83rRkvl&~NO&kmoD>_pzM+{>g#N(Cl7nXP7F&+{ z*orxrflv5lgg=zsFcYA~W^5+dfSVzUcs)K;oz9jH2_%N0gU`=1!p{skO!y9-Cu)p! z+)1CL1s6{f7xog&VROZ0>_N%GV-n~x|7S>fi)iq($Okmow(ZR=-`ak6`?nhIHoU!i zB`CC>Upsz2a`?#yHv7D3{tIi4%80G%P2-!*%LOYLYdcRyYMWLk*J^vC?kCr3pA;?( ztBKdU(I;Iy5IvPjbOA^?OVwNWjWlef2cFmv_L1$U~8q&+$z~U)5pjM zY2c!(njWr$rJL1gxX?hLL&JzECT#Wk1|2xc1jS0Z8B@VD%t5V2q$-z3*h%3QM4 zHqg9L89ARNU->=BfPl8|L(m7L!}PN3{_OL=)qE|Wgv%edC zd`eU5tdw7g)QQIlQOYE^+i02BaG#KZ029B1?Z1+$U>9f#Y( z)~P`wO9_Dc5-6Z1RVrg=P`6xd+sN&wfh@O3fTkl=dQFXg0yUI#yz&*w1kGOQc9kWk4)bIrLyMZHGg1xI>3HNk-3P*v{pnOmg=4b?0I+0ezhH zUn7|;D;jCp52-B94RXY>3``9KYH)+?+X`P#?3yjHiTZh<16egE50u&@{QXN&$Mj ziL?P1(z2abHniOhEo~-&^G8p;QnRr6)#{h3U#(fF`O}cJ=S<-~{nv~3>AOP3~RG)BH!Q`}NTMde>1W>#p&*aef=nS;N#C%*s&MQ?ykrtx$+~1>qhdI!VUA%-wu-9&E9(RWr~~q@*=n; zZf5&bK_7A2I~~s;o|$=WhLRn2Z-L_^qJ?DIOAe9b;RAbM>VW~#!&0WYddk2KXjx#4 zjbl9)j+o6Ov~nz#h8Y(T-;=`hS3)up`T_qpC?H`dfrIFIv%24GbiI7;^}eO5*9I25 zmQT)az&<6}x%2y;n}}s^4rgzM8hQO%`GL19Af=D59q)-?VYSb*cE}U;j;$RU6E6AJ z4*7+w%d@S2o0&aV0fV=j*KS;UE)=tG4%;_J?4noZ=Z^xbShr-|%(#&;U-7(s-Cii! z#T719zzI?FcQORmp_S%{y)kC*2-`cb?d?5&&CbE6b6!a-uRNSr4#f=bcbisB-)R#n zNXIR&WzO;-C+~LgSBr(xCxj=5B00mb#&Z_IxzmP?uNJ>l{Bmh*Lrr)?jZoXNdO5P8 z?cV0K4IOi5*6kZ&_KL8*La1zw*-yP|KlLj|k#ckKe9YePuD#)X1DsMaaky-Zfvsh{p4lwLlciA$7a-BG-< zFH&~$t$oX$#Y0O&-#8ZAv{Tr$^R0d1vXg6$leaQ|Q?_OCP^^4!xP0&O)K7-*Rs6E% zXEl*lcci>ORz4Um9~7SEqrt1uYchU`;#>!QiI-m2chLLj2RCQnNs5ZvMd7AyDo5^ z+9sIVKKfuI)%-{CvXdV@EY{i1=mU8ea(_|XxU;h~?WeAy&drv;HWYMLr6o)gB*_zb zfA|a=YN`@C)7H_5W{;Z$&!K=HL6D zk)zDw!G=*1(wNYxVd3TPRrfu>3e3+@zZ$>Y5M)1F{aBb5k+KsH-epQ9dM4MbH^4+N zQ>yiO)vVxgA}{G{aT$yeKS6nE+Sb(Ll)q8^<+2kQS}z1VVrZeRnz|H_9wXL_7?%w;9lWcx29)>z;EW%0~Sh?kw&T>d}3y$M`g_njwL zRTNM_0mWV1#UbuP0)*}Zaf3MYK!uKyFam^-kU&-FD%rA}o}S2^WK9ygUG6v=GO@ey zw(}X%aXR#DdK%}LkZpJ8Jy$&y!DQQ?-ptHrcV~BO+1-xSGd=tL{oh?eij&#hC-JZM z{_p?(_xU@%Kch$#wBz)NY!4%zf z!g+LKSfcGMm@KGoi@o8GX@{@_pDP9mxu@2Sz1;QXuCMll)4TZeF06pf-)s(-Gzle5 z{Lao`NmnSnE6Bk>VLZP2TuzJG{Pj{eP@(I6jA)u7=(ZOsCNO5Fmc->_>bFvR;Mf2a z-YY&J-Z1v^1Y-B+DGkSrZm5EF)PUgACMgluvnm1<5hUmy77}L`yG)rMOX@4KpdI+M zkf3`QGfusr9=&32a(o&9<61Sbtn78YVI?hLip9@N4NgxnMPJw*1YZdhN_+%^mbwQ? z4>(cUMt%i3--vH(8EzTn1_p+QyhJ}?aOF^RgiRsvs=YJh#aLsI$dJKihUo5fa;SA7 znTM?)GCE2mRHlhcye+74009W5{jhUp+e_99B%wT}MIr449a@>BruY6G8u~A&v1#SH zYhtF#7IHubO(_XGss%@N&`}#Ab7h22$?R_YU3$Sn&pjJ9Ok#2=_Gj4f-G2V|3(x$) zGcrG_?d5?l4+PV;te>!TAhvPw8#aMfk%w-MZrp z*8aFr^ZV&eW@p3qhXZWkhbfNaSCWIy%20YGU)#M_x|YeqNG5GL(q4G_`KMpF^9Og< zvvR{(74Z!FNp~OBt8U?^o6?Tv$whX*TF6`;~)?g8&Wb zYl&K!fd~6>nkl0cz@Qn09~7JHDR+-b=o+*uP%auTY?n~QS^)UxQM#F0MY6;S^qdSW z+)fI|9Y?Vq#f-T1dd6CA~J9YSt8ItMYPa3)0z>NHw6wv z-{U3$=!B^V-`w?=?giql}8N?MEVbZbtPT{jPVb-88WecA*aG0%C~S*!wt%TnS=2 zc1d*7XV*xPu`l8)gB+=XfPozn$Y+nlnZR~lkZH&>A@6p5um11Idz6NxF{pA1l^hd) z5W6IO7@A!oE+yak-K?JQzVBg1|4=P39t?uCy_5~CA?zXMRCf+;$`*#A_ zq1fV08`jIkQ)0pP<+7D*v7z<8t!+Inc_HRY1%bVxxNQKGTRb5a)Gb{X3!25$=5R`j zkkSHJrIeOn$`Hsr3gHKs-R~6ty!2R5$X~Vn1r!Hbf{r5~la&4FlHfST58b?PyM?JRzUYqyxbJDk=kq_wW?;nP}!X~+45i3h6*sQO_z%eL)5hq{Y4PiV|zq~-_6M*GFQNXX>A4X83I4kovG^1ya9&jRuBDpdc|R6L!CM2B9FjLj8tyNGMOT>Gl7F$3`p|0)#Xw zCCqk?^OOkN^F4>VEw+2U|1z4=2#_YwYluiz`}`p}0?h=~R0M6U9s z3>;q|)Dru>LcXAdJkkTtF2^k2_+Bz!aCieM;4!PWVEL6FJ|P}H!55tTDB4nR+AP?z z@5MsnDW_s7Ze>?6yOnm2B*z!CaP6hU#muF6s7nft#<1fY?>M&-vvTb(6W3CO-Mx|r zKj;<)&#gPQLnSJ%;iEW;Qko*S-1hw%1kN$%SoT=XST0SK#y*N?L*Mi^==u{lxLnjO zxkmx5MZPncM$o5~o(6w)QbMmXXmcC;v9fWP%|SSW3ev1oCwQgGxC}X!FCZS>beW;Y z==$gxsqYOrjXjx5i0I1@Ql&nMaE89j*(1X3RKppzmt0~*xFRW>R%*m-7+XrNpF~*Y zblWwI`ke!2Yy(x&C+gQYlHK}u8itJ025hw7)YYK_ot0fO!B@_++v(21>;tKS8QaJR zfv`8p;T}ugb@XMjact>Jg@W2+zgNo4rD&T!50+Z#+KSAH*i-?zxj4;CtUGQfhjVbL zx_*b*NV-M>@;j^a%pl|AXS1R1r4oU4Dl)3M0-c|kOViJ2O1>l7*d_OcY>W?s%2Px* zyA*EZJ4PiX3I+Kec|2l-;7B7~Bj1cjUk<}q2iIju0sCyOt~`-#Su3UK&IRsS7PTa# znTUoJaVahPncBEmZsP*9%5NR7Qiq&VS7Nn2hH|-VeT{QD`X}8e%H?wPZn!kh8U2~r^;_~v`oHSOAHo`P3MkFQ z0keKA&Lu-WN38*OGFPOJyWWHt3_h*2<`?V3w3>&Ut&uYx)=9SUOy)}TVG*0*Iiimy zOJ8}mDK(|ZwYZa59hGWz)C-|b>I+)#HF4X>I#Sxe5W-NqN(iQ+woOX~vPh^|mQJ~v zt8Db=GS;6X#;DeVmH1|JF)qvXb@1d7(DA%HvdFlEZkCN~N%RnlJN5sUw%q+YwIw5s zU_RNZEzMkozDA7FPpq9QwHD~bHk<1IZ1h=+Zgx~>%o=q~H<|RiPhHrE^pv*Ihn`Dw zlcA4v`Dh0I3mN0!s`U9ZN>g&xIyFF&%t^;l4U~Aw>s-cMy4Ej;Gjw}_F}aWDs=Y}y zL*q`<j%A}S2mQ2$_0tTkXFg&5OsBlV{ILUb>z3atHOJLz z?E}VgrW^5h{4we*88e8n&I}6cb6HxgX!EH%ONn-5ArC9GDbQw?%Gs6FAy zG3ru|+y&O_+gnLV`Q^52rG^QTYNZ9WUw4*djTDK4r4#N~AaJ?{`r0>2Bsd(dy|a60nCosI8g1oTfTT9sJunLJ zwc&x*fukx=T07S_if2IY$jCX}{jFSkUwi*>%TWkiNl3oYOe}H3yxm`^;|a7fwy%Nk zugj7_l!N*r;{nrYPG_SKd!k5X%^^#~xCX(8jo*k9k9OV}QW@#=rOfd~+e+hC=J-aj z<0(6>5>WU6@&SNqgg1GKe6bOy)+v)l+rpCJMy-6%)R$O3Zf?N>j>8Vohq0(2rcMjp z7gk#qw!LHvbPJAcVaFlfacHS%sr}m(uuxz6-D#ofP{?s8*nL3~82r7=-R3_k*lq6c z7jIF~$OBO#m18wZL_%qjI^SDJ6wpSq6dAd7G8`h?z;&h;mba?8KVlQJdLP18kTtdH)O%d%p=sfj_#-2&zmJ)B9gh zv=pjNS|%hDl4%Fuxbw~V#j9Yl?0BhrG35{Y|MZRwJeyl!_E*Wpil`>Z0Jc;M3O>t* zmB0@r5;o~O`knH(JQz2m&D#k1&GPnY7qo%QSOLQ1p0)u3Wfpo&4+pic@b;|8wmWIX~7N+zn8~2p4 zf=TI#%tNVoA{Vx}Nr6`!+^yx=71o^$> zBJ<1fMF1p5m4fr<^S%LJe}!Bzk|zj8kED({;-8Sb5Fb><~#g zQD)z>46|CdX0)sGjDZ?xM2X|95i586gxMT6;>-(3@uOC{T5lW6oo~u{aGJbM1 zGz1C6)4?H+(CLx<`LT2S_yuunn!h|NjLn8@v%y;!rbLJSJy**P^J_V9{wfd7+j$vq z{fBhRi+-A=VWaS$VFp%V@JQnfFG=QvnA2qnva$vvQsrS<$FZ#h|Pi()Laz^#pH^1 z-VrW6!=IaaYieckyI0i-+U%`=^1HC{9IXu*%(loIITCPozAh(1DquuQVY>muJGa$cctNR6EJ@r@||^c<5S z_s-JWIda0}{E&jY1P4~HCg&$6&yRsI$V3dh;3WesSYmqE^}S2mY;8D{WdVqLlIgW% z)kmUiZ)hHvs$n{2!%n*H3PVJBlHN($_kT5;Y!8_9~y zg+j?@LzreiT6b7Shd4wDh5s)UC9U>sgiFgO&T5cl2Saj;>o6{fPnq-ht&BGhxu6x- zcNa74KY?_fS-iMg%&b|OS=l4jwci6EYRW?8a;a$DwP|$*vX?qT)~3ybB!=p)uN;3ZnwnvfwkUu3!WD2Pk#bKN4ud7nz$QGPd*b|(fzA7!QS;r zlV?vugtQ-Zbh?!abI z{c_xocLs~P1#7|GqsaXWtzT#rlc(3}v5N~PPb-FlRga*3dfmPqf=$s4zk&o6@M{D0 z!Q?73MVz^Cb1{8+r)b@?SyZ=lb9J6Sc{WruN-=ldI~^!hnPM2vd!L)-fN4*^Nl?cBeaeik)w#yQe;DCj)XF|3+>qV7|@erih zC)OO|3jrX!c8PC2#e1+S%!r=L{E;icg4yT$A$OBsz0|!Lv--4nc$h!rp;_#ZCzyW* z?>ZJbBw?DJFZJ=;PAtVNUHf(-ZdS5Zo#LJz+^tQ+5zxs1g;0u%a$Nc-@rE=Cycrg^M}!`jG7#`ARo>5U0t-EuH~wUOc9$7gd?(D$bS|uF8F^qDg93d$?xMVZ!sY&tVdH&)YfAzX}@rH2nhCaZi0|t+S zj^f3cdm3$yp<_& zM@O)>Q_SqVJMar!m)eDUWvKe&f5>5C*NyF z>WPQZZON5vWiO7t!I97j4>iK%W%0}ve)gt#=2q~8KX~x=y5k7RO}3fex21$_d4er3Fud3hw3UTz zwSuh{J>sNTcWBit)*ZQTYlXB!n)Bm$Q?wnub-!qLEp`j`+OYi&Z@=^XlJAxXJMZw9 z=EIk63zu$(ERmhKlYuKgG z7MS*RA1%T$$cSmmzUoF4LFB7R{+-ja08O7!9v`qd5t0$6t*}Y;X4)XL&rG%Xv!qqg zH8w*QC2zT4&JvP8dtJlc{{dM7z9!pryhzI$+ZlWXzTN=6GP4!Whc_}9&qn-}$s42c zDqDahtA@5lNAMo9Hdu_TU)UQ?$QKgwg9(K|;{eXMl}xvNH8Et*=Zki)q_4#Ag@;1c z!|PVt=X;*(S(v}u6SC&5CnVqPeUvMkj(Ax`U&pR}tZ1xw>&j;Qyb_Jys;QU^(uOkP z+OpczhT|Twx&gHp10unb_>^0r1Sri8$}V6vnb1usHndiaFZozY87hdYLiU%1a*9Fe zwSv-HCT(sBSW{Q}RHeW&HxqjkI`NRrdUy0^puxuUr7*%lY+oV-^CG@dw%#z9g_fra zF~@13h)QX>cpZ;Yt6i8du8*3F@nlQiq8zHIFt+#_JzDdP)o}w=0bd|A{7cS`;+r&h zyAd@!T_5B;D=ExHk;}Iv#7DKNdx+2o$E(Q(X$!PdVTK`e=;&8*a z0~;Y|n$t0zUG5YkAJe0@MC2PKoUT`h#ZpukA5V)~ z))XVhR>`Fy#N)YNBdRg zFRhEN~;4H$ur$Bn?qaRN+-K6xF>0?#tj0|_MQLL7!3 z>CSRnl&`VsR2lMNkeX2HZm>s*OZ(MNzrQ(#dh?vq?Hoi7BQFmzGuVZE8d4vz0h-z> zy;E|+lwY&CYPS;-i4ef;0GW&7T;$BZ9ih*t&3y)&g%*AS{a0lmd9^YR)qe=|gjzsAhbH7s$@{Fl5nz=)U zzL~GY3<-Bd&Nl3T8aYu_dB zr1dis*P(w>LSxqJq<`8h=pilwySOeb)L9(-WWjc;ij0${BI9JvWlWn~rfL;AYYI8Y zGfi6xP5Ic*)4!v&`=atq)8@+Fjd~so34r`?@a9p7S0t zgW;4!`X-Vs1>78XrGAVJI~^V5ij&zkvfv9RbJzgC z(q~8-55&B-D1ieDy0=zg7OJ*G4HYs9rPOMN!c#bSJS1>CQ^dzehy=5+k>n3^+rV`~0<; z8RD@?G5|6RFvVjf=Oj5p_}WleG&8cw+K(GuWu*`+8vBYk{1y*I(Lqce775b2MC&Zu z3p`FBfN^SAf*THkpPHGRpHyTSwvrE^s-m&!D?wTkLpu4Qu*<#Ves_GDKRwDjEABfg zgz;(Emk;i8%W?wQd1fXr;ddQrYf}`=#?ApcXQ5h&6TpnX0I}%UkpQ+Y}rNh|W8#aP2f`Woi;x_$TeB@oCFQd?@Hxe`kr;oAY zA0{gdv;%YA$$8ka{tp!2e}sbp&zfZ(Uq4J!Rnn(n&qm78LtxBn(_-C4z|L=^>AgmM z7seWPHa|>M29^{?vBo=ae0cEqu(uRx`D0)%2bRBKP8j?&NCS;QNW{l9Kl=Uct-53g z$c(jAooi4Yt`Z`=WLtdF=ejYCPIhk6b@AH76tVknVQPl4Z*L;%2xVHN^8E`cU$ggz zR67~uq?2z3IV<#7OpZVfoB#eVx}!}iGwRFCeS3)*=>13XyH20|IXTozVbUZA*5ss446^B)AR*T`ghPQNeXIIzWpk(Cw#=7aAdqV z^VKVh7v4$++}8H?)jRyiB|d2e79|t20x`kFLfDi}rn}@q@Cg&aVhASIfPLgFxYs3E zGd2?o7p=j>TAfcy#)}uinPu;0mhp9Mq0IJRN=G=QUr6Z>rVQTgSx*7T_u}5KJ8=Ad%dKFw-*Xl*QU&@tO(~+2{~2oR^Q-nJ@b*t zl-om?RgPYZ%)ty<%hnS!!io7pV*aa>i^%CtZ&}uoP_4A}}-028K6NGefjY z1v5K?shxLw-%HJgj#PH>V)IgsShDK}=_}_~J>o$wxMwK5XH?h&_SHmi&t!Pd6=Bbn z;GVf)_SJha_pU#mw4T(wkQs=6DW6YjUMz#N)C~vN>ID@`&T!=(p>oek^JaVB ze0aJy@nTQlX1K6kfbv}Kibvehv)09LXUy8|p3qq^b-_cM7ssy!&tAtjw_vsbKTn%G z>8H!mC)s)ErziOx2Nu5eFRBMXjJTcDtKg!PdW!90@j4j z_dnPF;sH7IO50jRFl{Jg9bR{&VrXR7F5TdryMkGJo=*VZc5*W{J5aXR^!3`Mj9_X# zEUo1hy|!n`y*%;lGeF!cX<6N~HpS<-?*W>{Ff(%)fLwv~B0|#o#uWr#yld$jX29)>7tj>9_M&tii$q=;q~oCU>{{ z-o$eQo7SXz*GX<9xq1n+_ukEI)k_`x&MvX0E4Zy26S5tN7PC-+WHGsXDJx{%u^Aip zdH-|%&)<3O&cbXsw(Q;5vdzSl7mHu6`f^oZR7|a1@`V!{Ly3*c*VpZ-FC2aTXu$be z+n@COs~+UL^G}~y%L$bZi`l~vJP@-_hwPqDqD)Cmzp}>h@dWn&iv;_p4{n)F$=86< z-(Ygi1F=7by5T2#5ezXuWMEHkmlU3IT7MWD1NX1(j#K&8zb>+q+mHzNZ(S`Zr;1~K zVLf!JB6_1D;neOp17JV)%My>V2X|u*1Ba2cKe2mOF6DeZXVK`;04p=d&udf$5<=s2 z0BVMB44TYFEl^E6p-E0SLV__}rgTRbxG`#vaxpA@m171P4IQ)C6=@pBs1d5^Cu!Ul z7FV2d+(uk#t!QBw7q-ceia|3}r%BYL#KhuFP@eR8)WKy~j4&ihE9gR4w+_K#Pt;<6 zq}&E0d2`Xayhn4%dU}w@q0}A4sgqts6EUtsH0RKV=TaiVxzuo}hHz;S;p}QSgB~T9 z(PPk%L`kyr@qiN(BlDKQL%n*QbL!tBw1GaYnlfmpDe3A%HIhPE|? z9?VkW(SDWj#I#4hE(_5=uay^O0u8iaqt+qN!D&PnYiVj+?2&Bam%1=$59u0l>gN)q zWza&@zKDFoa@zuuSUgM=8uTD%fmqHJFu)!hgY?F5J$Xv1kO8pvm?m&UXZ_Rx?pP^t z$2=gGN!Qk#E?Lq5;~d&p8GTMhIoQ^h4o=q-<4{|vOe>MbWf@X2!Uv0$^tE5;C2Rd4 zP4RcDIR9s(cZ2e#8-3`#tW*hS4fE;XHsxFGmn&CuR-xt0oe*Kaypq)>2-W)9gbB$V z`ku%&?7>M+mk*qbC?8yvJAvMC)mjR@?*lIK?;)q4mTYKCBzUey$)6VQ6eKw)-p71V zt9-%LY3XU{XruSD*1r-T?6p%*uh(LQ25Or$L*Q;vy2E%jj5s4F(Ac{%KiM_em#gm> z`|+0TrPhZ+&)3Pm*mbfmiI9a*>sBkXhKc_OAk9^|*CZNet0&JG$CHjH8xiWg{~0{A zA{`$q2}lqB*?>?F`wWlFiG~^G|C=;f>*@3aHA?{_sal(klpD+Mj;Ie~8|h3j#;6uadY&fJ4TTyr4NeegC>Qg08I88Kwi$x`ld-u zs>U@oPZXqi7t|5-q&3EFAgZ;$QliBWUF`Dod<}3oCnsxw`9FS%zL^7EO;IdjR6>6_ zQQBOxij4e9B1B3t%!6h|UrE|CS&9w>;!^TR5lHl&;~4y!DM{}sdL*;)UQ$#T_SYz1 z7;-M@J=KFINJO&w^OIxqK)&}$G$Ljf?=32q0!T!q&=d*On2<}{E3|EyuIi1V8m%R# znw%X}x2Za151BaXWfW|z5hj0z?Bybs0BL+MSRzJXGLWI85x5b5ADx4vBSV8SHfJ8P z5O_`GMI0L5MKT~iMw!GbHZS87#S@GTjWmq1RbOHFzOWZIvrw7V{# z!iU<3W;m|i5S30Or;1u?mA)(1wUlPy!KJhiCE$nY3LkaRE#6BeQ2lu_6&-zh3SsLn z&rVFL4g0_UH(cH@Qmah&(y}R$fA>%xj#6&g$oV0?V3bxycqKChlFrln^ny`e&(Ynt z$ieh#@@`NN>LU^cEU`;h1%&|q`)sA$cA}x zBTg<8hKY%?`e*c#`mbypQ6*-w8(I4z<&oat?Z(H~@aM}1sruI-ZrUNy3^RseCNvhB z0a!_*)e9A08hG`(VBf}4+r7NqyRvOHPTbqGc2L}V zia+ZW_IlUtB+?w+W+uaW?F;O)6CwjGR+U4(W?vc#x=1U5 z-#Z?%P7uMh6_yjHUP=nu3twwoytXv*`ki1&vtV!Lchix1Ju!7*kC>PrxF9B$gH(t_ zI~JP1)c@*)U@ry*Dv=Q*;VxcZnik7zW~ALS)lFX zrvoPY{(+ttwEmDp-+b0Q0_}&rRM!3P7nCe^-!G^OrgD-!z_#y|uN+@JAObPJ;h1XX zk5A>K0_kl0od{V^N<^ljFI@?o7LzKMb}naq``}7r$a+XA{zd4!1ntFq`9A&t$CnKW z_96cGbjW&fJ*RLnUd*Wu=j;%2c7$^pA>mJA=?k_%rs!}j!l_tl6CB(51_|01m9+@0 zzPgaDp0NGm2nVoYd5>6iAY?nZo>>sM70#>_GAr+O0I4)k_R>LEX-H1vvuZ-gHJgsC zZ$y19DwKOx96A%sJ^PKQZ$$l(_84@YMO}@VTZkT*a>TNkU$xW}%-kRB-t}gnm>#(rPn~Q0!B0$>@e_z zosD7VG2VG>d7g|2tlkRl0&?JukmDxH&8vM&rNO-VaNbTKZ)eciyiz1MQN^QS$5S6? znX;-thstgGz-7uWhPF{&Enjy;%xhikzMt10bohk4{)Maj@F|fy9p=sp+EK7RrB{|!p&Vmb62RjCscY$XzqDqVrgt` zj2}ArvrDfHFCP0>!|;2z^wfGmH^LqabbXAKpP-Ez+f9 zSK^Wc=eaD-$z^jnTrQWV3l)bWrb>9!c8v8g5bI7tdPc!MgL=2#OdNy_X{!)%!E7FY zt=!2FZ_QF(p;U(BnvzR*l2Y4>4*;x+)UO^JKUW09kH2dQDcU%LDK?;@>+9QXDD5MJ zDs@!3Q#3Fn?O3QmTO5hDQ9 zv`dL&INh^bxgR7+goumVu8q`uq%fC$DE*OiAOR=6nKni~CW|WP!g%uM0(Z z7%xe8LH1J0Mv|-e z7|HVT{A&gD4XWa*V^G90S_+Zbw9t1QO9vyi9tjj_ybzLn5#c zVo|@h9?uW$vg`*FD}q2Co$4zsknv%M|D)`Q(Ev8=`r7ig)0=`V1%K#(w54bdb;6C* zVbEe`$(UUmjMR@4g+`}K$WDW#MktxD3)3CV7+x>kv6Cbt`>@02Ve(_bIZO_RV7$Gt z_CBtGdqfiGUgpRW?T zFNQ=OAuO|WlpXBIM9F69&gF?-5p?BHEvf9ppiA$vh!ez{WIwjbKe+d6{w&b9qy4WSo81DC|!8Noh- zGs>*Fm&q&~wQR=(ZBD`FgmS)>w>d+$otr7?3nPJBVn)T%E-|Aan9_JJ<^zi*x!o*@q5!b~_lq@4 zw+O7dLM(2Td{#XS`eZCPbZ$Mlc(H@8!C?kmdq|<&M6qteq&$8GVWkeQUu#{8wGQ)m*-AWbFo=&`H>YgNE}(@$9AGNk}(c z4d#1;sXin@$i;!0#T#Ny{jyce*(o@7^1FsYwqbe``)c!RC5z|3RSolk9RPl4Y7cJj z5Q{s4xt)TelkX;2fc2E@m-D`y7r4%s@8%0yS9Zbq@$gz1f6VZ9zkjvnonihvHuBTPJS;p^Z;oC;U9V5Z269}jlXMD-a z=Qk|(t#+*LhKxj7pP8XB$E7Va2l~adD&SApnm({t<1&b7az1cgv~T;Q+7y5A!v>Q* z@z)>6njBdln=JG?WntT^Ih&%94AJpLW!%u4Qct7p{`%dEM z|ERDl=IEa2zb>=)9RQx=f^4%5&=zc>Ul-xX4Ywb}3be}OsWwU26Ko=n)fg`56 zK_5|#^swXSO`sNQ$4A0fS3_!Bc~~h=R>}@NBHNZ>61cdLON~*$k$t4yR4x;?WLMw8 z1~A@j*Atob@##`}VmK~A|CLe;jbs!7;*~_CMq3(EnM;H@q$GDDIJeOq6W}wW2NA|C z^kcQYlw#zDKUTuvq|B{Ki8vT0NA#U`HJss)2rVMXm>yEjgVIEwnT!0gLjBSp!vJGR zhUbX%(3Xt%n!*|FM#rbY8^jf$Prv|#;47|m`~M4`4h&9qzNC*G~pw@QhEZH`Pj1Vkjok=tC68Y zc+GHUL`ZAIMo4SiP~qfoz;ssc6KBmG?xW!N@GvRGU|!;C8KW`4zq59 zB+gv6CUv0^QQX-|IdpzmM*g%CVygozbn4Vz<90@HvI`=5{(iaVJGnx`5j;C0oHDMQ z#(cPQBEqGs@fnB>(8x4Avlb|dYyq`4!B#QIEI5t2*oe&_Z^D(Etll&3(Txv_P>w2VAA$sT4DRtP$bY*hdB;k-#BB zz~-umIx+IU2e%@PRlDQ#qd@6Hkk&wNrprJsdt&^`w}USBp}{et9YP~m>y5cv5v!C{ zUblC^zJir8cdLB|SIc^jPEO=^X;rSC+s^IK2uSYSL9l5fFRo#$^^$Aknm9>EcsI94 z9|yO0tMH7dm#3=-r?C&Z^H_=Y>Doc9Gu`}_s?<7Uhp^Y;_Upo{Bq|V^QX_k`MzrA$ zpuc4U`ThWR5acUZgkV_rcjOr@A3MZqr4Cq3PwWMVD<3v%enbCNQfG5!!CaxP9tyUq z2VFm?lKVk{arVHh_Q-6a`wF`*>ODH*nX1_=?NYfzTFv#|mDV4SzUp-)*V!{@xAguO zDU3Ql{ghIOTqC$X{m7ov;XAmCB4*(u)PA}gV^w7Ry~sGvX~eaN@N9krBvO&F9wOVF zYt`q7YtuhP#Hh@dMG@;jEZ6>ouOJU7=i4x+K9Uc^jLG_Lht>iSHLpYGfG&S5XG1@Y z<+}8_7%3#7CnNSzutC1nmlhd{I+M|2H!lyllt|um8T4fi^X?G722PxtL znH&TYy0n-)`y?NX#U9-_jo8U6-@)W(uP&6$xL44HI@%DeJV|6$S^GKq5m_aRr2FjI zuH*wm*b-`!IoEK~pi0VB-a>8%J6Z1VunYTHmFY!#(p<}&>yWG6+ItmcVfT7st08_c zR30Bc*U92m!ArHckN(HVcq{vve3U^Fho(Ks_D8fRs5;a*g3jS^W|X**WozUksHP|V zFh(Nw%3#D2BC7Xo#P_IXa~9Jcd{m6)heYav#;$~sT0Zo4|4Q4EZMo@RC;v~$KkAqD zm@}PbCP%e(0sQ&`VDEf2Wh*hFE!I9H%f^&>P+bEMm3%4TwcaXM11gP)80qz4K`gzD z?<6b7ow$3X0=&eo{Sg(Gda|U&ZR#+05Co(b0uubp<)2=7`@)YdhC8Ns{6Bdrd~#Aa zIT<`T6*@i@>X`aS3Mavhe=cXA`RfJyNV|LA))wbF%B|khba#xL2)c1E`7tUzQIP$G3Sl3_c}3O>bZD8542yOQ51)w3Telc-D%38A zZWRfJEt&O`>l<_#R^O_6J~MJ@>~sH#D6B{hf?Qt2XOfV}smcZX`Lg6H=hJq7Cv&M~ z;nGX}i(~iG%fFi`cQ9v;*`F_4&D4{K>t_IY2cj>E^v4vfCRbOiljzgr>U4U+_=Jhk zF_} zBb9sq4Sh#6X@6Y3!gugHRptSSDe8k0o!_6YzLvj`1tHhd)04bQ*n%4!Z;-wBSdZ`*W`7wU^lKB9QA$`nd@h2 z*qT8GFR6O_a};xisy-s6=zMeQ>wNNkQERws?43$wm?s%xe_z1O7#bx~dVZ7$+x z`S!W|`weoH`vL2?Gj86$_mJ2U%!jMJiVP@bW;dnu~x zbeB)j6IZ3OSmLF`DKm;sr`OE7cQ=LqdkUXUpT9+q)cH3O&SNZ1dYNLhG~>LDcVyC? zDIfbbY%~U$80)`fFG%W=A%!zO3Y%3Jv*&XZCCU74q^khTT0{CIHV$LJXk(B%_(p=R z=WU<_Q(#M8nfGnP%3Vle1rfuBK|uS8kC&IL5xw)SlNJrF`|cqE10guuygew~nC7s}rrwC@n|w+GBGxWDMejbPugd_u4v_yi(& z9mJM^`_qyim0;1JwS&Lv#~ZJ?Ra!+_i629Y3DydF{nL`4mi+KDhQ%kX_+;JQP2x_y z=Jy@heBO4^u^n*Gm1GpYvRAN{fy;DbGZiq>{I=a<_U>Tnp1Zx9$#`BI6|>5#`M9hdE0USQ4L$4>Npo&YX z1zRDsLoWmvA4P(`e$6d7s!@F@EmkB2cR6+?=6lJjO~Uq0z4uxtKYa3U`uQ7_qr;XS zs^pvI9*Z#QgU6u7Ln-%}&sg*y;mtXv=qxwqEb~;_o0hgH{Io~)MJrf{C9s}yb+_E7M2J*vfu;KTS?Pu;Oxx}3>7cB8rC_P$?Tzq~h8ePAIkaN&MR z`RcB<-D2x7SU6~_U5f|A+#O=-4lt1%knmiJ4LY{piw4_>aHR!W5`$^GB}8fEDd^bE z??1_(I!lnnd!Gu~#@4T1Lk|3C0@lacEKB=W;_g=;2^L-!s*fy=t&Xi(e=@}%1OMuh zcx*=KnE4a)q8YE=Exe2mdtss%KRuB8B5&z_P z=-BwrTKMUUVm&MrU&2S&kkYrZ#Hg%=d<8(_$VuEO%Vt3lU);PByP7EO?hh9XNGR0n z^^ME^P<=}vCUE<{vwHPue)zQ53H;zOvGd%$?#;}+SBDm}zjpS`aoHwwu&zzaZwqD; zWI8hk-;7Pdw2)qpmdRj>&v3z9+bcG8tW^q4LwbMy1k}YZh$mn=VO}^fZ+LaePIMfC_d!bj2X7!s{Djw*3<6Uc1C;c3W>Y|@hmTuDdPV9+-9O;5T zlw1VKOBC&v=&S_C(F0^-zU??)>lU1DB%VD)AHn5MkHO-Ac=`e!FPrf^3v<1<#aRLx zplAHFK-C*R{Zd|9BpvUQmNCj%i{%`>lS7`D2CUEWG`%}-d4}HIu^giwdLCM(a!3@# zBSn2YYBma^K4mWIS6Xh1MQ1JF(8}+aSe@aAJYolW%sH`R93Fymf---W;)Tmk&+>D( z#A!c&`)P6d8N9lP>O=JOgCJdC(c;H#IYasB!Ve~bi)QxuQx-pUkCfY%%^bjo1L3=H z`*Mm{*ci-d3g_$>a`vwr6LStNU`S*IV#CgA!C4)2)`p$Eyt8+?{QEWEsadTQ8hZJ@ znULf12bQS9J~NcOqhHVez(n`UH7mEohVHcrv0+H^Subor?>PES$=cMC{R#U(>pJ zlRxI+QMIGz`Sz(`^#vile4#sVbF-{z`NYcgwV1VAVi(5uX|c;gHHqmA{a3lWbOU#{ z%txqNXE68Tsm;F8pQkY0z>G7i)H4tKc; z2oHyTJRvmp=)KqGX@0-WpS=j!Z}BV!$Q|*lG-i9L%%kR`l(9kl=s!c8$FLIN$Bh*X z;f`U<;Av9AVDMU=CC^FAVVdEO;V0tb_NZM8mei@GRH`FrRr%5IVvHXkeJG6RxTalGu$hlwJPzzaomY^ z_w()VgQtFl&)5c@`@Qx}TiQZb0QmT&9|AI}wB}>z9Yxz0Y+pPYDE&s|E0v2~!JOKV zwQdu7_4c|qeUJjk`rg4{{Sm&db#?bUt^D9=-ZLc*UI-qY=6ean;*xoaY9QeP4ZY}T z3sc0OHJcI}K7C-PRr%8gsV3JI^RGW{Fs0`LN}U)+8vhCS35iYr^l_3Lv{?ySwRC)`lXo?R9V7$6f;B(%(V=@K{q%m@kM`{Gm}7os z&+^2?{H!7d?)`eZC&BuQ8oOtoWiuhcvpaS(Gt<);yV)2`_xlpglt%wDCjCrd^e+pe zaX*fz)C;>fN&K3GtRWSkzMzv$L|L2x=FuObyi zkhAQPX%z(1z7=jbSv}{X6=A>C)Xg#yB;` zD0kGBF~&bO#;wCAAYHps5|nrAP`_=p~U1VQNBTnrOLhb`=k`LlDSMCm22byk5sxe z;a-o*aPz1_x*9cgutE7k`_*XvgUy<+a@QCO3NPb|KvhAdQgg|}u_U43L0wAMAo#kG z7w6D=EhxSzbFqhF&ysL0yVK~sm8me5@OcbGKaACRXJ_XtEf6ieH3!Ty*%s19-0a*W zVBBDmX&6Mt3Obm+NzP$RKYkc=l58sA)kSznuSkN>4+~F3If0xiGqptt5NQJGvCrw4 z>Q8_bD48ng^QY>_8_c#Hh#wqc>aQ#$G`uOvwq#O^d}JOR^MY96CFa0}eQaW4R5?pa zlm?=3Z6uMu@7g)`sn@p=PtVfBMm+nauY8hf--}eL87c%7O*)5DNhBJ=+ek+uK|Do% zvGiC-X~et7X0A=Pd%d&X4O{QzE$J?97?sFwy+j?}unmuSrN>nID7AHLW@d6?&^tRm z>GMf1A_PWl8!=K&y+5NbWUEnf=96S$O{FjiMBJ7iB=9w`jbyn`8}1anLPne1uwEXU zzT$lv<@m4o^Sy!iA?HbWU8V0PmcEr0O56h!F>8F-nk87X0=C!Y-x~h@i9b8>-BY|3 z@HvNJKP8-8DkPUKRj*q4({75*M9< zBg_l8p1&1Nb_vO@U~=(2E9`i@aPawqfss%`>1LWUkp7L^uiOr%RrB_0<<-ehLfIyE zdQIV?2BD}ST(nmJbX3v)m5INa{)_3g^q=ScEH{{ToVOnbNZLZ%H|k!g3+HSXa<&I^ z8iL7ZN3tpx?t`z$;v%^hA^v?|TRm7Q!vdoRO#BVl|Nql8T#J}>P$yhOM6y2weVK>={V z`3p1C=cFMYP5zfD`^$9q3OQK8K#n9oCW=jC(MwaKH=F#t*Oqu^9ni4xZR)A-QSY)cjPb%EF+*YdMcx= z=21}?$R(TB7~z&pYm8b*lYp1Dm>X7D*O_O?v&^22G*j62L+kq5%;Z7u?;{|RF!?AO z*cqG6A6lc$){l|^bNEYB;d`c}_e=@znd1J=RQ{eR88`2l5}8lRd!~5y7M_mxWApA> z*W=>v#;nH_+>KhdmEVnCPi(mxzhQgkZuCa%Q+P|*T%YsvsrA9w?RTvo$C%Cg@6BMZ zZr=aEW-%8&h>td>e(bQCN6ZhB%;tXc16#B?`++0I?0ArBH4nfy)_l_ZAl;6G6ig4d$-V4`n&NQdsP-(T_^M|6c*R8Ri X@A_QV^TS_o-?yei9Nn73+U5TN26bwA diff --git a/.github/scripts/__pycache__/test_host_lanes.cpython-314.pyc b/.github/scripts/__pycache__/test_host_lanes.cpython-314.pyc deleted file mode 100644 index 787ddf817c4434e4e0982a510ac917e5d08c4b22..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 5662 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 CC%6j$ diff --git a/.github/scripts/__pycache__/test_intel_host_tests.cpython-314.pyc b/.github/scripts/__pycache__/test_intel_host_tests.cpython-314.pyc deleted file mode 100644 index 59bc583602a94a14b8cbc97dcdf6292860c8a904..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 63079 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 L6Et-$YZLzu_^BV~ From 68af1055ad74e3c888cb19356829af2f015ba731 Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Thu, 12 Nov 2026 01:02:25 +0000 Subject: [PATCH 8/9] =?UTF-8?q?ci:=20fail=20stale=20generated=20files=20in?= =?UTF-8?q?=20honesty=20(`cargo=20xtask=20check-freshness`,=20SPEC.md=20?= =?UTF-8?q?=C2=A79.4)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Of 248 ci runs this month 84 failed, many of them full gates on trees whose generated files were not regenerated; they failed hours in. The new task checks, without Lean and in about 3 s, that every input a committed build oracle (expected/build/manifest.json) records still has its digest and length, that every such project's lock passes `lexlean lock --check`, that every oracle and committed export package names this compiler's semantics, and that every committed export package names its project's committed semantic ID. Honesty runs it before its recipes, so a stale ready pull request fails before the macOS and Linux fan-out starts. It replaces no check of the gate. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/ci.yml | 5 + CHANGELOG.md | 4 + SPEC.md | 2 +- crates/conformance/src/cases/repository.rs | 9 + crates/conformance/src/freshness.rs | 318 +++++++++++++++++++++ crates/conformance/src/lib.rs | 1 + xtask/Cargo.toml | 2 +- xtask/src/main.rs | 15 + 8 files changed, 354 insertions(+), 2 deletions(-) create mode 100644 crates/conformance/src/freshness.rs diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 812c99c315..6c1833fbd3 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -151,6 +151,11 @@ jobs: env: PYTHONDONTWRITEBYTECODE: "1" run: python3 -m unittest discover -s .github/scripts -p 'test_intel_host_tests.py' + # Stale generated files fail here in minutes, before the expensive + # roots: every input a committed build oracle records, every lock, and + # every committed export package must be current (§9.4). No Lean. + - name: Check that the committed generated files are current + run: cargo xtask check-freshness - name: Run the honesty part of the acceptance gate shell: bash run: | diff --git a/CHANGELOG.md b/CHANGELOG.md index 17a425bd30..f9347aa72f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,6 +17,10 @@ workspace carried at those versions without a tag. ## Unreleased +- `cargo xtask check-freshness` (SPEC.md §9.4), run in the honesty job before the expensive roots: + every input a committed build oracle records still hashes to its recorded digest, every lock + passes `lexlean lock --check`, and every committed export package names this compiler's + semantics and its project's committed semantic ID. Stale generated files fail in minutes. - `rustix` 1.1.6 (RUSTSEC-2026-0486: the extended-attribute functions marked unwritten bytes as initialized for a zero-length buffer), so `cargo deny` passes; `errno` and `tempfile` resolve `windows-sys` 0.59, the version `fs4` 0.13 and `rustix` 1.1.6 both accept. diff --git a/SPEC.md b/SPEC.md index 6e1c370fbe..791ed065cc 100644 --- a/SPEC.md +++ b/SPEC.md @@ -703,7 +703,7 @@ Every normative gate job runs on the standard GitHub-hosted runner, `ubuntu-24.0 The Intel host factory is separate from the normative BDD and Atlas partitions above: it transfers only the same-run host test construction and dependency data of §8.3. Construction requires successful honesty; consumers require construction; the aggregate requires all of them and cannot skip an incomplete result. The factory's behavioral tests run in the initial honesty job, before the expensive roots, and exercise inventory completeness, custody and fail-closed result joins without needing an Intel runner. These tests do not substitute for execution of the complete workload on Intel macOS. -`ci.yml` MUST expose the initial `honesty` job (retaining the previous check context) separately so claim drift is distinguishable from code failure. It runs the existing format, model and specification-link recipes and the complete BDD meta-gate target, without Lean. The remaining rows, supported hosts and Atlas prefix MUST require its success; these recipes and meta tests run once in the normative gate. Both the plan's previous-run evidence and release evidence MUST require the honesty row, including its successful conclusion; missing, failed or skipped honesty never establishes full acceptance. The separate `honesty.yml` workflow is subsumed by this same-run job. +`ci.yml` MUST expose the initial `honesty` job (retaining the previous check context) separately so claim drift is distinguishable from code failure. It runs the existing format, model and specification-link recipes and the complete BDD meta-gate target, without Lean. Before them it runs `cargo xtask check-freshness`, also without Lean: every input a committed build oracle (`expected/build/manifest.json`) records still has its recorded digest and length, every such project's lock passes `lexlean lock --check`, every oracle and every committed package under `tests/production-export/` names this compiler's semantics, and every such package names its project's committed semantic ID. A tree committed without regenerating what its change moves fails there in minutes, before the expensive roots; the check adds a precondition and replaces no check of the gate, which still compares every generated byte. The remaining rows, supported hosts and Atlas prefix MUST require its success; these recipes and meta tests run once in the normative gate. Both the plan's previous-run evidence and release evidence MUST require the honesty row, including its successful conclusion; missing, failed or skipped honesty never establishes full acceptance. The separate `honesty.yml` workflow is subsumed by this same-run job. `reproducibility.yml` MUST perform two builds in distinct absolute directories and compare every platform-independent artifact byte-for-byte after path normalization. diff --git a/crates/conformance/src/cases/repository.rs b/crates/conformance/src/cases/repository.rs index 09a8125bb8..ee821a6a0d 100644 --- a/crates/conformance/src/cases/repository.rs +++ b/crates/conformance/src/cases/repository.rs @@ -2244,6 +2244,15 @@ pub(crate) fn run(id: &str) { ); // The honesty and reproducibility workflows stay separate. let honesty = job("honesty"); + // §9.4: stale generated files fail in honesty, before the gate + // command and every expensive root. + let fresh = honesty + .find(" run: cargo xtask check-freshness\n") + .expect("§9.4: honesty checks that the committed generated files are current"); + assert!( + fresh < honesty.find("just --timestamp").expect("the gate command"), + "§9.4: the freshness check runs before the honesty recipes" + ); assert!( honesty.contains("LEXLEAN_BDD_PART: ${{ matrix.bdd_part }}") && honesty.contains("fromJSON(needs.plan.outputs.honesty)") diff --git a/crates/conformance/src/freshness.rs b/crates/conformance/src/freshness.rs new file mode 100644 index 0000000000..828e6e4f5f --- /dev/null +++ b/crates/conformance/src/freshness.rs @@ -0,0 +1,318 @@ +//! Whether the committed generated files are current (SPEC.md §9.4), checked +//! by `cargo xtask check-freshness` in the initial honesty job, without Lean +//! and in seconds. A change to a source, a project file, a lock, or the +//! compiler that was committed without regenerating what depends on it fails +//! here, before the expensive roots of the gate start, instead of hours into +//! them. It adds a precondition to the gate and replaces none of its checks: +//! `golden`, `examples`, and the bootstrap and production-export cases still +//! compare every generated byte. +//! +//! What it reads: each committed build oracle `expected/build/manifest.json` +//! records the digest and length of every input its build read and the +//! compiler semantics that built it; each committed package of +//! `tests/production-export/` records, in `provenance.json`, the compiler +//! semantics and the semantic ID of the build it was exported from; each +//! project's `lexlean.lock` is what `lexlean lock --check` accepts. + +use std::collections::BTreeMap; + +use camino::{Utf8Path, Utf8PathBuf}; +use lexlean::{Engine, LockRequest}; +use serde_json::Value; +use sha2::{Digest, Sha256}; + +/// The projects of `tests/production-export/`, each with its directory. +pub const EXPORTED: [(&str, &str); 5] = [ + ("bootstrap", "bootstrap"), + ("helpdesk", "examples/helpdesk"), + ("production", "examples/production"), + ("production-coverage", "examples/production-coverage"), + ("stdlib", "stdlib"), +]; + +/// What the check read. +#[derive(Debug, Default, Clone, PartialEq, Eq)] +pub struct Summary { + /// Projects with a committed build oracle. + pub projects: usize, + /// Recorded inputs hashed. + pub inputs: usize, + /// Committed export packages read. + pub packages: usize, +} + +fn sha256_hex(bytes: &[u8]) -> String { + Sha256::digest(bytes) + .iter() + .map(|byte| format!("{byte:02x}")) + .collect() +} + +fn read_json(path: &Utf8Path) -> Result { + let bytes = std::fs::read(path.as_std_path()).map_err(|error| format!("{path}: {error}"))?; + serde_json::from_slice(&bytes).map_err(|error| format!("{path}: {error}")) +} + +/// Every project directory under `root` with a committed build oracle. +#[must_use] +pub fn oracle_projects(root: &Utf8Path) -> Vec { + let mut found = Vec::new(); + for parent in [root.to_owned(), root.join("examples")] { + let Ok(entries) = std::fs::read_dir(parent.as_std_path()) else { + continue; + }; + for entry in entries.flatten() { + let Ok(path) = Utf8PathBuf::from_path_buf(entry.path()) else { + continue; + }; + if path.join("expected/build/manifest.json").is_file() { + found.push(path); + } + } + } + found.sort(); + found +} + +/// The source packages a project names, by package, as directories. +fn source_packages( + root: &Utf8Path, + project: &Utf8Path, +) -> Result, String> { + let file = project.join("lexlean.toml"); + let text = + std::fs::read_to_string(file.as_std_path()).map_err(|error| format!("{file}: {error}"))?; + let config: toml::Value = toml::from_str(&text).map_err(|error| format!("{file}: {error}"))?; + let mut packages = BTreeMap::new(); + for row in config + .get("source_package") + .and_then(toml::Value::as_array) + .into_iter() + .flatten() + { + if let (Some(name), Some(path)) = ( + row.get("package").and_then(toml::Value::as_str), + row.get("path").and_then(toml::Value::as_str), + ) { + packages.insert(name.to_owned(), root.join(path)); + } + } + Ok(packages) +} + +/// Whether one project's committed build oracle and lock are current. Returns +/// the oracle's semantic ID and the number of inputs hashed. +/// +/// # Errors +/// +/// Every stale or unreadable input, one per line. +pub fn check_project(root: &Utf8Path, project: &Utf8Path) -> Result<(String, usize), String> { + let mut unmet = Vec::new(); + let manifest = read_json(&project.join("expected/build/manifest.json"))?; + let name = project.strip_prefix(root).unwrap_or(project); + let language = manifest["language"].as_str().unwrap_or_default(); + let compiler = lexlean::compiler_semantics_id_for(language).to_hex(); + if manifest["compiler"]["semantics_id"].as_str() != Some(compiler.as_str()) { + unmet.push(format!( + "{name}: expected/build was built by compiler semantics {}, this compiler is {compiler}", + manifest["compiler"]["semantics_id"] + )); + } + let packages = source_packages(root, project)?; + let mut hashed = 0; + for input in manifest["inputs"].as_array().into_iter().flatten() { + let path = input["path"].as_str().unwrap_or_default(); + if input["kind"] == "lexicon" { + // A lexicon's digest is its package tree's: the lock records a + // local package's (`lock --check` below), and the compiler's + // semantics ID, compared above, covers an embedded one. + continue; + } + let file = match path.split_once(':') { + Some((package, relative)) => match packages.get(package) { + Some(directory) => directory.join(relative), + None => { + unmet.push(format!( + "{name}: input `{path}` names no source package of lexlean.toml" + )); + continue; + } + }, + None => project.join(path), + }; + hashed += 1; + match std::fs::read(file.as_std_path()) { + Ok(bytes) => { + if input["sha256"].as_str() != Some(sha256_hex(&bytes).as_str()) + || input["byte_length"].as_u64() != Some(bytes.len() as u64) + { + unmet.push(format!( + "{name}: `{path}` changed since expected/build was generated" + )); + } + } + Err(error) => unmet.push(format!("{name}: `{path}`: {error}")), + } + } + let lock = Engine::load(&project.join("lexlean.toml")).and_then(|engine| { + engine.lock(LockRequest { + check_only: true, + allow_network: false, + }) + }); + if let Err(error) = lock { + unmet.push(format!( + "{name}: `lexlean lock --check` fails: {:?}", + error + .diagnostics + .iter() + .map(|diagnostic| diagnostic.message.clone()) + .collect::>() + )); + } + if unmet.is_empty() { + Ok(( + manifest["semantic_id"] + .as_str() + .unwrap_or_default() + .to_owned(), + hashed, + )) + } else { + Err(unmet.join("\n")) + } +} + +/// Whether every committed generated file under `root` is current. +/// +/// # Errors +/// +/// Every stale file, one per line, with the regeneration that renews it. +pub fn check(root: &Utf8Path) -> Result { + let mut unmet = Vec::new(); + let mut summary = Summary::default(); + let mut semantic = BTreeMap::new(); + for project in oracle_projects(root) { + summary.projects += 1; + match check_project(root, &project) { + Ok((id, hashed)) => { + summary.inputs += hashed; + semantic.insert(project, id); + } + Err(reason) => unmet.push(reason), + } + } + let compiler = lexlean::compiler_semantics_id_for(lexlean::LANGUAGE_1_2).to_hex(); + for (exported, directory) in EXPORTED { + let packages = root + .join("tests/production-export") + .join(exported) + .join("packages"); + let expected = semantic.get(&root.join(directory)); + for entry in walkdir::WalkDir::new(packages.as_std_path()) + .into_iter() + .flatten() + { + if entry.file_name() != "provenance.json" { + continue; + } + let Ok(path) = Utf8PathBuf::from_path_buf(entry.into_path()) else { + continue; + }; + summary.packages += 1; + let relative = path.strip_prefix(root).unwrap_or(&path).to_owned(); + let provenance = match read_json(&path) { + Ok(value) => value, + Err(reason) => { + unmet.push(reason); + continue; + } + }; + if provenance["compiler_semantics"].as_str() != Some(compiler.as_str()) { + unmet.push(format!( + "{relative}: exported by compiler semantics {}, this compiler is {compiler}", + provenance["compiler_semantics"] + )); + } + let sources: Vec<&str> = provenance["sources"] + .as_array() + .into_iter() + .flatten() + .filter_map(Value::as_str) + .collect(); + if expected.is_none_or(|id| sources != [id.as_str()]) { + unmet.push(format!( + "{relative}: exported from {sources:?}, {directory}/expected/build is {}", + expected.map_or("missing", String::as_str) + )); + } + } + } + if unmet.is_empty() { + Ok(summary) + } else { + unmet.sort(); + Err(format!( + "{} committed generated file(s) are stale; regenerate them (`regenerate.yml`, or the `-write` recipes):\n{}", + unmet.len(), + unmet.join("\n") + )) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn copy(from: &Utf8Path, to: &Utf8Path) { + for entry in walkdir::WalkDir::new(from.as_std_path()) + .into_iter() + .flatten() + { + let relative = entry + .path() + .strip_prefix(from.as_std_path()) + .expect("below"); + if relative.starts_with(".lexlean") { + continue; + } + let target = to.as_std_path().join(relative); + if entry.file_type().is_dir() { + std::fs::create_dir_all(&target).expect("dir"); + } else if entry.file_type().is_file() { + std::fs::copy(entry.path(), &target).expect("copy"); + } + } + } + + #[test] + fn a_committed_oracle_is_current_and_a_changed_input_is_stale() { + let root = crate::support::repo_root(); + let temp = tempfile::tempdir().expect("tempdir"); + let copy_root = Utf8PathBuf::from_path_buf(temp.path().to_owned()).expect("utf8"); + let project = copy_root.join("examples/nat-add-zero"); + copy(&root.join("examples/nat-add-zero"), &project); + let (semantic, hashed) = + check_project(©_root, &project).expect("the committed oracle is current"); + assert!(!semantic.is_empty() && hashed >= 2, "{semantic} {hashed}"); + let source = walkdir::WalkDir::new(project.join("src").as_std_path()) + .into_iter() + .flatten() + .find(|entry| entry.path().extension().is_some_and(|ext| ext == "tex")) + .expect("a source") + .into_path(); + let mut text = std::fs::read_to_string(&source).expect("source"); + text.push('\n'); + std::fs::write(&source, text).expect("write"); + let stale = check_project(©_root, &project).expect_err("a changed source is stale"); + assert!( + stale.contains("changed since expected/build was generated"), + "{stale}" + ); + std::fs::remove_file(project.join("expected/build/manifest.json")).expect("remove"); + assert!( + check_project(©_root, &project).is_err(), + "a missing oracle fails" + ); + } +} diff --git a/crates/conformance/src/lib.rs b/crates/conformance/src/lib.rs index 3a974e2dcb..302d753f7c 100644 --- a/crates/conformance/src/lib.rs +++ b/crates/conformance/src/lib.rs @@ -16,6 +16,7 @@ pub mod certification_library; pub mod differential; pub mod evidence; pub mod fixtures; +pub mod freshness; pub mod gnaf; pub mod inventory; pub mod lcnf_adapter; diff --git a/xtask/Cargo.toml b/xtask/Cargo.toml index f6090f3784..52f7929b01 100644 --- a/xtask/Cargo.toml +++ b/xtask/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "xtask" -description = "Repository gates: validate-model, validate-spec-links, verify-examples, check-golden, check-reproducibility, check-fixtures, check-calculus, check-production-export, check-package, check-test-inventory, bdd, ci-summary, ci-hints, ci-shards, release-artifacts, release-check, validate." +description = "Repository gates: validate-model, validate-spec-links, verify-examples, check-golden, check-reproducibility, check-fixtures, check-calculus, check-production-export, check-freshness, check-package, check-test-inventory, bdd, ci-summary, ci-hints, ci-shards, release-artifacts, release-check, validate." version.workspace = true edition.workspace = true rust-version.workspace = true diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 9887022ba5..982df70867 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -35,6 +35,7 @@ fn main() -> ExitCode { "check-fixtures" => check_fixtures(&root, write), "check-calculus" => check_calculus(&root, write), "check-production-export" => check_production_export(write), + "check-freshness" => check_freshness(&root), "check-package" => check_package(&root), "check-test-inventory" => ci::check_test_inventory(&root), "bdd" => ci::bdd(&root), @@ -60,6 +61,8 @@ fn main() -> ExitCode { their generator\n\ check-production-export §24.7: the consumer's exported packages equal the committed\n\ packages under tests/production-export\n\ + check-freshness §9.4: every committed build oracle's recorded inputs, every lock, + and every committed export package are current (no Lean) check-package §30.3, RP-12: package lexlean crate, verify offline build & identity\n\ check-test-inventory RP-13: the `test` and `bdd` recipes partition the workspace tests,\n\ and the parts of .github/bdd-parts.json partition `bdd`\n\ @@ -124,6 +127,18 @@ fn check_production_export(write: bool) -> Result<(), Fail> { Ok(()) } +/// §9.4: the committed generated files are current, checked in honesty +/// before the expensive roots (`repo_conformance::freshness`). +fn check_freshness(root: &Path) -> Result<(), Fail> { + let root = camino::Utf8Path::from_path(root).ok_or("the repository path is UTF-8")?; + let summary = repo_conformance::freshness::check(root)?; + println!( + "check-freshness: {} build oracles ({} recorded inputs), their locks, and {} committed export packages are current (§9.4)", + summary.projects, summary.inputs, summary.packages + ); + Ok(()) +} + fn example_dirs(root: &Path) -> Result, Fail> { let mut dirs = Vec::new(); for entry in std::fs::read_dir(root.join("examples"))? { From d59533cdf50986a7282ae7dc9a061973ccb430f1 Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Thu, 12 Nov 2026 01:05:23 +0000 Subject: [PATCH 9/9] ci: drop the five duplicate keys of .github/bdd-parts.json bootstrap-runtime, preservation-lists, preservation-runtime, preservation-support and preservation-prims each appeared twice with identical values; a JSON parse merged them silently. The parsed plan is unchanged. Co-Authored-By: Claude Opus 5.5 --- .github/bdd-parts.json | 15 --------------- 1 file changed, 15 deletions(-) diff --git a/.github/bdd-parts.json b/.github/bdd-parts.json index c601ddd607..755a14e7a6 100644 --- a/.github/bdd-parts.json +++ b/.github/bdd-parts.json @@ -243,21 +243,6 @@ "VR-22", "VR-23" ], - "preservation-lists": [ - "SP-15" - ], - "preservation-runtime": [ - "SP-22" - ], - "preservation-support": [ - "SP-25" - ], - "bootstrap-runtime": [ - "BS-09" - ], - "preservation-prims": [ - "SP-28" - ], "preservation-std": [ "SP-29", "SP-32",