@@ -39,8 +39,16 @@ port.pac, port.summary.text()
 
 ## Checking a build
 
-`mhfu-port diff OLD NEW` compares two builds group by group and clip by clip. `constraints`
-holds the engine's rules on a monster PAC; `build` refuses a port that breaks one.
+| Command | What it prints |
+|---|---|
+| `mhfu-port diff OLD NEW` | Two builds compared group by group and clip by clip |
+| `mhfu-port verify PAC --manifest M` | A structural audit against the donor: stream partition, driven palette joints, tears across the body's fork, every vertex's weights |
+| `mhfu-port validate PAC` | The engine's rules (`constraints`) on any monster PAC; `build` refuses a port that breaks one |
+| `mhfu-port pose PAC --manifest M` | The port's clips against the donor's, joint by joint |
+| `mhfu-port stretch PAC [--fork]` | How far each clip pulls the mesh apart, and the tear across the fork |
+| `mhfu-port floor PAC... --host 75` | Where the idle pose puts the feet by the animation alone, against the host (not yet where the game puts a port) |
+| `mhfu-port fidelity M` | The port's skin weights against the donor's own |
+| `mhfu-port slots`, `labels` | Which host move plays which ported clip; hand labels checked against a build |
 
 ## Licence
 
 
@@ -0,0 +1,138 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+# SPDX-FileCopyrightText: 2026 sp00ktober
+"""`slots` and `labels`: what each animation slot of a built port plays."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from collections.abc import Iterator
+from contextlib import contextmanager
+from pathlib import Path
+from typing import TYPE_CHECKING, TextIO
+
+from mhfu.em.moveset import Moveset
+from mhfu.files import monster_pac
+from mhp_formats import p3rd
+
+from .. import data, manifest, slots
+
+if TYPE_CHECKING:
+    from . import Subparsers
+
+
+def register(sub: Subparsers) -> None:
+    p = sub.add_parser(
+        "slots", help="each host slot's (main, sub) pairs, lengths and donor clip in a port, as CSV"
+    )
+    p.add_argument("port", type=Path, nargs="?", help="a built model PAC")
+    _common(p)
+    p.set_defaults(run=run_slots)
+
+    q = sub.add_parser("labels", help="which hand labels describe a donor clip, per build, as CSV")
+    q.add_argument("labels", type=Path, help="`N -> text` lines, N the a1 forced")
+    q.add_argument("ports", type=Path, nargs="+", help="the builds the labels may come from")
+    _common(q)
+    q.set_defaults(run=run_labels)
+
+
+def _common(p: argparse.ArgumentParser) -> None:
+    p.add_argument("--manifest", type=Path, help="the port's: host, donor and clip names")
+    p.add_argument("--host", type=int, metavar="SPECIES", help="the MHFU host")
+    p.add_argument("--donor", type=int, metavar="FILE", help="MHP3rd moveset file")
+    p.add_argument("--stream", type=int, default=0, help="the donor stream (default: 0)")
+    p.add_argument("-o", "--out", type=Path, help="CSV file (default: stdout)")
+    data.add_arguments(p)
+
+
+def _resolve(args: argparse.Namespace) -> dict[int, str]:
+    """Fill `--host` and `--donor` from the manifest where not given; the manifest's clip
+    names by slot."""
+    names: dict[int, str] = {}
+    if args.manifest:
+        m = manifest.load(args.manifest)
+        args.host = m.port.host_species if args.host is None else args.host
+        args.donor = m.source.anim if args.donor is None else args.donor
+        for name, clip in sorted(m.clips.items()):
+            names[clip.slot] = f"{names[clip.slot]} {name}" if clip.slot in names else name
+    if args.host is None:
+        raise ValueError("give --host or --manifest")
+    return names
+
+
+def run_slots(args: argparse.Namespace) -> int:
+    names = _resolve(args)
+    d = data.from_arguments(args)
+    host = slots.anim_of(d.fu.read(monster_pac(args.host)))
+    drivers = slots.driven(Moveset(d.fu.em(args.host)))
+    port = slots.anim_of(args.port.read_bytes()) if args.port else None
+    donor = p3rd.Anim.from_bytes(d.p3rd.read(args.donor)) if args.donor is not None else None
+    rows = slots.catalog(host, drivers, port, donor, args.stream, names)
+    with _output(args.out) as out:
+        slots.write_catalog(rows, out)
+
+    driven = [r for r in rows if r.pairs]
+    silent = [r.slot for r in driven if not r.host_streams]
+    say(f"{len(rows)} slots, {len(driven)} driven by a (main, sub) pair")
+    if silent:
+        say(f"  {len(silent)} driven slots have no host clip, so their pairs cannot animate:")
+        say(f"    {_ids(silent)}")
+    size = slots.slot_count(host)
+    past = [a1 for a1 in drivers if a1 >= size]
+    if past:
+        say(f"  {len(past)} driven ids name no slot of the {size}: {_ids(past)}")
+    if port is not None:
+        most = max((r.shared for r in rows), default=0)
+        say(f"  {sum(r.shared > 1 for r in rows)} port slots share their clip (at most {most})")
+    held = [r.source for r in rows if r.source is not None]
+    if held:
+        n = {m: sum(s.match == m for s in held) for m in ("same", "fill", "unknown")}
+        say(f"  port: {n['same']} own donor clip, {n['fill']} the fill, {n['unknown']} unknown")
+        if not n["same"]:
+            say(
+                f"  no port slot holds its own clip of donor file {args.donor} stream "
+                f"{args.stream}: is that the moveset the port was built from?"
+            )
+    return 0
+
+
+def run_labels(args: argparse.Namespace) -> int:
+    _resolve(args)
+    if args.donor is None:
+        raise ValueError("give --donor or --manifest")
+    d = data.from_arguments(args)
+    labels = slots.read_labels(args.labels.read_text())
+    builds = {}
+    for path in args.ports:
+        if path.stem in builds:
+            raise ValueError(f"two builds named {path.stem}")
+        builds[path.stem] = slots.anim_of(path.read_bytes())
+    donor = p3rd.Anim.from_bytes(d.p3rd.read(args.donor))
+    drivers = slots.driven(Moveset(d.fu.em(args.host)))
+    rows = slots.verdicts(labels, builds, donor, args.stream, drivers)
+    with _output(args.out) as out:
+        slots.write_verdicts(rows, list(builds), out)
+
+    say(f"{len(rows)} labels over {len(builds)} builds")
+    for name in builds:
+        say(f"  {name}: {sum(name in v.transfers for v in rows)} hold their own donor clip")
+    if len(builds) > 1:
+        say(f"  {sum(len(v.transfers) == len(builds) for v in rows)} under every build")
+    return 0
+
+
+@contextmanager
+def _output(path: Path | None) -> Iterator[TextIO]:
+    if path is None:
+        yield sys.stdout
+        return
+    with path.open("w", newline="") as f:
+        yield f
+
+
+def say(line: str) -> None:
+    print(line, file=sys.stderr)
+
+
+def _ids(ids: list[int]) -> str:
+    return " ".join(map(str, ids))
@@ -0,0 +1,178 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+# SPDX-FileCopyrightText: 2026 sp00ktober
+"""`verify`, `validate`, `pose`, `stretch`, `floor` and `fidelity`: offline checks of a built
+port."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from mhfu.files import monster_pac
+
+from .. import build, constraints, data, fidelity, manifest, pose, verify
+from ..slots import frames
+
+if TYPE_CHECKING:
+    from . import Subparsers
+
+
+def register(sub: Subparsers) -> None:
+    p = sub.add_parser("verify", help="the structural audit of a built port")
+    p.add_argument("port", type=Path, help="a built model PAC")
+    p.add_argument("--manifest", type=Path, help="also check the donor's rig and skin survived")
+    data.add_arguments(p)
+    p.set_defaults(run=run_verify)
+
+    p = sub.add_parser("validate", help="the engine's rules on any monster PAC")
+    p.add_argument("pac", type=Path)
+    p.add_argument("--template", type=int, metavar="SPECIES", help="keep this species' bone tree")
+    data.add_arguments(p)
+    p.set_defaults(run=run_validate)
+
+    p = sub.add_parser("pose", help="the port's clips against the donor's, joint by joint")
+    p.add_argument("port", type=Path)
+    p.add_argument("--manifest", type=Path, required=True)
+    data.add_arguments(p)
+    p.set_defaults(run=run_pose)
+
+    p = sub.add_parser("stretch", help="how far the port's clips pull its mesh apart")
+    p.add_argument("port", type=Path)
+    p.add_argument("--slot", type=int, help="every triangle at one frame of this slot")
+    p.add_argument("--frame", type=int, help="with --slot; default: mid-clip")
+    p.add_argument("--fork", action="store_true", help="only the tear across the body fork")
+    p.add_argument("--top", type=int, default=15, help="rows to print (default: 15)")
+    p.set_defaults(run=run_stretch)
+
+    p = sub.add_parser("floor", help="where the rest pose puts the feet")
+    p.add_argument("pacs", type=Path, nargs="*", help="built or native model PACs")
+    p.add_argument("--host", type=int, metavar="SPECIES", help="measure this host's PAC first")
+    data.add_arguments(p)
+    p.set_defaults(run=run_floor)
+
+    p = sub.add_parser("fidelity", help="whether the porter keeps the donor's skin")
+    p.add_argument("manifest", type=Path)
+    data.add_arguments(p)
+    p.set_defaults(run=run_fidelity)
+
+
+def run_verify(args: argparse.Namespace) -> int:
+    port = verify.Port(args.port.read_bytes())
+    if args.manifest:
+        m = manifest.load(args.manifest)
+        d = build.donor(m, data.from_arguments(args))
+        checks = verify.audit(port, d.skeleton, build.parts(d, m.build))
+    else:
+        checks = verify.audit(port)
+    width = max(len(c.name) for c in checks)
+    for c in checks:
+        print(f"{'PASS' if c.ok else 'FAIL'}  {c.name:<{width}}  {c.detail}")
+    failed = sum(not c.ok for c in checks)
+    print(f"\n{len(checks)} checks, {failed} failed")
+    return 1 if failed else 0
+
+
+def run_validate(args: argparse.Namespace) -> int:
+    port = verify.Port(args.pac.read_bytes())
+    template = None
+    if args.template is not None:
+        fu = data.from_arguments(args).fu
+        template = verify.Port(fu.read(monster_pac(args.template))).skeleton
+    results = constraints.validate(port.model, port.skeleton, port.anim, template)
+    for r in results:
+        print(r)
+    errors = sum(r.level == "error" for r in results)
+    print(f"{errors} errors, {len(results) - errors} warnings")
+    return 1 if errors else 0
+
+
+def run_pose(args: argparse.Namespace) -> int:
+    m = manifest.load(args.manifest)
+    d = build.donor(m, data.from_arguments(args))
+    port = verify.Port(args.port.read_bytes())
+    r = pose.compare(port, d.skeleton, d.clips, build.record_map(d, m.build))
+    print(f"{r.matched} of {r.bones} donor bones placed (pad {r.pad}), {r.compared} compared")
+    print(f"{'slot':>4} {'joints':>6} {'median':>8} {'p90':>8} {'worst':>8} {'lift':>7}")
+    for s in r.slots:
+        print(
+            f"{s.slot:>4} {s.joints:>6} {s.median:>8.2f} {s.p90:>8.2f} {s.worst:>8.2f} "
+            f"{s.lift:>7.1f}"
+        )
+    if r.absent:
+        print(f"donor slots the port does not fill: {' '.join(map(str, r.absent))}")
+    if r.partial:
+        shown = ", ".join(f"{s} ({a} of {b} joints)" for s, a, b in r.partial)
+        print(f"filled in only some parts, not compared: {shown}")
+    verdict = "plays its donor's moveset" if r.ok else "differs from its donor"
+    print(
+        f"{len(r.slots)} clips, worst {r.worst:.2f} units (tolerance {pose.TOLERANCE}): {verdict}"
+    )
+    return 0 if r.ok else 1
+
+
+def run_stretch(args: argparse.Namespace) -> int:
+    port = verify.Port(args.port.read_bytes())
+    if args.fork:
+        t = verify.tear(port)
+        print("no edge crosses the body fork" if t is None else f"worst tear {t}")
+        print(f"gate: {verify.TEAR_LIMIT:.0f} units")
+        return 0
+    if args.slot is not None:
+        clip = port.clip(args.slot)
+        if clip is None:
+            raise ValueError(f"slot {args.slot} is empty in this port")
+        frame = args.frame if args.frame is not None else frames(clip) // 2
+        rows = verify.faces(port, args.slot, frame)
+        print(f"slot {args.slot} frame {frame}: {len(rows)} triangles grow")
+        print(
+            f"grown >50: {sum(s.growth > 50 for s, _ in rows)}, "
+            f">150: {sum(s.growth > 150 for s, _ in rows)}"
+        )
+        for s, ratio in rows[: args.top]:
+            print(f"  +{s.growth:7.0f}  {ratio:5.1f}x  group {s.group:3d}  joints {_pair(s)}")
+        return 0
+    worst = verify.worst(port)
+    print(f"{len(worst)} clip samples, worst {worst[0].growth:.0f} units" if worst else "no clips")
+    for s in worst[: args.top]:
+        print(
+            f"  +{s.growth:7.0f}  slot {s.slot:3d} frame {s.frame:3d}  group {s.group:3d}  "
+            f"joints {_pair(s)}"
+        )
+    return 0
+
+
+def run_floor(args: argparse.Namespace) -> int:
+    pacs: list[tuple[str, bytes]] = []
+    if args.host is not None:
+        fu = data.from_arguments(args).fu
+        pacs.append((f"host {args.host}", fu.read(monster_pac(args.host))))
+    pacs += [(p.name, p.read_bytes()) for p in args.pacs]
+    if not pacs:
+        raise ValueError("give PACs to measure, or --host")
+    rows = [(name, pose.rest_floor(verify.Port(pac))) for name, pac in pacs]
+    width = max(len(name) for name, _ in rows)
+    print(f"{'':<{width}}  {'floor':>7}  {'vertex':>6}  joint")
+    for name, f in rows:
+        print(f"{name:<{width}}  {f.height:>7.1f}  {f.vertex:>6}  {f.joint}")
+    if len(rows) > 1:
+        (first, a), (last, b) = rows[0], rows[-1]
+        print(f"\n{last} stands {b.height - a.height:+.1f} units against {first}")
+    return 0
+
+
+def run_fidelity(args: argparse.Namespace) -> int:
+    r = fidelity.of_build(manifest.load(args.manifest), data.from_arguments(args))
+    f = r.fidelity
+    print(f"skin {r.skin}: {f.vertices} vertices, donor {f.expected}")
+    print(f"on other joints than the donor's: {f.wrong_set}")
+    print(
+        f"weight error: worst {f.max_error:.6f}, mean {f.mean_error:.6f} "
+        f"(one u8 step {fidelity.WEIGHT_STEP:.6f})"
+    )
+    print("keeps the donor's skin" if f.ok else "does not keep the donor's skin")
+    return 0 if f.ok else 1
+
+
+def _pair(s: verify.Stretch) -> str:
+    return "-".join(map(str, s.joints))