@@ -179,16 +179,16 @@ def coverage(
     port: AnimPack,
     host: AnimPack | None = None,
     donor: Mapping[int, anim.Clip] | None = None,
-    layout: Mapping[int, int] | None = None,
+    layout: layouts.Layout | None = None,
 ) -> Coverage:
-    """Each entry of a built pack against the donor clip `layout` (entry -> MHP3rd id; by
-    default each entry read as the clip of its own id) puts there and the host's pack; every
-    entry is UNKNOWN without the donor."""
+    """Each entry of a built pack against the donor clip `layout` puts there (by default each
+    entry read as the clip of its own id) and the host's pack; every entry is UNKNOWN without
+    the donor."""
     table = clip_table(port)
     host_table = clip_table(host) if host is not None else {}
     donor = donor or {}
     if layout is None:
-        layout = {cid: cid for cid in donor if cid in table}
+        layout = layouts.Layout({cid: cid for cid in donor if cid in table})
     held = slots.correspondence(port, donor, layout) if donor else {}
     cov = Coverage(has_source=bool(donor), has_host=host is not None)
     for slot, fp in sorted(table.items()):
@@ -201,11 +201,11 @@ def coverage(
             kind = FILLER
         else:
             kind = HOST if host_table.get(slot) == fp else ALTERED
-        cid = layout.get(slot)
+        cid = layout.entries.get(slot)
         fp_src = fingerprint(donor[cid]) if cid is not None and cid in donor else None
         cov.slots[slot] = SlotCoverage(slot, kind, fp[0], fp[1], fp_src, cid)
     if host is not None:
-        placed = set(layout.values())
+        placed = set(layout.entries.values())
         cov.dropped = {cid: fingerprint(c) for cid, c in donor.items() if cid not in placed}
     return cov
 
 
@@ -267,7 +267,7 @@ def run_clips(args: argparse.Namespace) -> int:
     port = slots.anim_of(b.pac)
     table = clips.clip_table(port)
     host, donor = inputs.host_anim(m, games), inputs.donor_clips(m, games)
-    cov = clips.coverage(port, host, donor, layout.of(m, donor, host).entries)
+    cov = clips.coverage(port, host, donor, layout.of(m, donor, host))
     if args.import_labels:
         labels = slots.read_labels(args.import_labels.read_text(encoding="utf-8"))
         provenance = args.labels_from or clips.UNRECORDED.format(args.import_labels.name)
 
@@ -466,7 +466,7 @@ def own_moves(
             refused += _refused(dataclasses.replace(m, moves={name: mv}, rules=[]), lay, known)
     out += refused or _refused(dataclasses.replace(m, moves=judged), lay, known)
     for name, mv in mine:
-        e = lay.ids.get(m.clips[mv.clip].id) if mv.clip is not None else mv.anim
+        e = lay.entry(m.clips[mv.clip]) if mv.clip is not None else mv.anim
         frames = lay.frames.get(e) if e is not None else None
         for i, a in enumerate(mv.attacks):
             if frames is not None and a.frame < frames and a.end is not None and a.end > frames:
 
@@ -970,7 +970,7 @@ def _measure_coverage(self) -> tuple[clips.Coverage, list[str]]:
             notes.append(f"original moveset unreadable ({e})")
         if host is not None and donor is not None:
             try:
-                placed = layout.of(m, donor, host).entries
+                placed = layout.of(m, donor, host)
             except ValueError as e:
                 notes.append(f"no clip layout ({e}): each anim read as its own clip id")
         return clips.coverage(port, host, donor, placed), notes
 
@@ -49,14 +49,14 @@ def packs(make_clip):
 
 def test_coverage(packs):
     port, host, donor = packs
-    cov = C.coverage(port, host, donor, {1: 1, 2: 2, 5: 5, 6: 6})
+    cov = C.coverage(port, host, donor, layout.Layout({1: 1, 2: 2, 5: 5, 6: 6}))
     kinds = {s: c.kind for s, c in cov.slots.items()}
     assert kinds == {1: C.CARRIED, 2: C.CARRIED, 3: C.FILLER, 4: C.HOST, 5: C.ALTERED, 6: C.CARRIED}
     assert cov.dropped == {7: (90, False)} and cov.slots[2].scriptable
     assert cov.counts()[C.DROPPED] == 1 and "1 donor clip(s) DROPPED" in cov.summary()
     assert "idle copy" in cov.slots[3].why().lower()
     assert cov.sources() == {1: 1, 2: 2, 5: 5, 6: 6}
-    moved = C.coverage(port, host, donor, {2: 6, 6: 2})
+    moved = C.coverage(port, host, donor, layout.Layout({2: 6, 6: 2}))
     assert (moved.kind(2), moved.kind(6), moved.slots[2].clip) == (C.ALTERED, C.FILLER, 6)
 
 
@@ -202,11 +202,15 @@ def test_zinogre(games, built, ports):
     m = manifest.load(ports / "zinogre.toml")
     port = slots.anim_of(built("zinogre"))
     host, donor = host_anim(m, games), donor_clips(m, games)
-    cov = C.coverage(port, host, donor, layout.of(m, donor, host).entries)
+    cov = C.coverage(port, host, donor, layout.of(m, donor, host))
     n = cov.counts()
-    assert len(cov.slots) == n[C.CARRIED] == 102 and n[C.FILLER] == n[C.DROPPED] == 0
+    assert len(cov.slots) == n[C.CARRIED] == 103 and n[C.FILLER] == n[C.DROPPED] == 0
     assert all(t.trusted for t in C.track_labels(m, C.clip_table(port), sources=cov.sources()))
-    assert {t.status for t in C.track_labels(m, C.clip_table(port))} == {C.UNCHECKABLE}
+    pinned = {name for name, c in m.clips.items() if c.slot is not None}
+    got = {t.name: t.status for t in C.track_labels(m, C.clip_table(port))}
+    assert {k: v for k, v in got.items() if v != C.UNCHECKABLE} == dict.fromkeys(
+        pinned, C.STILL_VALID
+    ), "without a layout only a pin is checkable"
 
 
 def test_brute(built):
 
@@ -91,7 +91,7 @@ def test_clips(games, ports, tmp_path, capsys):
     data = ["--data", str(games.fu.root), "--p3rd-data", str(games.p3rd.root)]
     assert main(["port", "clips", str(ports / "zinogre.toml"), *data]) == 0
     out = capsys.readouterr().out
-    assert "102 populated slot(s): 102 carried, 0 filler" in out and "DROPPED" not in out
+    assert "103 populated slot(s): 103 carried, 0 filler" in out and "DROPPED" not in out
     assert main(["port", "clips", str(ports / "zinogre.toml"), "--slots", *data]) == 0
     assert "a1 2    CARRIED  welcome_howl" in capsys.readouterr().out
     path = tmp_path / "z.toml"
 
@@ -5,7 +5,7 @@
 import numpy as np
 import pytest
 from mhfu.files import monster_pac
-from mhfu_port import layout, manifest, travel, verify
+from mhfu_port import fk, layout, manifest, motion, travel, verify
 from mhfu_port.model import MHFU, MHP3RD, ModelError
 from mhfu_studio.monster import inputs
 from mhfu_studio.monster.core.scene import Scene, open_scene
@@ -89,7 +89,9 @@ def test_donor_matches_port(games, built, ports, name, joints, groups, vertices,
     src = Scene.from_manifest(m, side="source", data=games)
     port = Scene.from_bytes(built(name), name, manifest=m)
     host = inputs.host_anim(m, games)
-    entry = layout.of(m, inputs.donor_clips(m, games), host).ids
+    lay = layout.of(m, inputs.donor_clips(m, games), host)
+    played = layout.clips(lay, {c.slot: c.source for c in src.clips})
+    tracks = {c.slot: c.joint_tracks for c in src.clips}
     assert src.game == MHP3RD and src.rig.n == joints and src.record_to_bone
     assert (
         (len(src.groups), src.n_vertices)
@@ -109,24 +111,25 @@ def test_donor_matches_port(games, built, ports, name, joints, groups, vertices,
     s_idx = np.array(sorted(b for b, j in c.tree.items() if j not in (0, root)))
     p_idx = np.array([c.tree[i] for i in s_idx])
     worst, compared = 0.0, 0
-    for clip in src.clips:
-        pc = port._by_slot[entry[clip.slot]]
+    for e, clip in played.items():
+        pc = port._by_slot[e]
         assert pc.whole_rig
         turn = turn_of(port, pc)
         th = -turn.keys[0] / travel.TURN * math.tau if turn else 0.0
         face = np.array(
             [[math.cos(th), 0, -math.sin(th)], [0, 1, 0], [math.sin(th), 0, math.cos(th)]]
         )
-        for frame in (clip.frames // 4, clip.frames // 2):
-            a = src.pose(clip, frame).joints @ face
+        want, n = fk.Curves(clip, src.rig, tracks[lay.entries[e]]), motion.frames(clip)
+        for frame in (n // 4, n // 2):
+            a = src.rig.world(*want.at(float(frame)))[:, :3, 3] @ face
             b = pose_at(port, pc, frame).joints
             lift = b[body, 1] - a[anchor, 1]
             off = (a[s_idx] - a[anchor]) - (b[p_idx] - b[body])
             worst = max(
                 worst, float(np.linalg.norm(off, axis=1).max()), abs(lift - m.build.ground_lift)
             )
             compared += 1
-    assert compared == 2 * len(src.clips) and worst < 0.2, (compared, worst)
+    assert compared == 2 * len(played) and worst < 0.2, (compared, worst)
 
 
 def test_manifest_port(games, ports):
 
@@ -172,10 +172,10 @@ def test_ported_zinogre_dashes_at_a_far_hunter(lua: Any, tmp_path: Path) -> None
 
 
 def zinogre_clips() -> dict[str, int]:
-    """The entries `mhfu-port inject` writes to zinogre_clips.lua: a clip below the host's 123
-    entries sits in the entry of its MHP3rd id, which the manifest gives as `source`."""
+    """The entries `mhfu-port inject` writes to zinogre_clips.lua: a pinned clip's `slot`, else
+    the entry of its MHP3rd id `source`, where a clip below the host's 123 entries sits."""
     clips = tomllib.loads(PORT.read_text(encoding="utf-8"))["clips"]
-    return {name: clips[name]["source"] for name in FOLLOWER_CLIPS}
+    return {name: clips[name].get("slot", clips[name].get("source")) for name in FOLLOWER_CLIPS}
 
 
 CLIPS = zinogre_clips()
 
@@ -230,9 +230,10 @@ def animation(
     placed: Layout,
     lift: float = 0.0,
 ) -> fu.Anim:
-    """The donor's moveset on the rig's joints in the entries `placed` gives it, its pelvis
-    raised by `lift` world units, and on its own rig its travel and turns where the engine takes
-    them (`travel.carry`). Entries it leaves keep the host's clips on the host's rig."""
+    """The donor's moveset on the rig's joints in the entries `placed` gives it, cut where it
+    cuts, its pelvis raised by `lift` world units, and on its own rig its travel and turns where
+    the engine takes them (`travel.carry`). Entries it leaves keep the host's clips on the
+    host's rig."""
     clips: Mapping[int, Clip] = d.clips
     if lift:
         bone_of_record = {r: bone for bone, r in record_of.items()}
@@ -243,17 +244,19 @@ def animation(
     # records are not positional in either mode: joint -> donor bone -> record
     track_of = {j: record_of.get(bone) for j, bone in bind.bone_of.items() if bone is not None}
     keep = bind.mode == "retarget"
-    out = motion.build(clips, placed.entries, h.anim, bind.rig.streams, track_of, keep)
+    played = layouts.clips(placed, clips)
+    out = motion.build(played, {e: e for e in played}, h.anim, bind.rig.streams, track_of, keep)
     return out if keep else travel.carry(out, bind.rig.skeleton)
 
 
 def authored(m: Manifest, placed: Layout) -> dict[int, float]:
     """Entry -> the manifest's `turn` of the clip it holds."""
-    return {
-        placed.ids[c.id]: c.turn
-        for c in m.clips.values()
-        if c.turn is not None and c.id in placed.ids
-    }
+    out = {}
+    for c in m.clips.values():
+        e = placed.entry(c)
+        if c.turn is not None and e is not None:
+            out[e] = c.turn
+    return out
 
 
 # 6. the PAC
@@ -284,7 +287,7 @@ def build(m: Manifest, data: Data) -> Built:
     placed = layout(m, d, h)
     anim = animation(d, h, bind, record_of, placed, m.build.ground_lift)
     turned = travel.turns(anim, bind.rig.skeleton, authored(m, placed))
-    frames = {e: motion.frames(d.clips[cid]) for e, cid in placed.entries.items()}
+    frames = {e: motion.frames(c) for e, c in layouts.clips(placed, d.clips).items()}
     placed = dataclasses.replace(placed, turns=turned, frames=frames)
     out = pac(h, bind.rig, model, d.textures, anim)
     summary = Summary(
 
@@ -58,10 +58,10 @@ def _resolve(args: argparse.Namespace) -> manifest.Manifest | None:
 
 def _layout(
     m: manifest.Manifest | None, donor: Mapping[int, Clip], host: fu.Anim, species: int
-) -> dict[int, int]:
+) -> layout.Layout:
     """The manifest's layout of the donor's clips, else the packer's alone."""
     clips = m.clips if m is not None else {}
-    return layout.plan(clips, donor, host, species).entries
+    return layout.plan(clips, donor, host, species)
 
 
 def run_slots(args: argparse.Namespace) -> int:
@@ -72,7 +72,7 @@ def run_slots(args: argparse.Namespace) -> int:
     port = slots.anim_of(args.port.read_bytes()) if args.port else None
     donor = motion.moveset(d.p3rd.read(args.donor)) if args.donor is not None else None
     placed = _layout(m, donor, host, args.host) if donor is not None else None
-    ids = {cid: e for e, cid in (placed or {}).items()}
+    ids = placed.ids if placed is not None else {}
     named = sorted(m.clips.items()) if m is not None else []
     names = {e: n for n, c in named if (e := layout.where(c, ids)) is not None}
     rows = slots.catalog(host, drivers, port, donor, placed, names)