make_golden_packet.py

# SPDX-License-Identifier: AGPL-3.0-or-later
# Copyright 2026 Chelsea Kelly-Reif
"""Regenerate the current-version golden packet fixture.

The golden corpus (``tests/golden/packet-vN/``) pins backward compatibility: every
packet version habitable has ever emitted must keep verifying forever
(``tests/test_golden.py``). Run this after an intentional, reviewed change to the
export format to (re)build the *current* version's fixture:

    uv run python scripts/make_golden_packet.py

It builds a fresh, self-contained packet with the real pipeline (a deterministic
clock and a fixed-time local RFC 3161 issuer) and copies the verifiable subset —
``bundle.json``, its signature, and the shared media — into
``tests/golden/packet-v<PACKET_VERSION>/``. Older fixtures (e.g. ``packet-v1``) are
the back-compat contract and are never touched by this script.
"""

from __future__ import annotations

import shutil
import tempfile
from collections.abc import Callable
from pathlib import Path

import piexif
from PIL import Image

from habitable.artifact import add_relationship, capture_artifact
from habitable.capture import capture
from habitable.packet import PACKET_VERSION, build_packet
from habitable.tsa import LocalRfc3161TSA
from habitable.vault import Vault

_FIXED_EPOCH = 1_767_312_000  # 2026-01-02T00:00:00Z — reproducible timestamps
_GENERATED_AT = "2026-01-02T00:10:00Z"
_ROOT = Path(__file__).resolve().parent.parent
_GOLDEN = _ROOT / "tests" / "golden" / f"packet-v{PACKET_VERSION}"


def _counter_ms(start_ms: int) -> Callable[[], int]:
    state = {"t": start_ms}

    def tick() -> int:
        state["t"] += 1
        return state["t"]

    return tick


def _synthetic_photo(path: Path) -> None:
    """A never-real JPEG carrying an EXIF capture time and GPS (stripped on export)."""
    exif = {
        "0th": {},
        "Exif": {piexif.ExifIFD.DateTimeOriginal: b"2026:01:02 09:15:00"},
        "GPS": {
            piexif.GPSIFD.GPSLatitudeRef: b"N",
            piexif.GPSIFD.GPSLatitude: ((38, 1), (33, 1), (0, 1)),
            piexif.GPSIFD.GPSLongitudeRef: b"W",
            piexif.GPSIFD.GPSLongitude: ((121, 1), (44, 1), (0, 1)),
        },
        "1st": {},
        "thumbnail": None,
    }
    Image.new("RGB", (48, 48), (70, 70, 60)).save(path, "jpeg", exif=piexif.dump(exif))


def main() -> int:
    work = Path(tempfile.mkdtemp(prefix="golden-packet-"))
    vault = Vault.create(
        work / "vault",
        "golden-passphrase",
        case_id="golden-4B",
        unit="4B",
        time_source=_counter_ms(_FIXED_EPOCH * 1000),
    )
    issue = vault.document.add_issue(
        category="mold", room="bathroom", title="Black mold", severity="high"
    )
    vault.add_timeline_event(
        issue,
        event_type="condition_observed",
        text="mold on ceiling",
        occurred_at="2026-01-02",
        source="firsthand",
    )

    photo = work / "p.jpg"
    _synthetic_photo(photo)
    tsa = LocalRfc3161TSA("golden-tsa", time_source=lambda: _FIXED_EPOCH)
    capture(vault, photo, issue_id=issue, tsa=tsa)

    # Exercise the version-specific surfaces, not just the shape every version
    # shares (issue #160). A fixture that carries no artifact, relationship,
    # profile, or handoff view leaves `_verify_v4_workflows` -- roughly 250
    # lines of hostile-input parsing in the standalone verifier -- with nothing
    # to bite on, which is how packet v4 shipped pinned by nothing.
    vault.document.set_use_case_profile("repair_delivery")
    request = work / "repair-request.txt"
    request.write_text(
        "Synthetic repair request for the golden fixture. Never real tenant data.\n",
        encoding="utf-8",
    )
    artifact = capture_artifact(
        vault,
        request,
        issue_id=issue,
        artifact_type="repair_request",
        title="Repair request",
        source_assertion="tenant copy",
        occurred_at="2026-01-02",
        tsa=tsa,
    )
    add_relationship(
        vault,
        issue_id=issue,
        relationship_type="documents_condition",
        source_id=artifact.artifact_id,
        target_id=issue,
    )

    out = work / "packet"
    build_packet(vault, out, generated_at=_GENERATED_AT, make_pdf=False)

    # Commit only the verifiable, self-contained subset (mirrors packet-v1's shape).
    if _GOLDEN.exists():
        shutil.rmtree(_GOLDEN)
    (_GOLDEN / "media").mkdir(parents=True)
    shutil.copy(out / "bundle.json", _GOLDEN / "bundle.json")
    shutil.copy(out / "bundle.sig.json", _GOLDEN / "bundle.sig.json")
    for media_file in sorted((out / "media").iterdir()):
        shutil.copy(media_file, _GOLDEN / "media" / media_file.name)

    print(f"wrote {_GOLDEN.relative_to(_ROOT)} (packet_version={PACKET_VERSION})")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())