#!/usr/bin/env python3
"""Independent verifier of the packaging corpus (extensions/packaging.md).

Written from the extension text. It shares no code with wai-pack, which generates the
corpus. It takes BLAKE3 from ../claim-conformance/_blake3.py and the WIV1 parser and
keyframe-0 decoder from ../int-payload-conformance/int_payload_verify.py, both written
from their specifications, reads the capability registry from its published export
(../registry/capabilities.json), reads TOML with the standard library's tomllib (TOML
1.0), checks Ed25519 signatures with ../claim-conformance/_ed25519.py, WAI's strict rule
(SPEC §7 *Signatures*) written from RFC 8032, signs its own re-derivations with the
`cryptography` package, imported only where it signs, and implements the rest:

- the policy (§3): the value-kind walk, the schema with every default, the constraints
  and their refusal names, the effective policy as JSON, RFC 8785 canonical JSON and the
  digest; every case of policy/ is recomputed, every equal pair compared, and every
  policy of refusals/policy/ refused with its reason, the capability rules of §3.6
  included;
- the sources (§4.7): a Y4M reader with BT.709 limited-range conversion to RGB8, and a
  WAV reader; every source of refusals/source/ refused with its reason, and every frame
  of conversions/ converted to the SHA-256 the corpus states;
- the unit conversions (§4.4, §4.5);
- the fixtures, regenerated from their definition and checked against their pinned
  SHA-256, and wai.pack.scenecut/1 (§4.3) with its lookahead clauses, written in the
  on-demand form (every frame known), against the streaming segmenter's vectors; and the
  classification (§4.6) of every piece;
- the encode vectors: which frames each one codes (every piece of every fixture, cut by
  the segmenter above), each payload's BLAKE3, its header's parameters, every decoded
  frame's SHA-256, and the SSE of the decode against the regenerated source; and the
  encoder's choices (§5.5) recomputed from the decode: every motion vector by the
  search, its order and its tie-break, on the source and the previous decoded frame;
  every coded residual (the stream's symbols) equal to quantize(source − prediction);
  and the residual table and its offset equal to the fit of those residuals;
- the choice of step (§5.6): every candidate's SSE from an encoder of its own (search,
  quantization, reconstruction, closed loop), and the step the rule chooses;
- the stage index (§6.2–§6.4): the WSIX reader and its refusals, the rules in their
  order, each tier from the registry's replicate class, the index digest and the stage
  root (a jwp-receipts §2.2 Merkle root); and the object rules of §6.3 over WAI1 and WAI2
  envelopes. Every case of mutations/ (an index; an index and its objects; a receipt and
  its indexes) gets its reason, and every file of mutations/ is used by a case;
- the package receipt (§9.1): its JSON reader, its signing payload with the energy class
  of energy-measurement §2.7–§2.8, its receipt hash, and its verification against its
  indexes; and version 1 (§9.3), every receipt of receipts/: its payload, receipt hash,
  segment map root, counts and signature;
- the package (packs/, §11.3, in its order, without the source): the LISTING, the
  receipt, policy.json and policy.toml, the indexes, every object, each prefix digest by
  decoding its WIV1 base, the plan file, the floor objects, the CMAF files rebuilt byte
  for byte from their temporal units (an AV1 OBU reader and sequence header parser, §7.6's
  boxes), every catalog rendered byte for byte (§8.3–§8.8), §9.4's claim rule, and no
  unlisted or unexpected file; then what only the source decides: the fixture
  regenerated and cut, each piece's start, duration, flags and kind, its rules, moments
  and class plan (§8.1), each base's sse (§6.6) and step (§5.6) and its decode equal to the
  encoder's reconstruction, and the supplied floor (§7.3): its listing, a temporal unit
  per frame, shown key frames exactly at the piece starts, and each floor object holding
  its piece's units of the stream;
- the package mutations (package-mutations/): each case the golden altered (re-sealed
  with its key where the receipt or LISTING alone would catch it), written out and
  verified as above without its inputs, and refused with the reason the corpus gives it
  (the first check that fails), or accepted where the corpus says `ok`.

    python3 pack_verify.py <pack-conformance dir>

Exit status 0 only if every vector verifies. Python 3.11 or later (tomllib).
"""
import hashlib
import json
import os
import re
import shutil
import sys
import tempfile
import tomllib

HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, os.path.join(HERE, "..", "claim-conformance"))
sys.path.insert(0, os.path.join(HERE, "..", "int-payload-conformance"))
from _blake3 import blake3  # noqa: E402
import _ed25519 as ED  # noqa: E402
import int_payload_verify as IPV  # noqa: E402

MAX_INTEGER = (1 << 53) - 1
U32 = (1 << 32) - 1
# The frames of each piece an encode vector codes: the first ENCODE_FRAMES.
ENCODE_FRAMES = 12

# ---------------------------------------------------------------- canonical JSON (RFC 8785)


def jcs(v):
    if v is None:
        return "null"
    if v is True:
        return "true"
    if v is False:
        return "false"
    if isinstance(v, int):
        if not 0 <= v <= MAX_INTEGER:
            raise ValueError("an integer outside the canonical subset")
        return str(v)
    if isinstance(v, str):
        return json.dumps(v, ensure_ascii=False)
    if isinstance(v, list):
        return "[" + ",".join(jcs(x) for x in v) + "]"
    if isinstance(v, dict):
        keys = sorted(v, key=lambda k: k.encode("utf-16-be"))
        return "{" + ",".join(json.dumps(k, ensure_ascii=False) + ":" + jcs(v[k]) for k in keys) + "}"
    raise ValueError("a value outside the canonical subset")


# ---------------------------------------------------------------- policy (§3)


class Refused(Exception):
    def __init__(self, code, at=""):
        super().__init__(code)
        self.code = code
        self.at = at


def is_int(v):
    return isinstance(v, int) and not isinstance(v, bool)


def kinds(v, at):
    """Stage 1: the value kinds canonical JSON cannot carry, members in key order."""
    import datetime

    if isinstance(v, float):
        raise Refused("policy-float", at)
    if isinstance(v, (datetime.datetime, datetime.date, datetime.time)):
        raise Refused("policy-datetime", at)
    if is_int(v) and v < 0:
        raise Refused("policy-negative", at)
    if is_int(v) and v > MAX_INTEGER:
        raise Refused("policy-integer-range", at)
    if isinstance(v, list):
        for i, x in enumerate(v):
            kinds(x, f"{at}[{i}]")
    if isinstance(v, dict):
        for k in sorted(v):
            kinds(v[k], f"{at}.{k}" if at else k)


class Tab:
    def __init__(self, t, at):
        self.t, self.at = t, at

    def err(self, code, k):
        return Refused(code, f"{self.at}.{k}" if self.at else k)

    def keys(self, allowed):
        for k in sorted(self.t):
            if k not in allowed:
                raise self.err("policy-unknown-key", k)

    def string(self, k):
        if k not in self.t:
            return None
        if not isinstance(self.t[k], str):
            raise self.err("policy-type", k)
        return self.t[k]

    def string_req(self, k):
        s = self.string(k)
        if s is None:
            raise self.err("policy-missing-key", k)
        return s

    def ident(self, k):
        s = self.string_req(k)
        if not s or len(s.encode()) > 255:
            raise self.err("policy-value", k)
        return s

    def uint(self, k):
        if k not in self.t:
            return None
        if not is_int(self.t[k]):
            raise self.err("policy-type", k)
        return self.t[k]

    def uint_in(self, k, lo, hi, default):
        v = self.uint(k)
        if v is None:
            if default is None:
                raise self.err("policy-missing-key", k)
            return default
        if v < lo or v > hi:
            raise self.err("policy-value", k)
        return v

    def uint_opt_in(self, k, lo, hi):
        v = self.uint(k)
        if v is not None and (v < lo or v > hi):
            raise self.err("policy-value", k)
        return v

    def boolean(self, k, default):
        if k not in self.t:
            return default
        if not isinstance(self.t[k], bool):
            raise self.err("policy-type", k)
        return self.t[k]

    def table(self, k):
        if k not in self.t:
            return Tab({}, f"{self.at}.{k}" if self.at else k)
        if not isinstance(self.t[k], dict):
            raise self.err("policy-type", k)
        return Tab(self.t[k], f"{self.at}.{k}" if self.at else k)

    def table_req(self, k):
        if k not in self.t:
            raise self.err("policy-missing-key", k)
        return self.table(k)

    def tables(self, k):
        if k not in self.t:
            return []
        v = self.t[k]
        if not isinstance(v, list) or not all(isinstance(x, dict) for x in v):
            raise self.err("policy-type", k)
        return [Tab(x, f"{k}[{i}]") for i, x in enumerate(v)]

    def strings(self, k):
        if k not in self.t:
            return None
        v = self.t[k]
        if not isinstance(v, list) or not all(isinstance(x, str) for x in v):
            raise self.err("policy-type", k)
        return list(v)

    def uints(self, k):
        if k not in self.t:
            return None
        v = self.t[k]
        if not isinstance(v, list) or not all(is_int(x) for x in v):
            raise self.err("policy-type", k)
        return list(v)


# §3.3: the parameters each capability's rung takes; another capability takes none.
PARAMS = {
    "wai.video.int_motion": [
        ("block", ("one_of", [4, 8, 16, 32], 16)),
        ("search", ("int", 0, 32, 7)),
        ("mv_precision", ("one_of", [1, 2], 2)),
        ("q_candidates", ("ints", 1, 255, [8])),
        ("max_sse_px_milli", ("int", 0, MAX_INTEGER, 0)),
    ],
    "wai.video.int_refine": [("q", ("int", 1, 255, None))],
    "wai.video.av1": [("source", ("word", ["supplied", "encode"], "supplied"))],
    "wai.video.av1.lossless": [("source", ("word", ["supplied", "encode"], "supplied"))],
    "wai.audio.int_refine": [("to_rate", ("int", 1, 384000, None)), ("q", ("int", 1, 65535, None))],
    "wai.audio.flac": [("source", ("word", ["encode", "supplied"], "encode"))],
}

MEDIA = ["video", "image", "audio", "world", "feed", "avatar", "film"]
KINDS = ["natural", "static", "synthetic", "motion_high"]


def read_params(rung, cap):
    p = rung.table("params")
    schema = PARAMS.get(cap, [])
    p.keys([k for k, _ in schema])
    out = {}
    for k, kind in schema:
        if kind[0] == "int":
            out[k] = p.uint_in(k, kind[1], kind[2], kind[3])
        elif kind[0] == "one_of":
            v = p.uint_in(k, 0, MAX_INTEGER, kind[2])
            if v not in kind[1]:
                raise p.err("policy-value", k)
            out[k] = v
        elif kind[0] == "ints":
            v = p.uints(k)
            v = list(kind[3]) if v is None else v
            if not v or any(x < kind[1] or x > kind[2] for x in v):
                raise p.err("policy-value", k)
            out[k] = v
        else:
            v = p.string(k)
            v = kind[2] if v is None else v
            if v not in kind[1]:
                raise p.err("policy-value", k)
            out[k] = v
    return out


def is_hex64(s):
    return len(s) == 64 and all(c in "0123456789abcdef" for c in s)


def read_policy(doc):
    """Stage 2. Returns the policy as a dict of its JSON members (layer_lag_ms unchecked)."""
    top = Tab(doc, "")
    top.keys(["schema", "asset_id", "royalty_free_only", "lead", "component", "segmentation", "ladder", "floor",
              "live", "class", "moment", "rule", "defaults", "classify"])
    if top.string_req("schema") != "wai.pack.policy/1":
        raise top.err("policy-schema", "schema")
    P = {"schema": "wai.pack.policy/1", "asset_id": top.ident("asset_id"),
         "royalty_free_only": top.boolean("royalty_free_only", False), "lead": top.ident("lead")}
    if "component" not in doc:
        raise top.err("policy-missing-key", "component")
    comps = []
    for c in top.tables("component"):
        c.keys(["id", "media", "source", "timebase"])
        m = {"id": c.ident("id")}
        media = c.string_req("media")
        if media not in MEDIA:
            raise c.err("policy-value", "media")
        m["media"] = media
        s = c.string("source")
        if s is not None:
            m["source"] = s
        tb = c.table_req("timebase")
        tb.keys(["num", "den"])
        m["timebase"] = {"num": tb.uint_in("num", 1, U32, None), "den": tb.uint_in("den", 1, U32, None)}
        comps.append(m)
    P["component"] = comps
    s = top.table("segmentation")
    s.keys(["target_ms", "min_ms", "max_ms", "scene_cut", "cut_abs_permille", "cut_rel_permille", "cut_window",
            "lookahead_frames", "closed"])
    seg = {"target_ms": s.uint_in("target_ms", 0, MAX_INTEGER, 2000),
           "min_ms": s.uint_in("min_ms", 0, MAX_INTEGER, 1000),
           "max_ms": s.uint_in("max_ms", 0, MAX_INTEGER, 4000)}
    sc = s.string("scene_cut")
    sc = "wai.pack.scenecut/1" if sc is None else sc
    if sc != "wai.pack.scenecut/1":
        raise s.err("policy-value", "scene_cut")
    seg["scene_cut"] = sc
    seg["cut_abs_permille"] = s.uint_in("cut_abs_permille", 1, 1000, 300)
    seg["cut_rel_permille"] = s.uint_in("cut_rel_permille", 0, 1000000, 3000)
    seg["cut_window"] = s.uint_in("cut_window", 3, 64, 8)
    seg["lookahead_frames"] = s.uint_in("lookahead_frames", 0, 64, 6)
    seg["closed"] = s.boolean("closed", True)
    P["segmentation"] = seg
    ladder = []
    for r in top.tables("ladder"):
        r.keys(["id", "component", "capability", "role", "refines", "params"])
        m = {"id": r.ident("id"), "component": r.ident("component"), "capability": r.string_req("capability")}
        role = r.string_req("role")
        if role not in ("base", "refinement", "floor"):
            raise r.err("policy-value", "role")
        m["role"] = role
        t = r.string("refines")
        if t is not None:
            m["refines"] = t
        m["params"] = read_params(r, m["capability"])
        ladder.append(m)
    P["ladder"] = ladder
    f = top.table("floor")
    f.keys(["supplied_listing", "extra_keyframes"])
    fl = {}
    sl = f.string("supplied_listing")
    if sl is not None:
        if not is_hex64(sl):
            raise f.err("policy-value", "supplied_listing")
        fl["supplied_listing"] = sl
    fl["extra_keyframes"] = f.boolean("extra_keyframes", False)
    P["floor"] = fl
    lv = top.table("live")
    lv.keys(["layer_lag_ms"])
    lag = lv.uints("layer_lag_ms")
    classes = []
    for c in top.tables("class"):
        c.keys(["id", "max_layer", "max_kbps", "floor_only"])
        m = {"id": c.ident("id"), "max_layer": c.uint_in("max_layer", 0, 255, 0)}
        k = c.uint_opt_in("max_kbps", 1, U32)
        if k is not None:
            m["max_kbps"] = k
        m["floor_only"] = c.boolean("floor_only", False)
        classes.append(m)
    P["class"] = classes
    moments = []
    for m in top.tables("moment"):
        m.keys(["id", "from_ms", "to_ms", "tags"])
        x = {"id": m.ident("id"), "from_ms": m.uint_in("from_ms", 0, MAX_INTEGER, None),
             "to_ms": m.uint_in("to_ms", 0, MAX_INTEGER, None)}
        if x["to_ms"] <= x["from_ms"]:
            raise m.err("policy-value", "to_ms")
        x["tags"] = m.strings("tags") or []
        moments.append(x)
    P["moment"] = moments
    rules = []
    for r in top.tables("rule"):
        r.keys(["id", "when", "then"])
        x = {"id": r.ident("id")}
        w = r.table("when")
        w.keys(["piece_kind", "moment_tag"])
        when = {}
        pk = w.strings("piece_kind")
        if pk is not None:
            if any(k not in KINDS for k in pk):
                raise w.err("policy-value", "piece_kind")
            when["piece_kind"] = pk
        mt = w.strings("moment_tag")
        if mt is not None:
            when["moment_tag"] = mt
        t = r.table("then")
        t.keys(["ladder", "max_layer", "deadline_ms"])
        then = {}
        ld = t.strings("ladder")
        if ld is not None:
            then["ladder"] = ld
        ml = t.uint_opt_in("max_layer", 0, 255)
        if ml is not None:
            then["max_layer"] = ml
        dl = t.uint_opt_in("deadline_ms", 1, U32)
        if dl is not None:
            then["deadline_ms"] = dl
        x["when"], x["then"] = when, then
        rules.append(x)
    P["rule"] = rules
    d = top.table("defaults")
    d.keys(["deadline_ms"])
    P["defaults"] = {"deadline_ms": d.uint_in("deadline_ms", 1, U32, 1500)}
    c = top.table("classify")
    c.keys(["static_permille", "static_mad_milli", "synthetic_bins", "motion_high_milli"])
    P["classify"] = {"static_permille": c.uint_in("static_permille", 0, 1000, 5),
                     "static_mad_milli": c.uint_in("static_mad_milli", 0, MAX_INTEGER, 300),
                     "synthetic_bins": c.uint_in("synthetic_bins", 0, 64, 12),
                     "motion_high_milli": c.uint_in("motion_high_milli", 0, MAX_INTEGER, 9000)}
    return P, lag


def first_dup(ids):
    seen = set()
    for i in ids:
        if i in seen:
            return i
        seen.add(i)
    return None


def layers(P):
    by = {r["id"]: r for r in P["ladder"]}
    out = {}
    for r in P["ladder"]:
        k, cur = 0, r
        while "refines" in cur and cur["refines"] in by:
            k, cur = k + 1, by[cur["refines"]]
        out[r["id"]] = k
    return out


def constrain(P, lag):
    """Stage 3, in the order of the extension's list."""
    def no(code):
        raise Refused(code)
    if not P["component"] or len(P["component"]) > 8:
        no("policy-too-many-components")
    if len(P["ladder"]) > 64:
        no("policy-too-many-rungs")
    if len(P["class"]) > 32:
        no("policy-too-many-classes")
    if len(P["rule"]) > 32:
        no("policy-too-many-rules")
    if len(P["moment"]) > 32:
        no("policy-too-many-moments")
    # One namespace for every id, so no reference names two things.
    if first_dup(x["id"] for k in ("component", "ladder", "class", "moment", "rule") for x in P[k]) is not None:
        no("policy-duplicate-id")
    if P["lead"] not in [c["id"] for c in P["component"]]:
        no("policy-lead")
    s = P["segmentation"]
    if not s["closed"]:
        no("policy-open-gop")
    if not (1 <= s["min_ms"] <= s["target_ms"] <= s["max_ms"]):
        no("policy-piece-bounds")
    comps = {c["id"] for c in P["component"]}
    if any(r["component"] not in comps for r in P["ladder"]):
        no("policy-ladder-component")
    if any((r["role"] == "refinement") != ("refines" in r) for r in P["ladder"]):
        no("policy-refines-role")
    by = {r["id"]: r for r in P["ladder"]}
    if any("refines" in r and r["refines"] not in by for r in P["ladder"]):
        no("policy-dangling-refines")
    for r in P["ladder"]:
        seen, cur = {r["id"]}, r
        while "refines" in cur:
            if cur["refines"] in seen:
                no("policy-refines-cycle")
            seen.add(cur["refines"])
            cur = by[cur["refines"]]
    for r in P["ladder"]:
        if r["role"] != "refinement":
            continue
        cur = r
        while "refines" in cur:
            cur = by[cur["refines"]]
            if cur["component"] != r["component"]:
                no("policy-refines-base")
        if cur["role"] != "base":
            no("policy-refines-base")
    if first_dup(r["refines"] for r in P["ladder"] if "refines" in r) is not None:
        no("policy-refines-branch")
    for c in P["component"]:
        if not any(r["component"] == c["id"] and r["role"] == "base" for r in P["ladder"]):
            no("policy-no-base")
    n = max(layers(P).values(), default=0) + 1
    if any(c["max_layer"] > n - 1 for c in P["class"]):
        no("policy-class-layer")
    if any(r["then"].get("max_layer", 0) > n - 1 for r in P["rule"]):
        no("policy-class-layer")
    for r in P["rule"]:
        if "ladder" in r["then"]:
            rs = [by.get(i) for i in r["then"]["ladder"]]
            ok = rs and all(rs) and all(x["component"] == rs[0]["component"] for x in rs) \
                and any(x["role"] == "base" for x in rs)
            if not ok:
                no("policy-rule-ladder")
    lag = [0] * n if lag is None else lag
    if len(lag) != n or lag[0] != 0 or any(b < a for a, b in zip(lag, lag[1:])):
        no("policy-layer-lag")
    P["live"] = {"layer_lag_ms": lag}
    deadlines = {r["then"]["deadline_ms"] for r in P["rule"] if "deadline_ms" in r["then"]}
    deadlines.add(P["defaults"]["deadline_ms"])
    if len(deadlines) > 4:
        no("policy-too-many-deadlines")
    for d in deadlines:
        if any(d < x + 1 for x in lag[1:]):
            no("policy-deadline-unreachable")
    return P


MAX_DEPTH = 32
I64 = (-(1 << 63), (1 << 63) - 1)


def shallow(v, depth):
    """Every container in v, itself at depth `depth`, at most MAX_DEPTH deep (§3.2). The
    recursion stops at the first container past it."""
    if isinstance(v, list):
        return depth <= MAX_DEPTH and all(shallow(x, depth + 1) for x in v)
    if isinstance(v, dict):
        return depth <= MAX_DEPTH and all(shallow(x, depth + 1) for x in v.values())
    return True


def in_i64(v):
    """TOML's integers are 64-bit (TOML 1.0); tomllib reads any size."""
    if is_int(v):
        return I64[0] <= v <= I64[1]
    if isinstance(v, list):
        return all(in_i64(x) for x in v)
    if isinstance(v, dict):
        return all(in_i64(x) for x in v.values())
    return True


def parse_policy(text):
    """§3.2: not TOML 1.0, a byte-order mark, an integer outside 64 bits, or nesting past
    MAX_DEPTH are `policy-toml`, before any value kind; then the three stages."""
    if text.startswith("\ufeff"):
        raise Refused("policy-toml")
    try:
        doc = tomllib.loads(text)
    except (tomllib.TOMLDecodeError, RecursionError):
        raise Refused("policy-toml")
    if not all(shallow(v, 2) for v in doc.values()) or not in_i64(doc):
        raise Refused("policy-toml")
    for k in sorted(doc):
        kinds(doc[k], k)
    P, lag = read_policy(doc)
    return constrain(P, lag)


def parse_policy_bytes(b):
    """A policy's bytes: UTF-8 with no byte-order mark (§3.2)."""
    if b.startswith(b"\xef\xbb\xbf"):
        raise Refused("policy-toml")
    try:
        text = b.decode("utf-8")
    except UnicodeDecodeError:
        raise Refused("policy-toml")
    return parse_policy(text)


def digest(P):
    return blake3(b"wai:pack-policy\x01" + jcs(P).encode()).hex()


# ---------------------------------------------------------------- what a packager may emit (§3.6)

with open(os.path.join(HERE, "..", "registry", "capabilities.json"), "rb") as _f:
    REGISTRY = {c["capability"]: c for c in json.loads(_f.read())["capabilities"]}


def rung_refusal(cap, role, royalty_free_only):
    r = REGISTRY.get(cap)
    if r is None:
        return f"capability-unknown:{cap}"
    if r["kind"] in ("record", "derivation"):
        return f"capability-not-payload:{cap}"
    if r["status"] == "candidate":
        return f"capability-candidate:{cap}"
    if r["role"] != ("refinement" if role == "refinement" else "standalone"):
        return f"capability-role:{cap}"
    if royalty_free_only:
        if r["licence"] is None:
            return f"license-unclassified:{cap}"
        if r["licence"] != "royalty-free":
            return f"license-refused:{cap}:{r['licence']}"
    return None


def admit(b):
    """A packager's verdict on a policy's bytes: the policy's refusal, or the first rung's."""
    P = parse_policy_bytes(b)
    for r in P["ladder"]:
        code = rung_refusal(r["capability"], r["role"], P["royalty_free_only"])
        if code:
            raise Refused(code)
    return P


# ---------------------------------------------------------------- sources (§4.7)


def clip(v):
    return 0 if v < 0 else 255 if v > 255 else v


def bt709(y, cb, cr):
    y, cb, cr = y - 16, cb - 128, cr - 128
    return (clip((298 * y + 459 * cr + 128) >> 8), clip((298 * y - 55 * cb - 136 * cr + 128) >> 8),
            clip((298 * y + 541 * cb + 128) >> 8))


def line(b, pos, at_end):
    """A line of at most 1024 bytes and its newline; None at the end of the bytes."""
    if pos >= len(b):
        return None, pos
    nl = b.find(b"\n", pos, pos + 1025)
    if nl < 0:
        raise Refused(at_end)
    return b[pos:nl], nl + 1


def u32_digits(s):
    if not s or len(s) > 10 or not s.isdigit():
        return None
    v = int(s)
    return v if v <= U32 else None


def read_y4m(b):
    """(w, h, rate, chroma, frames as RGB8 bytes)."""
    l, pos = line(b, 0, "y4m-header")
    if l is None:
        raise Refused("y4m-header")
    parts = l.split(b" ")
    if parts[0] != b"YUV4MPEG2":
        raise Refused("y4m-header")
    w = h = rate = None
    chroma = "420"
    for p in parts[1:]:
        if not p:
            continue
        tag, v = p[:1], p[1:]
        if tag == b"W" or tag == b"H":
            x = u32_digits(v)
            if x is None:
                raise Refused("y4m-header")
            if tag == b"W":
                w = x
            else:
                h = x
        elif tag == b"F":
            nd = v.split(b":")
            n = u32_digits(nd[0]) if len(nd) == 2 else None
            d = u32_digits(nd[1]) if len(nd) == 2 else None
            if not n or not d:
                raise Refused("y4m-header")
            rate = (n, d)
        elif tag == b"I" and v != b"p":
            raise Refused("y4m-interlaced")
        elif tag == b"C":
            if v in (b"420jpeg", b"420paldv", b"420mpeg2", b"420"):
                chroma = "420"
            elif v == b"444":
                chroma = "444"
            else:
                raise Refused("y4m-colorspace")
    if not w or not h or w * h > (1 << 26) // 3:
        raise Refused("y4m-header")
    cw, ch = (w, h) if chroma == "444" else ((w + 1) // 2, (h + 1) // 2)
    size = w * h + 2 * cw * ch
    frames = []
    while True:
        l, pos = line(b, pos, "y4m-truncated")
        if l is None:
            break
        parts = l.split(b" ")
        if parts[0] != b"FRAME":
            raise Refused("y4m-truncated")
        for p in parts[1:]:
            if p[:1] in (b"W", b"H", b"C"):
                raise Refused("y4m-size-change")
            if p[:1] == b"I" and p[1:] != b"p":
                raise Refused("y4m-interlaced")
        if pos + size > len(b):
            raise Refused("y4m-truncated")
        yp, up, vp = b[pos:pos + w * h], b[pos + w * h:pos + w * h + cw * ch], b[pos + w * h + cw * ch:pos + size]
        pos += size
        rgb = bytearray()
        for y in range(h):
            for x in range(w):
                ci = y * w + x if chroma == "444" else (y >> 1) * cw + (x >> 1)
                rgb.extend(bt709(yp[y * w + x], up[ci], vp[ci]))
        frames.append(bytes(rgb))
    return w, h, rate, chroma, frames


def read_wav(b):
    if len(b) < 12 or b[0:4] != b"RIFF" or b[8:12] != b"WAVE":
        raise Refused("wav-format")
    pos, fmt = 12, None
    while True:
        if pos + 8 > len(b):
            raise Refused("wav-truncated")
        cid, ln = b[pos:pos + 4], int.from_bytes(b[pos + 4:pos + 8], "little")
        pos += 8
        if cid == b"fmt ":
            if not 16 <= ln <= 40:
                raise Refused("wav-format")
            if pos + ln > len(b):
                raise Refused("wav-truncated")
            f = b[pos:pos + ln]
            tag, ch, rate = int.from_bytes(f[0:2], "little"), int.from_bytes(f[2:4], "little"), int.from_bytes(f[4:8], "little")
            align, bits = int.from_bytes(f[12:14], "little"), int.from_bytes(f[14:16], "little")
            if tag != 1 or bits != 16 or ch == 0 or rate == 0 or align != 2 * ch:
                raise Refused("wav-format")
            fmt = (ch, rate)
            pos += ln + (ln & 1)
        elif cid == b"data":
            if fmt is None or ln % (2 * fmt[0]):
                raise Refused("wav-format")
            if pos + ln > len(b):
                raise Refused("wav-truncated")
            return fmt, b[pos:pos + ln]
        else:
            pos += ln + (ln & 1)
            if pos > len(b):
                raise Refused("wav-truncated")


def source_verdict(name, b):
    try:
        read_y4m(b) if name.endswith(".y4m") else read_wav(b)
        return "ok"
    except Refused as r:
        return r.code


# ---------------------------------------------------------------- unit conversions (§4.4, §4.5)


U64 = (1 << 64) - 1


def units_from_ms(ms, num, den):
    return min(max(ms * num // (1000 * den), 1), U64)


def align(start, lead, comp):
    return min(start * comp[0] * lead[1] // (comp[1] * lead[0]), U64)


# ---------------------------------------------------------------- fixtures


M32 = 0xFFFFFFFF


def mix(v):
    v ^= v >> 16
    v = (v * 0x7FEB352D) & M32
    v ^= v >> 15
    v = (v * 0x846CA68B) & M32
    v ^= v >> 16
    return v


def noise(seed, x, y, t):
    return mix(seed ^ mix(x ^ mix(y ^ mix(t))))


def ramp(lo, hi, dx, dy, speed, jitter, seed, cb, cr):
    def y_of(x, y, t):
        v = (x * dx + y * dy + t * speed) % 32
        base = lo + v * (hi - lo) // 31
        if jitter:
            return min(max(max(base + noise(seed, x, y, t) % 3 - 1, 0), 16), 235)
        return base
    return y_of, (cb, cr)


def blocks(levels, bw, bh, speed, cb, cr):
    return (lambda x, y, t: levels[((x + t * speed) // bw + y // bh) % 3]), (cb, cr)


def noise_shot(lo, hi, seed, cb, cr):
    return (lambda x, y, t: lo + noise(seed, x, y, t) % (hi - lo + 1)), (cb, cr)


# A span's optional fourth member: LOCAL reads `t` as the frame's index within the span
# (0..n-1) instead of the global frame index, so two LOCAL spans of one shot are equal
# frame for frame.
LOCAL = "local"


def fixture_spans(name):
    """(w, h, spans): each span (frames, shot, blend target or None[, LOCAL])."""
    if name == "video-base-01":
        shot = blocks([40, 120, 200], 8, 6, 1, 100, 160)
        return 64, 36, [(60, ramp(20, 200, 1, 1, 1, True, 11, 110, 140), None),
                        (25, shot, None, LOCAL),
                        (50, ramp(30, 220, 2, 1, 1, True, 12, 150, 120), None),
                        (25, shot, None, LOCAL),
                        (40, ramp(16, 160, 1, 2, 1, True, 13, 128, 128), None)]
    if name == "cuts-01":
        a = ramp(20, 100, 1, 1, 1, True, 1, 110, 140)
        b = ramp(120, 220, 2, 1, 1, True, 2, 150, 120)
        flash = noise_shot(228, 235, 3, 128, 128)
        c = ramp(30, 90, 1, 2, 1, True, 4, 120, 120)
        d = ramp(150, 230, 1, 0, 2, True, 5, 136, 136)
        e = ramp(40, 120, 0, 1, 1, True, 6, 100, 150)
        f = ramp(140, 200, 1, 0, 1, True, 7, 160, 110)
        return 32, 18, [(60, a, None), (30, b, None), (6, flash, None), (44, b, None), (20, c, None), (40, c, d),
                        (30, d, None), (30, e, None), (30, f, None), (30, e, None), (30, f, None)]
    if name == "kinds-01":
        return 32, 18, [(40, ramp(20, 200, 1, 1, 0, False, 0, 128, 128), None),
                        (40, blocks([40, 120, 200], 8, 6, 1, 128, 128), None),
                        (40, noise_shot(16, 235, 7, 128, 128), None),
                        (40, ramp(16, 80, 1, 1, 1, True, 8, 128, 128), None),
                        (130, ramp(60, 180, 2, 1, 0, False, 0, 140, 116), None)]
    return None


def fixture(name):
    w, h, spans = fixture_spans(name)
    cw, ch = (w + 1) // 2, (h + 1) // 2
    out = bytearray(f"YUV4MPEG2 W{w} H{h} F25:1 Ip A1:1 C420jpeg\n".encode())
    t = 0
    for span in spans:
        n, (y_of, chroma), to = span[:3]
        local = span[3:] == (LOCAL,)
        for i in range(n):
            out += b"FRAME\n"
            def blend(a, b):
                return (a * (n - i - 1) + b * (i + 1)) // n
            tt = i if local else t
            for y in range(h):
                for x in range(w):
                    v = y_of(x, y, tt)
                    out.append(blend(v, to[0](x, y, tt)) if to else v)
            cb, cr = chroma
            if to:
                cb, cr = blend(cb, to[1][0]), blend(cr, to[1][1])
            out += bytes([cb]) * (cw * ch) + bytes([cr]) * (cw * ch)
            t += 1
    return bytes(out)


# ---------------------------------------------------------------- scene cut (§4.3) and kinds (§4.6)


def luma(r, g, b):
    return (77 * r + 150 * g + 29 * b + 128) >> 8


def distance(a, b, wh):
    return sum(abs(x - y) for x, y in zip(a, b)) * 1000 // (2 * wh)


def segment(frames, w, h, p):
    """The on-demand form: every frame known, `last` the final index."""
    wh = w * h
    ys = [[luma(f[i], f[i + 1], f[i + 2]) for i in range(0, len(f), 3)] for f in frames]
    hists = []
    for y in ys:
        hh = [0] * 64
        for v in y:
            hh[v >> 2] += 1
        hists.append(hh)
    n = len(frames)
    last = n - 1
    scores = [0] + [distance(hists[f], hists[f - 1], wh) for f in range(1, n)]
    L = p["lookahead"]

    def rejected(f):
        if any(distance(hists[f + k], hists[f - 1], wh) < p["cut_abs"] for k in range(1, min(L, last - f) + 1)):
            return True
        return any(distance(hists[f], hists[f - 1 - j], wh) < p["cut_abs"] for j in range(1, min(L, f - 1) + 1))

    starts, flags, window, start = [0], [0], [], 0
    for f in range(1, n):
        ln, s = f - start, scores[f]
        med = sorted(window)[(len(window) - 1) // 2] if window else 0
        hard = ln >= p["min"] and s >= p["cut_abs"] and (len(window) < 3 or s * 1000 >= p["cut_rel"] * med)
        soft = ln >= p["target"] and 2 * s >= p["cut_abs"]
        if (hard or soft) and not rejected(f):
            flag = 1
        elif ln >= p["max"]:
            flag = 2
        else:
            flag = 0
        if flag:
            starts.append(f)
            flags.append(flag)
            start, window = f, []
        else:
            window = (window + [s])[-p["window"]:]
    pieces = []
    for i, st in enumerate(starts):
        end = starts[i + 1] if i + 1 < len(starts) else n
        abs_diff = changed = 0
        for f in range(st + 1, end):
            for a, b in zip(ys[f], ys[f - 1]):
                abs_diff += abs(a - b)
                changed += a != b
        compared = wh * (end - st - 1)
        pieces.append({"start": st, "len": end - st, "flags": flags[i], "abs_diff": abs_diff, "changed": changed,
                       "compared": compared, "occupancy": sum(1 for c in hists[st] if c)})
    return pieces, scores


def classify(pc, c):
    mad = pc["abs_diff"] * 1000 // pc["compared"] if pc["compared"] else 0
    chg = pc["changed"] * 1000 // pc["compared"] if pc["compared"] else 0
    if mad <= c["static_mad_milli"] and chg <= c["static_permille"]:
        kind = "static"
    elif pc["occupancy"] <= c["synthetic_bins"]:
        kind = "synthetic"
    elif mad >= c["motion_high_milli"]:
        kind = "motion_high"
    else:
        kind = "natural"
    return kind, mad, chg


def plan_digest(starts):
    b = b"wai:pack-plan\x01" + len(starts).to_bytes(8, "little")
    for s in starts:
        b += s.to_bytes(8, "little")
    return blake3(b).hex()


# ---------------------------------------------------------------- the encoder's choices (§5.5, §5.6)


def quantize(r, q):
    """r / q rounded to the nearest integer, halves away from zero."""
    m = (2 * abs(r) + q) // (2 * q)
    return -m if r < 0 else m


def hist_to_cdf(hist, precision=16):
    """§5.5's table: every symbol frequency 1 + floor(R·h/H), the remainder one each to the
    largest R·h mod H (the lower symbol first), the escape 1."""
    total, n = 1 << precision, len(hist)
    r = total - n - 1
    weight = [1] * n if all(h == 0 for h in hist) else list(hist)
    big_h = sum(weight)
    freq = [1 + r * x // big_h for x in weight]
    given = sum(f - 1 for f in freq)
    order = sorted(range(n), key=lambda i: -(r * weight[i] % big_h))
    for i in order[:r - given]:
        freq[i] += 1
    freq.append(1)
    cdf, acc = [0], 0
    for f in freq:
        acc += f
        cdf.append(acc)
    return cdf


def residual_table(residuals):
    """The table and offset of §5.5 from a clip's residuals."""
    lo, hi = min(residuals), max(residuals)
    width = min(hi - lo + 1, 4095)
    hist = [0] * width
    for r in residuals:
        if lo <= r < lo + width:
            hist[r - lo] += 1
    return hist_to_cdf(hist), lo


def clampi(v, lo, hi):
    return lo if v < lo else hi if v > hi else v


def block_rows(ref, h, w, y0, y1, x0, x1, dy, dx, prec):
    """The decoder's prediction (integer-payloads §3) of the rows y0..y1, columns x0..x1
    of a block from the reference frame `ref` (h·w·3 bytes) with vector (dy, dx): one
    tuple of R, G, B samples per row."""
    def cols(xs):
        return [clampi(x, 0, w - 1) * 3 + c for x in xs for c in range(3)]

    def rowsl(y):
        k = clampi(y, 0, h - 1) * w * 3
        return ref[k:k + w * 3]
    out = []
    if prec == 1:
        get = cols(range(x0 + dx, x1 + dx))
        for y in range(y0, y1):
            row = rowsl(y + dy)
            out.append([row[i] for i in get])
        return out
    fy, fx = dy & 1, dx & 1
    ga = cols(range(x0 + (dx >> 1), x1 + (dx >> 1)))
    gb = cols(range(x0 + (dx >> 1) + 1, x1 + (dx >> 1) + 1))
    for y in range(y0, y1):
        iy = y + (dy >> 1)
        r0 = rowsl(iy)
        a = [r0[i] for i in ga]
        if not fy and not fx:
            out.append(a)
            continue
        if not fy:
            b = [r0[i] for i in gb]
            out.append([(p + q + 1) >> 1 for p, q in zip(a, b)])
            continue
        r1 = rowsl(iy + 1)
        c = [r1[i] for i in ga]
        if not fx:
            out.append([(p + q + 1) >> 1 for p, q in zip(a, c)])
            continue
        b = [r0[i] for i in gb]
        d = [r1[i] for i in gb]
        out.append([(p + q + s + t + 2) >> 2 for p, q, s, t in zip(a, b, c, d)])
    return out


def search_block(src, ref, h, w, y0, x0, block, rng, prec):
    """§5.5's motion search for one block: dy outer, dx inner, each ascending over
    -rng..=rng; the least SAD wins, a tie to the smaller |dy| + |dx|, then the earlier."""
    y1, x1 = min(y0 + block, h), min(x0 + block, w)
    srows = [src[(y * w + x0) * 3:(y * w + x1) * 3] for y in range(y0, y1)]
    best = None  # (cost, l1, dy, dx)
    for dy in range(-rng, rng + 1):
        for dx in range(-rng, rng + 1):
            cost = 0
            for s, p in zip(srows, block_rows(ref, h, w, y0, y1, x0, x1, dy, dx, prec)):
                cost += sum(abs(a - b) for a, b in zip(s, p))
                if best is not None and cost > best[0]:
                    break
            l1 = abs(dy) + abs(dx)
            if best is None or cost < best[0] or (cost == best[0] and l1 < best[1]):
                best = (cost, l1, dy, dx)
    return best[2], best[3]


def frame_pred(ref, h, w, block, mvs, prec):
    """A whole frame's prediction from `ref` with its blocks' vectors (raster order)."""
    pred = [0] * (h * w * 3)
    nbx = -(-w // block)
    for by in range(-(-h // block)):
        for bx in range(nbx):
            y0, x0 = by * block, bx * block
            y1, x1 = min(y0 + block, h), min(x0 + block, w)
            dy, dx = mvs[by * nbx + bx]
            for y, row in zip(range(y0, y1), block_rows(ref, h, w, y0, y1, x0, x1, dy, dx, prec)):
                pred[(y * w + x0) * 3:(y * w + x1) * 3] = row
    return pred


def frame_vectors(src, ref, h, w, block, rng, prec):
    nbx, nby = -(-w // block), -(-h // block)
    return [search_block(src, ref, h, w, by * block, bx * block, block, rng, prec) for by in range(nby) for bx in range(nbx)]


def closed_loop(frames, h, w, block, search, prec, q):
    """The encoder's reconstruction and its SSE (§5.5), without the entropy coder: each
    frame's vectors searched against the previous frame as reconstructed."""
    if len(frames) == 1:
        block, prec = 1, 1
    rng = search * prec if len(frames) > 1 else 0
    recon, sse = [], 0
    for f, src in enumerate(frames):
        if f == 0:
            pred = [128] * len(src)
        else:
            mvs = frame_vectors(src, recon[f - 1], h, w, block, rng, prec)
            pred = frame_pred(recon[f - 1], h, w, block, mvs, prec)
        cur = []
        for t, p in zip(src, pred):
            v = clampi(p + quantize(t - p, q) * q, 0, 255)
            sse += (t - v) * (t - v)
            cur.append(v)
        recon.append(cur)
    return recon, sse


def encoder_choices(v, params, src, decoded):
    """Item by item, what §5.5 makes of the source against the payload: every motion
    vector, every coded residual, and the table and its offset. Returns the failures."""
    h, w, n, q, prec, block = v["h"], v["w"], v["n_frames"], v["q"], v["mv_precision"], v["block"]
    bad = []
    rng = params["search"] * prec if n > 1 else 0
    nb = -(-h // block) * -(-w // block)
    d = IPV.Rans(v["rans"])
    residuals = []
    for f in range(n):
        if f == 0:
            pred = [128] * (h * w * 3)
        else:
            mvs = frame_vectors(src[f], decoded[f - 1], h, w, block, rng, prec)
            if mvs != [tuple(m) for m in v["mvs"][(f - 1) * nb:f * nb]]:
                bad.append(f"frame {f}: a motion vector is not the search's")
            pred = frame_pred(decoded[f - 1], h, w, block, [tuple(m) for m in v["mvs"][(f - 1) * nb:f * nb]], prec)
        for t, p in zip(src[f], pred):
            r = quantize(t - p, q)
            residuals.append(r)
            if d.decode(v["cdf"], v["offset"]) != r:
                bad.append(f"frame {f}: a coded residual is not quantize(source - prediction)")
                return bad
    cdf, offset = residual_table(residuals)
    if (cdf, offset) != (list(v["cdf"]), v["offset"]):
        bad.append("the residual table or its offset is not the fit of the residuals")
    return bad


def sse_px_milli(sse, h, w, n):
    return sse * 1000 // (3 * h * w * n)


def choose_q(metric_of, candidates, bound):
    """§5.6: the largest candidate meeting the bound, else the smallest."""
    qs = sorted(set(candidates), reverse=True)
    for q in qs:
        if metric_of(q) <= bound:
            return q
    return qs[-1]


# ---------------------------------------------------------------- the stage index (§6.2–§6.4)


MEDIA_CLASSES = ["video", "image", "audio", "world", "feed", "avatar", "film"]
ROLES = ["base", "refinement", "floor", "snapshot", "ops", "receipt", "asset"]
BASE, REFINEMENT, FLOOR = 0, 1, 2
NO_REFINES = 0xFFFFFFFF
PIECE_KINDS = KINDS + ["world", "audio"]
ENTRY_DUP, ENTRY_DERIVED = 2, 4
TIER_NAMES = [None, "entropy-consistency", "decode-equivalence"]


def le(b, at, n):
    return int.from_bytes(b[at:at + n], "little")


def pad8(n):
    return (n + 7) // 8 * 8


def parse_index(b):
    """§6.2: a WSIX file read into its header, records, class plan and strings, or the
    reader's refusal, the first that applies."""
    if b[:4] != b"WSIX":
        raise Refused("index-magic")
    if len(b) < 6:
        raise Refused("index-truncated")
    if le(b, 4, 2) != 1:
        raise Refused("index-version")
    if len(b) < 160:
        raise Refused("index-truncated")
    n_p, n_e, n_s, n_c = le(b, 16, 4), le(b, 20, 4), le(b, 24, 4), le(b, 28, 4)
    # Every table's size from its count, before anything is read from it.
    at_e = 160 + 32 * n_p
    at_c = at_e + 128 * n_e
    at_plan = at_c + 16 * n_c
    at_s = at_plan + pad8(n_c * n_p)
    if at_s > len(b):
        raise Refused("index-truncated")
    raw, pos = [], at_s
    for _ in range(n_s):
        if pos + 2 > len(b) or pos + 2 + le(b, pos, 2) > len(b):
            raise Refused("index-truncated")
        raw.append(b[pos + 2:pos + 2 + le(b, pos, 2)])
        pos += 2 + le(b, pos, 2)
    end = at_s + pad8(pos - at_s)
    if end > len(b):
        raise Refused("index-truncated")
    P = [b[160 + 32 * i:192 + 32 * i] for i in range(n_p)]
    E = [b[at_e + 128 * i:at_e + 128 * (i + 1)] for i in range(n_e)]
    C = [b[at_c + 16 * i:at_c + 16 * (i + 1)] for i in range(n_c)]
    reserved = [b[146:160], b[at_plan + n_c * n_p:at_s], b[pos:end]]
    reserved += [p[28:32] for p in P] + [e[58:60] + e[108:112] + e[120:128] for e in E] + [c[8:16] for c in C]
    if any(any(r) for r in reserved):
        raise Refused("index-reserved")
    if le(b, 6, 2) >= len(MEDIA_CLASSES):
        raise Refused("index-media-class")
    for e in E:
        if e[54] >= len(ROLES):
            raise Refused("index-role")
        if e[56] >= len(TIER_NAMES):
            raise Refused("index-tier")
    strings = []
    for s in raw:
        try:
            strings.append(s.decode("utf-8"))
        except UnicodeDecodeError:
            raise Refused("index-string")
    if not all(strings) or any(i >= n_s for i in [le(b, 144, 2)] + [le(e, 52, 2) for e in E] + [le(c, 0, 2) for c in C]):
        raise Refused("index-string")
    if end != len(b):
        raise Refused("index-trailing")
    return {
        "raw": b, "media_class": le(b, 6, 2), "tb": (le(b, 8, 4), le(b, 12, 4)), "policy_digest": b[32:64],
        "prev": b[64:96], "first_piece": le(b, 96, 8), "first_entry": le(b, 104, 8), "plan_digest": b[112:144],
        "component": strings[le(b, 144, 2)], "strings": strings,
        "pieces": [{"start": le(p, 0, 8), "duration": le(p, 8, 4), "first_entry": le(p, 12, 4),
                    "n_entries": le(p, 16, 2), "kind": p[18], "flags": p[19], "rules": le(p, 20, 4),
                    "moments": le(p, 24, 4)} for p in P],
        "entries": [{"record": e, "hash": e[0:32], "byte_len": le(e, 32, 8), "piece": le(e, 40, 8),
                     "refines": le(e, 48, 4), "cap": strings[le(e, 52, 2)], "role": e[54], "layer": e[55],
                     "tier": e[56], "flags": e[57], "deadline": le(e, 60, 4), "prefix": e[64:96],
                     "sse": le(e, 96, 8), "man_len": le(e, 104, 4), "payload_len": le(e, 112, 8)} for e in E],
        "classes": [{"name": strings[le(c, 0, 2)], "max_layer": c[2], "flags": c[3], "max_kbps": le(c, 4, 4)}
                    for c in C],
        "plan": [list(b[at_plan + k * n_p:at_plan + (k + 1) * n_p]) for k in range(n_c)],
    }


def cap_tier(cap):
    """§6.4: decode-equivalence (2) for a registry class that reconstructs exactly,
    entropy-consistency (1) for neural-entropy-exact, none (0) otherwise."""
    rep = (REGISTRY.get(cap) or {}).get("replicate")
    return 2 if rep in ("standard-defined", "neural-int-exact") else 1 if rep == "neural-entropy-exact" else 0


def due_tier(E, i):
    """The tier §6.4 gives entry i: a refinement holds decode-equivalence only over a prefix
    that does; a floor states none; any other entry its capability's."""
    e = E[i]
    if e["role"] == REFINEMENT:
        return 2 if E[e["refines"]]["tier"] == 2 and cap_tier(e["cap"]) == 2 else 0
    return 0 if e["role"] == FLOOR else cap_tier(e["cap"])


def owners(ix):
    """The window-relative piece of each entry, by the pieces' entry ranges."""
    return [k for k, pc in enumerate(ix["pieces"]) for _ in range(pc["n_entries"])]


def highest_layer(ix, k):
    pc = ix["pieces"][k]
    es = ix["entries"][pc["first_entry"]:pc["first_entry"] + pc["n_entries"]]
    return max((e["layer"] for e in es if e["role"] in (BASE, REFINEMENT)), default=0)


def index_rules(ix):
    """§6.3's rules in their order, with §6.4's tiers; the first broken is the refusal."""
    if 0 in ix["tb"]:
        raise Refused("index-timebase")
    # An index with no previous window starts the timeline and the chain (§4.5).
    if not any(ix["prev"]) and (ix["first_piece"] or ix["first_entry"] or (ix["pieces"] and ix["pieces"][0]["start"])):
        raise Refused("window-start")
    pieces, E, before = ix["pieces"], ix["entries"], 0
    for k, pc in enumerate(pieces):
        if pc["duration"] == 0 or (k and pc["start"] != pieces[k - 1]["start"] + pieces[k - 1]["duration"]):
            raise Refused("piece-order")
        if pc["first_entry"] != before or pc["n_entries"] == 0:
            raise Refused("piece-entries")
        if pc["kind"] >= len(PIECE_KINDS) or pc["flags"] > 0x0F:
            raise Refused("piece-kind")
        before += pc["n_entries"]
    if before != len(E):
        raise Refused("piece-entries")
    rank = {BASE: 0, REFINEMENT: 1, FLOOR: 2}
    own = owners(ix)
    for i, e in enumerate(E):
        pc = pieces[own[i]]
        if e["piece"] != ix["first_piece"] + own[i]:
            raise Refused("piece-entries")
        if e["flags"] > 0x07:
            raise Refused("entry-flags")
        if i > pc["first_entry"]:
            p = E[i - 1]
            if rank.get(e["role"], 3) < rank.get(p["role"], 3) or \
                    (e["role"] == p["role"] == REFINEMENT and e["layer"] < p["layer"]):
                raise Refused("entry-order")
        refinement = e["role"] == REFINEMENT
        if (e["role"] in (BASE, FLOOR) and e["layer"] > 0) or (refinement and e["layer"] == 0) \
                or refinement != (e["refines"] != NO_REFINES):
            raise Refused("layer-role")
        if refinement:
            if e["refines"] >= len(E):
                raise Refused("refines-outside-window")
            if not pc["first_entry"] <= e["refines"] < i:
                raise Refused("refines-mismatch")
            if E[e["refines"]]["layer"] != e["layer"] - 1:
                raise Refused("layer-gap")
        due = due_tier(E, i)
        if e["layer"] > 0 and e["tier"] == 1:
            raise Refused("tier-entropy-passthrough")
        if e["layer"] > 0 and e["tier"] == 2 and due != 2:
            raise Refused("tier-weakest")
        if e["tier"] != due:
            raise Refused("tier-mismatch")
        if any(e["prefix"]) and e["tier"] != 2:
            raise Refused("digest-without-tier")
        if e["deadline"] and not refinement:
            raise Refused("deadline-role")
        if e["role"] == FLOOR and not e["flags"] & ENTRY_DERIVED:
            raise Refused("floor-derived-from")
        earlier = [x for x in E[:i] if x["hash"] == e["hash"]]
        if any(x["byte_len"] != e["byte_len"] for x in earlier):
            raise Refused("dup-length")
        if bool(e["flags"] & ENTRY_DUP) != bool(earlier):
            raise Refused("dup-flag")
    if len(ix["plan"]) != len(ix["classes"]):
        raise Refused("class-plan")
    for cl, row in zip(ix["classes"], ix["plan"]):
        if cl["flags"] > 0x01:
            raise Refused("class-flags")
        if len(row) != len(pieces):
            raise Refused("class-plan")
        for k, v in enumerate(row):
            if cl["flags"] & 1:
                ok = v == 0xFF
            else:
                ok = v == 0xFF or (v <= cl["max_layer"] and v <= highest_layer(ix, k))
            if not ok:
                raise Refused("class-plan")


def merkle_root(items):
    """jwp-receipts §2.2: each item under the leaf domain, pairs under the node domain, an
    odd level's last node duplicated; no items, 32 zero bytes."""
    if not items:
        return bytes(32)
    level = [blake3(b"moq-jwp:merkle-leaf\x01" + x) for x in items]
    while len(level) > 1:
        if len(level) % 2:
            level.append(level[-1])
        level = [blake3(b"moq-jwp:merkle-node\x01" + level[i] + level[i + 1]) for i in range(0, len(level), 2)]
    return level[0]


def index_digest(b):
    return blake3(b"wai:pack-stage-index\x01" + b)


def stage_root(ix):
    """§6.2: the Merkle root over BLAKE3("wai:pack-stage\\x01" ‖ entry record)."""
    return merkle_root([blake3(b"wai:pack-stage\x01" + e["record"]) for e in ix["entries"]])


# ---------------------------------------------------------------- objects (§5, §6.3)


def content_hash(b):
    """jwp-receipts §2.1."""
    return blake3(b"moq-jwp:object\x01" + b)


def read_json(b, minus_zero=False):
    """JSON in UTF-8 whose objects name no member twice (SPEC §2), or None. With
    `minus_zero`, the number -0 is read as the float -0.0, as RFC 8259 readers that keep
    its sign do, so no rule that requires an integer accepts it."""
    def members(pairs):
        d = {}
        for k, v in pairs:
            if k in d:
                raise ValueError("a member named twice")
            d[k] = v
        return d

    def no_constant(s):
        raise ValueError(s)

    def finite(t):
        # RFC 8259 readers that hold numbers as binary64 refuse one past its range.
        v = float(t)
        if v in (float("inf"), float("-inf")):
            raise ValueError(t)
        return v
    try:
        hook = (lambda t: float(t) if t == "-0" else int(t)) if minus_zero else int
        return json.loads(b.decode("utf-8"), object_pairs_hook=members, parse_constant=no_constant, parse_int=hook,
                          parse_float=finite)
    except (UnicodeDecodeError, ValueError, RecursionError):
        return None


def opt_str(o, k):
    """An OPTIONAL string member: absent, null, or a string."""
    return k not in o or o[k] is None or isinstance(o[k], str)


def prior_ok(p):
    """SPEC §3.1: a pin is null, or an object whose id, sha256 and determinism are strings,
    form and tier OPTIONAL strings, supersedes null or an object of a string sha256 and an
    OPTIONAL string form."""
    if p is None:
        return True
    if not isinstance(p, dict) or not all(isinstance(p.get(k), str) for k in ("id", "sha256", "determinism")):
        return False
    sup = p.get("supersedes")
    return opt_str(p, "form") and opt_str(p, "tier") and \
        (sup is None or (isinstance(sup, dict) and isinstance(sup.get("sha256"), str) and opt_str(sup, "form")))


def is_number(v):
    return isinstance(v, (int, float)) and not isinstance(v, bool)


def manifest_typed(m, v2):
    """SPEC §3 and §7.1: a manifest that parses with its members' types. wai, media and
    intent are strings. A WAI1's model_requirement is an object whose capability is a
    string, fallback and sim_metric OPTIONAL strings, min_sim null or a number; its
    conditioning an object whose kind is a string and prior a pin; security null or an
    object of an OPTIONAL string encryption and an OPTIONAL u64 kid. A WAI2's renditions are
    objects whose capability and kind are strings, id, sha256, role, companion_of and
    companion_of_id OPTIONAL strings, prior a pin. Members this revision does not define
    may have any value; refines, derived_from, envelope_manifest and target any JSON."""
    if not isinstance(m, dict) or not all(isinstance(m.get(k), str) for k in ("wai", "media", "intent")):
        return False
    if v2:
        rs = m.get("renditions")
        return isinstance(rs, list) and all(
            isinstance(r, dict) and isinstance(r.get("capability"), str) and isinstance(r.get("kind"), str)
            and all(opt_str(r, k) for k in ("id", "sha256", "role", "companion_of", "companion_of_id")) and prior_ok(r.get("prior"))
            for r in rs)
    mr, c, sec = m.get("model_requirement"), m.get("conditioning"), m.get("security")
    if not isinstance(mr, dict) or not isinstance(mr.get("capability"), str) or not opt_str(mr, "fallback") \
            or not opt_str(mr, "sim_metric") or not (mr.get("min_sim") is None or is_number(mr["min_sim"])):
        return False
    if not isinstance(c, dict) or not isinstance(c.get("kind"), str) or not prior_ok(c.get("prior")):
        return False
    return sec is None or (isinstance(sec, dict) and opt_str(sec, "encryption")
                           and (sec.get("kid") is None or (is_int(sec["kid"]) and 0 <= sec["kid"] < 1 << 64)))


def read_envelope(b):
    """Exactly one WAI1 or WAI2 envelope and nothing after it (http-delivery §5.1), its
    manifest JSON that parses (SPEC §2, §7.1): (man_len, payload_len, the member that
    names the capability, the capability, each payload with the capabilities that decode
    it), or None. The member is the WAI1 manifest, or the WAI2's first rendition entry; a
    WAI2's payload length is every component's; a WAI1's payload is decoded by its
    capability and its fallback (SPEC §4)."""
    if len(b) < 8 or b[:4] not in (b"WAI1", b"WAI2"):
        return None
    ml = le(b, 4, 4)
    if 8 + ml > len(b):
        return None
    man = read_json(b[8:8 + ml])
    # §6.3: "does not parse" is the typed parse with SPEC §3's members.
    if not manifest_typed(man, b[:4] == b"WAI2"):
        return None
    if b[:4] == b"WAI1":
        if 12 + ml > len(b) or len(b) != 12 + ml + le(b, 8 + ml, 4):
            return None
        mr = man.get("model_requirement") if isinstance(man.get("model_requirement"), dict) else {}
        caps = [c for c in (mr.get("capability"), mr.get("fallback")) if isinstance(c, str)]
        return ml, le(b, 8 + ml, 4), man, mr.get("capability"), [(caps, b[12 + ml:])]
    rs = man.get("renditions")
    at = 8 + ml
    if not isinstance(rs, list) or not rs or not all(isinstance(r, dict) for r in rs) or at + 2 > len(b):
        return None
    n = le(b, at, 2)
    head = at + 2 + 8 * n
    if n != len(rs) or head > len(b):
        return None
    total, parts = 0, []
    for i in range(n):
        if le(b, at + 2 + 8 * i, 4) != total:
            return None
        parts.append(([rs[i].get("capability")], b[head + total:head + total + le(b, at + 6 + 8 * i, 4)]))
        total += le(b, at + 6 + 8 * i, 4)
    return (ml, total, rs[0], rs[0].get("capability"), parts) if len(b) == head + total else None


WIR1_KIND = {"wai.image.int_refine": "rgb8", "wai.video.int_refine": "rgb8", "wai.audio.int_refine": "pcm",
             "wai.splat.int_refine": "tensor"}


def wir1_parses(cap, p):
    """staged-delivery A.1–A.3: a WIR1 payload's parse, for the capability's unit kind."""
    if p[:4] != b"WIR1" or len(p) < 44 or p[4] != 1 or le(p, 42, 2):
        return False
    elem, pred, mode, n, d0, d1, d2 = p[5], p[6], p[7], le(p, 8, 4), le(p, 12, 4), le(p, 16, 4), le(p, 20, 4)
    rn, rd, q, cdf_len = le(p, 24, 4), le(p, 28, 4), le(p, 32, 4), le(p, 40, 2)
    if elem not in (1, 2) or pred not in (0, 1, 2) or mode not in (0, 1) or 0 in (n, d0, d1, d2):
        return False
    if not ((rn >= 1 and rd >= 1) if pred == 2 else rn == rd == 0):
        return False
    if not 1 <= q <= 65535 or not 3 <= cdf_len <= 4097:
        return False
    kind = WIR1_KIND[cap]
    if kind == "rgb8" and (elem != 1 or pred not in (0, 1) or d2 != 3):
        return False
    if kind == "pcm" and (elem != 2 or pred not in (0, 2) or d1 != 1):
        return False
    if kind == "tensor" and (elem != 1 or pred != 0):
        return False
    if d0 * d1 * d2 > 1 << 26 or n > 1 << 20 or n * d0 * d1 * d2 > 1 << 30:
        return False
    at = 44
    for _ in range(n if mode else 1):
        if at + 4 * cdf_len > len(p):
            return False
        try:
            IPV.check_cdf([le(p, at + 4 * k, 4) for k in range(cdf_len)])
        except IPV.Refused:
            return False
        at += 4 * cdf_len
    if at + 4 * n > len(p):
        return False
    lens = [le(p, at + 4 * k, 4) for k in range(n)]
    if any(x % 4 or x < 8 for x in lens):
        return False
    return at + 4 * n + sum(lens) == len(p)


def payload_parses(cap, p):
    """§6.2 with staged-measurement §3.2 and its Appendix A: a payload of a capability WAI
    pins to a binary format parses as that format, by the parse a sink runs; a capability
    with no pinned format asks nothing of it."""
    if cap in IPV.CAP_MAGIC:
        try:
            IPV.parse(cap, p)
            return True
        except IPV.Refused:
            return False
    return wir1_parses(cap, p) if cap in WIR1_KIND else True


def derived_from_ok(df):
    """SPEC §7.1, *Derived renditions*: the member's four values in their forms."""
    return isinstance(df, dict) and all(isinstance(df.get(k), str) and df[k] for k in
                                        ("motif", "motif_capability", "renderer", "settings")) \
        and is_hex64(df["motif"]) and is_hex64(df["settings"])


def refines_ok(ix, i, rf):
    """§5.4: `base` the content hash of its piece's base, `layer` its layer, and as
    producers in `prev` only objects of the layers below it, the entry it refines among them."""
    E, pc = ix["entries"], ix["pieces"][owners(ix)[i]]
    e, mine = E[i], E[pc["first_entry"]:pc["first_entry"] + pc["n_entries"]]
    base = next((x for x in mine if x["role"] == BASE), None)
    if not isinstance(rf, dict) or base is None or rf.get("base") != base["hash"].hex():
        return False
    if not is_int(rf.get("layer")) or rf["layer"] != e["layer"]:
        return False
    prev = rf.get("prev")
    if isinstance(prev, str):
        producers = [prev]
    elif isinstance(prev, list) and prev and all(isinstance(r, dict) for r in prev):
        producers = [r.get("producer") for r in prev]
    else:
        return False
    below = {x["hash"].hex() for x in mine if x["role"] in (BASE, REFINEMENT) and x["layer"] < e["layer"]}
    return all(p in below for p in producers) and E[e["refines"]]["hash"].hex() in producers


def object_rules(ix, i, data):
    """§6.3, with the objects in hand: entry i's object, the first rule broken is the refusal."""
    e = ix["entries"][i]
    if len(data) != e["byte_len"]:
        raise Refused("object-length")
    if content_hash(data) != e["hash"]:
        raise Refused("object-hash")
    env = read_envelope(data)
    if env is None:
        raise Refused("non-envelope-entry")
    ml, pl, m, cap, parts = env
    if ml != e["man_len"] or pl != e["payload_len"]:
        raise Refused("object-lengths")
    if cap != e["cap"]:
        raise Refused("object-capability")
    wai2 = data[:4] == b"WAI2"
    # A refinement's object is a WAI1 that carries refines (§5.4).
    if e["role"] == REFINEMENT and (wai2 or not refines_ok(ix, i, m.get("refines"))):
        raise Refused("object-refines")
    # derived_from: a WAI1's manifest member; a WAI2's entries', present when any entry
    # carries it and well formed only when every one that does is. null is absent.
    if wai2:
        dfs = [r.get("derived_from") for r in read_json(data[8:8 + ml])["renditions"] if r.get("derived_from") is not None]
        has, good = bool(dfs), all(derived_from_ok(x) for x in dfs)
    else:
        has = m.get("derived_from") is not None
        good = not has or derived_from_ok(m["derived_from"])
    if has != bool(e["flags"] & ENTRY_DERIVED) or not good:
        raise Refused("object-derived-from")
    # §6.2, after the other object rules: where WAI checks a payload's format, the lengths
    # are its counted bytes (staged-measurement §3), so every such payload parses as its
    # format.
    if not all(payload_parses(c, p) for caps, p in parts for c in caps):
        raise Refused("object-lengths")
    return m


# ---------------------------------------------------------------- package receipts (§9)


PARENT_KINDS = ["none", "live-window", "re-pack"]
# energy-measurement §2.7: a class's tag, and the evidence members each class carries.
CLASS_TAGS = {"HwShunt": 1, "ModelBased": 2, "Estimator": 3, "OnChipCounter": 4, "CalibratedInstrument": 5}
FILTERING = {"Unknown": 0, "Off": 1, "On": 2}
EVIDENCE = {"OnChipCounter": {"energy_uncertainty", "energy_counter_filtering"},
            "CalibratedInstrument": {"energy_uncertainty", "energy_calibration_ref"}}
EVIDENCE_MEMBERS = {"energy_uncertainty", "energy_counter_filtering", "energy_calibration_ref"}
V2_MEMBERS = {"asset_id", "components", "grant", "joules_micro", "kind", "packager", "parent_kind",
              "parent_receipt_hash", "policy_digest", "receipt_hash", "sig", "signer_id", "signer_pubkey",
              "stored_bytes", "total_bytes", "total_entries", "unique_objects", "version", "work_units"}
V1_MEMBERS = {"asset_id", "grant", "joules_micro", "kind", "parent_receipt_hash",
              "receipt_hash", "segment_map_root", "segments", "sig", "signer_id", "signer_pubkey", "stored_bytes",
              "total_bytes", "total_segments", "unique_segments", "work_segment_ops"}
RECEIPT_ID = b"wai:video-package-receipt-id\x01"


def be(v, n):
    return v.to_bytes(n, "big")


def lp(s):
    s = s.encode()
    return be(len(s), 4) + s


def is_hex(s, n):
    return isinstance(s, str) and len(s) == n and all(c in "0123456789abcdef" for c in s)


def is_u53(v):
    return is_int(v) and 0 <= v <= MAX_INTEGER


def need(ok):
    if not ok:
        raise Refused("receipt-json")


def energy_label(j, strict):
    """energy-measurement §2.7: the class's signed encoding from its JSON members, or None
    for no class. Evidence without its class, a class without its evidence, and evidence a
    class does not carry are refused. Version 2 (`strict`, §9.1) writes the evidence exactly
    as its class carries it, with no null in its place; version 1 (§9.3) reads a null
    evidence member as absent, and an on-chip counter's filtering, absent, as Unknown."""
    cls = j.get("energy_provenance")
    if strict:
        need(not any(k in j and j[k] is None for k in EVIDENCE_MEMBERS))
        present = EVIDENCE_MEMBERS & set(j)
    else:
        present = {k for k in EVIDENCE_MEMBERS if j.get(k) is not None}
    if cls is None:
        need(not present)
        return None
    allowed = EVIDENCE.get(cls, set())
    lenient = set() if strict else {"energy_counter_filtering"}
    need(isinstance(cls, str) and cls in CLASS_TAGS and present <= allowed and (allowed - present) <= lenient)
    out = bytes([CLASS_TAGS[cls]])
    if cls in EVIDENCE:
        u = j["energy_uncertainty"]
        need(isinstance(u, dict) and set(u) == {"relative_ppm", "window_us"} and is_u53(u["relative_ppm"])
             and u["relative_ppm"] <= U32 and is_u53(u["window_us"]))
        out += be(u["relative_ppm"], 4) + be(u["window_us"], 8)
        if cls == "OnChipCounter":
            f = j.get("energy_counter_filtering") or "Unknown"
            need(isinstance(f, str) and f in FILTERING)
            out += bytes([FILTERING[f]])
        else:
            ref = j["energy_calibration_ref"]
            need(isinstance(ref, str) and ref != "")
            out += lp(ref)
    return out


def grant_bytes(g):
    """The grant as §9.1 (and version 1) sign it: grant_hash ‖ u32 len ‖ capability ‖ u64
    joule_ceiling_micro (null: 2^64 − 1) ‖ u8 0, or u8 1 ‖ u64 funds_ceiling."""
    need(isinstance(g, dict) and set(g) == {"capability", "funds_ceiling", "grant_hash", "joule_ceiling_micro"})
    need(isinstance(g["capability"], str) and is_hex(g["grant_hash"], 64))
    need(g["joule_ceiling_micro"] is None or is_u53(g["joule_ceiling_micro"]))
    need(g["funds_ceiling"] is None or is_u53(g["funds_ceiling"]))
    out = bytes.fromhex(g["grant_hash"]) + lp(g["capability"])
    out += be(U64 if g["joule_ceiling_micro"] is None else g["joule_ceiling_micro"], 8)
    return out + (b"\x00" if g["funds_ceiling"] is None else b"\x01" + be(g["funds_ceiling"], 8))


def v1_leaf(s):
    return blake3(b"wai:video-package-seg\x01" + be(s["index"], 8) + bytes.fromhex(s["content_hash"])
                  + be(s["duration_ms"], 8) + be(s["byte_len"], 8))


def read_receipt(b):
    """§9.1 and §9.3: a receipt's JSON read as version 1 or 2, every member in its form,
    its signing payload rebuilt and its receipt_hash checked; refuses receipt-version and
    receipt-json. Returns the version, the JSON, the payload and the class encoding."""
    # RFC 8259 with no member named twice; -0 is read as a number that is not an integer,
    # so it is refused where an integer is required; a string that cannot be written in
    # UTF-8 (a lone surrogate escape) has no form (receipt-json).
    j = read_json(b, minus_zero=True)
    need(isinstance(j, dict))
    try:
        r = receipt_payload(j)
        need(blake3(RECEIPT_ID + r["payload"] + bytes.fromhex(j["sig"])).hex() == j["receipt_hash"])
    except (UnicodeEncodeError, OverflowError, ValueError):
        raise Refused("receipt-json")
    return r


def receipt_payload(j):
    """A receipt's members read in their forms and its signing payload: version 2's
    (§9.1), or version 1's (§9.3), the version a receipt without `version` has."""
    v = j.get("version", 1)
    if not is_int(v) or v not in (1, 2):
        raise Refused("receipt-version")
    need(isinstance(j.get("asset_id"), str) and j.get("kind") == "package")
    # Version 2 writes every member, null where there is none (energy_provenance among
    # them, §9.1); version 1 may leave energy_provenance out (§9.3).
    if v == 2:
        need(V2_MEMBERS | {"energy_provenance"} <= set(j) and set(j) <= V2_MEMBERS | {"energy_provenance"} | EVIDENCE_MEMBERS)
    else:
        need(V1_MEMBERS <= set(j) and set(j) <= V1_MEMBERS | {"version", "energy_provenance"} | EVIDENCE_MEMBERS)
    label = energy_label(j, v == 2)
    counts = ("total_entries", "unique_objects", "total_bytes", "stored_bytes", "work_units") if v == 2 else \
        ("total_segments", "unique_segments", "total_bytes", "stored_bytes", "work_segment_ops")
    need(all(is_u53(j[k]) for k in counts + ("joules_micro",)))
    need(is_hex(j["receipt_hash"], 64) and is_hex(j["sig"], 128) and is_hex(j["signer_pubkey"], 64))
    need(isinstance(j["signer_id"], str))
    grant = grant_bytes(j["grant"])
    signer = bytes.fromhex(j["signer_pubkey"]) + lp(j["signer_id"])
    figure = be(j["joules_micro"], 8)
    if v == 2:
        need(j["parent_kind"] in PARENT_KINDS if isinstance(j["parent_kind"], str) else False)
        none = j["parent_kind"] == "none"
        need(j["parent_receipt_hash"] is None if none else is_hex(j["parent_receipt_hash"], 64))
        need(is_hex(j["policy_digest"], 64) and isinstance(j["packager"], str))
        cs = j["components"]
        need(isinstance(cs, list))
        for c in cs:
            need(isinstance(c, dict) and set(c) == {"id", "index", "index_digest", "media_class", "stage_root"})
            need(isinstance(c["id"], str) and c["id"] != "" and c["index"] == f"index-{c['id']}.wsix")
            need(is_hex(c["index_digest"], 64) and is_hex(c["stage_root"], 64))
            need(isinstance(c["media_class"], str) and c["media_class"] in MEDIA_CLASSES)
        payload = b"wai:pack-receipt" + (b"\x01" if label is None else b"\x02")
        payload += lp(j["asset_id"]) + bytes.fromhex(j["policy_digest"])
        payload += bytes([PARENT_KINDS.index(j["parent_kind"])])
        payload += b"" if none else bytes.fromhex(j["parent_receipt_hash"])
        payload += be(len(cs), 4)
        for c in cs:
            payload += lp(c["id"]) + bytes([MEDIA_CLASSES.index(c["media_class"])])
            payload += bytes.fromhex(c["index_digest"]) + bytes.fromhex(c["stage_root"])
        payload += b"".join(be(j[k], 8) for k in counts) + lp(j["packager"])
        payload += figure + (label or b"") + grant + signer
    else:
        need(j["parent_receipt_hash"] is None or is_hex(j["parent_receipt_hash"], 64))
        need(is_hex(j["segment_map_root"], 64) and isinstance(j["segments"], list))
        for s in j["segments"]:
            need(isinstance(s, dict) and set(s) == {"byte_len", "content_hash", "duration_ms", "index"})
            need(is_u53(s["byte_len"]) and is_u53(s["duration_ms"]) and is_u53(s["index"]))
            need(is_hex(s["content_hash"], 64))
        payload = b"wai:video-package-receipt\x01" + lp(j["asset_id"]) + bytes.fromhex(j["segment_map_root"])
        payload += b"".join(be(j[k], 8) for k in counts) + figure + (label or b"\x00") + grant
        payload += b"\x00" if j["parent_receipt_hash"] is None else b"\x01" + bytes.fromhex(j["parent_receipt_hash"])
        payload += be(len(j["segments"]), 8) + b"".join(v1_leaf(s) for s in j["segments"]) + signer
    return {"version": v, "json": j, "payload": payload, "label": label}


def ed25519_verifies(pk, sig, msg):
    """WAI's strict rule (SPEC §7 *Signatures*): a canonical key of large order, S < L, R
    not of small order, and the cofactorless equation with R compared byte for byte. The
    `cryptography` package alone accepts a key of small order, a second spelling of a key,
    and an R of small order."""
    return ED.verifies(pk, msg, sig)


def ed25519_from_seed(seed, msg):
    """The public key of a 32-byte seed and its signature over msg (RFC 8032; deterministic)."""
    from cryptography.hazmat.primitives import serialization
    from cryptography.hazmat.primitives.asymmetric import ed25519
    sk = ed25519.Ed25519PrivateKey.from_private_bytes(seed)
    pk = sk.public_key().public_bytes(serialization.Encoding.Raw, serialization.PublicFormat.Raw)
    return pk, sk.sign(msg)


def package_counts(ixs):
    """§9.1: entries, distinct content hashes, referenced and stored bytes, work units; None
    when a content hash comes at two lengths."""
    E = [e for ix in ixs for e in ix["entries"]]
    first = {}
    for e in E:
        if first.setdefault(e["hash"], e["byte_len"]) != e["byte_len"]:
            return None
    return {"total_entries": len(E), "unique_objects": len(first), "total_bytes": sum(e["byte_len"] for e in E),
            "stored_bytes": sum(first.values()), "work_units": len(E)}


def verify_receipt_v2(r, index_files):
    """§9.1's verification of a version-2 receipt against its indexes, in its components'
    order: the first refusal that applies. Returns the parsed indexes."""
    j = r["json"]
    if r["version"] != 2:
        raise Refused("receipt-version")
    if not j["components"] or len(index_files) != len(j["components"]):
        raise Refused("receipt-index-count")
    ixs = []
    for c, b in zip(j["components"], index_files):
        ix = parse_index(b)
        index_rules(ix)
        if index_digest(b).hex() != c["index_digest"]:
            raise Refused("receipt-index-digest")
        if stage_root(ix).hex() != c["stage_root"]:
            raise Refused("receipt-stage-root")
        if ix["component"] != c["id"] or MEDIA_CLASSES[ix["media_class"]] != c["media_class"]:
            raise Refused("receipt-component")
        if ix["policy_digest"].hex() != j["policy_digest"]:
            raise Refused("receipt-policy-digest")
        ixs.append(ix)
    if len({c["id"] for c in j["components"]}) != len(j["components"]):
        raise Refused("receipt-component")
    counts = package_counts(ixs)
    if counts is None or any(counts[k] != j[k] for k in counts):
        raise Refused("receipt-counts")
    live = [any(ix["prev"]) for ix in ixs]
    if not (all(live) if j["parent_kind"] == "live-window" else not any(live)):
        raise Refused("receipt-parent-kind")
    lab = r["label"]
    if (lab is None) != (j["joules_micro"] == 0) or (lab is not None and lab[0] == CLASS_TAGS["HwShunt"]):
        raise Refused("receipt-energy")
    if not ed25519_verifies(bytes.fromhex(j["signer_pubkey"]), bytes.fromhex(j["sig"]), r["payload"]):
        raise Refused("receipt-signature")
    return ixs


# ---------------------------------------------------------------- the AV1 floor (§7)


class Malformed(Exception):
    pass


def obus(b):
    """The low-overhead OBU format (AV1 §5.3): every OBU with its size field, read into
    (type, the OBU's bytes, its payload)."""
    out, p = [], 0
    while p < len(b):
        hdr = b[p]
        if hdr & 0x80 or not hdr & 0x02:
            raise Malformed("the forbidden bit, or an OBU without its size field")
        q, size, shift = p + 1 + (hdr >> 2 & 1), 0, 0
        for k in range(8):
            if q >= len(b):
                raise Malformed("a size field past the end")
            size |= (b[q] & 0x7F) << shift
            shift, q = shift + 7, q + 1
            if not b[q - 1] & 0x80:
                break
        else:
            raise Malformed("a size field over 8 bytes")
        if q + size > len(b):
            raise Malformed("an OBU past the end")
        out.append((hdr >> 3 & 0x0F, b[p:q + size], b[q:q + size]))
        p = q + size
    return out


OBU_SEQ, OBU_TD, OBU_FRAME_HEADER, OBU_FRAME = 1, 2, 3, 6


def temporal_units(b):
    """A stream split at each temporal delimiter: (the unit's bytes, its OBUs)."""
    units = []
    for t, whole, payload in obus(b):
        if t == OBU_TD:
            units.append([b"", []])
        elif not units:
            raise Malformed("an OBU before the first temporal delimiter")
        units[-1][0] += whole
        units[-1][1].append((t, whole, payload))
    return [(u, o) for u, o in units]


class Bits:
    def __init__(self, b):
        self.b, self.p = b, 0

    def f(self, n):
        v = 0
        for _ in range(n):
            if self.p >= 8 * len(self.b):
                raise Malformed("a sequence header past its end")
            v = v << 1 | (self.b[self.p >> 3] >> (7 - (self.p & 7)) & 1)
            self.p += 1
        return v

    def uvlc(self):
        zeros = 0
        while not self.f(1):
            zeros += 1
        return (1 << 32) - 1 if zeros >= 32 else self.f(zeros) + (1 << zeros) - 1


def sequence_header(payload):
    """sequence_header_obu (AV1 §5.5): profile, operating point 0's level and tier, the
    frame size, and color_config's bit depth, monochrome and chroma fields."""
    r = Bits(payload)
    s = {"profile": r.f(3), "still": r.f(1), "reduced": r.f(1)}
    if s["reduced"]:
        s["level"], s["tier"] = r.f(5), 0
    else:
        decoder_model = 0
        if r.f(1):  # timing_info_present_flag
            r.f(32), r.f(32)
            if r.f(1):  # equal_picture_interval
                r.uvlc()
            decoder_model = r.f(1)
            if decoder_model:
                delay_bits = r.f(5) + 1
                r.f(32), r.f(5), r.f(5)
        initial_delay = r.f(1)
        for i in range(r.f(5) + 1):
            r.f(12)
            level = r.f(5)
            tier = r.f(1) if level > 7 else 0
            if i == 0:
                s["level"], s["tier"] = level, tier
            if decoder_model and r.f(1):
                r.f(delay_bits), r.f(delay_bits), r.f(1)
            if initial_delay and r.f(1):
                r.f(4)
    wb, hb = r.f(4) + 1, r.f(4) + 1
    s["max_w"], s["max_h"] = r.f(wb) + 1, r.f(hb) + 1
    if not s["reduced"] and r.f(1):  # frame_id_numbers_present_flag
        r.f(4), r.f(3)
    r.f(1), r.f(1), r.f(1)  # 128x128 superblock, filter intra, intra edge filter
    if not s["reduced"]:
        r.f(1), r.f(1), r.f(1), r.f(1)  # interintra, masked compound, warped motion, dual filter
        order_hint = r.f(1)
        if order_hint:
            r.f(1), r.f(1)  # jnt_comp, ref_frame_mvs
        screen = 2 if r.f(1) else r.f(1)  # seq_choose_screen_content_tools, else its value
        if screen > 0 and not r.f(1):  # seq_choose_integer_mv
            r.f(1)
        if order_hint:
            r.f(3)
    r.f(1), r.f(1), r.f(1)  # superres, cdef, restoration
    hbd = r.f(1)
    s["high_bitdepth"], s["twelve_bit"] = hbd, 0
    if s["profile"] == 2 and hbd:
        s["twelve_bit"] = r.f(1)
        s["bit_depth"] = 12 if s["twelve_bit"] else 10
    else:
        s["bit_depth"] = 10 if hbd else 8
    s["mono"] = 0 if s["profile"] == 1 else r.f(1)
    cp = tc = mc = 2
    if r.f(1):  # color_description_present_flag
        cp, tc, mc = r.f(8), r.f(8), r.f(8)
    s["csp"] = 0
    if s["mono"]:
        r.f(1)
        s["ssx"] = s["ssy"] = 1
    elif cp == 1 and tc == 13 and mc == 0:
        s["ssx"] = s["ssy"] = 0
    else:
        r.f(1)
        if s["profile"] == 0:
            s["ssx"] = s["ssy"] = 1
        elif s["profile"] == 1:
            s["ssx"] = s["ssy"] = 0
        elif s["bit_depth"] == 12:
            s["ssx"] = r.f(1)
            s["ssy"] = r.f(1) if s["ssx"] else 0
        else:
            s["ssx"], s["ssy"] = 1, 0
        if s["ssx"] and s["ssy"]:
            s["csp"] = r.f(2)
    return s


def unit_frame(obu_list):
    """The first frame header or frame OBU of a unit, or None."""
    return next((p for t, _, p in obu_list if t in (OBU_FRAME_HEADER, OBU_FRAME)), None)


def shown_key(obu_list, seq):
    """§7.3: a unit starts at a shown key frame when its first frame header has
    show_existing_frame 0, frame_type KEY_FRAME and show_frame 1 (AV1 §5.9.2), or the
    sequence uses the reduced still-picture header."""
    p = unit_frame(obu_list)
    if p is None:
        return False
    if seq["reduced"]:
        return True
    return len(p) > 0 and p[0] >> 7 == 0 and p[0] >> 5 & 3 == 0 and p[0] >> 4 & 1 == 1


def key_frame(obu_list, seq):
    """A unit whose first frame header is a key frame, shown or not."""
    p = unit_frame(obu_list)
    return p is not None and (seq["reduced"] or (len(p) > 0 and p[0] >> 7 == 0 and p[0] >> 5 & 3 == 0))


def av1c(seq, seq_obu):
    """§7.6: the AV1 binding's configuration record: marker and version 1, the profile,
    level, tier, bit depth, monochrome and chroma fields, no initial presentation delay,
    then the sequence header OBU."""
    return bytes([0x81, seq["profile"] << 5 | seq["level"],
                  seq["tier"] << 7 | seq["high_bitdepth"] << 6 | seq["twelve_bit"] << 5 | seq["mono"] << 4
                  | seq["ssx"] << 3 | seq["ssy"] << 2 | seq["csp"], 0]) + seq_obu


def av1_codecs(seq):
    """§7.6: av01.<profile>.<level, two digits><M or H>.<bit depth, two digits>."""
    return f"av01.{seq['profile']}.{seq['level']:02d}{'H' if seq['tier'] else 'M'}.{seq['bit_depth']:02d}"


def floor_payload(p):
    """§7.2: n, h, w, fps_num, fps_den as u32 LE, then n units, each a u32 LE length and its
    bytes; None when it is not that."""
    if len(p) < 20:
        return None
    n, h, w, fn, fd = (le(p, 4 * i, 4) for i in range(5))
    units, at = [], 20
    for _ in range(n):
        if at + 4 > len(p) or at + 4 + le(p, at, 4) > len(p):
            return None
        units.append(p[at + 4:at + 4 + le(p, at, 4)])
        at += 4 + le(p, at, 4)
    return (n, h, w, fn, fd, units) if at == len(p) else None


# ---------------------------------------------------------------- CMAF (§7.6)


def u16(v):
    return be(v, 2)


def u32(v):
    return be(v, 4)


def box(kind, *parts):
    body = b"".join(parts)
    return u32(8 + len(body)) + kind + body


def full_box(kind, version, flags, *parts):
    return box(kind, bytes([version]) + be(flags, 3), *parts)


UNITY = b"".join(u32(x) for x in (0x00010000, 0, 0, 0, 0x00010000, 0, 0, 0, 0x40000000))


def language(code):
    """ISO/IEC 14496-12 mdhd: three letters, each minus 0x60 in five bits."""
    return (ord(code[0]) - 0x60) << 10 | (ord(code[1]) - 0x60) << 5 | (ord(code[2]) - 0x60)


def init_mp4(tb_num, w, h, config):
    """§7.6's init.mp4: ftyp, then moov (mvhd, trak, mvex), every time 0."""
    ftyp = box(b"ftyp", b"cmfc", u32(0), b"cmfc", b"iso6", b"av01")
    mvhd = full_box(b"mvhd", 0, 0, u32(0), u32(0), u32(tb_num), u32(0), u32(0x00010000), u16(0x0100),
                    bytes(10), UNITY, bytes(24), u32(2))
    tkhd = full_box(b"tkhd", 0, 3, u32(0), u32(0), u32(1), u32(0), u32(0), bytes(8), u16(0), u16(0), u16(0),
                    u16(0), UNITY, u32(w << 16), u32(h << 16))
    mdhd = full_box(b"mdhd", 0, 0, u32(0), u32(0), u32(tb_num), u32(0), u16(language("und")), u16(0))
    hdlr = full_box(b"hdlr", 0, 0, u32(0), b"vide", bytes(12), b"video\x00")
    vmhd = full_box(b"vmhd", 0, 1, u16(0), bytes(6))
    dinf = box(b"dinf", full_box(b"dref", 0, 0, u32(1), full_box(b"url ", 0, 1)))
    av01 = box(b"av01", bytes(6), u16(1), u16(0), u16(0), bytes(12), u16(w), u16(h), u32(0x00480000),
               u32(0x00480000), u32(0), u16(1), bytes(32), u16(24), u16(0xFFFF), box(b"av1C", config))
    stbl = box(b"stbl", full_box(b"stsd", 0, 0, u32(1), av01), full_box(b"stts", 0, 0, u32(0)),
               full_box(b"stsc", 0, 0, u32(0)), full_box(b"stsz", 0, 0, u32(0), u32(0)),
               full_box(b"stco", 0, 0, u32(0)))
    trak = box(b"trak", tkhd, box(b"mdia", mdhd, hdlr, box(b"minf", vmhd, dinf, stbl)))
    mvex = box(b"mvex", full_box(b"trex", 0, 0, u32(1), u32(1), u32(0), u32(0), u32(0)))
    return ftyp + box(b"moov", mvhd, trak, mvex)


def fragment(piece, start, tb_den, samples):
    """§7.6's fragment: moof (mfhd, traf: tfhd, tfdt, trun with the offset of the mdat
    payload), then mdat. samples: (bytes, at a shown key frame)."""
    def moof(offset):
        trun = full_box(b"trun", 0, 0x000701, u32(len(samples)), u32(offset),
                        *(u32(tb_den) + u32(len(s)) + u32(0x02000000 if key else 0x01010000) for s, key in samples))
        traf = box(b"traf", full_box(b"tfhd", 0, 0x020000, u32(1)), full_box(b"tfdt", 1, 0, be(start * tb_den, 8)),
                   trun)
        return box(b"moof", full_box(b"mfhd", 0, 0, u32(piece + 1)), traf)
    m = moof(0)
    return moof(len(m) + 8) + box(b"mdat", *(s for s, _ in samples))


def without_delimiters(obu_list):
    return b"".join(whole for t, whole, _ in obu_list if t != OBU_TD)


# ---------------------------------------------------------------- classes and catalogs (§8)


def ms_text(units, num, den):
    """§8.3: floor(d · den · 1000 / num) milliseconds as S.mmm."""
    ms = units * den * 1000 // num
    return f"{ms // 1000}.{ms % 1000:03d}"


def bps(nbytes, units, num, den):
    return -(-8 * nbytes * num // (units * den))


def listed_bytes(ix, k, top):
    """The bytes of piece k's bases and refinements up to layer `top`."""
    pc = ix["pieces"][k]
    return sum(e["byte_len"] for e in ix["entries"][pc["first_entry"]:pc["first_entry"] + pc["n_entries"]]
               if e["role"] in (BASE, REFINEMENT) and e["layer"] <= top)


def class_plan(P, ix):
    """§8.1: each piece's moments and matching rules as bits, and per class the highest
    layer it lists for each piece, 0xFF for the floor only."""
    num, den = ix["tb"]
    bits, rows = [], [[] for _ in P["class"]]
    for k, pc in enumerate(ix["pieces"]):
        s_ms, e_ms = pc["start"] * den * 1000 // num, (pc["start"] + pc["duration"]) * den * 1000 // num
        moments = [i for i, m in enumerate(P["moment"]) if s_ms < m["to_ms"] and e_ms > m["from_ms"]]
        tags = {t for i in moments for t in P["moment"][i]["tags"]}
        rules, then = [], {}
        for i, r in enumerate(P["rule"]):
            w = r["when"]
            if "piece_kind" in w and PIECE_KINDS[pc["kind"]] not in w["piece_kind"]:
                continue
            if "moment_tag" in w and not tags & set(w["moment_tag"]):
                continue
            rules.append(i)
            then.update(r["then"])
        bits.append((sum(1 << i for i in rules), sum(1 << i for i in moments)))
        for row, cl in zip(rows, P["class"]):
            if cl["floor_only"]:
                row.append(0xFF)
                continue
            top = min(cl["max_layer"], then.get("max_layer", 255), highest_layer(ix, k))
            if "max_kbps" in cl:
                while top >= 0 and -(-8 * listed_bytes(ix, k, top) * num // (1000 * pc["duration"] * den)) \
                        > cl["max_kbps"]:
                    top -= 1
            row.append(0xFF if top < 0 else top)
    return bits, rows


def listed(ix, k, top):
    """The bases and refinements piece k lists up to layer `top`, in entry order."""
    pc = ix["pieces"][k]
    if top == 0xFF:
        return []
    return [e for e in ix["entries"][pc["first_entry"]:pc["first_entry"] + pc["n_entries"]]
            if e["role"] in (BASE, REFINEMENT) and e["layer"] <= top]


def codecs_value(objects):
    """http-delivery §4.2 over a sequence of WAI1 objects (entries): the union, an alt per
    distinct capability of the objects that are not layers, a layer's capability after `+`
    in its base's alt; and the floor, the alts every such object has."""
    alts, joined = [], {}
    for e in objects:
        if e["role"] != REFINEMENT and e["cap"] not in alts:
            alts.append(e["cap"])
    bases = [e for e in objects if e["role"] != REFINEMENT]
    for e in objects:
        if e["role"] == REFINEMENT:
            base_cap = e.get("base_cap")
            joined.setdefault(base_cap, [])
            if e["cap"] not in joined[base_cap]:
                joined[base_cap].append(e["cap"])

    def alt(c):
        return "+".join(x[len("wai."):] for x in [c] + joined.get(c, []))
    union = "wai1." + "|".join(alt(c) for c in alts)
    floor = "wai1." + "|".join(alt(c) for c in alts if all(b["cap"] == c for b in bases))
    return union, floor


def render_catalogs(P, ix, c, floor, size, policy_hex):
    """§8.3–§8.8 for one component c: every catalog file as the index, the objects and the
    floor give it. floor: (codecs, width, height, [(fragment name, bytes)]); size: (W, H)."""
    num, den = ix["tb"]
    pieces, plan = ix["pieces"], ix["plan"]
    F, FW, FH, frags = floor
    W, H = size
    first_piece, first_start = ix["first_piece"], pieces[0]["start"]
    total = sum(pc["duration"] for pc in pieces)
    tgt = max(-(-pc["duration"] * den // num) for pc in pieces)
    out = {}

    def text(lines):
        return "".join(x + "\n" for x in lines).encode()

    def rates(per):
        """(BANDWIDTH, AVERAGE-BANDWIDTH) over (bytes, units) pairs."""
        return (max(bps(n, d, num, den) for n, d in per),
                bps(sum(n for n, _ in per), sum(d for _, d in per), num, den))
    fb, fa = rates([(len(fr), pc["duration"]) for (_, fr), pc in zip(frags, pieces)])
    head = ["#EXTM3U", "#EXT-X-VERSION:7", "#EXT-X-INDEPENDENT-SEGMENTS"]
    inf = f'#EXT-X-STREAM-INF:BANDWIDTH={fb},AVERAGE-BANDWIDTH={fa},CODECS="{F}",RESOLUTION={FW}x{FH}'
    # The floor variant's URI resolves from hls/classic/ and from every class's directory
    # alike, so a class's master is the classical one with at most one line added.
    out["hls/classic/master.m3u8"] = text(head + [inf, f"../classic/floor-{c}.m3u8"])
    media = ["#EXTM3U", "#EXT-X-VERSION:7", f"#EXT-X-TARGETDURATION:{tgt}", "#EXT-X-MEDIA-SEQUENCE:0",
             "#EXT-X-PLAYLIST-TYPE:VOD", "#EXT-X-INDEPENDENT-SEGMENTS"]
    lines = media + [f'#EXT-X-MAP:URI="../../floor/{c}/init.mp4"']
    for (name, _), pc in zip(frags, pieces):
        lines += [f"#EXTINF:{ms_text(pc['duration'], num, den)},", f"../../floor/{c}/{name}"]
    out[f"hls/classic/floor-{c}.m3u8"] = text(lines + ["#EXT-X-ENDLIST"])
    mpd_head = ['<?xml version="1.0" encoding="UTF-8"?>',
                '<MPD xmlns="urn:mpeg:dash:schema:mpd:2011" profiles="urn:mpeg:dash:profile:full:2011" '
                f'type="static" mediaPresentationDuration="PT{ms_text(total, num, den)}S" minBufferTime="PT{tgt}S">',
                '  <Period id="p0" start="PT0S">']
    mpd_tail = ["    </AdaptationSet>", "  </Period>", "</MPD>"]

    def timeline(ks):
        return ["          <SegmentTimeline>"] + \
            [f'            <S t="{(pieces[k]["start"] - first_start) * den}" d="{pieces[k]["duration"] * den}"/>'
             for k in ks] + ["          </SegmentTimeline>"]
    lines = mpd_head + [
        f'    <AdaptationSet id="1" contentType="video" mimeType="video/mp4" codecs="{F}" width="{FW}" '
        f'height="{FH}" segmentAlignment="true" startWithSAP="1">',
        f'      <Representation id="{c}-floor" bandwidth="{fb}">', f'        <SegmentList timescale="{num}">',
        f'          <Initialization sourceURL="../floor/{c}/init.mp4"/>'] + timeline(range(len(pieces)))
    lines += [f'          <SegmentURL media="../floor/{c}/{name}"/>' for name, _ in frags]
    out["dash/classic.mpd"] = text(lines + ["        </SegmentList>", "      </Representation>"] + mpd_tail)
    E = ix["entries"]
    by_hash = {}
    for e in E:
        by_hash.setdefault(e["hash"], e)
    for ci, cl in enumerate(P["class"]):
        name, row = cl["id"], plan[ci]
        lists = [listed(ix, k, row[k]) for k in range(len(pieces))]
        wai = any(lists)
        lines = head[:]
        if wai:
            lines.append('#EXT-X-SESSION-DATA:DATA-ID="science.transaction.wai.multivariant",VALUE="wai.m3u8"')
        out[f"hls/{name}/master.m3u8"] = text(lines + [inf, f"../classic/floor-{c}.m3u8"])
        views = []
        for k, pc in enumerate(pieces):
            v = {"dur": pc["duration"], "p": first_piece + k, "start": pc["start"], "stages": []}
            if row[k] == 0xFF:
                v["floor_only"] = True
            for e in lists[k]:
                s = {"bytes": e["byte_len"], "h": e["hash"].hex(), "layer": e["layer"]}
                if e["role"] == REFINEMENT:
                    s["refines"] = E[e["refines"]]["hash"].hex()
                    s["deadline_ms"] = e["deadline"]
                v["stages"].append(s)
            views.append(v)
        comp = {"pieces": views}
        if any(lists[k] for k in range(len(pieces))):
            comp["media_playlist"] = f"../hls/{name}/wai-{c}.m3u8"
        view = {"class": name, "components": {c: comp}, "policy_digest": policy_hex}
        out[f"stages/{name}.json"] = (jcs(view) + "\n").encode()
        if not wai:
            continue
        objs = []
        for k in range(len(pieces)):
            base = next((e for e in lists[k] if e["role"] == BASE), None)
            for e in lists[k]:
                objs.append(dict(e, base_cap=base and base["cap"]))
        union, fl = codecs_value(objs)
        wb, wa = rates([(sum(e["byte_len"] for e in lists[k]), pieces[k]["duration"])
                        for k in range(len(pieces)) if lists[k]])
        out[f"hls/{name}/wai.m3u8"] = text(head + [
            f'#EXT-X-SESSION-DATA:DATA-ID="science.transaction.wai.class",VALUE="{name}"',
            f'#EXT-X-SESSION-DATA:DATA-ID="science.transaction.wai.stages",URI="../../stages/{name}.json"',
            f'#EXT-X-STREAM-INF:BANDWIDTH={wb},AVERAGE-BANDWIDTH={wa},CODECS="{union}",X-WAI-FLOOR="{fl}",'
            f'RESOLUTION={W}x{H}', f"wai-{c}.m3u8"])
        lines = media[:]
        for k, pc in enumerate(pieces):
            p0 = pc["first_entry"]
            base = next(e for e in E[p0:p0 + pc["n_entries"]] if e["role"] == BASE)
            if row[k] == 0xFF:
                lines.append("#EXT-X-GAP")
            # A layer line follows its segment's EXTINF, before the segment's URI
            # (http-delivery §10.4).
            lines.append(f"#EXTINF:{ms_text(pc['duration'], num, den)},")
            lines += [f'#WAI-LAYER:N={e["layer"]},URI="../../objects/{e["hash"].hex()}.wai#n={e["byte_len"]}"'
                      for e in lists[k] if e["role"] == REFINEMENT]
            lines.append(f"../../objects/{base['hash'].hex()}.wai#n={base['byte_len']}")
        out[f"hls/{name}/wai-{c}.m3u8"] = text(lines + ["#EXT-X-ENDLIST"])
        lines = mpd_head + [
            f'    <AdaptationSet id="1" contentType="video" mimeType="application/wai" codecs="{union}" '
            f'width="{W}" height="{H}">',
            '      <EssentialProperty schemeIdUri="tag:transaction.science,2026:wai/http-delivery"/>',
            f'      <SupplementalProperty schemeIdUri="tag:transaction.science,2026:wai/floor" value="{fl}"/>',
            f'      <SupplementalProperty schemeIdUri="tag:transaction.science,2026:wai/class" value="{name}"/>',
            '      <SupplementalProperty schemeIdUri="tag:transaction.science,2026:wai/stages" '
            f'value="../stages/{name}.json"/>']
        for layer in range(max(v for v in row if v != 0xFF) + 1):
            ks = [k for k in range(len(pieces)) if any(e["layer"] == layer for e in lists[k])]
            mine = [[e for e in lists[k] if e["layer"] == layer] for k in ks]
            peak = max((bps(sum(e["byte_len"] for e in m), pieces[k]["duration"], num, den)
                        for k, m in zip(ks, mine)), default=0)
            dep = f' dependencyId="{c}-l{layer - 1}"' if layer else ""
            lines += [f'      <Representation id="{c}-l{layer}"{dep} bandwidth="{peak}">',
                      f'        <SegmentList timescale="{num}">'] + timeline(ks)
            lines += [f'          <SegmentURL media="../objects/{e["hash"].hex()}.wai"/>' for m in mine for e in m]
            lines += ["        </SegmentList>", "      </Representation>"]
        out[f"dash/{name}.mpd"] = text(lines + mpd_tail)
    has_floor = any(e["role"] == FLOOR for e in E)
    out["moq/catalog.json"] = render_moq(c, E, P["live"]["layer_lag_ms"], P["defaults"]["deadline_ms"],
                                         (F, FW, FH) if has_floor else None)
    return out


def render_moq(c, E, lag, default_deadline, floor):
    """§8.4: moq/catalog.json. One track per (layer, deadline), by layer, then by deadline
    ascending; a refinement track depends on every track that carries an entry its entries
    refine, in track order, so it never names a track the catalog does not hold. floor:
    (codecs, width, height) or None."""
    keys = sorted({(e["layer"], e["deadline"]) for e in E if e["role"] in (BASE, REFINEMENT)})

    def name(key):
        layer, deadline = key
        return f"{c}/l{layer}" + (f"@{deadline}" if layer and deadline != default_deadline else "")
    tracks = []
    for ti, (layer, deadline) in enumerate(keys):
        es = [e for e in E if e["role"] in (BASE, REFINEMENT) and (e["layer"], e["deadline"]) == (layer, deadline)]
        caps = []
        for e in es:
            if e["cap"] not in caps:
                caps.append(e["cap"])
        t = {"name": name((layer, deadline)), "packaging": "wai", "renderGroup": 1,
             "priority": 64 + 32 * layer, "wai_capabilities": caps, "wai_layer": layer, "wai_receipts": False}
        if min(e["tier"] for e in es):
            t["wai_determinism"] = TIER_NAMES[min(e["tier"] for e in es)]
        if layer == 0 and floor is not None:
            t["altGroup"] = 1
        if layer:
            deps = set()
            for e in es:
                below = E[e["refines"]]
                dt = keys.index((below["layer"], below["deadline"]))
                if dt >= ti:
                    raise ValueError("a refinement refines an entry on no earlier track")
                deps.add(dt)
            t["depends"] = [name(keys[x]) for x in sorted(deps)]
            t["wai_delivery_timeout_ms"] = max(0, deadline - (lag[layer] if layer < len(lag) else 0))
        tracks.append(t)
    if floor is not None:
        tracks.append({"altGroup": 1, "codec": floor[0], "height": floor[2], "name": f"{c}/floor", "packaging": "cmaf",
                       "renderGroup": 1, "width": floor[1]})
    return (jcs({"tracks": tracks, "version": 1}) + "\n").encode()


# ---------------------------------------------------------------- the corpus


class Report:
    def __init__(self):
        self.failures = 0
        self.checked = 0

    def check(self, ok, what):
        self.checked += 1
        if not ok:
            self.failures += 1
            print(f"FAIL {what}")


def load(path):
    with open(path, "rb") as f:
        return f.read()


def tree(root):
    """Every file below root, as paths, in byte order, read strictly (§11.3 step 1): every
    name, one beginning with `.` and a `*.sha256` file included; None when an entry is a
    symbolic link or neither a file nor a directory, when a directory cannot be read, or
    when a directory below root holds nothing (§11.1: no other file or directory)."""
    def unreadable(e):
        raise e
    out = []
    try:
        for at, dirs, files in os.walk(root, onerror=unreadable):
            if at != root and not dirs and not files:
                return None
            for n in dirs + files:
                full = os.path.join(at, n)
                if os.path.islink(full) or not (os.path.isdir(full) or os.path.isfile(full)):
                    return None
            out += [os.path.relpath(os.path.join(at, f), root).replace(os.sep, "/") for f in files]
    except OSError:
        return None
    return sorted(out, key=lambda p: p.encode())


SEGMENT_FIRST = set("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-")


def segment_ok(s):
    """SPEC §3.1: a path segment."""
    return s != "" and s[0] in SEGMENT_FIRST and all(c in SEGMENT_FIRST | {"."} for c in s) and not s.endswith(".")


def listing(root, paths):
    """SPEC §3.1: a line per file, its SHA-256, two spaces, its path and a line feed."""
    return "".join(hashlib.sha256(load(os.path.join(root, p))).hexdigest() + "  " + p + "\n" for p in paths).encode()


def seg_params(P, tb):
    s = P["segmentation"]
    return {"min": units_from_ms(s["min_ms"], *tb), "target": units_from_ms(s["target_ms"], *tb),
            "max": units_from_ms(s["max_ms"], *tb), "cut_abs": s["cut_abs_permille"], "cut_rel": s["cut_rel_permille"],
            "window": s["cut_window"], "lookahead": s["lookahead_frames"]}


def clip_digest(frames):
    """SPEC §7, *Digests*: the SHA-256 of the frames' SHA-256 digests concatenated."""
    return hashlib.sha256(b"".join(hashlib.sha256(f).digest() for f in frames)).digest()


def verify_pack(rep, d, name, pkg=None, inputs=True):
    """packs/<name>/: package/ (or `pkg`) verified in §11.3's order, without the source;
    then, with `inputs`, the package's inputs: policy.toml as given, and what only the
    source decides (the plan, each base's sse and step) and the supplied floor."""
    root = os.path.join(d, "packs", name)
    pkg = pkg or os.path.join(root, "package")
    tag = f"packs/{name}"
    files = tree(pkg)
    if files is None:
        rep.check(False, f"{tag}: a symbolic link or an entry that is neither file nor directory (unexpected-file)")
        return
    paths_ok = all(all(segment_ok(s) for s in p.split("/")) for p in files) and len({p.lower() for p in files}) == len(files)
    rep.check(paths_ok, f"{tag}: every file, read strictly, has a listing path (SPEC §3.1) (unexpected-file)")
    if not paths_ok:
        return
    if "LISTING" not in files:
        rep.check(False, f"{tag}: no LISTING (listing-missing)")
        return
    others = [p for p in files if p != "LISTING"]
    ok = load(os.path.join(pkg, "LISTING")) == listing(pkg, others)
    rep.check(ok, f"{tag}: LISTING is the listing of the other files (listing-mismatch)")
    if not ok:
        return
    def get(p):
        return load(os.path.join(pkg, p)) if p in files else b""
    raw = get("package.receipt.json")
    try:
        r = read_receipt(raw)
        if r["version"] != 2:
            raise Refused("receipt-version")
    except Refused as e:
        rep.check(False, f"{tag}: package.receipt.json does not read as version 2 ({e.code})")
        return
    j = r["json"]
    ok = raw == jcs(j).encode()
    rep.check(ok, f"{tag}: package.receipt.json is RFC 8785 canonical JSON, its receipt's own form (receipt-json)")
    if not ok:
        return

    # The policy: as given, its effective canonical JSON, its digest (§3.2, §11.1).
    toml_b, pj = get("policy.toml"), get("policy.json")
    if inputs:
        rep.check(toml_b == load(os.path.join(root, "policy.toml")), f"{tag}: policy.toml is the policy as given")
    rep.check(blake3(b"wai:pack-policy\x01" + pj).hex() == j["policy_digest"],
              f"{tag}: policy.json hashes to the receipt's policy digest (policy-digest-mismatch)")
    # policy.toml parsed (§3.2–§3.4); the override applied, policy.json's
    # royalty_free_only, which only ever forces it on (§3.2); then §3.6 under that
    # effective policy, below.
    try:
        P = parse_policy_bytes(toml_b)
    except Refused as e:
        rep.check(False, f"{tag}: policy.toml refused ({e.code})")
        return
    given = read_json(pj)
    if isinstance(given, dict) and given.get("royalty_free_only") is True:
        P["royalty_free_only"] = True
    ok = jcs(P).encode() == pj
    rep.check(ok, f"{tag}: policy.json is policy.toml's effective canonical JSON (policy-json-mismatch)")
    if not ok:
        return
    ids = [c["id"] for c in P["component"]] + [c["id"] for c in P["class"]]
    cls = [c["id"].lower() for c in P["class"]]
    ok = all(segment_ok(i) for i in ids) and len(set(cls)) == len(cls) and "classic" not in cls
    rep.check(ok, f"{tag}: component and class ids are path segments, class ids distinct in any case, none `classic` (pack-id)")
    if not ok:
        return
    # §3.6 under the effective policy: royalty_free_only as policy.json states it.
    refused = next((code for code in (rung_refusal(x["capability"], x["role"], P["royalty_free_only"]) for x in P["ladder"]) if code), None)
    rep.check(refused is None, f"{tag}: the effective policy asks for nothing a packager may not emit ({refused})")
    if refused:
        return
    # The receipt's components are the policy's, by id, order and media (§11.3).
    ok = [(c["id"], c["media_class"]) for c in j["components"]] == [(x["id"], x["media"]) for x in P["component"]]
    rep.check(ok, f"{tag}: the receipt's components are the policy's, by id, order and media (policy-component-mismatch)")
    if not ok:
        return

    # The indexes and the receipt's own refusals (§9.1).
    index_files = []
    for c in j["components"]:
        present = c["index"] in files
        rep.check(present, f"{tag}: {c['index']} present (index-missing)")
        if not present:
            return
        index_files.append(load(os.path.join(pkg, c["index"])))
    try:
        ixs = verify_receipt_v2(r, index_files)
        rep.check(True, f"{tag}: the receipt verifies against its indexes (§9.1)")
    except Refused as e:
        rep.check(False, f"{tag}: the receipt against its indexes ({e.code})")
        return
    seed = bytes.fromhex(load(os.path.join(root, "key.hex")).decode().strip())
    pk, sig = ed25519_from_seed(seed, r["payload"])
    rep.check(pk.hex() == j["signer_pubkey"], f"{tag}: the receipt's signer is the package key")
    rep.check(sig.hex() == j["sig"], f"{tag}: the signature is the package key's over the payload (§11.2)")

    named = {"LISTING", "policy.toml", "policy.json", "package.receipt.json"} | {c["index"] for c in j["components"]}
    for c, ix in zip(j["components"], ixs):
        try:
            named |= verify_component(rep, tag, root, pkg, files, P, j, c, ix, inputs)
        except (Refused, Malformed, ValueError, OverflowError, UnicodeError, KeyError, IndexError) as x:
            # A package this verifier cannot read further is refused, never a crash.
            rep.check(False, f"{tag} {c['id']}: refused ({type(x).__name__}: {x})")
            return

    # §9.4: a metered package publishes its measurement claim; an unmetered one, none.
    claim = f"claims/{j['receipt_hash']}.measurement.json"
    if j["joules_micro"]:
        rep.check(claim in files, f"{tag}: a metered package's measurement claim (measurement-claim-missing)")
        rep.check(False, f"{tag}: this verifier does not check a measurement claim (measurement-claim-invalid)")
        named.add(claim)
    else:
        rep.check(not any(p.startswith("claims/") for p in others),
                  f"{tag}: an unmetered package publishes no measurement claim (§9.4)")
    unlisted = [p for p in others if p.startswith("objects/") and p not in named]
    rep.check(not unlisted, f"{tag}: object files no entry names: {unlisted} (object-unlisted)")
    catalogs = ("hls/", "dash/", "moq/", "stages/")
    extra = [p for p in others if p.startswith(catalogs) and p not in named]
    rep.check(not extra, f"{tag}: catalogs past the ones the index gives: {extra} (catalog-unexpected)")
    other = [p for p in others if p not in named and not p.startswith(("objects/",) + catalogs)]
    rep.check(not other, f"{tag}: other files: {other} (unexpected-file)")


class Capture(Report):
    """A report that keeps what fails, in order, and prints nothing."""
    def __init__(self):
        super().__init__()
        self.failed = []

    def check(self, ok, what):
        self.checked += 1
        if not ok:
            self.failures += 1
            self.failed.append(what)


REASON_AT_END = re.compile(r"\(([a-z0-9][a-z0-9.:-]*)\)$")


def package_verdict(d, name, pkg):
    """The reason §11.3 gives the package in `pkg` (the first check that fails, by the
    reason it names), or `ok`; the inputs of packs/<name>/ are not consulted."""
    cap = Capture()
    verify_pack(cap, d, name, pkg=pkg, inputs=False)
    if not cap.failed:
        return "ok"
    m = REASON_AT_END.search(cap.failed[0])
    return m.group(1) if m else f"no reason named: {cap.failed[0]}"


def verify_package_mutations(rep, d):
    """package-mutations/: each case the golden less the files it removes (and the
    directories that leaves with nothing in them), with its overlay and the directories
    it adds that hold nothing (`empty_dirs`) or cannot be read (`unreadable_dirs`, mode 0
    where the platform has modes), written out and verified as a package (§11.3); refused
    with the corpus's reason, or accepted where it says `ok`."""
    m = os.path.join(d, "package-mutations")
    held = tree(m)
    if held is None:
        rep.check(False, "package-mutations/: a symbolic link or an entry that is neither file nor directory")
        return
    pm = json.loads(load(os.path.join(m, "expected.json")))
    golden = os.path.join(d, "packs", pm["pack"], "package")
    used = {"expected.json"}
    with tempfile.TemporaryDirectory() as tmp:
        for c in pm["cases"]:
            pkg = os.path.join(tmp, c["name"])
            shutil.copytree(golden, pkg)
            for p in c["remove"]:
                os.remove(os.path.join(pkg, p))
            for at, dirs, files in os.walk(pkg, topdown=False):
                if at != pkg and not os.listdir(at):
                    os.rmdir(at)
            for p in held:
                if p.startswith(c["name"] + "/"):
                    used.add(p)
                    dst = os.path.join(pkg, p[len(c["name"]) + 1:])
                    os.makedirs(os.path.dirname(dst), exist_ok=True)
                    shutil.copyfile(os.path.join(m, p), dst)
            for p in c.get("empty_dirs", []) + c.get("unreadable_dirs", []):
                os.makedirs(os.path.join(pkg, p))
            for p in c.get("unreadable_dirs", []):
                os.chmod(os.path.join(pkg, p), 0)
            got = package_verdict(d, pm["pack"], pkg)
            for p in c.get("unreadable_dirs", []):
                os.chmod(os.path.join(pkg, p), 0o755)
            rep.check(got == c["reason"], f"package-mutations {c['name']}: {got}, the corpus says {c['reason']}")
    rest = [p for p in held if p not in used]
    rep.check(not rest, f"package-mutations/: files no case uses: {rest}")


def unreached(files, c):
    """The floor and catalog files of a component whose verification stopped at an earlier
    refusal: named, so that refusal is not reported again as unexpected files."""
    return {p for p in files if p.startswith((f"floor/{c}/", "hls/", "dash/", "moq/", "stages/"))}


def index_against_policy(P, comp, c, ix):
    """§11.3 step 6, the index against its component's policy, in its order: its timebase
    and media; its string table (the component's id, the class ids, each capability at its
    first use); its class records (the policy's classes); each entry's role, capability
    and layer a rung's of the component; each piece's kind one a video piece has, and its
    rules, moments and class plan §8.1's. None when it holds, else what fails."""
    if ix["tb"] != (comp["timebase"]["num"], comp["timebase"]["den"]) or MEDIA_CLASSES[ix["media_class"]] != comp["media"]:
        return "the timebase or media class"
    caps = []
    for e in ix["entries"]:
        if e["cap"] not in caps:
            caps.append(e["cap"])
    if ix["strings"] != [c["id"]] + [x["id"] for x in P["class"]] + caps or ix["strings"][0] != ix["component"]:
        return "the string table"
    want = [(x["id"], min(x["max_layer"], 255), int(x["floor_only"]), min(x.get("max_kbps", 0), U32)) for x in P["class"]]
    if [(x["name"], x["max_layer"], x["flags"], x["max_kbps"]) for x in ix["classes"]] != want:
        return "the class records"
    lay = layers(P)
    for i, e in enumerate(ix["entries"]):
        role = ROLES[e["role"]]
        if not any(r["component"] == c["id"] and r["role"] == role and r["capability"] == e["cap"] and lay[r["id"]] == e["layer"]
                   for r in P["ladder"]):
            return f"entry {i}: no rung of the component"
    if any(pc["kind"] >= len(KINDS) for pc in ix["pieces"]):
        return "a piece kind a video piece does not have"
    bits, rows = class_plan(P, ix)
    if bits != [(pc["rules"], pc["moments"]) for pc in ix["pieces"]]:
        return "the rules and moments"
    if rows != ix["plan"]:
        return "the class plan"
    return None


def verify_component(rep, tag, root, pkg, files, P, j, c, ix, inputs=True):
    """§11.3 per component, then (with `inputs`) the source's side. Returns the files it
    names."""
    t = f"{tag} {c['id']}"
    comp = next((x for x in P["component"] if x["id"] == c["id"]), None)
    if comp is None:
        rep.check(False, f"{t}: the receipt's component is not the policy's")
        return set()
    tb = (comp["timebase"]["num"], comp["timebase"]["den"])
    num, den = tb
    pieces, E = ix["pieces"], ix["entries"]
    why = index_against_policy(P, comp, c, ix)
    rep.check(why is None, f"{t}: the index against the policy: {why} (index-policy-mismatch)")
    if why is not None:
        return set(unreached(files, c["id"])) | {f"plan-{c['id']}.txt"} | {f"objects/{e['hash'].hex()}.wai" for e in E}
    starts = [pc["start"] for pc in pieces]
    plan_file = f"plan-{c['id']}.txt"
    rep.check(plan_file in files and load(os.path.join(pkg, plan_file)) == "".join(f"{s}\n" for s in starts).encode(),
              f"{t}: {plan_file} is the index's plan (plan-mismatch)")
    rep.check(ix["plan_digest"].hex() == plan_digest(starts), f"{t}: the index's plan_digest is its starts' (§4.2)")
    if inputs:
        # Of the golden, not a rule a package is held to: a live window is a package too
        # (§6.1, §9.2).
        rep.check(ix["first_piece"] == 0 and ix["first_entry"] == 0 and not any(ix["prev"]),
                  f"{t}: the golden is on-demand content, one window (§6.1)")
    named = {plan_file}

    # Every entry's object (§6.3), the decode-equivalent prefixes (§6.5).
    objs, mans, decoded = {}, {}, {}
    for i, e in enumerate(E):
        path = f"objects/{e['hash'].hex()}.wai"
        named.add(path)
        if path not in files:
            rep.check(False, f"{t}: entry {i}: {path} (object-missing)")
            continue
        objs[i] = load(os.path.join(pkg, path))
        try:
            mans[i] = object_rules(ix, i, objs[i])
            rep.check(True, f"{t}: entry {i}: the object rules (§6.3)")
        except Refused as x:
            rep.check(False, f"{t}: entry {i}: the object rules (§6.3) ({x.code})")
    if len(mans) != len(E):
        return named | unreached(files, c['id'])
    size = None
    for i, e in enumerate(E):
        if e["role"] != BASE:
            continue
        ml = e["man_len"]
        try:
            w = IPV.parse_wiv1(objs[i][12 + ml:], 0)
            if e["hash"] not in decoded:
                decoded[e["hash"]] = (w, IPV.decode_wiv1_k0(w))
        except IPV.Refused as x:
            rep.check(False, f"{t}: entry {i}: the WIV1 payload is refused ({x})")
            return named | unreached(files, c['id'])
        size = size or (w["w"], w["h"])
        # §5.2: the reference packager's base manifest, as SPEC §3 orders it.
        want = {"wai": "1.0", "media": comp["media"], "intent": "replicate",
                "model_requirement": {"capability": e["cap"]}, "conditioning": {"kind": e["cap"].split(".")[-1]},
                "target": {"frames": pieces[owners(ix)[i]]["duration"], "h": w["h"], "w": w["w"]}}
        rep.check(objs[i][8:8 + ml] == json.dumps(want, separators=(",", ":")).encode(),
                  f"{t}: entry {i}: the base's manifest is §5.2's")
    for i, e in enumerate(E):
        if e["tier"] != 2:
            continue
        if e["role"] != BASE:
            rep.check(False, f"{t}: entry {i}: a refinement's prefix, which this verifier does not decode")
            continue
        rep.check(clip_digest(decoded[e["hash"]][1]) == e["prefix"],
                  f"{t}: entry {i}: the prefix decodes to its prefix_digest (prefix-digest)")

    # The floor objects (§7.2) and the CMAF files their temporal units give (§7.6).
    rung = next((r for r in P["ladder"] if r["component"] == c["id"] and r["role"] == "floor"), None)
    sup = P["floor"].get("supplied_listing")
    settings = blake3(b"wai:render-settings\x01" + jcs({"source": "supplied", "supplied_listing": sup}).encode()).hex() \
        if sup else None
    seq = seq_obu = None
    units_of, frags = [], []
    own = owners(ix)
    for k, pc in enumerate(pieces):
        mine = [i for i in range(len(E)) if own[i] == k]
        bases = [i for i in mine if E[i]["role"] == BASE]
        fl = [i for i in mine if E[i]["role"] == FLOOR]
        rep.check(len(bases) == 1 and rung is not None and len(fl) == 1 and E[fl[0]]["cap"] == rung["capability"],
                  f"{t}: piece {k}: one base, and one floor object of the floor rung's capability (§5, §7.2) (floor-object-mismatch)")
        if len(bases) != 1 or len(fl) != 1:
            return named | unreached(files, c['id'])
        base, i = bases[0], fl[0]
        df = mans[i]["derived_from"]
        rep.check(df["motif"] == E[base]["hash"].hex() and df["motif_capability"] == E[base]["cap"],
                  f"{t}: piece {k}: the floor presents its piece's base (floor-motif-mismatch)")
        rep.check(sup is not None and df["renderer"] == f"supplied@{sup}" and df["settings"] == settings,
                  f"{t}: piece {k}: a supplied floor's renderer and settings (§7.2) (floor-object-mismatch)")
        fp = floor_payload(objs[i][12 + E[i]["man_len"]:])
        if fp is None:
            rep.check(False, f"{t}: piece {k}: the floor payload is not §7.2's framing (floor-object-mismatch)")
            return named | unreached(files, c['id'])
        rep.check(len(fp[5]) == pc["duration"], f"{t}: piece {k}: one temporal unit per frame (floor-object-mismatch)")
        try:
            units = [obus(u) for u in fp[5]]
            if any(not o or o[0][0] != OBU_TD or sum(x[0] == OBU_TD for x in o) != 1 or unit_frame(o) is None for o in units):
                raise Malformed("a unit that is not one temporal unit holding a frame")
            if seq is None:
                seq_obu = next((whole for typ, whole, _ in units[0] if typ == OBU_SEQ), None) if units else None
                if seq_obu is None:
                    raise Malformed("the first unit holds no sequence header")
                seq = sequence_header(obus(seq_obu)[0][2])
            # §7.3 against the package: every sequence header the first's bytes, a shown key
            # frame with one.
            for o in units:
                if any(typ == OBU_SEQ and whole != seq_obu for typ, whole, _ in o):
                    raise Malformed("a sequence header other than the first")
                if shown_key(o, seq) and not any(typ == OBU_SEQ for typ, _, _ in o):
                    raise Malformed("a shown key frame without a sequence header")
        except Malformed as x:
            rep.check(False, f"{t}: piece {k}: the floor payload ({x}) (floor-av1-malformed)")
            return named | unreached(files, c['id'])
        rep.check(fp[:5] == (pc["duration"], seq["max_h"], seq["max_w"], num, den),
                  f"{t}: piece {k}: the floor payload's n, h, w, fps_num and fps_den (§7.2) (floor-object-mismatch)")
        rep.check(mans[i].get("target") == {"frames": pc["duration"], "h": seq["max_h"], "w": seq["max_w"]},
                  f"{t}: piece {k}: the floor's target is its piece's frames and its size (§5.2, §7.2) (floor-object-mismatch)")
        keys = [shown_key(o, seq) for o in units]
        ok = bool(keys) and keys[0] and (P["floor"]["extra_keyframes"] or not any(keys[1:]))
        rep.check(ok, f"{t}: piece {k}: it opens on a shown key frame, with no other unless the policy allows (floor-keyframe-mismatch)")
        if not ok:
            return named | unreached(files, c['id'])
        units_of.append(fp[5])
        frag = fragment(ix["first_piece"] + k, pc["start"], den, [(without_delimiters(o), shown_key(o, seq)) for o in units])
        frags.append((hashlib.sha256(frag).hexdigest() + ".m4s", frag))
    init = init_mp4(num, seq["max_w"], seq["max_h"], av1c(seq, seq_obu))
    for p, want in [("init.mp4", init)] + frags:
        path = f"floor/{c['id']}/{p}"
        named.add(path)
        rep.check(path in files and load(os.path.join(pkg, path)) == want,
                  f"{t}: {path} is the one the floor's temporal units give (floor-cmaf-mismatch)")

    # The catalogs (§8.3–§8.8).
    try:
        cats = render_catalogs(P, ix, c["id"], (av1_codecs(seq), seq["max_w"], seq["max_h"], frags), size,
                               j["policy_digest"])
    except (ValueError, OverflowError) as x:
        # A time or count past the canonical range (a start past 2^53 − 1): no catalog can
        # be written for this index (§11.3).
        rep.check(False, f"{t}: no catalog can be written for the index ({x}) (catalog-mismatch)")
        return named | unreached(files, c['id'])
    for path in sorted(cats):
        named.add(path)
        rep.check(path in files and load(os.path.join(pkg, path)) == cats[path],
                  f"{t}: {path} is the one the index, the objects and the floor give (catalog-mismatch)")
    if inputs:
        verify_sources(rep, t, root, P, comp, ix, decoded, units_of)
    return named


def verify_sources(rep, t, root, P, comp, ix, decoded, units_of):
    """What only the source decides: the pieces (§4.3, §4.6) and their rules, moments and
    class plan (§8.1), each base's sse (§6.6) and step (§5.6), and the supplied floor (§7.3)."""
    num, den = comp["timebase"]["num"], comp["timebase"]["den"]
    source = comp.get("source", "")
    name = source[:-len(".y4m")]
    if not source.endswith(".y4m") or fixture_spans(name) is None:
        rep.check(False, f"{t}: the source {source!r} is no fixture this verifier generates (pack-source-missing)")
        return
    w, h, rate, _, frames = read_y4m(fixture(name))
    rep.check(rate == (num, den), f"{t}: the source's frame rate is its timebase (pack-source-rate)")
    pieces, _ = segment(frames, w, h, seg_params(P, (num, den)))
    got = [(pc["start"], pc["len"], pc["flags"], KINDS.index(classify(pc, P["classify"])[0])) for pc in pieces]
    rep.check(got == [(pc["start"], pc["duration"], pc["flags"], pc["kind"]) for pc in ix["pieces"]],
              f"{t}: every piece's start, duration, flags and kind are the segmenter's (§4.3, §4.6)")
    bits, rows = class_plan(P, ix)
    rep.check(bits == [(pc["rules"], pc["moments"]) for pc in ix["pieces"]],
              f"{t}: every piece's rules and moments (§8.1)")
    rep.check(rows == ix["plan"], f"{t}: the class plan is §8.1's")
    rung = next(r for r in P["ladder"] if r["component"] == comp["id"] and r["role"] == "base")
    p = rung["params"]
    own, cache, chosen = owners(ix), {}, set()
    for i, e in enumerate(ix["entries"]):
        if e["role"] != BASE:
            continue
        pc = ix["pieces"][own[i]]
        src = frames[pc["start"]:pc["start"] + pc["duration"]]
        wv, dec = decoded[e["hash"]]
        sse = sum((a - b) ** 2 for s, f in zip(src, dec) for a, b in zip(s, f))
        rep.check(len(dec) == len(src) and sse == e["sse"], f"{t}: entry {i}: sse against the source (§6.6)")
        n = len(src)
        rep.check((wv["block"], wv["mv_precision"]) == ((p["block"], p["mv_precision"]) if n > 1 else (1, 1)),
                  f"{t}: entry {i}: the payload's block and precision are the rung's (§5.5)")
        key = hashlib.sha256(b"".join(src)).digest()

        def sse_of(q, key=key, src=src):
            if (key, q) not in cache:
                cache[key, q] = closed_loop(src, h, w, p["block"], p["search"], p["mv_precision"], q)
            return sse_px_milli(cache[key, q][1], h, w, len(src))
        q = choose_q(sse_of, p["q_candidates"], p["max_sse_px_milli"])
        rep.check(wv["q"] == q, f"{t}: entry {i}: the step is §5.6's choice ({wv['q']}, the rule {q})")
        rep.check([bytes(f) for f in cache[key, q][0]] == dec,
                  f"{t}: entry {i}: the payload decodes to the encoder's reconstruction at that step (§5.5)")
        if (e["hash"], key) not in chosen:
            chosen.add((e["hash"], key))
            bad = encoder_choices(wv, p, src, dec)
            rep.check(not bad, f"{t}: entry {i}: every vector, coded residual and the table are the encoder's (§5.5)"
                      + (f": {bad[0]}" if bad else ""))

    # The supplied floor (§7.3): its listing, its temporal units and its key frames.
    sup = os.path.join(root, "floor")
    names = tree(sup)
    rep.check(hashlib.sha256(listing(sup, names)).hexdigest() == P["floor"].get("supplied_listing"),
              f"{t}: the supplied floor's listing hashes to floor.supplied_listing (floor-listing-mismatch)")
    stream = f"{comp['id']}.obu"
    if stream not in names:
        rep.check(False, f"{t}: no {stream} in the supplied floor (floor-stream-missing)")
        return
    try:
        units = temporal_units(load(os.path.join(sup, stream)))
        if not units or not any(typ == OBU_SEQ for typ, _, _ in units[0][1]):
            raise Malformed("the first unit holds no sequence header")
        first = next(whole for typ, whole, _ in units[0][1] if typ == OBU_SEQ)
        seq = sequence_header(obus(first)[0][2])
        for u, o in units:
            if unit_frame(o) is None:
                raise Malformed("a unit holding no frame")
            if any(typ == OBU_SEQ and whole != first for typ, whole, _ in o):
                raise Malformed("a sequence header other than the first")
            if shown_key(o, seq) and not any(typ == OBU_SEQ for typ, _, _ in o):
                raise Malformed("a shown key frame without a sequence header")
        rep.check(True, f"{t}: the supplied stream splits into temporal units, each a frame (floor-av1-malformed)")
    except Malformed as x:
        rep.check(False, f"{t}: the supplied stream ({x}) (floor-av1-malformed)")
        return
    rep.check(len(units) == len(frames), f"{t}: one temporal unit per source frame (floor-frame-count)")
    keys = [f for f, (_, o) in enumerate(units) if shown_key(o, seq)]
    starts = [pc["start"] for pc in ix["pieces"]]
    ok = set(starts) <= set(keys) and (P["floor"]["extra_keyframes"] or keys == starts)
    rep.check(ok, f"{t}: shown key frames at the piece starts {starts}, and only there: {keys} (floor-keyframe-mismatch)")
    rep.check([[u for u, _ in units[pc["start"]:pc["start"] + pc["duration"]]] for pc in ix["pieces"]] == units_of,
              f"{t}: each floor object holds its piece's temporal units of the supplied stream (§7.2)")


def mutation_verdict(m, c, used):
    """A case of mutations/: the index's verdict (§6.2, §6.3), then each entry's object's
    (§6.3), or the receipt's (§9.1)."""
    def get(p):
        used.add(p)
        return load(os.path.join(m, p))
    try:
        if c["kind"] in ("index", "objects"):
            ix = parse_index(get(c["index"]))
            index_rules(ix)
            if c["kind"] == "objects":
                for i, e in enumerate(ix["entries"]):
                    p = os.path.join(c["objects"], e["hash"].hex() + ".wai")
                    if not os.path.isfile(os.path.join(m, p)):
                        return "object-missing"
                    object_rules(ix, i, get(p))
            return "ok"
        r = read_receipt(get(c["receipt"]))
        verify_receipt_v2(r, [get(p) for p in c["indexes"]])
        return "ok"
    except Refused as e:
        return e.code


def verify_v1_receipt(rep, name, b, want_hash, refused=False):
    """§9.3: a version-1 receipt read, its payload rebuilt, its hash, counts, segment map
    root and signature; with `refused`, everything but a signature that every verifier
    refuses (SPEC §7 *Signatures*)."""
    try:
        r = read_receipt(b)
    except Refused as e:
        rep.check(False, f"{name}: refused ({e.code})")
        return
    j = r["json"]
    rep.check(r["version"] == 1, f"{name}: version 1")
    rep.check(j["receipt_hash"] == want_hash, f"{name}: receipt_hash is the corpus's")
    rep.check(blake3(RECEIPT_ID + r["payload"] + bytes.fromhex(j["sig"])).hex() == want_hash,
              f"{name}: receipt_hash is BLAKE3 over the payload and signature")
    segs = j["segments"]
    rep.check(merkle_root([v1_leaf(s) for s in segs]).hex() == j["segment_map_root"],
              f"{name}: segment_map_root is the Merkle root of the segment leaves")
    first = {}
    for s in segs:
        first.setdefault(s["content_hash"], s["byte_len"])
    rep.check([s["index"] for s in segs] == list(range(len(segs))), f"{name}: segment indices 0..n-1")
    rep.check((j["total_segments"], j["unique_segments"], j["total_bytes"], j["stored_bytes"], j["work_segment_ops"])
              == (len(segs), len(first), sum(s["byte_len"] for s in segs), sum(first.values()), len(segs)),
              f"{name}: the segment counts")
    rep.check(ed25519_verifies(bytes.fromhex(j["signer_pubkey"]), bytes.fromhex(j["sig"]), r["payload"]) != refused,
              f"{name}: the signature " + ("is refused" if refused else "verifies"))


def verify(d):
    rep = Report()
    pol = json.loads(load(os.path.join(d, "policy", "expected.json")))
    for c in pol["cases"]:
        P = parse_policy_bytes(load(os.path.join(d, "policy", c["file"])))
        if c.get("overrides", {}).get("royalty_free_only") is True:
            P["royalty_free_only"] = True
        rep.check(jcs(P) == c["canonical"], f"policy/{c['file']}: canonical JSON")
        rep.check(digest(P) == c["digest"], f"policy/{c['file']}: digest")
    names = sorted(n for n in os.listdir(os.path.join(d, "policy")) if n.endswith(".toml"))
    rep.check(sorted({c["file"] for c in pol["cases"]}) == names, "policy/: every policy is a case")
    for n in names:
        try:
            admit(load(os.path.join(d, "policy", n)))
            got = "ok"
        except Refused as r:
            got = r.code
        rep.check(got == "ok", f"policy/{n}: a packager accepts it ({got})")
    for a, b in pol["equal"]:
        da, db = (digest(parse_policy_bytes(load(os.path.join(d, "policy", f)))) for f in (a, b))
        rep.check(da == db, f"policy/{a} and {b}: one policy, one digest")

    ref = json.loads(load(os.path.join(d, "refusals", "expected.json")))
    listed = set()
    for c in ref["cases"]:
        listed.add(c["file"])
        b = load(os.path.join(d, "refusals", c["file"]))
        if c["file"].startswith("policy/"):
            try:
                admit(b)
                got = "ok"
            except Refused as r:
                got = r.code
        else:
            got = source_verdict(c["file"], b)
        rep.check(got == c["reason"] and got != "ok", f"refusals/{c['file']}: {got}, the corpus says {c['reason']}")
    for sub in ("policy", "source"):
        for n in os.listdir(os.path.join(d, "refusals", sub)):
            rep.check(f"{sub}/{n}" in listed, f"refusals/{sub}/{n} is a case")

    conv = json.loads(load(os.path.join(d, "conversions.json")))
    for c in conv["ms_to_units"]:
        rep.check(units_from_ms(c["ms"], c["num"], c["den"]) == c["units"], f"ms_to_units {c}")
    for c in conv["align"]:
        rep.check(align(c["start"], c["lead"], c["component"]) == c["units"], f"align {c}")
    for c in conv["y4m_rgb"]:
        _, _, _, _, frames = read_y4m(load(os.path.join(d, c["file"])))
        rep.check([hashlib.sha256(f).hexdigest() for f in frames] == c["rgb_sha256"], f"{c['file']}: RGB8 frames")

    sc = json.loads(load(os.path.join(d, "scenecut", "expected.json")))
    P = parse_policy_bytes(load(os.path.join(d, "scenecut", sc["policy"])))
    comp = next(c for c in P["component"] if c["id"] == sc["component"])
    tb = (comp["timebase"]["num"], comp["timebase"]["den"])
    s = P["segmentation"]
    p = {"min": units_from_ms(s["min_ms"], *tb), "target": units_from_ms(s["target_ms"], *tb),
         "max": units_from_ms(s["max_ms"], *tb), "cut_abs": s["cut_abs_permille"], "cut_rel": s["cut_rel_permille"],
         "window": s["cut_window"], "lookahead": s["lookahead_frames"]}
    cut = {}
    for fx in sc["fixtures"]:
        b = fixture(fx["name"])
        rep.check(hashlib.sha256(b).hexdigest() == fx["sha256"], f"fixture {fx['name']}: SHA-256")
        w, h, rate, _, frames = read_y4m(b)
        rep.check(len(frames) == fx["frames"] and rate == (25, 1), f"fixture {fx['name']}: frames and rate")
        pieces, scores = segment(frames, w, h, p)
        rep.check(scores == fx["scores"], f"scenecut {fx['name']}: scores")
        got = []
        for pc in pieces:
            kind, mad, chg = classify(pc, P["classify"])
            got.append({"start": pc["start"], "len": pc["len"], "flags": pc["flags"], "kind": kind,
                        "mad_milli": mad, "changed_permille": chg, "occupancy": pc["occupancy"]})
        rep.check(got == fx["pieces"], f"scenecut {fx['name']}: pieces")
        rep.check(plan_digest([x["start"] for x in got]) == fx["plan_digest"], f"scenecut {fx['name']}: plan digest")
        cut[fx["name"]] = (frames, got, w, h)

    enc = json.loads(load(os.path.join(d, "encode", "expected.json")))
    want = []
    for fx in sc["fixtures"]:
        for i, pc in enumerate(cut[fx["name"]][1]):
            for s in ("a", "b"):
                want.append((f"{fx['name']}-p{i}-{s}.wiv1", fx["name"], pc["start"], min(pc["len"], ENCODE_FRAMES)))
    rep.check([(v["file"], v["fixture"], v["first"], v["frames"]) for v in enc["vectors"]] == want,
              "encode: one vector per piece of each fixture and parameter set, at the piece's first frames")
    names = sorted(n for n in os.listdir(os.path.join(d, "encode")) if n.endswith(".wiv1"))
    rep.check(names == sorted(v["file"] for v in enc["vectors"]), "encode/: every payload is a vector")
    for v in enc["vectors"]:
        b = load(os.path.join(d, "encode", v["file"]))
        rep.check(blake3(b).hex() == v["blake3"], f"encode/{v['file']}: BLAKE3")
        try:
            w = IPV.parse_wiv1(b, 0)
            frames = IPV.decode_wiv1_k0(w)
        except IPV.Refused as e:
            rep.check(False, f"encode/{v['file']}: refused {e}")
            continue
        p = v["params"]
        head = (w["block"], w["mv_precision"], w["q"], w["n_frames"])
        rep.check(head == ((p["block"], p["mv_precision"], p["q"], v["frames"]) if v["frames"] > 1 else (1, 1, p["q"], 1)),
                  f"encode/{v['file']}: the header's block, precision, step and frames")
        rep.check([hashlib.sha256(f).hexdigest() for f in frames] == v["frame_sha256"], f"encode/{v['file']}: decoded frames")
        src = cut[v["fixture"]][0][v["first"]:v["first"] + v["frames"]]
        sse = sum((a - b) ** 2 for s, f in zip(src, frames) for a, b in zip(s, f))
        rep.check(sse == v["sse"], f"encode/{v['file']}: SSE against the source")
        for why in encoder_choices(w, p, src, frames):
            rep.check(False, f"encode/{v['file']}: {why}")
        rep.check(True, f"encode/{v['file']}: the encoder's choices")

    qc = json.loads(load(os.path.join(d, "qchoice", "expected.json")))
    cache = {}
    for s in qc["sets"]:
        p = s["params"]
        for pc in s["pieces"]:
            frames, _, w, h = cut[pc["fixture"]]
            src = frames[pc["first"]:pc["first"] + pc["frames"]]

            def sse_of(q, pc=pc, src=src, p=p, w=w, h=h):
                key = (pc["fixture"], pc["first"], pc["frames"], p["block"], p["search"], p["mv_precision"], q)
                if key not in cache:
                    _, sse = closed_loop(src, h, w, p["block"], p["search"], p["mv_precision"], q)
                    cache[key] = (sse, sse_px_milli(sse, h, w, len(src)))
                return cache[key]
            got = [{"q": q, "sse": sse_of(q)[0], "sse_px_milli": sse_of(q)[1]} for q in p["q_candidates"]]
            rep.check(got == pc["candidates"], f"qchoice {pc['fixture']} piece {pc['piece']}: each candidate's SSE")
            rep.check(choose_q(lambda q: sse_of(q)[1], p["q_candidates"], p["max_sse_px_milli"]) == pc["q"],
                      f"qchoice {pc['fixture']} piece {pc['piece']} bound {p['max_sse_px_milli']}: the step chosen")

    for name in sorted(os.listdir(os.path.join(d, "packs"))):
        verify_pack(rep, d, name)

    m = os.path.join(d, "mutations")
    used = {"expected.json"}
    for c in json.loads(load(os.path.join(m, "expected.json")))["cases"]:
        got = mutation_verdict(m, c, used)
        rep.check(got == c["reason"], f"mutations {c['name']}: {got}, the corpus says {c['reason']}")
    rest = [p for p in tree(m) if p not in used]
    rep.check(not rest, f"mutations/: files no case uses: {rest}")

    rc = json.loads(load(os.path.join(d, "receipts", "expected.json")))
    for c in rc["cases"]:
        verify_v1_receipt(rep, f"receipts/{c['file']}", load(os.path.join(d, "receipts", c["file"])), c["receipt_hash"],
                          c.get("signature") == "refused")
    rep.check(tree(os.path.join(d, "receipts")) == sorted([c["file"] for c in rc["cases"]] + ["expected.json"]),
              "receipts/: every receipt is a case")

    # catalogs/: MoQ catalogs of indexes with refinements on more than one deadline (§8.4).
    cc = json.loads(load(os.path.join(d, "catalogs", "expected.json")))
    for c in cc["cases"]:
        ix = parse_index(load(os.path.join(d, c["index"])))
        index_rules(ix)
        f = c["floor"]
        got = render_moq(ix["component"], ix["entries"], c["layer_lag_ms"], c["default_deadline"], (f["codec"], f["w"], f["h"]))
        rep.check(got == c["moq"].encode(), f"{c['index']}: the MoQ catalog §8.4 gives")
        names = {t["name"] for t in json.loads(got)["tracks"]}
        rep.check(all(x in names for t in json.loads(got)["tracks"] for x in t.get("depends", [])),
                  f"{c['index']}: no dependency names a track the catalog does not hold")
    rep.check(tree(os.path.join(d, "catalogs")) == sorted([c["index"][len("catalogs/"):] for c in cc["cases"]] + ["expected.json"]),
              "catalogs/: every index is a case")
    verify_package_mutations(rep, d)
    return rep


def main(argv):
    if len(argv) != 2:
        print(__doc__)
        return 2
    rep = verify(argv[1])
    print(f"pack_verify: {rep.checked - rep.failures}/{rep.checked} checks hold")
    return 0 if rep.failures == 0 else 1


if __name__ == "__main__":
    sys.exit(main(sys.argv))