Kyeongmin/C.E.L_Slide_test2
1
0
Fork 0
Code Issues 6 Pull Requests Actions Packages Projects Releases Wiki Activity

feat(#89): IMP-89 89-a u1~u5 Layer A render path activation (B4→mapper source-of-truth switch, default-OFF flag)

Browse Source 
PHASE_Z_B4_MAPPER_SOURCE env flag (default OFF) switches slot_payload
source-of-truth from legacy mapper-only / V4 rank-1 to B4 PlacementPlan
.selected_template_id at the single switch site in the runtime loop.
OFF preserves final.html SHA byte-equivalence (u4 parity guard, mdx 01-05).
ON requires Layer A render-active path; BLOCKED exits on B4 no-cover
and on B4-selected FitError (IMP-87 honesty gate pattern — NO silent
fallback). Distinct from PHASE_Z_B4_GATEKEEPER (mismatch render-skip).

Units (1 commit = 1 axis per Stage 1 scope_lock):
  u1 — _b4_mapper_source_enabled() flag reader (default OFF)
  u2 — _select_mapper_template_id() selector wired at the switch site
  u3 — _b4_mapper_source_blocked_exit() for b4_no_cover / b4_selected_fit_error
  u4 — render SHA parity regression (tests/regression/ baseline mdx 01-05)
  u5 — slot_payload byte-equivalence (matches_mapper=True axis, mdx 01-05)

Targeted 89-a suite 63 PASS; Phase Z regression 323 PASS; IMP-87 mirror
20 PASS. Demo activation via .env only (no vite.config hardcoding).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
이경민
2026-05-24 00:33:28 +09:00
parent 896f273ffa
commit b1bbe27c38
9 changed files with 1434 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
tests/regression/__init__.py Normal file
View File

56
tests/regression/fixtures/89a_pre_baseline_sha.json Normal file
View File

@@ -0,0 +1,56 @@
{
"schema_version": 2,
"axis": "IMP-89 89-a u4 — final.html SHA baseline captured via FULL run_phase_z2_mvp1 pipeline (flag OFF / default)",
"description": "Frozen SHA-256 of `final.html` bytes (the artifact written to disk at src/phase_z2_pipeline.py:5994-5996) captured by running the full Phase Z pipeline end-to-end for each mdx 01-05 under PHASE_Z_B4_MAPPER_SOURCE=OFF. Under flag OFF the 89-a selector `_select_mapper_template_id(plan, T)` returns `T` verbatim, so the mapper input is byte-identical to the pre-89-a legacy call shape `map_mdx_to_slots(section, unit.frame_template_id)` — the rendered HTML and therefore the final.html SHA match the pre-89-a baseline. The u4 regression test runs the same pipeline shape under flag OFF and asserts SHA equality. Regenerate only when an upstream mapper/render/template delta is deliberately reviewed and accepted.",
"captured_at_utc": "2026-05-23T15:03:40Z",
"renderer": {
"entrypoint": "src.phase_z2_pipeline.run_phase_z2_mvp1",
"write_site": "src/phase_z2_pipeline.py:5994-5996",
"artifact_relpath": "<RUNS_DIR>/<run_id>/phase_z2/final.html"
},
"mdx_batch": [
"01.mdx",
"02.mdx",
"03.mdx",
"04.mdx",
"05.mdx"
],
"mdx_files": {
"01.mdx": {
"mdx_file": "01.mdx",
"run_id": "89a_baseline_01",
"final_html_size_bytes": 29089,
"sha256": "ad6f16a3068b5a55bd900122688f691ffef0716b91de52151551242773595487",
"pipeline_exit_code": null
},
"02.mdx": {
"mdx_file": "02.mdx",
"run_id": "89a_baseline_02",
"final_html_size_bytes": 25249,
"sha256": "4832e3e45660eb95201425e975a4c285fb78493cf8d09d6395897f7897b1794b",
"pipeline_exit_code": null
},
"03.mdx": {
"mdx_file": "03.mdx",
"run_id": "89a_baseline_03",
"final_html_size_bytes": 39804,
"sha256": "7dae47b3d51aa15a6752e4543a746abb4c4da71e7e95895eee8ef08c2eabc948",
"pipeline_exit_code": null
},
"04.mdx": {
"mdx_file": "04.mdx",
"run_id": "89a_baseline_04",
"final_html_size_bytes": 27707,
"sha256": "2bce45041cdcca6518cd92586c1be9e051a5c98f5a0ad61fdde02604618a1d80",
"pipeline_exit_code": null
},
"05.mdx": {
"mdx_file": "05.mdx",
"run_id": "89a_baseline_05",
"final_html_size_bytes": 21187,
"sha256": "3ded2fff8cc45301675d2a8917af945b4003631688cad6f088976fd57ab9b12c",
"pipeline_exit_code": 1
}
},
"total_files": 5
}

168
tests/regression/scripts/capture_89a_pre_baseline.py Normal file
View File

@@ -0,0 +1,168 @@
"""IMP-89 89-a u4 — capture final.html SHA baseline via the FULL Phase Z pipeline.
Runs ``src.phase_z2_pipeline.run_phase_z2_mvp1`` end-to-end for every mdx file
in ``samples/mdx_batch/`` (01-05) under PHASE_Z_B4_MAPPER_SOURCE=OFF (default).
Each run writes a real ``final.html`` to disk at
``<RUNS_DIR>/<run_id>/phase_z2/final.html`` — exactly the production write
site at ``src/phase_z2_pipeline.py:5994-5996``. The bytes of that on-disk
artifact are SHA-256 hashed and stored in
``tests/regression/fixtures/89a_pre_baseline_sha.json``.
The u4 regression test in ``tests/regression/test_b4_mapper_source_sha_parity.py``
runs the same pipeline shape under flag OFF, reads the on-disk ``final.html``,
hashes its bytes, and asserts SHA equality with each frozen value. The
mathematical chain that makes this a genuine "pre-89-a baseline" guard:
* Under flag OFF, ``_select_mapper_template_id(plan, T) == T`` for every
``(plan, T)`` pair (locked by u2 + u4 algebraic precondition tests).
* Therefore the mapper input is byte-identical to the legacy pre-89-a call
shape ``map_mdx_to_slots(section, unit.frame_template_id)``.
* Therefore the rendered HTML is byte-identical to pre-89-a output.
* Therefore the on-disk ``final.html`` is byte-identical → SHA matches.
Any future drift — in the selector, mapper, render_slide, slide_base.html,
or any upstream code path — produces a divergent SHA and breaks the test.
Run from repo root::
python tests/regression/scripts/capture_89a_pre_baseline.py
The capture script is idempotent and meant to be re-run only when an
upstream mapper/render/template delta is reviewed and accepted. It refuses
to run with PHASE_Z_B4_MAPPER_SOURCE enabled (the post-89-a flag-ON state
is NOT the baseline axis).
"""
from __future__ import annotations
import hashlib
import json
import os
import sys
import tempfile
from datetime import datetime, timezone
from pathlib import Path
_REPO_ROOT = Path(__file__).resolve().parents[3]
sys.path.insert(0, str(_REPO_ROOT))
sys.path.insert(0, str(_REPO_ROOT / "src"))
import src.phase_z2_pipeline as pz2 # noqa: E402
_SAMPLES_DIR = _REPO_ROOT / "samples" / "mdx_batch"
_MDX_BATCH = ("01.mdx", "02.mdx", "03.mdx", "04.mdx", "05.mdx")
_OUT_PATH = (
_REPO_ROOT / "tests" / "regression" / "fixtures" / "89a_pre_baseline_sha.json"
)
def _capture_one(mdx_file: str, runs_root: Path) -> dict:
"""Run the full pipeline once and hash the on-disk final.html.
``pz2.RUNS_DIR`` MUST be pinned to ``runs_root`` by the caller before
invocation; ``run_phase_z2_mvp1`` writes final.html to
``<pz2.RUNS_DIR>/<run_id>/phase_z2/final.html``.
``SystemExit`` from the pipeline (e.g. IMP-87 EMPTY_SHELL_NO_CONTENT
BLOCKED exit on mdx 05) is caught: the BLOCKED exit fires AFTER the
final.html write at ``src/phase_z2_pipeline.py:5994-5996``, so the
artifact still exists on disk and the SHA is captured. The exit code
is recorded on the entry so the test can assert the same terminal
state under flag OFF. If final.html is missing post-exit, that is a
genuine pipeline failure and the script aborts.
"""
mdx_path = _SAMPLES_DIR / mdx_file
assert mdx_path.exists(), f"sample missing: {mdx_path}"
run_id = f"89a_baseline_{mdx_path.stem}"
pipeline_exit_code: int | None = None
try:
pz2.run_phase_z2_mvp1(mdx_path, run_id=run_id)
except SystemExit as exc:
pipeline_exit_code = (
int(exc.code) if isinstance(exc.code, int) else 1
)
final_html_path = runs_root / run_id / "phase_z2" / "final.html"
assert final_html_path.exists(), (
f"final.html not written by pipeline: {final_html_path} "
f"(pipeline_exit_code={pipeline_exit_code})"
)
raw_bytes = final_html_path.read_bytes()
assert len(raw_bytes) > 0, f"final.html is empty: {final_html_path}"
return {
"mdx_file": mdx_file,
"run_id": run_id,
"final_html_size_bytes": len(raw_bytes),
"sha256": hashlib.sha256(raw_bytes).hexdigest(),
"pipeline_exit_code": pipeline_exit_code,
}
def capture() -> dict:
assert os.environ.get("PHASE_Z_B4_MAPPER_SOURCE", "") == "", (
"PHASE_Z_B4_MAPPER_SOURCE must be unset when capturing baseline "
"(default-OFF state is the production-equivalent axis for u4). "
"Refusing to run with the flag enabled."
)
_OUT_PATH.parent.mkdir(parents=True, exist_ok=True)
with tempfile.TemporaryDirectory(prefix="89a_baseline_") as tmp:
runs_root = Path(tmp)
original_runs_dir = pz2.RUNS_DIR
pz2.RUNS_DIR = runs_root
try:
entries = [_capture_one(mf, runs_root) for mf in _MDX_BATCH]
finally:
pz2.RUNS_DIR = original_runs_dir
return {
"schema_version": 2,
"axis": (
"IMP-89 89-a u4 — final.html SHA baseline captured via FULL "
"run_phase_z2_mvp1 pipeline (flag OFF / default)"
),
"description": (
"Frozen SHA-256 of `final.html` bytes (the artifact written to "
"disk at src/phase_z2_pipeline.py:5994-5996) captured by running "
"the full Phase Z pipeline end-to-end for each mdx 01-05 under "
"PHASE_Z_B4_MAPPER_SOURCE=OFF. Under flag OFF the 89-a selector "
"`_select_mapper_template_id(plan, T)` returns `T` verbatim, so "
"the mapper input is byte-identical to the pre-89-a legacy call "
"shape `map_mdx_to_slots(section, unit.frame_template_id)` — "
"the rendered HTML and therefore the final.html SHA match the "
"pre-89-a baseline. The u4 regression test runs the same "
"pipeline shape under flag OFF and asserts SHA equality. "
"Regenerate only when an upstream mapper/render/template delta "
"is deliberately reviewed and accepted."
),
"captured_at_utc": (
datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
),
"renderer": {
"entrypoint": "src.phase_z2_pipeline.run_phase_z2_mvp1",
"write_site": "src/phase_z2_pipeline.py:5994-5996",
"artifact_relpath": "<RUNS_DIR>/<run_id>/phase_z2/final.html",
},
"mdx_batch": list(_MDX_BATCH),
"mdx_files": {entry["mdx_file"]: entry for entry in entries},
"total_files": len(entries),
}
def main() -> None:
data = capture()
_OUT_PATH.write_text(
json.dumps(data, indent=2, ensure_ascii=False) + "\n",
encoding="utf-8",
)
print(
f"wrote {_OUT_PATH} ({data['total_files']} files: "
f"{', '.join(data['mdx_files'].keys())})"
)
if __name__ == "__main__":
main()

347
tests/regression/test_b4_mapper_source_sha_parity.py Normal file
View File

@@ -0,0 +1,347 @@
"""IMP-89 89-a u4 — final.html SHA parity guard for mdx 01-05 under flag OFF.
Stage 2 u4 contract (verbatim)::
mdx 01-05 final.html SHA == pre-89-a baseline under
PHASE_Z_B4_MAPPER_SOURCE=OFF (default)
How this guard is wired
=======================
The baseline is captured ONCE by
``tests/regression/scripts/capture_89a_pre_baseline.py``, which runs the
FULL Phase Z pipeline (``src.phase_z2_pipeline.run_phase_z2_mvp1``) for
every mdx file in ``samples/mdx_batch/`` (01-05) under flag OFF, reads
the on-disk ``final.html`` artifact from
``<RUNS_DIR>/<run_id>/phase_z2/final.html``
(the production write site at ``src/phase_z2_pipeline.py:5994-5996``),
and SHA-256 hashes its bytes. The hash is frozen at::
tests/regression/fixtures/89a_pre_baseline_sha.json
This test re-runs the SAME pipeline shape (full ``run_phase_z2_mvp1``,
flag OFF, isolated tmp RUNS_DIR), reads the live on-disk ``final.html``,
hashes its bytes, and asserts SHA equality with the frozen value.
Why this is a genuine "pre-89-a baseline" guard
================================================
Under flag OFF the 89-a switch at ``src/phase_z2_pipeline.py:4771-4773``
calls ``_select_mapper_template_id(plan, unit.frame_template_id)``, which
returns ``unit.frame_template_id`` verbatim (locked by u2 unit tests +
``test_flag_off_selector_returns_legacy_input_per_section`` below). The
mapper input is therefore byte-identical to the pre-89-a call shape
``map_mdx_to_slots(section, unit.frame_template_id)`` (no selector
indirection), so:
* mapper output (slot_payload) is byte-identical
* render_slide output is byte-identical
* on-disk ``final.html`` is byte-identical
* SHA-256 matches the frozen baseline
Any future drift in ``_select_mapper_template_id``, ``map_mdx_to_slots``,
``render_slide``, ``slide_base.html``, family partials, or any upstream
pipeline step produces a divergent SHA and breaks this test.
Crucially the baseline is NOT recomputed in this process — it is read
from the on-disk JSON fixture. This makes the test a genuine regression
guard rather than a paired identity check.
"""
from __future__ import annotations
import hashlib
import json
import os
from pathlib import Path
import pytest
import src.phase_z2_pipeline as pz2
from src.phase_z2_pipeline import (
_b4_mapper_source_enabled,
_select_mapper_template_id,
extract_content_objects,
load_frame_contracts,
parse_mdx,
)
from src.phase_z2_placement_planner import plan_placement
FLAG = "PHASE_Z_B4_MAPPER_SOURCE"
_REPO_ROOT = Path(__file__).resolve().parents[2]
_SAMPLES_DIR = _REPO_ROOT / "samples" / "mdx_batch"
_MDX_BATCH = ("01.mdx", "02.mdx", "03.mdx", "04.mdx", "05.mdx")
_BASELINE_PATH = (
Path(__file__).parent / "fixtures" / "89a_pre_baseline_sha.json"
)
@pytest.fixture(scope="module")
def baseline() -> dict:
"""Load the frozen final.html SHA baseline from disk.
A missing file is a hard failure with a one-shot regen hint — the
baseline cannot be silently regenerated inside the test process
(that would defeat the regression-guard purpose).
"""
assert _BASELINE_PATH.exists(), (
f"baseline fixture missing: {_BASELINE_PATH}\n"
f"regenerate with: python tests/regression/scripts/"
f"capture_89a_pre_baseline.py"
)
with _BASELINE_PATH.open("r", encoding="utf-8") as f:
data = json.load(f)
assert data.get("schema_version") == 2, (
f"unexpected baseline schema_version: {data.get('schema_version')} "
f"(expected 2 — full-pipeline final.html SHA capture). Regenerate "
f"the fixture via capture_89a_pre_baseline.py."
)
assert data.get("total_files", 0) >= len(_MDX_BATCH), (
f"baseline has {data.get('total_files')} files — expected "
f">= {len(_MDX_BATCH)} (one per mdx 01-05)"
)
return data
def _live_pipeline_final_html_sha(
mdx_file: str, runs_root: Path
) -> tuple[str, int, int | None]:
"""Run the full pipeline once under flag OFF and SHA the on-disk final.html.
``pz2.RUNS_DIR`` MUST be pinned to ``runs_root`` by the caller (via
monkeypatch); ``run_phase_z2_mvp1`` writes final.html to
``<pz2.RUNS_DIR>/<run_id>/phase_z2/final.html``.
``SystemExit`` is caught (mirrors the capture script): the IMP-87
EMPTY_SHELL_NO_CONTENT BLOCKED exit on mdx 05 (and any analogous
terminal state) fires AFTER the final.html write site at
``src/phase_z2_pipeline.py:5994-5996``, so the artifact still exists
on disk and the SHA is the load-bearing parity axis. The exit code
is returned so the per-file test can assert the same terminal state
under flag OFF (any drift in exit semantics is a separate u3 axis
but surfaces here too).
Returns ``(sha256_hex, size_bytes, pipeline_exit_code)``.
"""
mdx_path = _SAMPLES_DIR / mdx_file
assert mdx_path.exists(), f"sample missing: {mdx_path}"
run_id = f"89a_live_{mdx_path.stem}"
pipeline_exit_code: int | None = None
try:
pz2.run_phase_z2_mvp1(mdx_path, run_id=run_id)
except SystemExit as exc:
pipeline_exit_code = (
int(exc.code) if isinstance(exc.code, int) else 1
)
final_html_path = runs_root / run_id / "phase_z2" / "final.html"
assert final_html_path.exists(), (
f"final.html not written by pipeline: {final_html_path} "
f"(pipeline_exit_code={pipeline_exit_code})"
)
raw_bytes = final_html_path.read_bytes()
return (
hashlib.sha256(raw_bytes).hexdigest(),
len(raw_bytes),
pipeline_exit_code,
)
@pytest.mark.integration
@pytest.mark.parametrize("mdx_file", _MDX_BATCH)
def test_post_89a_flag_off_final_html_sha_matches_frozen_baseline(
monkeypatch: pytest.MonkeyPatch,
tmp_path: Path,
mdx_file: str,
baseline: dict,
) -> None:
"""Per-mdx-file final.html SHA parity guard via the FULL pipeline.
Runs ``run_phase_z2_mvp1`` end-to-end with ``PHASE_Z_B4_MAPPER_SOURCE``
unset, reads the on-disk ``final.html``, hashes its bytes, and asserts
SHA equality with the frozen baseline. Any drift in the selector,
mapper, render_slide, slide_base.html, family partials, or any
upstream step manifests here as a SHA mismatch.
"""
monkeypatch.delenv(FLAG, raising=False)
assert _b4_mapper_source_enabled() is False
runs_root = tmp_path / "runs"
runs_root.mkdir(parents=True, exist_ok=True)
monkeypatch.setattr(pz2, "RUNS_DIR", runs_root)
expected = baseline["mdx_files"][mdx_file]
expected_sha = expected["sha256"]
expected_size = expected["final_html_size_bytes"]
expected_exit = expected.get("pipeline_exit_code")
live_sha, live_size, live_exit = _live_pipeline_final_html_sha(
mdx_file, runs_root
)
assert live_sha == expected_sha, (
f"final.html SHA parity broken for {mdx_file}:\n"
f" frozen pre-89-a baseline : {expected_sha} ({expected_size} bytes)\n"
f" live post-89-a flag-OFF : {live_sha} ({live_size} bytes)\n"
f" -> upstream drift in selector / mapper / render_slide / "
f"slide_base.html / family partials / pipeline step. Re-capture "
f"the baseline ONLY if the delta is deliberate and reviewed."
)
assert live_exit == expected_exit, (
f"pipeline exit-code parity broken for {mdx_file}: "
f"baseline={expected_exit} live={live_exit} — SHA matches but "
f"the pipeline terminal state diverged (IMP-87 BLOCKED axis)."
)
@pytest.mark.integration
def test_post_89a_flag_off_final_html_sha_holistic_sweep(
monkeypatch: pytest.MonkeyPatch,
tmp_path: Path,
baseline: dict,
) -> None:
"""Single-pass holistic sweep across mdx 01-05.
Aggregates the per-file SHA parity into one sweep so an accidental
parametrize zero-iteration cannot silently pass. Asserts (a) env gate
stays False throughout, (b) every baseline file's live SHA matches the
frozen value, (c) sweep coverage equals the full _MDX_BATCH.
"""
monkeypatch.delenv(FLAG, raising=False)
assert _b4_mapper_source_enabled() is False
runs_root = tmp_path / "runs"
runs_root.mkdir(parents=True, exist_ok=True)
monkeypatch.setattr(pz2, "RUNS_DIR", runs_root)
matched = 0
for mdx_file in _MDX_BATCH:
expected = baseline["mdx_files"][mdx_file]
live_sha, live_size, _live_exit = _live_pipeline_final_html_sha(
mdx_file, runs_root
)
assert live_sha == expected["sha256"], (
f"sweep mismatch on {mdx_file}: baseline {expected['sha256']} "
f"≠ live {live_sha} (size baseline={expected['final_html_size_bytes']} "
f"live={live_size})"
)
matched += 1
assert matched == len(_MDX_BATCH), (
f"sweep covered only {matched}/{len(_MDX_BATCH)} mdx files — "
f"coverage too shallow to guard final.html SHA parity."
)
@pytest.mark.parametrize("mdx_file", _MDX_BATCH)
def test_flag_off_selector_returns_legacy_input_per_section(
monkeypatch: pytest.MonkeyPatch, mdx_file: str
) -> None:
"""Algebraic precondition: ``_select_mapper_template_id(plan, T) == T``
under flag OFF for every section parsed from each mdx 01-05 file.
This is the property that makes the full-pipeline SHA parity hold
mathematically. The on-disk SHA tests above are the load-bearing
proof; this localizes the failure axis when SHA parity breaks.
Pure Python, no pipeline execution — fast unit-level check.
"""
monkeypatch.delenv(FLAG, raising=False)
assert _b4_mapper_source_enabled() is False
mdx_path = _SAMPLES_DIR / mdx_file
_title, sections, _footer = parse_mdx(mdx_path)
frame_contracts = list(load_frame_contracts().values())
legacy_pick = "LEGACY_V4_RANK_1_SENTINEL"
for section in sections:
content_objects = extract_content_objects(section, source_shape=None)
plan = plan_placement(
content_objects=content_objects,
frame_contracts=frame_contracts,
section_id=section.section_id,
)
resolved = _select_mapper_template_id(plan, legacy_pick)
assert resolved == legacy_pick, (
f"flag-OFF selector contract broken in {mdx_file} section "
f"{section.section_id}: B4 picked "
f"'{plan.selected_template_id}' but selector returned "
f"'{resolved}' (expected '{legacy_pick}')"
)
@pytest.mark.parametrize("mdx_file", _MDX_BATCH)
def test_flag_off_holds_when_b4_mismatches_legacy(
monkeypatch: pytest.MonkeyPatch, mdx_file: str
) -> None:
"""Highest-risk divergence scenario: B4 picks a template DIFFERENT
from the legacy V4 rank-1 input. Under flag OFF the selector MUST
still return the legacy input — never the B4 pick. Catches the axis
that would otherwise be invisible in the matches_mapper case.
"""
monkeypatch.delenv(FLAG, raising=False)
mdx_path = _SAMPLES_DIR / mdx_file
_title, sections, _footer = parse_mdx(mdx_path)
frame_contracts = list(load_frame_contracts().values())
legacy_distinct = "__89A_U4_SENTINEL_LEGACY_DISTINCT_FROM_B4__"
for section in sections:
content_objects = extract_content_objects(section, source_shape=None)
plan = plan_placement(
content_objects=content_objects,
frame_contracts=frame_contracts,
section_id=section.section_id,
)
assert plan.selected_template_id != legacy_distinct
resolved = _select_mapper_template_id(plan, legacy_distinct)
assert resolved == legacy_distinct, (
f"flag-OFF selector must return legacy input even when B4 "
f"would pick differently ({mdx_file} {section.section_id}: "
f"b4_pick={plan.selected_template_id} resolved={resolved})"
)
def test_flag_off_default_state_locks_gate_to_false() -> None:
"""Pin the default-OFF contract at the gate level.
``_b4_mapper_source_enabled()`` returning False under default env is
the precondition for SHA parity: the u3 BLOCKED gates and the u2
switch are both gated on this returning True, so a False default
guarantees the legacy code path remains intact.
"""
assert os.environ.get(FLAG, "") == ""
assert _b4_mapper_source_enabled() is False
def test_baseline_fixture_is_load_bearing(baseline: dict) -> None:
"""Sanity-check the frozen baseline file shape so a corrupted /
half-written fixture does not silently pass the SHA tests with zero
iterations.
"""
assert baseline["axis"].startswith("IMP-89 89-a u4")
assert set(baseline["mdx_files"].keys()) == set(_MDX_BATCH), (
f"baseline mdx coverage drift: {baseline['mdx_files'].keys()} "
f"vs expected {_MDX_BATCH}"
)
for mdx_file, entry in baseline["mdx_files"].items():
assert "sha256" in entry, f"baseline {mdx_file} missing sha256 key"
assert "final_html_size_bytes" in entry, (
f"baseline {mdx_file} missing final_html_size_bytes key"
)
sha = entry["sha256"]
assert isinstance(sha, str) and len(sha) == 64, (
f"baseline {mdx_file} sha256 is not a 64-char hex string: {sha!r}"
)
size = entry["final_html_size_bytes"]
assert isinstance(size, int) and size > 0, (
f"baseline {mdx_file} final_html_size_bytes is not positive int: "
f"{size!r}"
)
assert baseline["renderer"]["entrypoint"] == (
"src.phase_z2_pipeline.run_phase_z2_mvp1"
), (
"baseline renderer.entrypoint must be the full pipeline entry — "
f"got {baseline['renderer'].get('entrypoint')!r}. The previous "
"synthetic render_slide shape produced a fragment, not final.html."
)