Add files using upload-large-folder tool

.gitattributes

@@ -1,35 +1,5 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+weights/**/*.png filter=lfs diff=lfs merge=lfs -text
+weights/**/*.jpg filter=lfs diff=lfs merge=lfs -text
+weights/**/*.webp filter=lfs diff=lfs merge=lfs -text
+weights/**/*.avif filter=lfs diff=lfs merge=lfs -text
+weights/**/*.jxl filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,26 @@
+# Python
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.ruff_cache/
+.venv/
+venv/
+.cache/
+.DS_Store
+*.log
+
+# Secrets and local state
+.env
+.env.*
+*.pem
+*.key
+
+# Scratch outputs only; archived results and weights remain tracked
+scratch/
+tmp/
+runs/
+outputs/
+
+# Local agent/project notes
+tasks/
+.hermes/

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PixelModel-v4 image codec study contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,284 @@
+---
+license: mit
+tags:
+  - research
+  - weight-compression
+  - image-codecs
+---
+
+# PixelModel-v4 Image Codec Experiments
+
+This repository is a research archive for measuring how image codecs affect a
+PixelModel-v4 weight image and the model reconstructed from it. It is not the
+main PixelModel-v4 model repository and is not a replacement model card.
+
+## Scope/Provenance
+
+The upstream model card and model assets are licensed under MIT by
+[bench-labs/PixelModel-v4](https://huggingface.co/bench-labs/PixelModel-v4). The
+upstream model revision used by the experiment is
+`80878fdd6e130d229c2581424a3456b47b979d4b`. The packaged experimental source was captured from robustness-study commit
+`939465cee88e49ae212df48aac18e74459763a72`.
+
+The archive records a fixed comparison: 100 prompts, 50 sampling steps, CFG 6,
+Apple MPS, and identical prompt, seed, initial latent, and settings across
+conditions. The archive is intended for auditability and re-running the
+experiment, not for making claims about codecs outside these recorded settings.
+The `samples/` tree contains one artifact for every successful generation row
+(800 artifacts in the full 17-condition run), while failed rows retain null
+sample provenance.
+
+## Motivation
+
+PixelModel-v4 stores trained weights as image data, which makes ordinary image
+storage and transport tools relevant to model serialization. Earlier work used
+PNG as the lossless weight container. This repository explores what happens when
+the same fp16 weight image is passed through modern lossless and lossy codecs,
+then reconstructed with several byte-level methods. This is exploratory research:
+the goal is to record the observed relationship between codec output,
+reconstructed weight values, and generation behavior without proposing a
+general-purpose compression result.
+
+## Experimental Setup
+
+- Model: PixelModel-v4 DiT with an fp16 weight image, using the upstream revision above.
+- Weight representation: each fp16 word is serialized across image bytes; the
+  high byte contains the sign, exponent, and upper mantissa bits.
+- Prompts: 100 prompts.
+- Sampling: 50 steps, CFG 6.
+- Controls: identical prompt, seed, initial latent, and inference settings.
+- Device: Apple MPS for the archived full run.
+- Raw reconstruction is accepted only when the decoded weight tensor is finite.
+  A NaN count by itself is not called “nonfinite”; the gate checks the complete
+  tensor and reports NaN, +Inf, and -Inf separately.
+- FID is N/A for this archive. CLIP and confidence intervals are not included
+  unless they are present in the archived CSV.
+
+## Codecs Evaluated
+
+| Codec | Fixed setting | Role |
+|---|---:|---|
+| PNG | lossless | baseline |
+| WebP | lossless | lossless control |
+| JPEG | Q100 | lossy codec |
+| JPEG | Q80 | lossy codec |
+| WebP | Q80 | lossy codec |
+| AVIF | Q70 | lossy codec |
+| JPEG XL | distance 1 (`d1`) | lossy codec |
+
+The protected representation keeps the high byte as PNG data and stores the low
+byte through the lossy codec. The code also records the raw and finite-repair
+paths separately.
+
+## Reconstruction Methods
+
+| Method | Description |
+|---|---|
+| Raw | Decode the codec payload directly into the weight image representation. |
+| Finite Repair Zero | Replace decoded NaN, +Inf, and -Inf values with zero while leaving finite values unchanged. |
+| Protected High Byte | Preserve the high byte losslessly and decode only the low byte through the lossy codec. |
+
+## Representative Results
+
+The following links are relative archive paths. A failed cell is rendered as an
+explicit “NO SAMPLE” panel; it is not replaced with a black image or an inferred
+metric.
+
+![Representative cross-codec comparison tables](images/visual_tables_contact_sheet.png)
+
+*Caption: representative prompt panels across PNG, WebP lossless, raw lossy,
+finite repair, and protected high-byte reconstructions.*
+
+![Representative JPEG Q100 comparison table](images/visual_table_jpeg_q100.png)
+
+*Caption: JPEG Q100 table showing raw, finite-repair, and protected cells for representative prompts.*
+
+![Representative JPEG Q80 comparison table](images/visual_table_jpeg_q80.png)
+
+*Caption: JPEG Q80 table. Raw and Finite Repair Zero cells have no generated sample; Protected High Byte cells show the archived outputs.*
+
+![Representative WebP Q80 comparison table](images/visual_table_webp_q80.png)
+
+*Caption: lossy WebP Q80 table with explicit failed cells and archived Protected High Byte outputs.*
+
+![Representative AVIF Q70 comparison table](images/visual_table_avif_q70.png)
+
+*Caption: AVIF Q70 table with the same prompts, seeds, and inference settings as the controls.*
+
+![Representative JPEG XL d1 comparison table](images/visual_table_jxl_d1.png)
+
+*Caption: JPEG XL distance 1 table. Failed conditions are marked `NO SAMPLE`; no replacement image is used.*
+
+## Results table from available CSV only
+
+The values below are transcribed from the archived CSV outputs for the full
+100-prompt run. They are counts and payload measurements, not estimates.
+
+| Condition | Raw generation | Finite Repair Zero | Protected High Byte | Raw NaN / +Inf / -Inf | Protected exponent mismatch | Reliable payload saving vs PNG |
+|---|---:|---:|---:|---:|---:|---:|
+| PNG | 100/100 | N/A | N/A | 0 / 0 / 0 | 0 | 0.0000% |
+| WebP lossless | 100/100 | N/A | N/A | 0 / 0 / 0 | 0 | 24.2799% |
+| JPEG Q100 | 0/100 | 100/100 | 100/100 | 1,257 / 0 / 0 | 0 | -6.8825% |
+| JPEG Q80 | 0/100 | 0/100 | 100/100 | 144,962 / 289 / 0 | 0 | 36.5568% |
+| WebP Q80 | 0/100 | 0/100 | 100/100 | 1,097,350 / 0 / 0 | 0 | 37.6701% |
+| AVIF Q70 | 0/100 | 0/100 | 100/100 | 445,041 / 59 / 0 | 0 | 39.2740% |
+| JPEG XL d1 | 0/100 | 0/100 | 100/100 | 59,017 / 13 / 0 | 0 | 37.2180% |
+
+The lossless WebP payload divided by the PNG payload is
+`0.7572009918694315`. The saving percentages use PNG baseline payload bytes as
+the denominator; Protected High Byte payloads include the high-byte PNG and the
+codec-specific low-byte payload. If an
+archive CSV is absent or differs, the CSV is authoritative and this table must
+not be treated as an additional measurement.
+
+## Main Observations
+
+- PNG and WebP lossless completed 100/100 generations.
+- All five lossy raw conditions completed 0/100 generations.
+- JPEG was not uniquely fragile in this matrix: every tested lossy Raw setting
+  introduced non-finite fp16 values and was blocked before generation.
+- Finite Repair Zero completed 100/100 only for JPEG Q100; the other four lossy
+  conditions recorded non-finite generation-stage failures.
+- Protected High Byte completed 100/100 for all five lossy codecs.
+- The protected rows recorded zero exponent mismatches.
+- The raw diagnostic counts differ substantially across codecs; NaN, +Inf, and
+  -Inf are kept as separate fields.
+
+## Discussion
+
+Facts are the counts, byte diagnostics, exponent-mismatch counts, and payload
+measurements recorded in the CSV files. They describe this run and do not by
+themselves establish a causal mechanism.
+
+A hypothesis consistent with the observations is that the fp16 high byte—which
+contains the sign, exponent, and upper mantissa bits—is substantially more
+important to the recorded model behavior than the lower byte. Protected High
+Byte preserves that high byte while allowing low-byte compression to alter less
+significant bits. The successful protected runs demonstrate the outcome for this
+matrix, but they do not establish the proposed bit-importance mechanism as a
+general causal fact. Protected High Byte is also a hybrid representation, not a
+pure lossy weight artifact. Codec implementation choices, decoder behavior,
+tensor layout, and the MPS runtime may contribute.
+
+## Repository Contents
+
+```text
+images/                         Archived figures and representative images
+results/                        CSV results, reports, and archive_manifest.json
+samples/                        800 successful sample artifacts for all successful generation rows
+weights/                        Archived payloads and weights/manifest.csv
+scripts/cross_codec_report.py   Report generation
+scripts/render_visual_tables.py Portable fail-closed visual-table renderer
+scripts/verify_archive.py       Hash, byte-count, containment, and symlink verifier
+scripts/pixelmodel_robustness/  11 packaged robustness modules
+scripts/dit.py                  Packaged DiT implementation
+scripts/config/                 Experiment configuration and prompt manifests
+tests/                          Focused codec, repair, report, renderer, and archive tests
+```
+
+## Reproducibility
+
+The full runner may require Apple MPS because that is the archived runtime. The
+following commands are generic and intentionally do not promise universal
+hardware reproducibility.
+
+```bash
+uv sync --locked
+uv run --locked pytest
+PYTHONPATH=scripts uv run --locked python scripts/verify_archive.py --root .
+PYTHONPATH=scripts uv run --locked python scripts/render_visual_tables.py \
+  --run-dir . \
+  --prompt-ids-manifest results/representative_prompt_ids.json \
+  --output scratch/rendered-tables
+```
+
+The complete archived experiment uses the packaged runner and the archived
+configuration. Start with a small smoke test before attempting the full run.
+The full implementation may require MPS and the source assets.
+
+## How to verify/re-run
+
+1. Verify the archive before reading results:
+
+   ```bash
+   PYTHONPATH=scripts uv run --locked python scripts/verify_archive.py --root .
+   ```
+
+2. Run the focused tests:
+
+   ```bash
+   uv run --locked pytest
+   ```
+
+3. Inspect the packaged report and experiment command surfaces:
+
+   ```bash
+   PYTHONPATH=scripts uv run --locked python scripts/cross_codec_report.py --help
+   PYTHONPATH=scripts uv run --locked python -m pixelmodel_robustness.cross_codec_experiment --help
+   ```
+
+4. For a fresh source checkout, obtain the upstream assets at the exact
+   revision. This command is a prerequisite only; it does not alter this
+   archive:
+
+   ```bash
+   hf download bench-labs/PixelModel-v4 \
+     --revision 80878fdd6e130d229c2581424a3456b47b979d4b
+   ```
+
+5. Use the packaged runner's `--help` output to select the input paths and
+   output run directory, then run on a machine with the required model runtime.
+   Preserve the runner manifest, encoded payloads, materialized weight images,
+   samples, resource log, and raw rows together. `samples/` contains all 800
+   successful sample artifacts, so raw sample provenance is complete even though
+   the compact archive intentionally deduplicates payloads. Complete
+   report regeneration should target a fresh canonical run directory with
+   materialized weight images; the compact archive layout is not sufficient for
+   a fully fresh report regeneration.
+
+For AVIF, Pillow must have AVIF support. JPEG XL requires an ImageMagick build
+with the libjxl delegate. These codec prerequisites are recorded by the
+experiment where available.
+
+## Weights archive explanation
+
+The `weights/` directory is an archive of experiment inputs and codec payloads,
+not a new or fine-tuned model release. `weights/manifest.csv` records the path,
+byte count, and SHA-256 for each listed payload. Git LFS is configured for this
+directory. The archive verifier checks that paths stay inside the repository,
+that listed files exist with the recorded bytes and hashes, that paths are not
+duplicated, and that no symlink is used in the archived trees.
+
+## Limitations
+
+- The experiment covers one model version, PixelModel-v4 at the pinned revision.
+- Only the listed codec settings were evaluated; the setting matrix is limited.
+- No result here establishes that one codec is universally superior.
+- The full run uses one fixed prompt/seed/latent/settings protocol and one
+  Apple MPS runtime.
+- The results do not establish codec performance for other models, tensor
+  layouts, image dimensions, devices, Pillow versions, or libjxl versions.
+- Generation success is a gate outcome, not a quality ranking.
+- No FID result is reported; FID is N/A here.
+- Missing or failed samples are not imputed.
+- The archive does not claim that protected high-byte storage preserves every
+  aspect of a model outside the recorded experiment.
+- These observations should not be generalized beyond this experiment without
+  additional models, settings, runtimes, and independently specified evaluations.
+
+## Future Work
+
+- Perform bit-level importance analysis with pre-registered corruption masks.
+- Evaluate exponent-only corruption.
+- Evaluate mantissa-only corruption at controlled bit positions.
+- Test additional codecs and codec settings.
+- Investigate learned, weight-aware compression methods.
+- Repeat the protocol across additional model revisions, tensor layouts, prompt
+  sets, devices, and decoder versions.
+
+## License and acknowledgment
+
+This archive is released under the MIT License. It acknowledges
+[bench-labs/PixelModel-v4](https://huggingface.co/bench-labs/PixelModel-v4) and
+its MIT-licensed upstream model card. This repository is an experimental archive
+built from the robustness-study source; it is not the upstream model repository.

pyproject.toml

@@ -0,0 +1,43 @@
+[project]
+name = "pixelmodel-v4-image-codec-study"
+version = "0.1.0"
+description = "Research archive for PixelModel-v4 weight-image codec robustness experiments"
+requires-python = ">=3.11,<3.12"
+dependencies = [
+    "numpy",
+    "pillow",
+    "pandas",
+    "matplotlib",
+    "scikit-image",
+    "pytest",
+    "ruff",
+    "torch",
+    "diffusers==0.31.0",
+    "transformers==4.49.0",
+    "safetensors",
+    "torchmetrics",
+    "torch-fidelity",
+    "scipy",
+    "accelerate>=1.14.0",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["scripts"]
+
+[tool.ruff]
+line-length = 120
+target-version = "py311"
+exclude = [
+    "scripts/cross_codec_report.py",
+    "scripts/dit.py",
+    "scripts/pixelmodel_robustness/**",
+    "tests/test_cross_codec.py",
+    "tests/test_cross_codec_experiment.py",
+    "tests/test_cross_codec_report.py",
+    "tests/test_jpeg_repair.py",
+    ".venv",
+    ".pytest_cache",
+    ".ruff_cache",
+    "scratch",
+]

tests/test_cross_codec.py

@@ -0,0 +1,482 @@
+"""Task 1 cross-codec adapterの契約テスト。"""
+
+from __future__ import annotations
+
+from dataclasses import FrozenInstanceError, replace
+from io import BytesIO
+
+import numpy as np
+import pytest
+from PIL import Image
+
+from pixelmodel_robustness.cross_codec import (
+    CODEC_SPECS,
+    CONDITION_IDS,
+    CONDITION_REGISTRY,
+    CodecSpec,
+    ConditionSpec,
+    JxlCodecError,
+    ProtectedArtifact,
+    decode_l_plane,
+    decode_protected_high,
+    decode_rgb,
+    encode_l_plane,
+    encode_protected_high,
+    encode_rgb,
+    preflight_codecs,
+    repair_nonfinite_zero,
+    semantic_hash,
+)
+
+
+def rgb_image() -> Image.Image:
+    return Image.fromarray(
+        np.array(
+            [[[0, 1, 2], [20, 40, 60]], [[100, 120, 140], [240, 220, 200]]],
+            dtype=np.uint8,
+        ),
+        "RGB",
+    )
+
+
+def gray_plane() -> np.ndarray:
+    return np.arange(16, dtype=np.uint8).reshape(4, 4) * 13
+
+
+def test_registry_has_exact_order_and_stable_semantic_hash() -> None:
+    assert CONDITION_IDS == (
+        "png_baseline", "webp_lossless", "jpeg_q100_raw", "jpeg_q100_repair_zero",
+        "jpeg_q100_protected_high", "jpeg_q80_raw", "jpeg_q80_repair_zero",
+        "jpeg_q80_protected_high", "webp_q80_raw", "webp_q80_repair_zero",
+        "webp_q80_protected_high", "avif_q70_raw", "avif_q70_repair_zero",
+        "avif_q70_protected_high", "jxl_d1_raw", "jxl_d1_repair_zero",
+        "jxl_d1_protected_high",
+    )
+    assert tuple(CONDITION_REGISTRY) == CONDITION_IDS
+    assert semantic_hash(CONDITION_REGISTRY) == semantic_hash(tuple(CONDITION_REGISTRY))
+    with pytest.raises(TypeError):
+        CONDITION_REGISTRY["new"] = CONDITION_REGISTRY["png_baseline"]  # type: ignore[index]
+
+
+def test_codec_spec_is_immutable_and_options_are_fixed() -> None:
+    spec = CODEC_SPECS["jpeg_q80"]
+    assert isinstance(spec, CodecSpec)
+    assert spec.quality == 80
+    assert spec.options["subsampling"] == 0
+    with pytest.raises(FrozenInstanceError):
+        spec.quality = 99  # type: ignore[misc]
+    assert CODEC_SPECS["webp_lossless"].options == {"lossless": True, "exact": True, "method": 6}
+    assert CODEC_SPECS["jxl_d1"].quality == 90
+    assert CODEC_SPECS["jxl_d1"].metadata["libjxl_distance"] == 1.0
+    assert "jxl:distance" not in str(CODEC_SPECS["jxl_d1"].options)
+
+
+def test_all_codec_options_and_nested_registry_objects_are_immutable() -> None:
+    expected = {
+        "png": {},
+        "webp_lossless": {"lossless": True, "exact": True, "method": 6},
+        "jpeg_q100": {"quality": 100, "subsampling": 0, "optimize": False},
+        "jpeg_q80": {"quality": 80, "subsampling": 0, "optimize": False},
+        "webp_q80": {"quality": 80, "lossless": False, "method": 6, "exact": True},
+        "avif_q70": {"quality": 70, "subsampling": "4:4:4", "speed": 6, "range": "full", "codec": "aom", "max_threads": 1, "autotiling": False},
+        "jxl_d1": {"quality": 90},
+    }
+    assert {name: dict(spec.options) for name, spec in CODEC_SPECS.items()} == expected
+    assert all(spec.grayscale is True for spec in CODEC_SPECS.values())
+    for spec in CODEC_SPECS.values():
+        with pytest.raises(TypeError):
+            spec.options["quality"] = 1  # type: ignore[index]
+        with pytest.raises(TypeError):
+            spec.metadata["changed"] = True  # type: ignore[index]
+    entry = CONDITION_REGISTRY["png_baseline"]
+    assert isinstance(entry, ConditionSpec)
+    with pytest.raises(FrozenInstanceError):
+        entry.mode = "tampered"  # type: ignore[misc]
+
+
+@pytest.mark.parametrize("codec", ("png", "webp_lossless", "jpeg_q100", "jpeg_q80", "webp_q80", "avif_q70"))
+def test_rgb_encode_decode_uses_fixed_contract(codec: str) -> None:
+    available = {item.name: item for item in preflight_codecs()}
+    if not available[codec].available:
+        pytest.skip(available[codec].reason or "codec unavailable")
+    payload = encode_rgb(rgb_image(), CODEC_SPECS[codec])
+    decoded = decode_rgb(payload, CODEC_SPECS[codec])
+    assert isinstance(payload, bytes)
+    assert decoded.mode == "RGB"
+    assert decoded.size == (2, 2)
+    if codec in {"png", "webp_lossless"}:
+        np.testing.assert_array_equal(np.asarray(decoded), np.asarray(rgb_image()))
+
+
+def test_grayscale_plane_round_trip_for_lossless_png() -> None:
+    payload = encode_l_plane(gray_plane(), CODEC_SPECS["png"])
+    decoded = decode_l_plane(payload, CODEC_SPECS["png"])
+    np.testing.assert_array_equal(decoded, gray_plane())
+
+
+def test_l_plane_adapter_passes_single_channel_image_to_encoder(monkeypatch: pytest.MonkeyPatch) -> None:
+    import pixelmodel_robustness.cross_codec as module
+
+    modes: list[str] = []
+    original_save = Image.Image.save
+
+    def capture_save(self: Image.Image, *args: object, **kwargs: object) -> object:
+        modes.append(self.mode)
+        return original_save(self, *args, **kwargs)
+
+    monkeypatch.setattr(Image.Image, "save", capture_save)
+    encode_l_plane(gray_plane(), CODEC_SPECS["png"])
+    assert modes[-1] == "L"
+    assert module.decode_l_plane(encode_l_plane(gray_plane(), CODEC_SPECS["png"]), CODEC_SPECS["png"]).dtype == np.uint8
+
+
+def test_jxl_l_plane_writes_l_mode_source_png(monkeypatch: pytest.MonkeyPatch) -> None:
+    import pixelmodel_robustness.cross_codec as module
+
+    source_modes: list[str] = []
+    seen_argv: list[list[str]] = []
+
+    def fake_jxl_run(argv: list[str]) -> object:
+        seen_argv.append(argv)
+        with Image.open(argv[2]) as source:
+            source_modes.append(source.mode)
+        Image.new("L", (4, 4)).save(argv[-1], format="PNG")
+        return type("Completed", (), {"returncode": 0, "stdout": "", "stderr": ""})()
+
+    monkeypatch.setattr(module, "_jxl_run", fake_jxl_run)
+    module._jxl_encode(Image.fromarray(gray_plane(), "L"))
+    assert source_modes == ["L"]
+    assert seen_argv[0][0:2] == ["-quality", "90"]
+    assert seen_argv[0][2].endswith("source.png")
+    assert seen_argv[0][3].endswith("payload.jxl")
+
+
+def test_protected_high_is_exact_and_payload_is_combined_bytes() -> None:
+    values = np.array([0.0, -0.0, 1.5, -2.25, 3.125, -4.5], dtype=np.float16)
+    artifact = encode_protected_high(values, (2, 3), CODEC_SPECS["jpeg_q80"])
+    assert isinstance(artifact, ProtectedArtifact)
+    decoded, metadata = decode_protected_high(artifact, (2, 3), values)
+    np.testing.assert_array_equal(decoded.view(np.uint16) >> 8, values.view(np.uint16) >> 8)
+    assert metadata["decoded_high_exact"] is True
+    assert metadata["high_mode"] == metadata["low_mode"] == "L"
+    assert metadata["dimensions"] == [2, 3]
+    assert metadata["combined_payload_bytes"] == len(artifact.payload)
+    assert metadata["combined_payload_sha256"]
+    with Image.open(BytesIO(artifact.low_codec_bytes)) as low_image:
+        assert metadata["low_mode"] == low_image.mode
+    assert metadata["high_encoded_bytes"] == len(artifact.high_png_bytes)
+    assert metadata["low_encoded_bytes"] == len(artifact.low_codec_bytes)
+    assert metadata["high_encoded_sha256"]
+    assert metadata["low_encoded_sha256"]
+    assert metadata["decoded_low_sha256"]
+    assert metadata["high_dimensions"] == metadata["low_dimensions"] == [2, 3]
+
+
+@pytest.mark.parametrize("mode", ["RGB", "P"])
+def test_protected_high_rejects_non_l_high_plane(mode: str) -> None:
+    values = np.array([0.0, 1.5, -2.25, 3.125, -4.5, 5.0], dtype=np.float16)
+    artifact = encode_protected_high(values, (2, 3), CODEC_SPECS["jpeg_q80"])
+    high = np.asarray(Image.open(BytesIO(artifact.high_png_bytes)).convert("L"), dtype=np.uint8)
+    stream = BytesIO()
+    tampered_image = np.stack([high] * 3, axis=-1) if mode == "RGB" else high
+    Image.fromarray(tampered_image, mode).save(stream, format="PNG")
+    tampered = ProtectedArtifact(stream.getvalue(), artifact.low_codec_bytes, artifact.low_codec)
+    with pytest.raises(ValueError, match="high plane mode"):
+        decode_protected_high(tampered, (2, 3), values)
+
+
+def test_protected_high_rejects_high_shape_tamper() -> None:
+    values = np.arange(6, dtype=np.float16)
+    artifact = encode_protected_high(values, (2, 3), CODEC_SPECS["jpeg_q80"])
+    stream = BytesIO()
+    Image.fromarray(np.zeros((1, 6), dtype=np.uint8), "L").save(stream, format="PNG")
+    tampered = ProtectedArtifact(stream.getvalue(), artifact.low_codec_bytes, artifact.low_codec)
+    with pytest.raises(ValueError, match="dimensions"):
+        decode_protected_high(tampered, (2, 3), values)
+
+
+def test_protected_high_zero_pads_to_capacity_and_checks_full_high_plane() -> None:
+    values = np.array([1.5, -2.25, 3.125], dtype=np.float16)
+    artifact = encode_protected_high(values, (2, 3), CODEC_SPECS["jpeg_q80"])
+    decoded, metadata = decode_protected_high(artifact, (2, 3), values)
+    expected_high = np.zeros(6, dtype=np.uint16)
+    expected_high[:3] = values.view(np.uint16)
+    np.testing.assert_array_equal(decoded.view(np.uint16) >> 8, expected_high >> 8)
+    assert decoded.size == 6
+    assert metadata["source_value_count"] == 3
+    with pytest.raises(ValueError, match="capacity"):
+        encode_protected_high(np.zeros(7, dtype=np.float16), (2, 3), CODEC_SPECS["jpeg_q80"])
+
+
+def test_zero_repair_changes_only_nonfinite_fp16_words() -> None:
+    raw = np.array([0.0, -0.0, np.nan, np.inf, -np.inf, 2.0], dtype=np.float16)
+    result = repair_nonfinite_zero(raw, {"layer": (0, len(raw))})
+    assert np.isfinite(result.values).all()
+    np.testing.assert_array_equal(result.values.view(np.uint16)[[0, 1, 5]], raw.view(np.uint16)[[0, 1, 5]])
+    assert result.repaired_value_count == 3
+
+
+def test_jxl_failure_preserves_subprocess_diagnostics(monkeypatch: pytest.MonkeyPatch) -> None:
+    import pixelmodel_robustness.cross_codec as module
+
+    def failed_run(*args: object, **kwargs: object) -> object:
+        class Completed:
+            returncode = 7
+            stdout = "ImageMagick 7.1.2"
+            stderr = "libjxl unavailable"
+
+        failed_run.args = args  # type: ignore[attr-defined]
+        failed_run.kwargs = kwargs  # type: ignore[attr-defined]
+        return Completed()
+
+    monkeypatch.setattr(module.subprocess, "run", failed_run)
+    with pytest.raises(JxlCodecError, match="returncode=7") as error:
+        module._jxl_run(["/tmp/in.png", "/tmp/out.jxl"])
+    assert error.value.stderr == "libjxl unavailable"
+    assert error.value.argv == ("/etc/profiles/per-user/scratchbrulee/bin/magick", "/tmp/in.png", "/tmp/out.jxl")
+    assert failed_run.kwargs["shell"] is False  # type: ignore[attr-defined]
+
+
+def test_jxl_preflight_reports_version_and_argv_without_silent_fallback() -> None:
+    result = {item.name: item for item in preflight_codecs()}["jxl_d1"]
+    assert isinstance(result.available, bool)
+    if result.available:
+        assert result.version
+        assert result.argv
+        assert result.metadata["quality"] == 90
+        assert result.metadata["libjxl_distance"] == 1.0
+        assert result.metadata["probe_q90_bytes"] > 0
+        assert result.metadata["probe_q50_bytes"] > 0
+        assert result.metadata["probe_q90_sha256"] != result.metadata["probe_q50_sha256"]
+        assert result.metadata["probe_dimensions"] == (8, 8)
+        assert result.metadata["probe_q50_dimensions"] == (8, 8)
+        assert "ImageMagick" in result.version
+        assert result.metadata["imagemagick_full_version"] == result.version
+        assert result.metadata["libjxl_delegate_version"] == "0.11.2"
+        assert result.metadata["argv_template"] == (
+            "/etc/profiles/per-user/scratchbrulee/bin/magick", "-quality", "90", "<source>", "<target>"
+        )
+        with pytest.raises(TypeError):
+            result.metadata["argv_template"][0] = "tampered"  # type: ignore[index]
+    else:
+        assert result.reason
+
+
+def test_encoded_bytes_are_readable_without_temp_artifact() -> None:
+    payload = encode_rgb(rgb_image(), CODEC_SPECS["png"])
+    with Image.open(BytesIO(payload)) as image:
+        assert image.format == "PNG"
+    assert isinstance(payload, bytes)
+
+
+def test_zero_repair_does_not_mutate_and_preserves_all_finite_fp16_bits() -> None:
+    raw = np.array([0.0, -0.0, np.nextafter(np.float16(0), np.float16(1)), np.finfo(np.float16).max, np.nan], dtype=np.float16)
+    before = raw.view(np.uint16).copy()
+    result = repair_nonfinite_zero(raw, {"layer": (0, len(raw))})
+    np.testing.assert_array_equal(raw.view(np.uint16), before)
+    np.testing.assert_array_equal(result.values.view(np.uint16)[:4], before[:4])
+
+
+def test_preflight_diagnostics_are_structured_for_jxl_failure(monkeypatch: pytest.MonkeyPatch) -> None:
+    import pixelmodel_robustness.cross_codec as module
+
+    def failed_run(*args: object, **kwargs: object) -> object:
+        return type("Completed", (), {"returncode": 9, "stdout": "version out", "stderr": "format err"})()
+
+    monkeypatch.setattr(module.subprocess, "run", failed_run)
+    result = module._jxl_version()
+    assert result.available is False
+    assert result.diagnostics == {
+        "argv": (module.MAGICK_PATH, "-version"), "stdout": "version out", "stderr": "format err", "returncode": 9,
+    }
+
+
+def test_non_jxl_encode_does_not_run_global_or_jxl_preflight(monkeypatch: pytest.MonkeyPatch) -> None:
+    import pixelmodel_robustness.cross_codec as module
+
+    monkeypatch.setattr(module, "preflight_codecs", lambda: (_ for _ in ()).throw(AssertionError("global preflight")))
+    monkeypatch.setattr(module, "_jxl_version", lambda: (_ for _ in ()).throw(AssertionError("JXL probe")))
+    payload = encode_rgb(rgb_image(), CODEC_SPECS["png"])
+    assert payload.startswith(b"\x89PNG")
+
+
+def test_avif_raw_decode_is_rgb_when_available() -> None:
+    status = {item.name: item for item in preflight_codecs()}["avif_q70"]
+    if not status.available:
+        pytest.skip(status.reason or "AVIF unavailable")
+    decoded = decode_rgb(encode_rgb(rgb_image(), CODEC_SPECS["avif_q70"]), CODEC_SPECS["avif_q70"])
+    assert decoded.mode == "RGB"
+
+
+def test_jxl_preflight_rejects_unparseable_libjxl_version(monkeypatch: pytest.MonkeyPatch) -> None:
+    import pixelmodel_robustness.cross_codec as module
+
+    def fake_run(args: list[str]) -> object:
+        if args == ["-version"]:
+            return type("Completed", (), {"returncode": 0, "stdout": "ImageMagick Delegates: jxl", "stderr": ""})()
+        if args == ["-list", "format"]:
+            return type("Completed", (), {"returncode": 8, "stdout": "format out", "stderr": "format err"})()
+        raise AssertionError(args)
+
+    monkeypatch.setattr(module, "_jxl_run", fake_run)
+    result = module._jxl_version()
+    assert result.available is False
+    assert result.reason
+    assert result.diagnostics == {
+        "argv": (module.MAGICK_PATH, "-list", "format"), "stdout": "format out", "stderr": "format err", "returncode": 8,
+    }
+
+
+def test_protected_high_rejects_l_mode_non_png_formats() -> None:
+    values = np.arange(6, dtype=np.float16)
+    artifact = encode_protected_high(values, (2, 3), CODEC_SPECS["jpeg_q80"])
+    for image_format in ("BMP", "TIFF"):
+        stream = BytesIO()
+        Image.fromarray(np.zeros((2, 3), dtype=np.uint8), "L").save(stream, format=image_format)
+        tampered = ProtectedArtifact(stream.getvalue(), artifact.low_codec_bytes, artifact.low_codec)
+        with pytest.raises(ValueError, match="format"):
+            decode_protected_high(tampered, (2, 3), values)
+
+
+def test_protected_low_codec_has_immutable_lossy_allowlist() -> None:
+    import pixelmodel_robustness.cross_codec as module
+
+    assert module.LOSSY_CODEC_NAMES == ("jpeg_q100", "jpeg_q80", "webp_q80", "avif_q70", "jxl_d1")
+    values = np.arange(6, dtype=np.float16)
+    for name in ("png", "webp_lossless"):
+        with pytest.raises(ValueError, match="lossy"):
+            encode_protected_high(values, (2, 3), CODEC_SPECS[name])
+    artifact = encode_protected_high(values, (2, 3), CODEC_SPECS["jpeg_q80"])
+    with pytest.raises(ValueError, match="lossy"):
+        decode_protected_high(replace(artifact, low_codec="png"), (2, 3), values)
+    with pytest.raises(TypeError):
+        module.LOSSY_CODEC_NAMES[0] = "png"  # type: ignore[index]
+
+
+def test_jxl_probe_failure_preserves_probe_diagnostics(monkeypatch: pytest.MonkeyPatch) -> None:
+    import pixelmodel_robustness.cross_codec as module
+
+    def fake_run(args: list[str]) -> object:
+        if args == ["-version"]:
+            return type("Completed", (), {"returncode": 0, "stdout": "ImageMagick Delegates: jxl", "stderr": "version err"})()
+        if args == ["-list", "format"]:
+            return type("Completed", (), {"returncode": 0, "stdout": "JXL* rw+ JPEG XL (libjxl 0.11.2)", "stderr": "format err"})()
+        raise AssertionError(args)
+
+    expected = module.JxlCodecError(
+        "probe failed", argv=[module.MAGICK_PATH, "-quality", "90", "source", "target"],
+        stdout="probe out", stderr="probe err", returncode=13,
+    )
+    monkeypatch.setattr(module, "_jxl_run", fake_run)
+    monkeypatch.setattr(module, "_jxl_encode", lambda *args, **kwargs: (_ for _ in ()).throw(expected))
+    result = module._jxl_version()
+    assert result.available is False
+    assert result.diagnostics["probe"] == {
+        "argv": expected.argv, "stdout": expected.stdout, "stderr": expected.stderr, "returncode": expected.returncode,
+    }
+
+
+def test_preflight_diagnostics_are_immutable_for_pillow_results() -> None:
+    result = preflight_codecs()[0]
+    with pytest.raises(TypeError):
+        result.diagnostics["changed"] = True  # type: ignore[index]
+
+
+def test_condition_registry_has_exact_full_semantics() -> None:
+    expected = (
+        ("png_baseline", "png", "raw", None, False),
+        ("webp_lossless", "webp_lossless", "raw", None, False),
+        ("jpeg_q100_raw", "jpeg_q100", "raw", None, False),
+        ("jpeg_q100_repair_zero", "jpeg_q100", "repair_zero", "zero", False),
+        ("jpeg_q100_protected_high", "jpeg_q100", "protected_high", None, True),
+        ("jpeg_q80_raw", "jpeg_q80", "raw", None, False),
+        ("jpeg_q80_repair_zero", "jpeg_q80", "repair_zero", "zero", False),
+        ("jpeg_q80_protected_high", "jpeg_q80", "protected_high", None, True),
+        ("webp_q80_raw", "webp_q80", "raw", None, False),
+        ("webp_q80_repair_zero", "webp_q80", "repair_zero", "zero", False),
+        ("webp_q80_protected_high", "webp_q80", "protected_high", None, True),
+        ("avif_q70_raw", "avif_q70", "raw", None, False),
+        ("avif_q70_repair_zero", "avif_q70", "repair_zero", "zero", False),
+        ("avif_q70_protected_high", "avif_q70", "protected_high", None, True),
+        ("jxl_d1_raw", "jxl_d1", "raw", None, False),
+        ("jxl_d1_repair_zero", "jxl_d1", "repair_zero", "zero", False),
+        ("jxl_d1_protected_high", "jxl_d1", "protected_high", None, True),
+    )
+    assert tuple((e.condition_id, e.codec, e.mode, e.repair, e.protected) for e in CONDITION_REGISTRY.values()) == expected
+
+
+def test_protected_encode_decode_do_not_mutate_source_bits() -> None:
+    values = np.array([0.0, -0.0, 1.5, -2.25, 3.125, -4.5], dtype=np.float16)
+    before = values.view(np.uint16).copy()
+    artifact = encode_protected_high(values, (2, 3), CODEC_SPECS["jpeg_q80"])
+    decode_protected_high(artifact, (2, 3), values)
+    np.testing.assert_array_equal(values.view(np.uint16), before)
+
+
+def test_expected_formats_and_forged_codec_spec_are_binding() -> None:
+    import pixelmodel_robustness.cross_codec as module
+
+    expected = {
+        "png": "PNG", "webp_lossless": "WEBP", "jpeg_q100": "JPEG", "jpeg_q80": "JPEG",
+        "webp_q80": "WEBP", "avif_q70": "AVIF", "jxl_d1": "JXL",
+    }
+    assert dict(module.EXPECTED_FORMAT_BY_CODEC) == expected
+    with pytest.raises(TypeError):
+        module.EXPECTED_FORMAT_BY_CODEC["png"] = "JPEG"  # type: ignore[index]
+    forged = replace(CODEC_SPECS["jpeg_q80"], format="PNG")
+    with pytest.raises(ValueError, match="semantic"):
+        encode_protected_high(np.arange(6, dtype=np.float16), (2, 3), forged)
+
+
+@pytest.mark.parametrize("codec", ("jpeg_q100", "jpeg_q80", "webp_q80", "avif_q70"))
+def test_non_jxl_decode_l_plane_rejects_payload_format_mismatch(codec: str) -> None:
+    png_payload = encode_l_plane(gray_plane(), CODEC_SPECS["png"])
+    with pytest.raises(ValueError, match="format"):
+        decode_l_plane(png_payload, CODEC_SPECS[codec])
+
+
+@pytest.mark.parametrize("codec", ("jpeg_q100", "jpeg_q80", "webp_q80", "avif_q70", "jxl_d1"))
+def test_protected_decode_rejects_png_bytes_for_every_lossy_codec(codec: str) -> None:
+    values = np.arange(6, dtype=np.float16)
+    artifact = encode_protected_high(values, (2, 3), CODEC_SPECS["jpeg_q80"])
+    png_payload = encode_l_plane(np.zeros((2, 3), dtype=np.uint8), CODEC_SPECS["png"])
+    tampered = replace(artifact, low_codec=codec, low_codec_bytes=png_payload)
+    with pytest.raises((ValueError, JxlCodecError)):
+        decode_protected_high(tampered, (2, 3), values)
+
+
+@pytest.mark.parametrize("codec", ("jpeg_q100", "jpeg_q80", "webp_q80", "avif_q70", "jxl_d1"))
+def test_decode_rgb_rejects_png_payload_for_every_lossy_codec(codec: str) -> None:
+    png_payload = encode_rgb(rgb_image(), CODEC_SPECS["png"])
+    with pytest.raises((ValueError, JxlCodecError)):
+        decode_rgb(png_payload, CODEC_SPECS[codec])
+
+
+def test_verified_preflight_token_skips_jxl_probe(monkeypatch: pytest.MonkeyPatch) -> None:
+    import pixelmodel_robustness.cross_codec as module
+    token = {"jxl_d1": module.CodecPreflight("jxl_d1", True, "fixture", None, ("fixture",), {})}
+    monkeypatch.setattr(module, "_jxl_version", lambda: (_ for _ in ()).throw(AssertionError("probe bypassed")))
+    monkeypatch.setattr(module, "_jxl_encode", lambda image: b"jxl-payload")
+    monkeypatch.setattr(module, "_jxl_decode", lambda payload: Image.new("RGB", (2, 2)))
+    assert module.encode_rgb(rgb_image(), CODEC_SPECS["jxl_d1"], verified_preflight=token) == b"jxl-payload"
+    assert module.decode_rgb(b"jxl-payload", CODEC_SPECS["jxl_d1"], verified_preflight=token).mode == "RGB"
+
+
+def test_verified_preflight_token_rejects_missing_or_unavailable_codec() -> None:
+    import pixelmodel_robustness.cross_codec as module
+    with pytest.raises(RuntimeError, match="unavailable"):
+        module.encode_rgb(rgb_image(), CODEC_SPECS["jxl_d1"], verified_preflight={})
+    token = {"jxl_d1": module.CodecPreflight("jxl_d1", False, None, "missing", (), {})}
+    with pytest.raises(RuntimeError, match="missing"):
+        module.encode_rgb(rgb_image(), CODEC_SPECS["jxl_d1"], verified_preflight=token)
+
+
+def test_decode_uses_canonical_format_for_forged_and_unknown_specs() -> None:
+    png_payload = encode_rgb(rgb_image(), CODEC_SPECS["png"])
+    forged = replace(CODEC_SPECS["jpeg_q80"], format="PNG")
+    unknown = CodecSpec("unknown_codec", "PNG", None, {}, {})
+    for spec in (forged, unknown):
+        with pytest.raises(ValueError, match="canonical|unknown"):
+            decode_rgb(png_payload, spec)
+        with pytest.raises(ValueError, match="canonical|unknown"):
+            decode_l_plane(png_payload, spec)

tests/test_cross_codec_experiment.py

@@ -0,0 +1,552 @@
+"""Cross-codec Task 2 runnerの厳格TDD契約。"""
+from __future__ import annotations
+
+import hashlib
+import json
+from argparse import Namespace
+from pathlib import Path
+
+import numpy as np
+import pytest
+from PIL import Image
+
+import pixelmodel_robustness.cross_codec as codecs
+from pixelmodel_robustness.prompts import CATEGORIES
+
+
+@pytest.fixture
+def fixture_inputs(tmp_path: Path) -> dict[str, Path]:
+    values = np.arange(16, dtype=np.float16)
+    pixels = np.zeros((4, 4, 3), dtype=np.uint8)
+    bits = values.view(np.uint16)
+    pixels.reshape(-1, 3)[:, 0] = (bits >> 8).astype(np.uint8)
+    pixels.reshape(-1, 3)[:, 1] = bits.astype(np.uint8)
+    image = tmp_path / "model.png"
+    Image.fromarray(pixels, "RGB").save(image)
+    manifest = tmp_path / "model_png.json"
+    manifest.write_text(json.dumps({"total_parameters": 16, "params": [{"name": "a", "numel": 8}, {"name": "b", "numel": 8}]}), encoding="utf-8")
+    config = tmp_path / "config.json"
+    config.write_text(json.dumps({"architecture": "fixture"}), encoding="utf-8")
+    model = tmp_path / "model.safetensors"
+    model.write_bytes(b"fixture")
+    prompts = tmp_path / "prompts.json"
+    rows = []
+    for index, category in enumerate(CATEGORIES):
+        rows.append({"prompt_id": f"first-{category}", "category": category, "prompt": f"first {category}", "seed": index, "initial_latent_seed": index})
+    for index in range(92):
+        category = CATEGORIES[index % len(CATEGORIES)]
+        rows.append({"prompt_id": f"p-{index}", "category": category, "prompt": f"prompt {index}", "seed": 100 + index, "initial_latent_seed": 100 + index})
+    prompts.write_text(json.dumps(rows), encoding="utf-8")
+    return {"image": image, "manifest": manifest, "config": config, "model": model, "prompts": prompts}
+
+
+def make_args(inputs: dict[str, Path], output: Path, **overrides: object) -> Namespace:
+    values = {"profile": "pilot", "image": str(inputs["image"]), "manifest": str(inputs["manifest"]), "config": str(inputs["config"]), "model": str(inputs["model"]), "prompts_manifest": str(inputs["prompts"]), "prompts": 8, "steps": 50, "cfg": 6.0, "device": "mps", "output": str(output), "conditions": "", "recover_lock": False, "fixture": True, "fake_runtime": False, "vae": "vae", "clip": "clip", "pilot_manifest": None}
+    values.update(overrides)
+    return Namespace(**values)
+
+
+def preflight() -> tuple[codecs.CodecPreflight, ...]:
+    return tuple(codecs.CodecPreflight(name, True, "fixture", None, ("fixture", name), {"fixture": True}) for name in codecs.CODEC_SPECS)
+
+
+def payload_factory(image: Image.Image, spec: codecs.CodecSpec) -> tuple[bytes, Image.Image]:
+    from io import BytesIO
+    stream = BytesIO()
+    image.convert("RGB").save(stream, format="PNG")
+    payload = stream.getvalue()
+    return payload, Image.open(BytesIO(payload)).convert("RGB")
+
+
+class Runtime:
+    def generate(self, prompt: str, seed: int) -> tuple[Image.Image, float]:
+        return Image.new("RGB", (4, 4), seed % 255), 0.5
+
+
+def runtime_factory(args: Namespace, device: str) -> tuple[object, object]:
+    return (lambda path: object()), Runtime()
+
+
+def test_pilot_selection_is_category_order_and_full_is_exact() -> None:
+    from pixelmodel_robustness.cross_codec_experiment import select_prompts
+    prompts = [{"prompt_id": f"{category}-{index}-{duplicate}", "category": category, "prompt": f"{category}-{index}-{duplicate}", "seed": index, "initial_latent_seed": index} for index, category in enumerate(CATEGORIES) for duplicate in range(2)]
+    selected = select_prompts(prompts, "pilot")
+    assert [item["prompt_id"] for item in selected] == [next(item["prompt_id"] for item in prompts if item["category"] == category) for category in CATEGORIES]
+    with pytest.raises(ValueError, match="exactly 100"):
+        select_prompts(prompts, "full")
+
+
+def test_cli_contract_rejects_before_output(fixture_inputs: dict[str, Path], tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import build_parser, run
+    args = build_parser().parse_args(["--profile", "pilot", "--image", str(fixture_inputs["image"]), "--manifest", str(fixture_inputs["manifest"]), "--config", str(fixture_inputs["config"]), "--model", str(fixture_inputs["model"]), "--prompts-manifest", str(fixture_inputs["prompts"]), "--output", str(tmp_path / "out"), "--prompts", "7"])
+    with pytest.raises(ValueError, match="8"):
+        run(args)
+    assert not Path(args.output).exists()
+
+
+def test_fixture_e2e_has_complete_rows_and_artifacts(fixture_inputs: dict[str, Path], tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import run
+    result = run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=runtime_factory)
+    rows = [json.loads(line) for line in (result / "results" / "raw_rows.jsonl").read_text().splitlines()]
+    weights = [row for row in rows if row["row_type"] == "weight"]
+    layers = [row for row in rows if row["row_type"] == "layer"]
+    generations = [row for row in rows if row["row_type"] == "generation"]
+    assert len(weights) == 17 and len(layers) == 34 and len(generations) == 136
+    assert all(row["attempted"] and row["completed"] and row["success"] for row in generations if not row["blocked"])
+    assert all((result / row["sample_path"]).is_file() and row["sample_bytes"] == (result / row["sample_path"]).stat().st_size and row["sample_hash"] == hashlib.sha256((result / row["sample_path"]).read_bytes()).hexdigest() for row in generations if row["success"])
+    baseline = next(row for row in weights if row["condition"] == "png_baseline")
+    assert (result / baseline["materialized"]["path"]).read_bytes() == fixture_inputs["image"].read_bytes()
+    assert json.loads((result / "pilot_gate.json").read_text())["pass"] is True
+
+
+def test_save_sample_supports_pil_chw_and_rejects_nonfinite(tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import _save_sample
+    class Tensor:
+        def __init__(self, value: np.ndarray): self.value = value
+        def detach(self): return self
+        def cpu(self): return self
+        def clamp(self, low: float, high: float): return Tensor(np.clip(self.value, low, high))
+        def permute(self, *axes: int): return Tensor(np.transpose(self.value, axes))
+        def numpy(self): return self.value
+    path = tmp_path / "nested" / "sample.png"
+    artifact = _save_sample(Tensor(np.ones((3, 4, 4), dtype=np.float32)), path, base=tmp_path)
+    assert path.is_file() and artifact["sha256"] == hashlib.sha256(path.read_bytes()).hexdigest()
+    with pytest.raises((ValueError, FloatingPointError)):
+        _save_sample(Tensor(np.full((3, 4, 4), np.nan, dtype=np.float32)), tmp_path / "bad.png", base=tmp_path)
+
+
+def test_loader_called_once_per_condition_and_baseline_path_exists(fixture_inputs: dict[str, Path], tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import run
+    calls: list[str] = []
+    def loader(path: str) -> object:
+        calls.append(path)
+        assert Path(path).is_file()
+        return object()
+    result = run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=lambda a, d: (loader, Runtime()))
+    rows = [json.loads(line) for line in (result / "results" / "raw_rows.jsonl").read_text().splitlines()]
+    nonblocked = {row["condition"] for row in rows if row["row_type"] == "weight" and not row["blocked"]}
+    assert len(calls) == len(nonblocked)
+    assert any(path.endswith("png_baseline.png") for path in calls)
+
+
+def test_model_loader_failure_is_one_attempt_and_gate_fails(fixture_inputs: dict[str, Path], tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import run
+    calls: list[str] = []
+    def loader(path: str) -> object:
+        calls.append(path)
+        raise ValueError("load failed")
+    result = run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=lambda a, d: (loader, Runtime()))
+    rows = [json.loads(line) for line in (result / "results" / "raw_rows.jsonl").read_text().splitlines()]
+    assert len(calls) == 17
+    assert all(not row["attempted"] and row["blocked"] and row["failure_stage"] == "model_load" and row["sample_path"] is None for row in rows if row["row_type"] == "generation")
+    assert json.loads((result / "pilot_gate.json").read_text())["pass"] is False
+
+
+def test_raw_block_repair_count_and_shared_payload(fixture_inputs: dict[str, Path], tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import run
+    def candidate(condition: str, values: np.ndarray) -> np.ndarray:
+        result = values.copy()
+        if condition == "jpeg_q100_raw": result[:3] = [np.nan, np.inf, -np.inf]
+        if condition == "jpeg_q80_raw": result[:3] = [np.nan, np.inf, -np.inf]
+        return result
+    result = run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=runtime_factory, candidate_factory=candidate)
+    rows = [json.loads(line) for line in (result / "results" / "raw_rows.jsonl").read_text().splitlines()]
+    weights = {row["condition"]: row for row in rows if row["row_type"] == "weight"}
+    assert weights["jpeg_q100_raw"]["blocked"] is True
+    assert weights["jpeg_q100_repair_zero"]["repaired_count"] == 3
+    assert weights["jpeg_q100_raw"]["payload_sha256"] == weights["jpeg_q100_repair_zero"]["payload_sha256"]
+
+
+def test_payload_storage_metrics_and_protected_artifacts(fixture_inputs: dict[str, Path], tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import run
+    result = run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=runtime_factory)
+    rows = [json.loads(line) for line in (result / "results" / "raw_rows.jsonl").read_text().splitlines()]
+    weights = {row["condition"]: row for row in rows if row["row_type"] == "weight"}
+    for row in weights.values():
+        assert {"payload_bytes", "payload_over_png", "png_over_payload", "size_saving_percent"} <= row.keys()
+    protected = weights["jpeg_q100_protected_high"]
+    assert {"high", "low"} <= protected["protected"].keys()
+    assert protected["payload_bytes"] == protected["protected"]["high"]["bytes"] + protected["protected"]["low"]["bytes"]
+
+
+def test_strict_rows_and_condition_completion_reject_tamper(fixture_inputs: dict[str, Path], tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import condition_complete, load_rows_strict, run
+    result = run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=runtime_factory)
+    manifest = json.loads((result / "manifest.json").read_text())
+    rows = load_rows_strict(result / "results" / "raw_rows.jsonl", manifest["run_identity_hash"])
+    sample = next(row for row in rows if row["row_type"] == "generation" and row["success"])
+    (result / sample["sample_path"]).write_bytes(b"tampered")
+    assert condition_complete(rows, sample["condition"], set(manifest["prompt_ids"]), {"a", "b"}, result) is False
+    with pytest.raises(ValueError, match="identity"):
+        load_rows_strict(result / "results" / "raw_rows.jsonl", "wrong")
+
+
+def test_strict_rows_reject_duplicate_canonical_identity(tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import load_rows_strict
+    path = tmp_path / "rows.jsonl"
+    row = {"row_type": "weight", "stage": "weight", "condition": "png_baseline", "prompt_id": None, "run_identity_hash": "identity"}
+    path.write_text(json.dumps(row) + "\n" + json.dumps(row) + "\n", encoding="utf-8")
+    with pytest.raises(ValueError, match="duplicate"):
+        load_rows_strict(path, "identity")
+
+
+def test_resume_skips_completed_and_rejects_completed_resume(fixture_inputs: dict[str, Path], tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import run
+    result = run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=runtime_factory)
+    args = make_args(fixture_inputs, result)
+    with pytest.raises(ValueError, match="completed"):
+        run(args, preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=runtime_factory)
+
+
+def test_full_gate_validation_rejects_tampered_gate_before_output(fixture_inputs: dict[str, Path], tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import run
+    pilot = run(make_args(fixture_inputs, tmp_path / "pilot"), preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=runtime_factory)
+    gate = pilot / "pilot_gate.json"
+    value = json.loads(gate.read_text())
+    value["prompt_ids"] = ["tampered"]
+    gate.write_text(json.dumps(value), encoding="utf-8")
+    args = make_args(fixture_inputs, tmp_path / "full", profile="full", prompts=100, fixture=False, pilot_manifest=str(gate))
+    with pytest.raises(ValueError, match="pilot gate"):
+        run(args, preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=runtime_factory)
+    assert not Path(args.output).exists()
+
+
+def test_invalid_prompt_category_and_duplicate_ids_rejected_before_output(fixture_inputs: dict[str, Path], tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import run
+    prompts = json.loads(fixture_inputs["prompts"].read_text())
+    prompts[0]["category"] = "invalid"
+    fixture_inputs["prompts"].write_text(json.dumps(prompts), encoding="utf-8")
+    with pytest.raises(ValueError, match="category"):
+        run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight)
+
+
+def test_preflight_identity_order_and_duplicates_rejected(fixture_inputs: dict[str, Path], tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import run
+    statuses = list(preflight())
+    statuses[0], statuses[1] = statuses[1], statuses[0]
+    with pytest.raises(RuntimeError, match="preflight"):
+        run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=lambda: tuple(statuses))
+
+
+def test_resource_sample_is_measured_and_three_violation_guard(fixture_inputs: dict[str, Path], tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    from pixelmodel_robustness import cross_codec_experiment as experiment
+    snapshot = experiment.sample_resource(tmp_path)
+    assert snapshot["rss_bytes"] > 0 and snapshot["system_available_percent"] > 0 and snapshot["disk_free_bytes"] > 0
+    monkeypatch.setattr(experiment, "sample_resource", lambda output: {"rss_bytes": 13 * 1024**3, "system_available_percent": 5.0, "disk_free_bytes": 1})
+    with pytest.raises(experiment.ResourceGuardError):
+        experiment.run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight)
+    assert not (tmp_path / "out").exists()
+
+
+def test_generation_failure_has_no_fake_sample(fixture_inputs: dict[str, Path], tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import run
+    class Failing(Runtime):
+        def generate(self, prompt: str, seed: int): raise FloatingPointError("nonfinite image")
+    result = run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=lambda a, d: (lambda path: object(), Failing()))
+    rows = [json.loads(line) for line in (result / "results" / "raw_rows.jsonl").read_text().splitlines()]
+    assert all(not row["success"] and row["sample_path"] is None and row["clip_score"] is None and row["first_error"] for row in rows if row["row_type"] == "generation")
+
+
+def test_generation_row_schema_and_layer_rows_have_no_prompt_hack(fixture_inputs: dict[str, Path], tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import run
+    result = run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=runtime_factory)
+    rows = [json.loads(line) for line in (result / "results" / "raw_rows.jsonl").read_text().splitlines()]
+    generation = next(row for row in rows if row["row_type"] == "generation")
+    assert {"category", "prompt", "seed", "initial_latent_seed", "attempt_count", "completed", "elapsed_seconds", "failure_stage", "failure_class", "first_error", "sample_path", "sample_hash", "sample_bytes"} <= generation.keys()
+    assert all(not str(row.get("prompt_id", "")).startswith("layer:") for row in rows if row["row_type"] == "layer")
+
+
+def test_full_fixture_gate_binding_unit_does_not_create_gate(fixture_inputs: dict[str, Path], tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import run
+    pilot = run(make_args(fixture_inputs, tmp_path / "pilot"), preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=runtime_factory)
+    gate = pilot / "pilot_gate.json"
+    args = make_args(fixture_inputs, tmp_path / "full", profile="full", prompts=100, fixture=False, pilot_manifest=str(gate))
+    with pytest.raises(ValueError):
+        run(args, preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=runtime_factory)
+    assert not (Path(args.output) / "pilot_gate.json").exists()
+
+
+def test_preflight_unavailable_fails_before_output(fixture_inputs: dict[str, Path], tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import run
+    def unavailable() -> tuple[codecs.CodecPreflight, ...]:
+        return tuple(codecs.CodecPreflight(name, name != "avif_q70", "fixture", None if name != "avif_q70" else "missing", ("fixture", name), {}) for name in codecs.CODEC_SPECS)
+    with pytest.raises(RuntimeError, match="preflight"):
+        run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=unavailable)
+    assert not (tmp_path / "out").exists()
+
+
+@pytest.mark.parametrize("artifact_key", ["sample", "payload", "materialized", "protected_high", "protected_low"])
+def test_validate_pilot_gate_rehashes_every_persisted_artifact(fixture_inputs: dict[str, Path], tmp_path: Path, artifact_key: str) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import run, validate_pilot_gate
+    result = run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=runtime_factory)
+    rows_path = result / "results" / "raw_rows.jsonl"
+    rows = [json.loads(line) for line in rows_path.read_text().splitlines()]
+    if artifact_key == "sample":
+        target = next(row for row in rows if row["row_type"] == "generation" and row["success"])
+        path = result / target["sample_path"]
+    elif artifact_key == "payload":
+        target = next(row for row in rows if row["row_type"] == "weight")
+        path = result / target["payload"]["path"]
+    elif artifact_key == "materialized":
+        target = next(row for row in rows if row["row_type"] == "weight" and row["materialized"])
+        path = result / target["materialized"]["path"]
+    else:
+        target = next(row for row in rows if row["row_type"] == "weight" and row["protected"])
+        path = result / target["protected"]["high" if artifact_key.endswith("high") else "low"]["path"]
+    path.write_bytes(path.read_bytes() + b"tamper")
+    with pytest.raises(ValueError, match="pilot gate"):
+        validate_pilot_gate(result / "pilot_gate.json")
+
+
+@pytest.mark.parametrize("status", ["running", "resource_guard_failed"])
+@pytest.mark.parametrize("tree_key", ["payload", "protected", "materialized"])
+def test_resume_revalidates_existing_weight_artifact_tree(fixture_inputs: dict[str, Path], tmp_path: Path, status: str, tree_key: str) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import run
+    result = run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=runtime_factory)
+    manifest_path = result / "manifest.json"
+    manifest = json.loads(manifest_path.read_text())
+    manifest["status"] = status
+    manifest_path.write_text(json.dumps(manifest), encoding="utf-8")
+    rows_path = result / "results" / "raw_rows.jsonl"
+    rows = [json.loads(line) for line in rows_path.read_text().splitlines()]
+    weight = next(row for row in rows if row["row_type"] == "weight" and row[tree_key])
+    artifact = weight[tree_key]
+    if tree_key == "protected":
+        artifact = artifact["high"]
+    (result / artifact["path"]).write_bytes(b"tampered")
+    with pytest.raises(ValueError, match="artifact tamper"):
+        run(make_args(fixture_inputs, result, recover_lock=True), preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=runtime_factory)
+
+
+def test_codec_encode_failure_is_canonical_and_gate_fails(fixture_inputs: dict[str, Path], tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import run
+    def failing_payload(image: Image.Image, spec: codecs.CodecSpec) -> tuple[bytes, Image.Image]:
+        if spec.name == "jpeg_q80":
+            raise OSError("encoder unavailable")
+        return payload_factory(image, spec)
+    result = run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight, payload_factory=failing_payload, runtime_factory=runtime_factory)
+    rows = [json.loads(line) for line in (result / "results" / "raw_rows.jsonl").read_text().splitlines()]
+    failed = [row for row in rows if row["row_type"] == "weight" and row["condition"].startswith("jpeg_q80")]
+    assert len(failed) == 3 and all(row["status"] == "codec_pipeline_failed" and row["blocked"] for row in failed)
+    assert all(row["failure_stage"] == "encode" for row in rows if row["row_type"] == "generation" and row["condition"].startswith("jpeg_q80"))
+    assert json.loads((result / "manifest.json").read_text())["status"] == "completed_with_pipeline_failures"
+    assert json.loads((result / "pilot_gate.json").read_text())["pass"] is False
+
+
+def test_codec_decode_failure_is_canonical_and_gate_fails(fixture_inputs: dict[str, Path], tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    import pixelmodel_robustness.cross_codec as module
+    from pixelmodel_robustness.cross_codec_experiment import run
+    original = module.decode_rgb
+    def failing_decode(payload: bytes, spec: codecs.CodecSpec, **kwargs: object) -> Image.Image:
+        if spec.name == "jpeg_q80":
+            raise ValueError("decoder rejected payload")
+        return original(payload, spec, **kwargs)
+    monkeypatch.setattr(module, "decode_rgb", failing_decode)
+    result = run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight, runtime_factory=runtime_factory)
+    rows = [json.loads(line) for line in (result / "results" / "raw_rows.jsonl").read_text().splitlines()]
+    failed = [row for row in rows if row["row_type"] == "generation" and row["condition"].startswith("jpeg_q80")]
+    assert len(failed) == 8 * 3 and all(not row["attempted"] and row["failure_stage"] == "decode" for row in failed)
+    assert json.loads((result / "pilot_gate.json").read_text())["pass"] is False
+
+
+def test_resource_preflight_is_persisted_once(fixture_inputs: dict[str, Path], tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import run
+    result = run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=runtime_factory)
+    rows = [json.loads(line) for line in (result / "results" / "resource_monitor.jsonl").read_text().splitlines()]
+    preflight_rows = [row for row in rows if row["row_type"] == "resource_guard" and row["stage"] == "preflight"]
+    assert len(preflight_rows) == 1 and preflight_rows[0]["rss_bytes"] > 0
+
+
+def test_protected_payload_is_read_back_before_generation(fixture_inputs: dict[str, Path], tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    import pixelmodel_robustness.cross_codec as module
+    from pixelmodel_robustness.cross_codec_experiment import run
+    calls = 0
+    original = module.decode_protected_high
+    def counted(*args: object, **kwargs: object):
+        nonlocal calls
+        calls += 1
+        return original(*args, **kwargs)
+    monkeypatch.setattr(module, "decode_protected_high", counted)
+    run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=runtime_factory)
+    assert calls == 5
+
+
+def test_scientific_gate_identity_projection_is_immutable_and_profile_neutral() -> None:
+    from pixelmodel_robustness.cross_codec_experiment import SCIENTIFIC_GATE_IDENTITY_KEYS, scientific_identity_hash
+    assert isinstance(SCIENTIFIC_GATE_IDENTITY_KEYS, tuple)
+    base = {key: f"value-{key}" for key in SCIENTIFIC_GATE_IDENTITY_KEYS}
+    base["mode"] = "real"
+    pilot = {**base, "profile": "pilot", "prompt_ids": ["p1"], "prompt_selection_hash": "pilot", "completed_at": "old"}
+    full = {**base, "profile": "full", "prompt_ids": ["p1", "p2"], "prompt_selection_hash": "full", "completed_at": "new"}
+    assert scientific_identity_hash(pilot) == scientific_identity_hash(full)
+    changed = {**full, "code_hashes": "tampered"}
+    assert scientific_identity_hash(full) != scientific_identity_hash(changed)
+
+
+def test_manifest_binds_jpeg_repair_module_hash_to_run_identity(fixture_inputs: dict[str, Path], tmp_path: Path) -> None:
+    from pixelmodel_robustness import jpeg_repair
+    from pixelmodel_robustness.cross_codec_experiment import run, scientific_identity_hash, sha256_file
+
+    result = run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=runtime_factory)
+    manifest = json.loads((result / "manifest.json").read_text())
+    expected = sha256_file(jpeg_repair.__file__)
+
+    assert manifest["run_identity"]["code_hashes"]["jpeg_repair"] == expected
+    assert manifest["scientific_identity_hash"] == scientific_identity_hash(manifest["run_identity"])
+    changed = {**manifest["run_identity"], "code_hashes": {**manifest["run_identity"]["code_hashes"], "jpeg_repair": "tampered"}}
+    assert scientific_identity_hash(changed) != manifest["scientific_identity_hash"]
+
+
+def test_webp_lossless_pixel_mismatch_is_pipeline_failure(fixture_inputs: dict[str, Path], tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import run
+    def mismatching_payload(image: Image.Image, spec: codecs.CodecSpec) -> tuple[bytes, Image.Image]:
+        payload, decoded = payload_factory(image, spec)
+        if spec.name == "webp_lossless":
+            decoded = decoded.copy()
+            decoded.putpixel((0, 0), (255, 0, 0))
+        return payload, decoded
+    result = run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight, payload_factory=mismatching_payload, runtime_factory=runtime_factory)
+    rows = [json.loads(line) for line in (result / "results" / "raw_rows.jsonl").read_text().splitlines()]
+    affected = [row for row in rows if row["condition"] == "webp_lossless"]
+    assert len([row for row in affected if row["row_type"] == "weight"]) == 1
+    assert all(row["failure_stage"] == "decode_invariant" for row in affected)
+    assert json.loads((result / "manifest.json").read_text())["status"] == "completed_with_pipeline_failures"
+    assert json.loads((result / "pilot_gate.json").read_text())["pass"] is False
+
+
+def test_protected_decode_failure_is_condition_local(fixture_inputs: dict[str, Path], tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    import pixelmodel_robustness.cross_codec as module
+    from pixelmodel_robustness.cross_codec_experiment import run
+    original = module.decode_protected_high
+    def failing_decode(artifact: object, shape: object, values: object, **kwargs: object):
+        if getattr(artifact, "low_codec", None) == "jpeg_q80":
+            raise RuntimeError("protected decoder failed")
+        return original(artifact, shape, values, **kwargs)
+    monkeypatch.setattr(module, "decode_protected_high", failing_decode)
+    result = run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=runtime_factory)
+    rows = [json.loads(line) for line in (result / "results" / "raw_rows.jsonl").read_text().splitlines()]
+    failed_weights = [row for row in rows if row["row_type"] == "weight" and row["status"] == "codec_pipeline_failed"]
+    assert [row["condition"] for row in failed_weights] == ["jpeg_q80_protected_high"]
+    assert all(row["failure_stage"] == "protected_invariant" for row in failed_weights)
+    assert json.loads((result / "pilot_gate.json").read_text())["pass"] is False
+
+
+def test_incomplete_failed_generation_rejects_any_sample_artifact_field(fixture_inputs: dict[str, Path], tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import condition_complete, load_rows_strict, run
+    result = run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=runtime_factory)
+    manifest = json.loads((result / "manifest.json").read_text())
+    rows = load_rows_strict(result / "results" / "raw_rows.jsonl", manifest["run_identity_hash"])
+    target = next(row for row in rows if row["row_type"] == "generation")
+    target["success"] = False
+    target["attempted"] = True
+    target["completed"] = True
+    target["failure_stage"] = "generation"
+    target["sample_bytes"] = 1
+    assert condition_complete(rows, target["condition"], set(manifest["prompt_ids"]), set(manifest["layer_ids"]), result) is False
+
+
+def test_completed_manifest_records_raw_rows_bytes(fixture_inputs: dict[str, Path], tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import run
+
+    result = run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=runtime_factory)
+    manifest = json.loads((result / "manifest.json").read_text())
+    raw = result / "results" / "raw_rows.jsonl"
+    assert manifest["raw_rows_bytes"] == raw.stat().st_size
+
+
+def test_resource_monitor_is_bound_and_gate_rejects_resource_tamper(fixture_inputs: dict[str, Path], tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import run, validate_pilot_gate
+    result = run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=runtime_factory)
+    manifest = json.loads((result / "manifest.json").read_text())
+    metadata = manifest["resource_monitor"]
+    assert metadata["binding_method"] == "run_completion" and metadata["bytes"] > 0 and metadata["sha256"]
+    resource = result / metadata["path"]
+    resource.write_bytes(resource.read_bytes() + b'{}\n')
+    with pytest.raises(ValueError, match="pilot gate|resource"):
+        validate_pilot_gate(result / "pilot_gate.json")
+
+
+def test_resource_monitor_migration_preserves_data_and_is_idempotent(fixture_inputs: dict[str, Path], tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import (
+        bind_completed_resource_monitor,
+        run,
+        validate_pilot_gate,
+        validate_resource_monitor,
+    )
+    result = run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=runtime_factory)
+    manifest_path = result / "manifest.json"
+    manifest = json.loads(manifest_path.read_text())
+    original_identity = {key: manifest[key] for key in ("source_sha256", "run_identity", "run_identity_hash", "scientific_identity_hash")}
+    manifest.pop("resource_monitor")
+    manifest["mode"] = "real"
+    manifest_path.write_text(json.dumps(manifest), encoding="utf-8")
+    tracked = [result / "results" / "raw_rows.jsonl", result / "results" / "resource_monitor.jsonl"]
+    tracked += [path for path in result.rglob("*") if path.is_file() and ("payloads" in path.parts or "samples" in path.parts)]
+    before = {str(path.relative_to(result)): (path.stat().st_size, hashlib.sha256(path.read_bytes()).hexdigest()) for path in tracked}
+    bind_completed_resource_monitor(result, fixture_inputs["image"])
+    bind_completed_resource_monitor(result, fixture_inputs["image"])
+    after = {str(path.relative_to(result)): (path.stat().st_size, hashlib.sha256(path.read_bytes()).hexdigest()) for path in tracked}
+    updated = json.loads(manifest_path.read_text())
+    assert before == after
+    assert {key: updated[key] for key in original_identity} == original_identity
+    assert updated["resource_monitor"]["binding_method"] == "post_run_verified"
+    gate_data = validate_pilot_gate(result / "pilot_gate.json")
+    assert gate_data["gate"]["resource_monitor"] == updated["resource_monitor"]
+    actual = validate_resource_monitor(result, updated, [json.loads(line) for line in (result / "results" / "raw_rows.jsonl").read_text().splitlines()])
+    assert all(updated["resource_monitor"][key] == actual[key] for key in actual)
+
+
+def test_migration_gate_rejects_forged_resource_annotations(fixture_inputs: dict[str, Path], tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import (
+        _hash,
+        bind_completed_resource_monitor,
+        run,
+        sha256_file,
+        validate_pilot_gate,
+    )
+    result = run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=runtime_factory)
+    manifest_path = result / "manifest.json"
+    manifest = json.loads(manifest_path.read_text())
+    manifest["mode"] = "real"
+    manifest.pop("resource_monitor")
+    manifest_path.write_text(json.dumps(manifest), encoding="utf-8")
+    bind_completed_resource_monitor(result, fixture_inputs["image"])
+    gate_path = result / "pilot_gate.json"
+    gate = json.loads(gate_path.read_text())
+    gate["resource_monitor"]["binding_method"] = "unknown"
+    gate_path.write_text(json.dumps(gate), encoding="utf-8")
+    with pytest.raises(ValueError, match="pilot gate|tampered"):
+        validate_pilot_gate(gate_path)
+    manifest = json.loads(manifest_path.read_text())
+    manifest["resource_monitor"]["binding_method"] = "unknown"
+    manifest_path.write_text(json.dumps(manifest), encoding="utf-8")
+    gate = json.loads(gate_path.read_text())
+    gate["resource_monitor"] = manifest["resource_monitor"]
+    gate["manifest_sha256"] = sha256_file(manifest_path)
+    gate["gate_hash"] = _hash({key: value for key, value in gate.items() if key != "gate_hash"})
+    gate_path.write_text(json.dumps(gate), encoding="utf-8")
+    with pytest.raises(ValueError, match="resource|pilot gate"):
+        validate_pilot_gate(gate_path)
+
+
+def test_bound_resource_rejects_invalid_post_run_annotations(fixture_inputs: dict[str, Path], tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import _validate_bound_resource, run, validate_resource_monitor
+    result = run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=runtime_factory)
+    manifest = json.loads((result / "manifest.json").read_text())
+    rows = [json.loads(line) for line in (result / "results" / "raw_rows.jsonl").read_text().splitlines()]
+    actual = validate_resource_monitor(result, manifest, rows)
+    for annotation in ({"bound_at": "not-utc", "binding_code_hash": "a" * 64}, {"bound_at": "2026-01-01T00:00:00+00:00", "binding_code_hash": "A" * 64}):
+        recorded = {**actual, "binding_method": "post_run_verified", **annotation}
+        with pytest.raises((ValueError, TypeError), match="bound_at|binding_code_hash"):
+            _validate_bound_resource(recorded, actual)
+
+
+def test_resource_monitor_migration_rejects_wrong_source(fixture_inputs: dict[str, Path], tmp_path: Path) -> None:
+    from pixelmodel_robustness.cross_codec_experiment import bind_completed_resource_monitor, run
+    result = run(make_args(fixture_inputs, tmp_path / "out"), preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=runtime_factory)
+    manifest_path = result / "manifest.json"
+    manifest = json.loads(manifest_path.read_text())
+    manifest.pop("resource_monitor")
+    manifest_path.write_text(json.dumps(manifest), encoding="utf-8")
+    with pytest.raises(ValueError, match="source"):
+        bind_completed_resource_monitor(result, tmp_path / "wrong.png")

tests/test_cross_codec_report.py

@@ -0,0 +1,547 @@
+from __future__ import annotations
+
+import csv
+import hashlib
+import json
+from pathlib import Path
+from types import MappingProxyType
+from typing import ClassVar
+
+import numpy as np
+import pytest
+from PIL import Image
+
+import cross_codec_report as report
+from pixelmodel_robustness import cross_codec
+from pixelmodel_robustness.cross_codec import CONDITION_IDS
+from pixelmodel_robustness.cross_codec_experiment import _hash, scientific_identity_hash, validate_resource_monitor
+
+
+def _artifact(root: Path, relative: str, data: bytes) -> dict[str, object]:
+    path = root / relative
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(data)
+    return {"path": relative, "bytes": len(data), "sha256": hashlib.sha256(data).hexdigest()}
+
+
+def _run(tmp_path: Path, *, status: str = "completed", mode: str = "real", prompt_count: int = 2, prompt_projection: str = "base") -> Path:
+    run = tmp_path / "run"
+    run.mkdir()
+    source = np.zeros((4, 4, 3), dtype=np.uint8)
+    Image.fromarray(source, "RGB").save(run / "source.png")
+    _artifact(run, "source.png", (run / "source.png").read_bytes())
+    prompts = [
+        {"prompt_id": f"p-{i}", "category": f"cat-{i}", "prompt": f"prompt {i}", "seed": i, "initial_latent_seed": i + 10}
+        for i in range(prompt_count)
+    ]
+    rows: list[dict[str, object]] = []
+    for index, condition in enumerate(CONDITION_IDS):
+        family = condition.replace("_repair_zero", "_raw").replace("_protected_high", "_raw")
+        payload = _artifact(run, f"payloads/{family}.bin", bytes([CONDITION_IDS.index(family) + 1, 2, 3]))
+        weight: dict[str, object] = {
+            "row_type": "weight", "stage": "weight", "condition": condition, "run_identity_hash": "run-hash",
+            "status": "completed", "failure_stage": None, "payload": payload, "protected": None,
+            "payload_bytes": payload["bytes"], "payload_sha256": payload["sha256"], "source_bytes": 3,
+            "payload_definition": "source payload; protected=high+low; materialized excluded",
+            "nan_count": index % 2, "posinf_count": 0, "neginf_count": 0,
+            "sign_mismatch_count": index, "exponent_mismatch_count": index * 2, "mantissa_mismatch_count": index * 3,
+            "repaired_count": 1 if "repair" in condition else 0, "mse": float(index), "mae": float(index) / 2,
+            "cosine": 1.0, "finite_pair_label": "all_elements", "observed": True,
+        }
+        if "protected_high" in condition:
+            high = _artifact(run, f"payloads/{condition}-high.png", b"high")
+            low = _artifact(run, f"payloads/{condition}-low.bin", b"low")
+            weight["protected"] = {"high": high, "low": low, "bytes": 7, "sha256": hashlib.sha256(b"highlow").hexdigest()}
+            weight["payload"] = {"high": high, "low": low, "bytes": 7, "sha256": hashlib.sha256(b"highlow").hexdigest()}
+            weight["payload_bytes"] = 7
+            weight["payload_sha256"] = hashlib.sha256(b"highlow").hexdigest()
+        rows.append(weight)
+        rows.append({"row_type": "layer", "stage": "layer", "condition": condition, "layer": "layer0", "prompt_id": None, "run_identity_hash": "run-hash", "finite": True, "mse": 0.0, "mae": 0.0, "cosine": 1.0})
+        for prompt in prompts:
+            success = not (condition == "jpeg_q80_raw" and prompt["prompt_id"] == "p-1")
+            sample = None
+            score = None
+            if success:
+                sample_path = f"samples/{condition}/{prompt['prompt_id']}.png"
+                sample = _artifact(run, sample_path, b"sample")
+                score = 0.5 + index / 100 + int(prompt["seed"]) / 1000
+            rows.append({
+                "row_type": "generation", "stage": "generation", "condition": condition,
+                "prompt_id": prompt["prompt_id"], "category": prompt["category"], "prompt": prompt["prompt"],
+                "seed": prompt["seed"], "initial_latent_seed": prompt["initial_latent_seed"],
+                "run_identity_hash": "run-hash", "attempted": True, "completed": True,
+                "success": success, "blocked": False, "failure_stage": None if success else "generation",
+                "first_error": None if success else "CLIP failed", "clip_score": score,
+                "sample": sample, "sample_path": sample["path"] if sample else None,
+                "sample_hash": sample["sha256"] if sample else None, "sample_bytes": sample["bytes"] if sample else None,
+            })
+    raw = run / "results" / "raw_rows.jsonl"
+    raw.parent.mkdir()
+    raw.write_text("".join(json.dumps(row, sort_keys=True) + "\n" for row in rows), encoding="utf-8")
+    resource = run / "results" / "resource_monitor.jsonl"
+    resource_rows = [{"row_type": "resource_guard", "stage": "preflight", "condition": None, "prompt_id": None, "run_identity_hash": "placeholder", "rss_bytes": 1, "system_available_percent": 90.0, "mps_allocated_bytes": None, "mps_driver_allocated_bytes": None, "violation_reason": None}]
+    resource_rows += [{"row_type": "resource", "stage": "resource", "condition": row["condition"], "prompt_id": row["prompt_id"], "run_identity_hash": "placeholder", "rss_bytes": 1, "system_available_percent": 90.0, "mps_allocated_bytes": None, "mps_driver_allocated_bytes": None, "violation_reason": None} for row in rows if row["row_type"] == "generation" and row["attempted"] and not row["blocked"]]
+    resource.write_text("".join(json.dumps(row, sort_keys=True) + "\n" for row in resource_rows), encoding="utf-8")
+    prompt_ids = [p["prompt_id"] for p in prompts]
+    selected_prompts = prompts if prompt_projection == "base" else [{**prompt, "paired_seed": prompt["seed"]} for prompt in prompts]
+    prompt_hash = _hash(selected_prompts)
+    identity = {"source_sha256": hashlib.sha256((run / "source.png").read_bytes()).hexdigest(), "source_bytes": (run / "source.png").stat().st_size, "model_sha256": None, "config_sha256": "config", "prompt_sha256": "prompts", "upstream_revision": "upstream", "code_hashes": {}, "runtime_git": {}, "runtime_platform": {}, "package_versions": {}, "vae": {}, "clip": {}, "requested_device": "mps", "resolved_device": "mps", "mode": mode, "steps": 50, "cfg": 6.0, "profile": "pilot", "prompt_ids": prompt_ids, "prompt_selection_hash": prompt_hash, "condition_registry_hash": cross_codec.semantic_hash(cross_codec.CONDITION_REGISTRY), "codec_preflight": []}
+    run_hash = _hash(identity)
+    for row in rows: row["run_identity_hash"] = run_hash
+    raw.write_text("".join(json.dumps(row, sort_keys=True) + "\n" for row in rows), encoding="utf-8")
+    resource_rows = [{**row, "run_identity_hash": run_hash} for row in resource_rows]
+    resource.write_text("".join(json.dumps(row, sort_keys=True) + "\n" for row in resource_rows), encoding="utf-8")
+    resource_metadata = validate_resource_monitor(run, {"run_identity_hash": run_hash}, rows)
+    manifest = {
+        "status": status, "mode": mode, "profile": "pilot", "run_identity": identity,
+        "run_identity_hash": run_hash, "scientific_identity_hash": scientific_identity_hash(identity), "raw_rows_sha256": hashlib.sha256(raw.read_bytes()).hexdigest(),
+        "raw_rows_bytes": raw.stat().st_size, "source_sha256": identity["source_sha256"], "source_bytes": identity["source_bytes"],
+        "condition_registry_hash": cross_codec.semantic_hash(cross_codec.CONDITION_REGISTRY), "conditions": list(CONDITION_IDS), "prompt_ids": prompt_ids, "layer_ids": ["layer0"],
+        "bootstrap": {"seed": 20260727, "resamples": 10000}, "prompt_selection_hash": prompt_hash, "resource_monitor": {**resource_metadata, "binding_method": "run_completion"},
+    }
+    (run / "manifest.json").write_text(json.dumps(manifest, sort_keys=True), encoding="utf-8")
+    return run
+
+
+def _csv(path: Path) -> list[dict[str, str]]:
+    with path.open(newline="", encoding="utf-8") as stream:
+        return list(csv.DictReader(stream))
+
+
+def test_condition_registry_is_exactly_ordered() -> None:
+    assert len(report.CONDITION_IDS) == 17
+    assert report.CONDITION_IDS == CONDITION_IDS
+
+
+def test_bootstrap_is_sorted_and_known_fixture() -> None:
+    pairs = [("p-2", 2.0), ("p-0", 0.0), ("p-1", 1.0)]
+    assert report.paired_bootstrap(pairs, seed=1, samples=1000) == report.paired_bootstrap(list(reversed(pairs)), seed=1, samples=1000)
+    result = report.paired_bootstrap(pairs, seed=1, samples=1000)
+    assert result["n"] == 3 and result["mean_delta"] == 1.0 and result["ci_low"] <= 1.0 <= result["ci_high"]
+
+
+def test_bootstrap_empty_is_na() -> None:
+    assert report.paired_bootstrap([], seed=1, samples=10)["n"] == 0
+    assert report.paired_bootstrap([], seed=1, samples=10)["ci_low"] is None
+
+
+def test_generate_exact_csv_schemas_and_counts(tmp_path: Path) -> None:
+    output = report.generate_report(_run(tmp_path), fixture=True)
+    assert {p.name for p in output.iterdir()} >= {"codec_conditions.csv", "weight_metrics.csv", "generation_metrics.csv", "storage_metrics.csv", "summary.md", "final_conclusion.md", "index.html", "report_manifest.json"}
+    assert len(_csv(output / "codec_conditions.csv")) == len(_csv(output / "weight_metrics.csv")) == len(_csv(output / "storage_metrics.csv")) == 17
+    assert len(_csv(output / "generation_metrics.csv")) == 34
+    assert list(_csv(output / "codec_conditions.csv")[0]) == list(report.CONDITION_COLUMNS)
+
+
+def test_failed_clip_is_na_not_zero(tmp_path: Path) -> None:
+    output = report.generate_report(_run(tmp_path), fixture=True)
+    failed = next(row for row in _csv(output / "generation_metrics.csv") if row["condition_id"] == "jpeg_q80_raw" and row["prompt_id"] == "p-1")
+    assert failed["clip_score"] in {"", "N/A"} and failed["success"] == "0"
+
+
+def test_condition_aggregate_has_fixed_denominator_and_failure_stage(tmp_path: Path) -> None:
+    output = report.generate_report(_run(tmp_path), fixture=True)
+    summary = _csv(output / "condition_summary.csv")
+    row = next(item for item in summary if item["condition_id"] == "jpeg_q80_raw")
+    assert row["attempted"] == "2" and row["completed"] == "2" and row["denominator"] == "2" and row["first_failure_stage"] == "generation"
+
+
+def test_payload_protected_raw_repair_share_and_materialized_exclusion(tmp_path: Path) -> None:
+    output = report.generate_report(_run(tmp_path), fixture=True)
+    rows = _csv(output / "storage_metrics.csv")
+    assert all(row["payload_definition"].startswith("encoded payload") for row in rows)
+    assert all(row["payload_bytes"] != "" for row in rows)
+    assert report.validate_protected_payload_rows(rows)
+
+
+def test_grid_has_thirteen_columns_and_q80_grid(tmp_path: Path) -> None:
+    output = report.generate_report(_run(tmp_path), fixture=True)
+    assert report.GRID_COLUMNS == ("PNG", "JPEG Q100 Raw", "JPEG Q100 Repair", "JPEG Q100 Protected", "WebP Q80 Raw", "WebP Q80 Repair", "WebP Q80 Protected", "AVIF Q70 Raw", "AVIF Q70 Repair", "AVIF Q70 Protected", "JXL d1 Raw", "JXL d1 Repair", "JXL d1 Protected")
+    for name in ("generation_comparison_grid.png", "generation_comparison_grid_jpeg_q80.png"):
+        assert (output / "plots" / name).is_file()
+
+
+def test_all_plots_are_decodable_and_nonempty(tmp_path: Path) -> None:
+    output = report.generate_report(_run(tmp_path), fixture=True)
+    for path in (output / "plots").glob("*.png"):
+        with Image.open(path) as image:
+            assert image.width >= 400 and image.height >= 200
+
+
+def test_identity_binds_required_inputs(tmp_path: Path) -> None:
+    output = report.generate_report(_run(tmp_path), fixture=True)
+    manifest = json.loads((output / "report_manifest.json").read_text())
+    for key in ("run_identity_hash", "raw_rows_sha256", "report_code_hash", "condition_registry_hash", "profile", "prompt_selection_hash"):
+        assert key in manifest["report_identity"]
+
+
+def test_same_identity_is_deterministic_except_generated_at(tmp_path: Path) -> None:
+    run = _run(tmp_path)
+    first = report.generate_report(run, fixture=True)
+    before = {str(p.relative_to(first)): p.read_bytes() for p in first.rglob("*") if p.is_file() and p.name != "report_manifest.json"}
+    second = report.generate_report(run, fixture=True)
+    after = {str(p.relative_to(second)): p.read_bytes() for p in second.rglob("*") if p.is_file() and p.name != "report_manifest.json"}
+    assert before == after
+
+
+def test_identity_mismatch_rejected_without_force(tmp_path: Path) -> None:
+    run = _run(tmp_path)
+    report.generate_report(run, fixture=True)
+    value = json.loads((run / "manifest.json").read_text())
+    value["prompt_selection_hash"] = "changed"
+    (run / "manifest.json").write_text(json.dumps(value), encoding="utf-8")
+    with pytest.raises(ValueError, match="identity|hash"):
+        report.generate_report(run, fixture=True)
+
+
+def test_force_report_allows_replacement(tmp_path: Path) -> None:
+    run = _run(tmp_path)
+    report.generate_report(run, fixture=True, report_options={"version": "A"})
+    assert report.generate_report(run, fixture=True, report_options={"version": "B"}, force_report=True).is_dir()
+
+
+def test_report_manifest_contains_relative_rehashed_artifacts(tmp_path: Path) -> None:
+    output = report.generate_report(_run(tmp_path), fixture=True)
+    manifest = json.loads((output / "report_manifest.json").read_text())
+    for artifact in manifest["artifacts"]:
+        path = output / artifact["path"]
+        assert not path.is_absolute() or str(path).startswith(str(output))
+        assert path.stat().st_size == artifact["bytes"]
+        assert hashlib.sha256(path.read_bytes()).hexdigest() == artifact["sha256"]
+
+
+def test_raw_tamper_rejected(tmp_path: Path) -> None:
+    run = _run(tmp_path)
+    (run / "results" / "raw_rows.jsonl").write_text("tampered\n", encoding="utf-8")
+    with pytest.raises(ValueError, match="raw"):
+        report.generate_report(run, fixture=True)
+
+
+def test_completed_pipeline_failure_is_rejected(tmp_path: Path) -> None:
+    run = _run(tmp_path, status="completed_with_pipeline_failures")
+    with pytest.raises(ValueError, match="pipeline|scientific"):
+        report.generate_report(run, fixture=True)
+
+
+def test_fixture_mode_is_not_scientific_conclusion(tmp_path: Path) -> None:
+    run = _run(tmp_path, mode="fixture")
+    output = report.generate_report(run, fixture=True)
+    text = (output / "final_conclusion.md").read_text()
+    assert "fixture" in text.lower() and "not final" in text.lower()
+
+
+def test_summary_and_conclusion_have_observations_questions_and_fid_na(tmp_path: Path) -> None:
+    output = report.generate_report(_run(tmp_path), fixture=True)
+    summary = (output / "summary.md").read_text()
+    conclusion = (output / "final_conclusion.md").read_text()
+    assert "Observations" in summary and "Conclusions" not in summary
+    assert "Questions" in conclusion and "FID" in conclusion and "N/A" in conclusion
+    assert all(f"Question {i}" in conclusion for i in range(1, 7))
+
+
+def test_weight_map_helper_uses_injected_decoder() -> None:
+    values = np.array([0, 1, 2, 3], dtype=np.uint8)
+    decoded = report.compute_weight_error_map(values, values + 1, decoder=lambda payload: payload)
+    assert decoded.shape == (2, 2) and float(decoded.mean()) == 1.0
+
+
+def test_missing_sample_is_annotated_not_synthesized(tmp_path: Path) -> None:
+    run = _run(tmp_path)
+    sample = run / "samples/png_baseline/p-0.png"
+    sample.unlink()
+    with pytest.raises(ValueError, match="sample|artifact|condition_complete"):
+        report.generate_report(run, fixture=True)
+
+
+def test_cli_parser_has_required_options() -> None:
+    parser = report.build_parser()
+    args = parser.parse_args(["--run-dir", "run", "--force-report"])
+    assert args.run_dir == "run" and args.force_report is True and args.output is None
+
+
+def test_paired_quality_csv_has_exact_order_and_png_zero(tmp_path: Path) -> None:
+    output = report.generate_report(_run(tmp_path), fixture=True)
+    rows = _csv(output / "paired_quality_metrics.csv")
+    assert [row["condition_id"] for row in rows] == list(CONDITION_IDS)
+    assert list(rows[0]) == list(report.PAIRED_COLUMNS)
+    assert rows[0]["paired_n"] == "2" and rows[0]["mean_delta"] == "0.0" and rows[0]["ci_low"] == "0.0" and rows[0]["ci_high"] == "0.0"
+
+
+def test_required_artifact_allowlist_and_public_manifest_verifier(tmp_path: Path) -> None:
+    output = report.generate_report(_run(tmp_path), fixture=True)
+    assert {item["path"] for item in json.loads((output / "report_manifest.json").read_text())["artifacts"]} == report.REQUIRED_ARTIFACTS
+    assert report.verify_report_manifest(output)
+
+
+def test_report_records_and_rehashes_source_and_resource_provenance(tmp_path: Path) -> None:
+    run = _run(tmp_path)
+    output = report.generate_report(run, fixture=True)
+    manifest = json.loads((output / "report_manifest.json").read_text())
+    provenance = manifest["input_provenance"]
+    assert provenance["source_sha256"] == json.loads((run / "manifest.json").read_text())["source_sha256"]
+    assert provenance["source_bytes"] == json.loads((run / "manifest.json").read_text())["source_bytes"]
+    assert "source_path" not in provenance and "source_path" not in manifest["report_identity"]
+    assert provenance["baseline_source_path"] == "payloads/png_baseline.bin"
+    assert provenance["baseline_source_sha256"] and provenance["baseline_source_bytes"] == 3
+    assert provenance["resource_monitor_path"] == "results/resource_monitor.jsonl"
+    assert provenance["resource_monitor_sha256"] and provenance["resource_monitor_bytes"] > 0
+    assert report.verify_report_manifest(output)
+    (run / provenance["baseline_source_path"]).write_bytes(b"tampered")
+    assert report.verify_report_manifest(output) is False
+
+
+def test_storage_ratios_use_baseline_payload_bytes_not_scientific_source_bytes(tmp_path: Path) -> None:
+    run = _run(tmp_path)
+    manifest_path = run / "manifest.json"
+    manifest = json.loads(manifest_path.read_text())
+    manifest["source_bytes"] = 10
+    manifest_path.write_text(json.dumps(manifest, sort_keys=True), encoding="utf-8")
+    rows = [json.loads(line) for line in (run / "results" / "raw_rows.jsonl").read_text().splitlines()]
+    target = next(row for row in rows if row.get("row_type") == "weight" and row.get("condition") == "jpeg_q100_raw")
+    payload = run / target["payload"]["path"]
+    payload.write_bytes(b"123456")
+    payload_hash = hashlib.sha256(payload.read_bytes()).hexdigest()
+    for row in rows:
+        if row.get("row_type") == "weight" and row.get("condition") in {"jpeg_q100_raw", "jpeg_q100_repair_zero"}:
+            row["payload_bytes"] = 6
+            row["payload_sha256"] = payload_hash
+            row["payload"]["bytes"] = 6
+            row["payload"]["sha256"] = payload_hash
+    raw = run / "results" / "raw_rows.jsonl"
+    raw.write_text("".join(json.dumps(row, sort_keys=True) + "\n" for row in rows), encoding="utf-8")
+    manifest["raw_rows_sha256"] = hashlib.sha256(raw.read_bytes()).hexdigest()
+    manifest["raw_rows_bytes"] = raw.stat().st_size
+    manifest_path.write_text(json.dumps(manifest, sort_keys=True), encoding="utf-8")
+    output = report.generate_report(run, fixture=True)
+    storage = {row["condition_id"]: row for row in _csv(output / "storage_metrics.csv")}
+    assert storage["png_baseline"]["source_bytes"] == "3"
+    assert storage["png_baseline"]["payload_over_png"] == "1.0"
+    assert storage["jpeg_q100_raw"]["payload_over_png"] == "2.0"
+    assert storage["jpeg_q100_raw"]["png_over_payload"] == "0.5"
+    assert storage["jpeg_q100_raw"]["size_saving_percent"] == "-100.0"
+
+
+def test_report_rejects_run_dir_as_output(tmp_path: Path) -> None:
+    run = _run(tmp_path)
+    with pytest.raises(ValueError, match="run directory"):
+        report.generate_report(run, run, fixture=True)
+
+
+def test_task2_fixture_run_integrates_with_report(tmp_path: Path) -> None:
+    from test_cross_codec_experiment import fixture_inputs, make_args, payload_factory, preflight, runtime_factory
+    (tmp_path / "task2").mkdir(parents=True)
+    inputs = fixture_inputs.__wrapped__(tmp_path / "task2")
+    from pixelmodel_robustness.cross_codec_experiment import run
+    run_dir = run(make_args(inputs, tmp_path / "task2-run"), preflight_factory=preflight, payload_factory=payload_factory, runtime_factory=runtime_factory)
+    output = report.generate_report(run_dir, fixture=True)
+    assert len(_csv(output / "generation_metrics.csv")) == 17 * 8
+
+
+def test_actual_exponent_map_is_nonzero_and_plot_calls_helper() -> None:
+    source = np.array([0x3C, 0x00, 0, 0], dtype=np.uint8)
+    candidate = source.copy(); candidate[0] ^= 0x7C
+    mapping = report.compute_exponent_density_map(source, candidate)
+    assert float(np.nansum(mapping)) > 0.0
+
+
+def _rewrite_raw(run: Path, mutator: object) -> None:
+    raw = run / "results" / "raw_rows.jsonl"
+    rows = [json.loads(line) for line in raw.read_text().splitlines()]
+    mutator(rows)
+    raw.write_text("".join(json.dumps(row, sort_keys=True) + "\n" for row in rows), encoding="utf-8")
+    manifest_path = run / "manifest.json"
+    manifest = json.loads(manifest_path.read_text())
+    manifest["raw_rows_sha256"] = hashlib.sha256(raw.read_bytes()).hexdigest()
+    manifest["raw_rows_bytes"] = raw.stat().st_size
+    resource_path = run / "results" / "resource_monitor.jsonl"
+    resource_rows = [json.loads(line) for line in resource_path.read_text().splitlines()]
+    expected = {(row["condition"], str(row["prompt_id"])) for row in rows if row.get("row_type") == "generation" and row.get("attempted") is True and not row.get("blocked")}
+    resource_rows = [row for row in resource_rows if row.get("row_type") == "resource_guard" or (row.get("condition"), str(row.get("prompt_id"))) in expected]
+    resource_path.write_text("".join(json.dumps(row, sort_keys=True) + "\n" for row in resource_rows), encoding="utf-8")
+    manifest["resource_monitor"] = {**validate_resource_monitor(run, manifest, rows), "binding_method": "run_completion"}
+    manifest_path.write_text(json.dumps(manifest, sort_keys=True), encoding="utf-8")
+
+
+@pytest.mark.parametrize("field", ["payload_bytes", "payload_sha256"])
+def test_top_level_payload_metadata_mismatch_is_rejected(tmp_path: Path, field: str) -> None:
+    run = _run(tmp_path)
+    rows = [json.loads(line) for line in (run / "results" / "raw_rows.jsonl").read_text().splitlines()]
+    weight = next(row for row in rows if row["row_type"] == "weight" and row["condition"] == "jpeg_q100_raw")
+    weight[field] = weight[field] + 1 if field == "payload_bytes" else "bad"
+    with pytest.raises(ValueError, match="payload metadata"):
+        report._verify_payload_contract(run, rows)
+
+
+def test_protected_nested_payload_mismatch_is_rejected(tmp_path: Path) -> None:
+    run = _run(tmp_path)
+    rows = [json.loads(line) for line in (run / "results" / "raw_rows.jsonl").read_text().splitlines()]
+    weight = next(row for row in rows if row["row_type"] == "weight" and row["condition"] == "jpeg_q100_protected_high")
+    weight["payload"]["bytes"] = 6
+    with pytest.raises(ValueError, match="payload metadata|protected"):
+        report._verify_payload_contract(run, rows)
+
+
+def test_all_blocked_has_explicit_n_zero_na_text(tmp_path: Path) -> None:
+    run = _run(tmp_path)
+    def block(rows: list[dict[str, object]]) -> None:
+        for row in rows:
+            if row.get("row_type") == "generation":
+                row.update(success=False, blocked=True, completed=True, clip_score=None, sample=None, sample_path=None, sample_hash=None, sample_bytes=None, failure_stage="blocked")
+    _rewrite_raw(run, block)
+    output = report.generate_report(run, fixture=True)
+    paired = _csv(output / "paired_quality_metrics.csv")
+    assert all(row["paired_n"] == "0" and row["mean_delta"] == "" and row["ci_low"] == "" and row["ci_high"] == "" and row["na_reason"] == "no successful finite prompt intersection" for row in paired)
+    summary = (output / "summary.md").read_text()
+    assert "N/A (no successful finite prompt intersection; N=0)" in summary and "None" not in summary
+    assert "None" not in (output / "final_conclusion.md").read_text()
+
+
+def test_lossless_sample_sha_rates_are_condition_specific(tmp_path: Path) -> None:
+    output = report.generate_report(_run(tmp_path), fixture=True)
+    rows = _csv(output / "condition_summary.csv")
+    by = {row["condition_id"]: row for row in rows}
+    assert by["png_baseline"]["sample_sha_match_rate"] == "1.0"
+    assert by["webp_lossless"]["sample_sha_match_rate"] == "1.0"
+    assert all(by[condition]["sample_sha_match_rate"] == "N/A" for condition in CONDITION_IDS if condition not in {"png_baseline", "webp_lossless"})
+
+
+def test_hypothesis_status_uses_observed_association_rule() -> None:
+    summaries = [{"condition_id": name, "nan_count": 1, "success": 0} for name in ("jpeg_q100_raw", "jpeg_q80_raw", "webp_q80_raw", "avif_q70_raw", "jxl_d1_raw")]
+    summaries += [{"condition_id": name, "success": 0} for name in ("jpeg_q100_repair_zero", "jpeg_q80_repair_zero", "webp_q80_repair_zero", "avif_q70_repair_zero", "jxl_d1_repair_zero")]
+    summaries += [{"condition_id": name, "success": 1, "exponent_mismatch_count": 0} for name in ("jpeg_q100_protected_high", "jpeg_q80_protected_high", "webp_q80_protected_high", "avif_q70_protected_high", "jxl_d1_protected_high")]
+    assert report.hypothesis_status(summaries) == "supported (5/5 associated lossy raw codecs)"
+
+
+def test_json_normalize_handles_immutable_nested_preflight_metadata() -> None:
+    value = MappingProxyType({"dims": (8, 8), "nested": MappingProxyType({"x": 1})})
+    assert report._json_normalize(value) == {"dims": [8, 8], "nested": {"x": 1}}
+
+
+def test_jxl_preflight_json_normalization_invokes_verified_decode(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    payload = _artifact(tmp_path, "payload.jxl", b"jxl")
+    class Preflight:
+        name = "jxl_d1"
+        version = "1"
+        metadata: ClassVar[dict[str, object]] = {"levels": (1, 2)}
+    called: dict[str, object] = {}
+    monkeypatch.setattr(report.cross_codec, "preflight_codecs", lambda: [Preflight()])
+    monkeypatch.setattr(report.cross_codec, "decode_rgb", lambda data, spec, verified_preflight=None: called.update(data=data, verified=verified_preflight) or np.zeros((1, 1, 3), dtype=np.uint8))
+    decoded, reason = report._decode_sample_payload(tmp_path, {"payload": payload}, "jxl_d1_raw", {"codec_preflight": [{"name": "jxl_d1", "version": "1", "metadata": {"levels": [1, 2]}}]}, fixture=False)
+    assert decoded is not None and reason is None and called["verified"]
+
+
+def test_jxl_preflight_changed_identity_rejects(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    payload = _artifact(tmp_path, "payload.jxl", b"jxl")
+    class Preflight:
+        name = "jxl_d1"
+        version = "2"
+        metadata: ClassVar[dict[str, object]] = {"levels": (1, 2)}
+    monkeypatch.setattr(report.cross_codec, "preflight_codecs", lambda: [Preflight()])
+    with pytest.raises(ValueError, match="JXL preflight identity mismatch"):
+        report._decode_sample_payload(tmp_path, {"payload": payload}, "jxl_d1_raw", {"codec_preflight": [{"name": "jxl_d1", "version": "1", "metadata": {"levels": [1, 2]}}]}, fixture=False)
+
+
+def test_pilot_conclusion_uses_concrete_codec_semantics(tmp_path: Path) -> None:
+    summaries = []
+    for condition in CONDITION_IDS:
+        raw = condition.endswith("_raw")
+        protected = condition.endswith("_protected_high")
+        summaries.append({"condition_id": condition, "success": 0 if raw else 8 if protected or condition in {"png_baseline", "webp_lossless", "jpeg_q100_repair_zero"} else 0, "denominator": 8, "nan_count": 1 if raw else 0, "exponent_mismatch_count": 1 if raw else 0, "payload_over_png": 0.8 if protected else 1.0, "clip_mean": 0.9 if not raw else None, "sample_sha_match_rate": 1.0 if condition in {"png_baseline", "webp_lossless"} else "N/A"})
+    paired = [{"condition_id": condition, "paired_n": 8, "mean_delta": 0.01, "ci_low": -0.01, "ci_high": 0.02} for condition in CONDITION_IDS]
+    report._documents(tmp_path, {"profile": "pilot"}, summaries, paired, fixture=False)
+    conclusion = (tmp_path / "final_conclusion.md").read_text()
+    assert "Hypothesis status: supported (5/5 associated lossy raw codecs)" in conclusion
+    assert "JPEG is not uniquely fragile in pilot" in conclusion
+    assert "Repair Zero recovered only JPEG Q100 (1/5)" in conclusion
+    assert "WebP Lossless" in conclusion and "WebP Q80 Protected" in conclusion
+    assert "JXL" in conclusion and "Question 6" in conclusion
+    assert "partially supported (1/5)" not in conclusion
+
+
+def test_full_conclusion_uses_dynamic_scope_and_full_run_language(tmp_path: Path) -> None:
+    summaries = []
+    for condition in CONDITION_IDS:
+        raw = condition.endswith("_raw")
+        protected = condition.endswith("_protected_high")
+        success = 100 if condition == "png_baseline" or protected or condition == "jpeg_q100_repair_zero" else 0
+        summaries.append({
+            "condition_id": condition,
+            "success": success,
+            "denominator": 100,
+            "nan_count": 1 if raw else 0,
+            "exponent_mismatch_count": 1 if raw else 0,
+            "payload_over_png": 0.8 if protected else 1.0,
+            "clip_mean": 0.9 if success else None,
+            "sample_sha_match_rate": 1.0 if condition in {"png_baseline", "webp_lossless"} else "N/A",
+        })
+    paired = [{"condition_id": condition, "paired_n": 100, "mean_delta": 0.01, "ci_low": -0.01, "ci_high": 0.02} for condition in CONDITION_IDS]
+
+    report._documents(tmp_path, {"profile": "full"}, summaries, paired, fixture=False)
+    conclusion = (tmp_path / "final_conclusion.md").read_text()
+
+    assert "JPEG is not uniquely fragile in full run" in conclusion
+    assert "all had 0/100 blocked" in conclusion
+    assert "other four 0/100" in conclusion
+    assert "protected candidates maintained baseline success" in conclusion
+    assert "Overall observed best" in conclusion
+    assert "pilot" not in conclusion.lower()
+    assert "limited to this pilot" not in conclusion
+
+
+def test_report_options_bind_identity_and_force_replacement(tmp_path: Path) -> None:
+    run = _run(tmp_path)
+    output = report.generate_report(run, fixture=True, report_options={"label": "A"})
+    first = json.loads((output / "report_manifest.json").read_text())["report_identity_hash"]
+    with pytest.raises(ValueError, match="identity"):
+        report.generate_report(run, fixture=True, report_options={"label": "B"})
+    report.generate_report(run, fixture=True, report_options={"label": "B"}, force_report=True)
+    second = json.loads((output / "report_manifest.json").read_text())["report_identity_hash"]
+    assert first != second
+
+
+def test_manifest_verifier_rejects_traversal_sha_tamper_and_duplicate(tmp_path: Path) -> None:
+    output = report.generate_report(_run(tmp_path), fixture=True)
+    manifest_path = output / "report_manifest.json"
+    manifest = json.loads(manifest_path.read_text())
+    manifest["artifacts"][0]["path"] = "../escape"
+    manifest_path.write_text(json.dumps(manifest), encoding="utf-8")
+    assert report.verify_report_manifest(output) is False
+    (tmp_path / "again").mkdir()
+    output = report.generate_report(_run(tmp_path / "again"), fixture=True)
+    manifest_path = output / "report_manifest.json"
+    manifest = json.loads(manifest_path.read_text())
+    manifest["artifacts"][0]["sha256"] = "bad"
+    manifest["artifacts"].append(dict(manifest["artifacts"][1]))
+    manifest_path.write_text(json.dumps(manifest), encoding="utf-8")
+    assert report.verify_report_manifest(output) is False
+
+
+def test_same_run_report_manifest_is_byte_deterministic(tmp_path: Path) -> None:
+    run = _run(tmp_path)
+    output = report.generate_report(run, fixture=True)
+    first = {str(path.relative_to(output)): path.read_bytes() for path in output.rglob("*") if path.is_file()}
+    report.generate_report(run, fixture=True)
+    second = {str(path.relative_to(output)): path.read_bytes() for path in output.rglob("*") if path.is_file()}
+    assert first == second
+
+
+def test_real_runner_paired_seed_hash_projection_is_resolved(tmp_path: Path) -> None:
+    run = _run(tmp_path, prompt_projection="paired")
+    output = report.generate_report(run, fixture=True)
+    manifest = json.loads((output / "report_manifest.json").read_text())
+    assert manifest["report_identity"]["prompt_projection"] == "paired_seed_equals_seed"
+    assert manifest["input_provenance"]["prompt_projection"] == "paired_seed_equals_seed"
+    assert [row["prompt_id"] for row in _csv(output / "generation_metrics.csv")[:2]] == ["p-0", "p-1"]
+
+
+def test_prompt_projection_rejects_unmatched_hash(tmp_path: Path) -> None:
+    prompts = [{"prompt_id": "p-0", "category": "cat", "prompt": "x", "seed": 1, "initial_latent_seed": 2}]
+    with pytest.raises(ValueError, match="prompt selection hash"):
+        report._resolve_prompt_projection(prompts, "not-a-candidate")
+
+
+def test_prompt_projection_fails_closed_on_ambiguous_hash(monkeypatch: pytest.MonkeyPatch) -> None:
+    prompts = [{"prompt_id": "p-0", "category": "cat", "prompt": "x", "seed": 1, "initial_latent_seed": 2}]
+    monkeypatch.setattr(report, "_hash", lambda value: "same-hash")
+    with pytest.raises(ValueError, match="ambiguous"):
+        report._resolve_prompt_projection(prompts, "same-hash")

tests/test_jpeg_repair.py

@@ -0,0 +1,238 @@
+"""JPEG repair Task 1-2の契約テスト。"""
+
+from __future__ import annotations
+
+from io import BytesIO
+
+import numpy as np
+import pytest
+from PIL import Image
+
+from pixelmodel_robustness.jpeg_repair import (
+    CLIP_STRATEGIES,
+    CONDITION_IDS,
+    build_jpeg_registry,
+    clip_candidate,
+    decode_jpeg_rgb,
+    decode_protected,
+    diagnostics,
+    encode_jpeg_q100,
+    encode_protected,
+    materialize_fp16_png,
+    repair_nonfinite,
+    semantic_hash,
+    validate_layer_offsets,
+)
+
+
+def _image() -> Image.Image:
+    return Image.fromarray(
+        np.array([[[0, 1, 2], [20, 40, 60]], [[100, 120, 140], [240, 220, 200]]], dtype=np.uint8),
+        "RGB",
+    )
+
+
+def test_registry_is_exact_ordered_and_semantically_hashed() -> None:
+    registry = build_jpeg_registry()
+    assert tuple(entry.condition_id for entry in registry) == CONDITION_IDS
+    assert len(registry) == 18
+    assert len({entry.parent_raw_sha256 for entry in registry[1:17]}) == 1
+    assert semantic_hash(registry) == semantic_hash(build_jpeg_registry())
+    assert tuple(entry.condition_id for entry in registry) == CONDITION_IDS
+
+
+def test_jpeg_q100_source_is_one_reusable_decode() -> None:
+    raw = encode_jpeg_q100(_image())
+    first = decode_jpeg_rgb(raw)
+    second = decode_jpeg_rgb(raw)
+    assert raw.startswith(b"\xff\xd8")
+    np.testing.assert_array_equal(first, second)
+    assert first.shape == (2, 2, 3)
+
+
+def test_fp16_flat_materialization_preserves_bits_and_png_contract() -> None:
+    values = np.array([0.0, -0.0, 1.5, -2.25, np.float16("inf")], dtype=np.float16)
+    png = materialize_fp16_png(values)
+    pixels = np.asarray(Image.open(BytesIO(png)).convert("RGB"), dtype=np.uint8).reshape(-1, 3)
+    np.testing.assert_array_equal((pixels[: len(values), 0].astype(np.uint16) << 8) | pixels[: len(values), 1], values.view(np.uint16))
+    assert pixels[:, 2].tolist() == [0] * len(values)
+
+
+def test_finite_repair_materialize_decode_preserves_original_uint16_bits() -> None:
+    original = np.array([0.0, -0.0, 1.5, -2.25, 3.125, -4.5], dtype=np.float16)
+    repaired = repair_nonfinite(original, "layer_mean", {"layer": (0, len(original))}).values
+    png = materialize_fp16_png(repaired)
+    pixels = np.asarray(Image.open(BytesIO(png)).convert("RGB"), dtype=np.uint8).reshape(-1, 3)
+    decoded_bits = (pixels[: len(original), 0].astype(np.uint16) << 8) | pixels[: len(original), 1].astype(np.uint16)
+    np.testing.assert_array_equal(decoded_bits, original.view(np.uint16))
+
+
+def test_protected_high_png_is_exact_low_jpeg_only_changes() -> None:
+    values = np.array([0.0, -0.0, 1.5, -2.25, 3.125, -4.5], dtype=np.float16)
+    artifact = encode_protected(values, (2, 3))
+    decoded, metadata = decode_protected(artifact.payload, (2, 3))
+    np.testing.assert_array_equal(decoded.view(np.uint16), values.view(np.uint16))
+    high = np.asarray(Image.open(BytesIO(artifact.high_png_bytes)).convert("L"), dtype=np.uint8)
+    np.testing.assert_array_equal(high.reshape(-1), (values.view(np.uint16) >> 8).astype(np.uint8))
+    assert metadata["payload_size_bytes"] == len(artifact.high_png_bytes) + len(artifact.low_jpeg_bytes)
+    assert metadata["high_mode"] == metadata["low_mode"] == "L"
+
+
+def test_repair_replaces_only_nonfinite_and_reports_signed_zero_bits() -> None:
+    raw = np.array([0.0, -0.0, np.nan, np.inf, -np.inf, 2.0], dtype=np.float16)
+    result = repair_nonfinite(raw, "layer_mean", {"layer": (0, len(raw))})
+    assert result.repaired_value_count == 3
+    assert result.nan_count == result.posinf_count == result.neginf_count == 1
+    assert np.isfinite(result.values).all()
+    np.testing.assert_array_equal(result.values.view(np.uint16)[[0, 1, 5]], raw.view(np.uint16)[[0, 1, 5]])
+
+
+def test_zero_repair_accepts_all_nonfinite_layer_and_preserves_finite_bits() -> None:
+    raw = np.array([np.nan, np.inf, -np.inf, 1.5, -0.0, np.nan], dtype=np.float16)
+    original_bits = raw.view(np.uint16).copy()
+
+    result = repair_nonfinite(raw, "zero", {"all_nonfinite": (0, 3), "mixed": (3, 6)})
+
+    assert np.isfinite(result.values).all()
+    assert result.repaired_value_count == 4
+    assert result.nan_count == 2
+    assert result.posinf_count == 1
+    assert result.neginf_count == 1
+    assert [record.repaired_count for record in result.layer_records] == [3, 1]
+    assert [record.nan_count for record in result.layer_records] == [1, 1]
+    assert [record.posinf_count for record in result.layer_records] == [1, 0]
+    assert [record.neginf_count for record in result.layer_records] == [1, 0]
+    finite = np.isfinite(raw)
+    np.testing.assert_array_equal(result.values.view(np.uint16)[finite], original_bits[finite])
+
+
+def test_repair_rejects_empty_finite_layer() -> None:
+    raw = np.array([np.nan, np.inf], dtype=np.float16)
+    with pytest.raises(ValueError, match="finite values"):
+        repair_nonfinite(raw, "layer_median", {"empty": (0, 2)})
+
+
+@pytest.mark.parametrize("method", ["layer_median", "layer_mean"])
+def test_repair_rejects_empty_finite_layer_for_statistical_methods(method: str) -> None:
+    raw = np.array([np.nan, np.inf, -np.inf], dtype=np.float16)
+    with pytest.raises(ValueError, match="finite values"):
+        repair_nonfinite(raw, method, {"empty": (0, 3)})
+
+
+@pytest.mark.parametrize("strategy", CLIP_STRATEGIES)
+def test_clip_strategies_use_candidate_only_and_record_changes(strategy: str) -> None:
+    candidate = np.array([-10.0, -1.0, 0.0, 1.0, 10.0], dtype=np.float16)
+    result = clip_candidate(candidate, {"layer": (0, 5)}, strategy)
+    assert result.values.dtype == np.float16
+    assert result.layers[0].strategy == strategy
+    assert result.layers[0].changed_count == int(np.count_nonzero(result.values.view(np.uint16) != candidate.view(np.uint16)))
+    assert np.isfinite(result.values).all()
+    assert result.layers[0].lower <= result.layers[0].upper
+
+
+def test_clip_uses_population_std_and_linear_percentile() -> None:
+    candidate = np.array([0.0, 1.0, 2.0, 100.0], dtype=np.float16)
+    result = clip_candidate(candidate, {"layer": (0, 4)}, "layer_mean_std_6")
+    expected = float(np.mean(candidate.astype(np.float64)) + 6 * np.std(candidate.astype(np.float64), ddof=0))
+    assert result.layers[0].upper == pytest.approx(expected)
+    percentile = clip_candidate(candidate, {"layer": (0, 4)}, "layer_pct_0.1_99.9")
+    expected_percentile = float(np.percentile(candidate.astype(np.float64), 99.9, method="linear"))
+    assert percentile.layers[0].upper == pytest.approx(expected_percentile)
+
+
+def test_clip_degenerate_and_threshold_equal_are_unchanged() -> None:
+    candidate = np.array([2.0, 2.0], dtype=np.float16)
+    result = clip_candidate(candidate, {"one": (0, 2)}, "layer_mean_std_5")
+    np.testing.assert_array_equal(result.values.view(np.uint16), candidate.view(np.uint16))
+    assert result.layers[0].changed_count == 0
+
+
+def test_fp16_bit_diagnostics_and_bounded_histogram() -> None:
+    baseline = np.array([1.0, -1.0, 0.0, 1.0], dtype=np.float16)
+    candidate = np.array([20.0, -1.0, np.float16("inf"), np.float16("nan")], dtype=np.float16)
+    result = diagnostics(baseline, candidate, {"layer": (0, 4)})
+    assert result["sign_mismatch_count"] == 0
+    assert result["exponent_mismatch_count"] == 3
+    assert result["mantissa_mismatch_count"] == 2
+    assert result["exponent_to31_count"] == 2
+    assert result["finite_extreme_outlier_count"] == 1
+    assert set(result["histograms"]) == {"baseline", "candidate", "delta"}
+    assert all(len(item["counts"]) <= 64 for item in result["histograms"].values())
+
+
+def test_registry_parent_identity_is_only_shared_by_raw_jpeg_conditions() -> None:
+    raw = encode_jpeg_q100(_image())
+    registry = build_jpeg_registry(raw)
+    assert len({entry.parent_raw_sha256 for entry in registry[1:17]}) == 1
+    assert registry[0].parent_raw_sha256 != registry[1].parent_raw_sha256
+    assert registry[17].parent_raw_sha256 != registry[1].parent_raw_sha256
+    assert registry[0].parent_raw_sha256 != registry[17].parent_raw_sha256
+
+
+def test_layer_offsets_are_contiguous_and_fail_closed() -> None:
+    assert validate_layer_offsets({"a": (0, 2), "b": (2, 4)}, 4) == {"a": (0, 2), "b": (2, 4)}
+    with pytest.raises(ValueError, match="contiguous"):
+        validate_layer_offsets({"a": (0, 2), "b": (3, 4)}, 4)
+    with pytest.raises(ValueError, match="overlap"):
+        validate_layer_offsets({"a": (0, 3), "b": (2, 4)}, 4)
+
+
+def test_diagnostics_extreme_uses_layer_baseline_max_and_reports_finite_stats() -> None:
+    baseline = np.array([1.0, 2.0, 0.0, 0.0], dtype=np.float16)
+    candidate = np.array([25.0, 2.0, 1.0, 0.0], dtype=np.float16)
+    result = diagnostics(baseline, candidate, {"first": (0, 2), "zero": (2, 4)})
+    assert result["finite_extreme_outlier_count"] == 2
+    assert result["finite_count"] == 4
+    assert result["max_abs_weight"] == pytest.approx(25.0)
+    assert result["nan_count"] == result["posinf_count"] == result["neginf_count"] == 0
+    assert result["layers"][0]["finite_extreme_outlier_count"] == 1
+    assert result["layers"][1]["finite_extreme_outlier_count"] == 1
+    assert result["layers"][1]["max_abs_weight"] == pytest.approx(1.0)
+
+
+def test_repair_has_layer_records_and_bounded_repaired_histogram() -> None:
+    raw = np.array([np.nan, np.inf, -np.inf, 1.0], dtype=np.float16)
+    result = repair_nonfinite(raw, "zero", {"layer": (0, 4)})
+    record = result.layer_records[0]
+    assert record.layer == "layer"
+    assert record.repaired_count == 3
+    assert record.nan_count == record.posinf_count == record.neginf_count == 1
+    assert sum(result.repaired_histogram["counts"]) == 3
+    assert len(result.repaired_histogram["counts"]) <= 64
+
+
+def test_clip_has_total_count_and_changed_value_histograms() -> None:
+    candidate = np.array([-100.0, -1.0, 0.0, 1.0, 100.0], dtype=np.float16)
+    result = clip_candidate(candidate, {"layer": (0, 5)}, "layer_mean_std_5")
+    assert result.total_clipped_count == result.layers[0].changed_count
+    assert sum(result.changed_pre_histogram["counts"]) == result.total_clipped_count
+    assert sum(result.changed_post_histogram["counts"]) == result.total_clipped_count
+    assert sum(result.changed_delta_histogram["counts"]) == result.total_clipped_count
+
+
+def test_protected_metadata_reports_decoded_planes_and_low_changes() -> None:
+    rng = np.random.default_rng(20260727)
+    values = rng.integers(0, 65536, size=32 * 32, dtype=np.uint16).view(np.float16)
+    artifact = encode_protected(values, (32, 32))
+    decoded, metadata = decode_protected(artifact.payload, (32, 32), source_values=values)
+    assert metadata["decoded_high_exact"] is True
+    assert metadata["decoded_high_sha256"]
+    assert metadata["decoded_low_sha256"]
+    assert metadata["decoded_low_changed_count"] > 0
+    assert 0.0 < metadata["decoded_low_changed_rate"] <= 1.0
+    assert metadata["pillow_version"]
+    assert metadata["combined_payload_exact"] is True
+    assert metadata["high_mode"] == metadata["low_mode"] == "L"
+    assert metadata["high_dimensions"] == metadata["low_dimensions"] == [32, 32]
+    assert metadata["combined_payload_sha256"]
+    assert metadata["combined_payload_bytes"] == metadata["high_bytes"] + metadata["low_bytes"]
+    assert "jpeg_codec_version" in metadata
+    assert decoded.shape == values.shape
+
+
+def test_combined_payload_parser_rejects_invalid_png_chunk_bounds() -> None:
+    values = np.arange(16, dtype=np.float16)
+    artifact = encode_protected(values, (4, 4))
+    broken = artifact.payload[:16] + b"\xff"
+    with pytest.raises(ValueError, match="PNG"):
+        decode_protected(broken, (4, 4))

tests/test_render_visual_tables.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from pathlib import Path
+
+import pytest
+from PIL import Image
+from render_visual_tables import CODECS, load_prompt_ids, load_rows, render
+
+
+def test_load_prompt_ids_accepts_manifest_object(tmp_path: Path) -> None:
+    path = tmp_path / "prompts.json"
+    path.write_text(json.dumps({"prompt_ids": ["p2", "p1"]}), encoding="utf-8")
+
+    assert load_prompt_ids(path) == ["p2", "p1"]
+
+
+def test_load_rows_fails_closed_when_a_success_has_no_sample(tmp_path: Path) -> None:
+    run = tmp_path / "run"
+    (run / "results").mkdir(parents=True)
+    row = {"row_type": "generation", "condition": "png_baseline", "prompt_id": "p1", "success": True}
+    (run / "results/raw_rows.jsonl").write_text(json.dumps(row) + "\n", encoding="utf-8")
+
+    with pytest.raises(ValueError, match="sample"):
+        load_rows(run, ["p1"])
+
+
+def test_load_rows_rejects_raw_rows_symlink(tmp_path: Path) -> None:
+    run = tmp_path / "run"
+    (run / "results").mkdir(parents=True)
+    target = tmp_path / "raw_rows.jsonl"
+    target.write_text("", encoding="utf-8")
+    (run / "results/raw_rows.jsonl").symlink_to(target)
+
+    with pytest.raises(ValueError, match="symlink"):
+        load_rows(run, ["p1"])
+
+
+def test_load_rows_rejects_raw_rows_path_escape(tmp_path: Path) -> None:
+    run = tmp_path / "run"
+    (run / "results").mkdir(parents=True)
+    (run / "results/raw_rows.jsonl").symlink_to(tmp_path / "outside.jsonl")
+    (tmp_path / "outside.jsonl").write_text("", encoding="utf-8")
+
+    with pytest.raises(ValueError, match="escapes run|symlink"):
+        load_rows(run, ["p1"])
+
+
+def test_render_rejects_sample_replaced_with_symlink_after_validation(tmp_path: Path) -> None:
+    run = tmp_path / "run"
+    sample = run / "samples/sample.png"
+    sample.parent.mkdir(parents=True)
+    Image.new("RGB", (4, 4), "blue").save(sample)
+    sample_hash = hashlib.sha256(sample.read_bytes()).hexdigest()
+    conditions = {"png_baseline", "webp_lossless"} | {
+        condition for codec in CODECS.values() for condition in codec[1:]
+    }
+    rows = [
+        {
+            "row_type": "generation",
+            "condition": condition,
+            "prompt_id": "p1",
+            "prompt": "test prompt",
+            "category": "test",
+            "success": True,
+            "sample_path": "samples/sample.png",
+            "sample_hash": sample_hash,
+            "clip_score": 1.0,
+        }
+        for condition in sorted(conditions)
+    ]
+    results = run / "results"
+    results.mkdir()
+    (results / "raw_rows.jsonl").write_text(
+        "".join(json.dumps(row) + "\n" for row in rows),
+        encoding="utf-8",
+    )
+    loaded = load_rows(run, ["p1"])
+    outside = tmp_path / "outside.png"
+    Image.new("RGB", (4, 4), "red").save(outside)
+    sample.unlink()
+    sample.symlink_to(outside)
+
+    with pytest.raises(ValueError, match="symlink"):
+        render(
+            "jpeg_q100",
+            CODECS["jpeg_q100"],
+            run.resolve(),
+            [loaded[("png_baseline", "p1")]],
+            loaded,
+            tmp_path / "output",
+        )
+
+
+def test_render_rejects_regular_sample_changed_after_validation(tmp_path: Path) -> None:
+    run = tmp_path / "run"
+    sample = run / "samples/sample.png"
+    sample.parent.mkdir(parents=True)
+    Image.new("RGB", (4, 4), "blue").save(sample)
+    sample_hash = hashlib.sha256(sample.read_bytes()).hexdigest()
+    conditions = {"png_baseline", "webp_lossless"} | {
+        condition for codec in CODECS.values() for condition in codec[1:]
+    }
+    rows = [
+        {
+            "row_type": "generation",
+            "condition": condition,
+            "prompt_id": "p1",
+            "prompt": "test prompt",
+            "category": "test",
+            "success": True,
+            "sample_path": "samples/sample.png",
+            "sample_hash": sample_hash,
+            "clip_score": 1.0,
+        }
+        for condition in sorted(conditions)
+    ]
+    results = run / "results"
+    results.mkdir()
+    (results / "raw_rows.jsonl").write_text(
+        "".join(json.dumps(row) + "\n" for row in rows),
+        encoding="utf-8",
+    )
+    loaded = load_rows(run, ["p1"])
+    Image.new("RGB", (4, 4), "red").save(sample)
+
+    with pytest.raises(ValueError, match="hash mismatch"):
+        render(
+            "jpeg_q100",
+            CODECS["jpeg_q100"],
+            run.resolve(),
+            [loaded[("png_baseline", "p1")]],
+            loaded,
+            tmp_path / "output",
+        )
+
+
+@pytest.mark.skipif(not hasattr(os, "mkfifo"), reason="FIFO is unavailable on this platform")
+def test_render_rejects_fifo_replacement_without_blocking(tmp_path: Path) -> None:
+    run = tmp_path / "run"
+    sample = run / "samples/sample.png"
+    sample.parent.mkdir(parents=True)
+    Image.new("RGB", (4, 4), "blue").save(sample)
+    sample_hash = hashlib.sha256(sample.read_bytes()).hexdigest()
+    conditions = {"png_baseline", "webp_lossless"} | {
+        condition for codec in CODECS.values() for condition in codec[1:]
+    }
+    rows = [
+        {
+            "row_type": "generation",
+            "condition": condition,
+            "prompt_id": "p1",
+            "prompt": "test prompt",
+            "category": "test",
+            "success": True,
+            "sample_path": "samples/sample.png",
+            "sample_hash": sample_hash,
+            "clip_score": 1.0,
+        }
+        for condition in sorted(conditions)
+    ]
+    results = run / "results"
+    results.mkdir()
+    (results / "raw_rows.jsonl").write_text(
+        "".join(json.dumps(row) + "\n" for row in rows),
+        encoding="utf-8",
+    )
+    loaded = load_rows(run, ["p1"])
+    sample.unlink()
+    os.mkfifo(sample)
+
+    with pytest.raises(ValueError, match="not a regular file"):
+        render(
+            "jpeg_q100",
+            CODECS["jpeg_q100"],
+            run.resolve(),
+            [loaded[("png_baseline", "p1")]],
+            loaded,
+            tmp_path / "output",
+        )

tests/test_verify_archive.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+import csv
+import hashlib
+import json
+from pathlib import Path
+
+import pytest
+from verify_archive import verify_archive
+
+
+def _write_archive(root: Path) -> None:
+    for relative, content in {
+        "images/example.png": b"image",
+        "results/metrics.csv": b"condition,success\npng,1\n",
+        "samples/example.png": b"sample",
+        "weights/model.png": b"weights",
+    }.items():
+        path = root / relative
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_bytes(content)
+    rows = []
+    for relative in ("weights/model.png",):
+        path = root / relative
+        rows.append(
+            {
+                "path": relative,
+                "bytes": str(path.stat().st_size),
+                "sha256": hashlib.sha256(path.read_bytes()).hexdigest(),
+            }
+        )
+    with (root / "weights/manifest.csv").open("w", newline="", encoding="utf-8") as handle:
+        writer = csv.DictWriter(handle, fieldnames=["path", "bytes", "sha256"])
+        writer.writeheader()
+        writer.writerows(rows)
+    manifest = {
+        "files": [
+            {
+                "path": relative,
+                "bytes": (root / relative).stat().st_size,
+                "sha256": hashlib.sha256((root / relative).read_bytes()).hexdigest(),
+            }
+            for relative in (
+                "images/example.png",
+                "results/metrics.csv",
+                "samples/example.png",
+                "weights/manifest.csv",
+            )
+        ]
+    }
+    (root / "results/archive_manifest.json").write_text(json.dumps(manifest), encoding="utf-8")
+
+
+def _refresh_manifest(root: Path) -> None:
+    manifest_path = root / "results/archive_manifest.json"
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    manifest.pop("files", None)
+    manifest["artifacts"] = []
+    for path in sorted(p for directory in ("images", "results", "samples", "weights")
+                       for p in (root / directory).rglob("*") if p.is_file() and p.name != "archive_manifest.json"):
+        relative = path.relative_to(root).as_posix()
+        manifest["artifacts"].append({"path": relative, "bytes": path.stat().st_size,
+                                      "sha256": hashlib.sha256(path.read_bytes()).hexdigest()})
+    manifest.update({"profile": "test", "prompt_count": 1, "conditions": ["png_baseline", "webp_lossless"]})
+    manifest_path.write_text(json.dumps(manifest), encoding="utf-8")
+
+
+def _add_generation_rows(root: Path) -> None:
+    sample = root / "samples/example.png"
+    rows = [
+        {"row_type": "generation", "condition": "png_baseline", "prompt_id": "p1", "success": True,
+         "sample_path": "samples/example.png", "sample_bytes": sample.stat().st_size,
+         "sample_hash": hashlib.sha256(sample.read_bytes()).hexdigest(), "sample_sha256": None},
+        {"row_type": "generation", "condition": "webp_lossless", "prompt_id": "p1", "success": False,
+         "sample_path": None, "sample_bytes": None, "sample_hash": None, "sample_sha256": None},
+    ]
+    (root / "results/raw_rows.jsonl").write_text("".join(json.dumps(row) + "\n" for row in rows), encoding="utf-8")
+    _refresh_manifest(root)
+
+
+def test_verify_archive_accepts_hash_and_containment_valid_archive(tmp_path: Path) -> None:
+    _write_archive(tmp_path)
+    _add_generation_rows(tmp_path)
+
+    report = verify_archive(tmp_path)
+
+    assert report["checked_files"] == 7
+    assert report["checked_weight_entries"] == 1
+    assert report["generation_rows"] == 2
+    assert report["successful_samples"] == 1
+
+
+def test_verify_archive_rejects_path_escape(tmp_path: Path) -> None:
+    _write_archive(tmp_path)
+    _add_generation_rows(tmp_path)
+    manifest_path = tmp_path / "results/archive_manifest.json"
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    manifest["artifacts"].append({"path": "../outside", "bytes": 0, "sha256": ""})
+    manifest_path.write_text(json.dumps(manifest), encoding="utf-8")
+
+    with pytest.raises(ValueError, match="containment"):
+        verify_archive(tmp_path)
+
+
+@pytest.mark.parametrize("mutation, message", [
+    ("missing", "sample"),
+    ("hash", "SHA-256"),
+    ("bytes", "byte count"),
+])
+def test_verify_archive_rejects_invalid_success_provenance(tmp_path: Path, mutation: str, message: str) -> None:
+    _write_archive(tmp_path)
+    _add_generation_rows(tmp_path)
+    raw = tmp_path / "results/raw_rows.jsonl"
+    row = json.loads(raw.read_text(encoding="utf-8").splitlines()[0])
+    if mutation == "missing":
+        row["sample_path"] = None
+    elif mutation == "hash":
+        row["sample_hash"] = "0" * 64
+    else:
+        row["sample_bytes"] += 1
+    raw.write_text(json.dumps(row) + "\n" + raw.read_text(encoding="utf-8").splitlines()[1] + "\n", encoding="utf-8")
+    _refresh_manifest(tmp_path)
+
+    with pytest.raises(ValueError, match=message):
+        verify_archive(tmp_path)
+
+
+def test_verify_archive_rejects_failed_row_with_sample(tmp_path: Path) -> None:
+    _write_archive(tmp_path)
+    _add_generation_rows(tmp_path)
+    raw = tmp_path / "results/raw_rows.jsonl"
+    rows = [json.loads(line) for line in raw.read_text(encoding="utf-8").splitlines()]
+    rows[1]["sample_path"] = "samples/example.png"
+    raw.write_text("\n".join(json.dumps(row) for row in rows) + "\n", encoding="utf-8")
+    _refresh_manifest(tmp_path)
+
+    with pytest.raises(ValueError, match="failed row"):
+        verify_archive(tmp_path)
+
+
+def test_verify_archive_rejects_raw_rows_symlink(tmp_path: Path) -> None:
+    _write_archive(tmp_path)
+    _add_generation_rows(tmp_path)
+    raw = tmp_path / "results/raw_rows.jsonl"
+    raw.unlink()
+    raw.symlink_to(tmp_path / "outside.jsonl")
+    (tmp_path / "outside.jsonl").write_text("", encoding="utf-8")
+
+    with pytest.raises(ValueError, match="symlink"):
+        verify_archive(tmp_path)
+
+
+def test_verify_archive_rejects_duplicate_manifest_path(tmp_path: Path) -> None:
+    _write_archive(tmp_path)
+    _add_generation_rows(tmp_path)
+    manifest_path = tmp_path / "results/archive_manifest.json"
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    manifest["artifacts"].append(manifest["artifacts"][0])
+    manifest_path.write_text(json.dumps(manifest), encoding="utf-8")
+
+    with pytest.raises(ValueError, match="duplicate archive path"):
+        verify_archive(tmp_path)
+
+
+def test_verify_archive_rejects_listed_hash_tamper(tmp_path: Path) -> None:
+    _write_archive(tmp_path)
+    _add_generation_rows(tmp_path)
+    path = tmp_path / "samples/example.png"
+    path.write_bytes(b"tampeR")
+
+    with pytest.raises(ValueError, match="SHA-256"):
+        verify_archive(tmp_path)
+
+
+def test_verify_archive_rejects_archived_tree_symlink_and_unlisted_file(tmp_path: Path) -> None:
+    _write_archive(tmp_path)
+    _add_generation_rows(tmp_path)
+    extra = tmp_path / "samples/unlisted.bin"
+    extra.write_bytes(b"extra")
+    with pytest.raises(ValueError, match="unlisted"):
+        verify_archive(tmp_path)
+    extra.unlink()
+    extra.symlink_to(tmp_path / "weights/model.png")
+
+    with pytest.raises(ValueError, match="symlink"):
+        verify_archive(tmp_path)

weights/README.md

@@ -0,0 +1,7 @@
+# Archived codec payloads
+
+This directory stores byte-exact encoded payloads from the full run. Raw and Finite Repair Zero share the same encoded codec payload, so identical files are stored once and mapped to both conditions in `manifest.csv`. Protected High Byte stores one deduplicated lossless high-byte PNG plus one low-byte payload per lossy codec.
+
+The reconstructed fp16 weight PNGs are not duplicated here: they are deterministic materializations of these payloads and would add substantial redundant storage. The original PixelModel-v4 source assets remain available from [`bench-labs/PixelModel-v4`](https://huggingface.co/bench-labs/PixelModel-v4) at revision `80878fdd6e130d229c2581424a3456b47b979d4b`.
+
+All payload sizes and SHA-256 hashes are recorded in `manifest.csv`. Protected combined hashes follow the canonical experiment's high-plus-low payload definition.

weights/manifest.csv

@@ -0,0 +1,14 @@
+artifact_path,role,codec,source_conditions,bytes,sha256,combined_payload_bytes,combined_payload_sha256
+weights/codec_payloads/png_baseline.png,codec_payload,PNG baseline,png_baseline,89711808,a7b64d9d69c6ba1e428a5957bf1eae7a60145dc60cf8341300e8bdbcf80b2b31,,
+weights/codec_payloads/webp_lossless.webp,codec_payload,WebP lossless,webp_lossless,67929870,134c0c741635bb91b0f80d386d03e7ae4b4652fe82a640d6ceb8e228eced0934,,
+weights/codec_payloads/jpeg_q100.jpg,codec_payload,JPEG Q100,jpeg_q100_raw;jpeg_q100_repair_zero,156060019,d74c6e5e16cdf93a5afef3a95b08ef8f2d529cef452beeff71c38fe9359d08d6,,
+weights/codec_payloads/jpeg_q80.jpg,codec_payload,JPEG Q80,jpeg_q80_raw;jpeg_q80_repair_zero,50283220,de6fadf8ec9b44b429629418d79d77b8e852a5cfcc43b0cd3035013eb59accc9,,
+weights/codec_payloads/webp_q80.webp,codec_payload,WebP Q80,webp_q80_raw;webp_q80_repair_zero,25810802,9139ab3d637498f7fb40f71d531a674098164a3226057cbd51dfb85be1b7da70,,
+weights/codec_payloads/avif_q70.avif,codec_payload,AVIF Q70,avif_q70_raw;avif_q70_repair_zero,29691217,b83258bd00e22d5e5d21236f5c441971c7c94b246e63d6eb6b41a1e23ce7952a,,
+weights/codec_payloads/jxl_d1.jxl,codec_payload,JPEG XL distance 1,jxl_d1_raw;jxl_d1_repair_zero,39437937,e7ef2f74cc503897f120d3b414c61bdcb198c8c91c012fa65c668f47c119966d,,
+weights/protected/high_byte.png,protected_high_byte,PNG lossless,jpeg_q100_protected_high;jpeg_q80_protected_high;webp_q80_protected_high;avif_q70_protected_high;jxl_d1_protected_high,32686473,82b3031ec79cf1541334e3f454a0af8705da2166f6bde7780196dd1e024df5ab,,
+weights/protected/low_byte/jpeg_q100_low.jpg,protected_low_byte,JPEG Q100,jpeg_q100_protected_high,63199775,99c2c391d129bd1df40e58a25f79ee8b954c7e78fcb1814774b4bf7ac3a6e277,95886248,f660afccf973caa294d8778a4b29596b0ab41266102e822944c5abb6f0982f74
+weights/protected/low_byte/jpeg_q80_low.jpg,protected_low_byte,JPEG Q80,jpeg_q80_protected_high,24229532,d32d9d1e7be1ea666a37fd761e1c74f94445562120313d01ba940711baeeddb1,56916005,30feef679679487aebd1e075cceea5823778c8cdec6643ec9e7296a04fb24000
+weights/protected/low_byte/webp_q80_low.webp,protected_low_byte,WebP Q80,webp_q80_protected_high,23230766,f200066cf1ffbace7aaa9733d3a5c017379037e4e5fa58b8b09b3c6985655fc9,55917239,f04180148fa0decf546c978319c45c683b38d9264d6ccef14a5b0feb697226c1
+weights/protected/low_byte/avif_q70_low.avif,protected_low_byte,AVIF Q70,avif_q70_protected_high,21791910,1698fedd0949bfdcf787576d35a81192e6f1adfc21f3499acb610d67d7a443e4,54478383,cd648cea401a6491c4f0829880ac483b497756266f6824548420606142aa7f62
+weights/protected/low_byte/jxl_d1_low.jxl,protected_low_byte,JPEG XL distance 1,jxl_d1_protected_high,23636365,a58701006f3b535cfc27473f9ae741c7d3d888c1f7741c53d047d91c82d0a050,56322838,637e8752eb53d94ffd2f2ee997292382d67afc405139dc9a50bd4d3061cb6877