@@ -0,0 +1,121 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+# SPDX-FileCopyrightText: 2026 sp00ktober
+"""Which clip fits after which: how well clip B's first pose continues clip A's last.
+
+A pose is each animated joint's local rotation as the engine's FK sees it (`fk`), with the
+body's heading about y taken out (YAW owns it, `travel`); the root's travel is location, which
+no rotation carries. Two poses are the mean angle between their joints, in degrees: smaller fits
+better. It ranks poses, not intent: a clip that hands to the next through a blend, or through a
+third clip, scores high.
+
+A channel holds past its last key, so a clip's first and last poses are its first and last keys'
+values: ranking a moveset takes two poses per clip, once (`Ends`).
+"""
+
+from __future__ import annotations
+
+from collections.abc import Collection, Mapping
+
+import numpy as np
+from mhp_formats.anim import Clip
+from mhp_formats.skeleton import Skeleton
+
+from . import build, fk, travel
+from .data import Data
+from .manifest import Manifest
+from .motion import SOURCE_BANK
+
+GOOD, FAIR = 10.0, 20.0
+"""Degrees. A fifth of a donor's clip pairs lie within GOOD (clips that start and end on the same
+stance); the Zinogre's backflip parts meet at 15, FAIR; beyond it the poses do not meet."""
+
+Scores = list[tuple[int, float]]
+
+
+def word(score: float) -> str:
+    """`good`, `fair` or `poor`."""
+    return "good" if score <= GOOD else "fair" if score <= FAIR else "poor"
+
+
+class Ends:
+    """The first and last pose of each clip: `(clips, joints, 3, 3)` rotations, the joints being
+    those some pose turns."""
+
+    def __init__(self, ids: tuple[int, ...], first: fk.Floats, last: fk.Floats) -> None:
+        self.ids, self.first, self.last = ids, first, last
+
+    def scores(self, a: int) -> fk.Floats:
+        """Degrees from the end of clip `a` to the start of each clip, in `ids` order."""
+        if a not in self.ids:
+            raise KeyError(f"no clip {a}")
+        if not self.first.shape[1]:
+            return np.zeros(len(self.ids))
+        trace = np.einsum("jik,njik->nj", self.last[self.ids.index(a)], self.first)
+        angle: fk.Floats = np.degrees(np.arccos(np.clip((trace - 1) / 2, -1, 1)))
+        mean: fk.Floats = angle.mean(axis=1)
+        return mean
+
+
+def ends(
+    clips: Mapping[int, Clip | fk.Curves],
+    skeleton: Skeleton,
+    record_of: Mapping[int, int] | None = None,
+) -> Ends:
+    """The end poses of `clips` (by id) on `skeleton`. `record_of` maps a donor's bones to its
+    clips' tracks (`build.record_map`); without it, track i drives joint i."""
+    rig = fk.Rig.from_skeleton(skeleton)
+    ids = tuple(sorted(clips))
+    rot, loc = [], []
+    for i in ids:
+        c = clips[i]
+        curves = c if isinstance(c, fk.Curves) else fk.Curves(c, rig, record_of)
+        r, t = curves.at(np.array([0.0, float(curves.last_frame)]))
+        rot.append(r)
+        loc.append(t)
+    if not ids:
+        return Ends(ids, np.zeros((0, 0, 3, 3)), np.zeros((0, 0, 3, 3)))
+    rotations, locations = np.stack(rot), np.stack(loc)
+    pose = fk.euler_xyz(rotations)
+    body = np.flatnonzero(rig.parents == travel.root(skeleton))
+    pose[..., body, :, :] = _unturned(rig.world(rotations, locations)[..., body, :3, :3])
+    moving = np.flatnonzero(np.abs(pose - np.eye(3)).max(axis=(0, 1, 3, 4)) > 1e-9)
+    return Ends(ids, pose[:, 0, moving], pose[:, 1, moving])
+
+
+def _unturned(body: fk.Floats) -> fk.Floats:
+    """`(..., body, 3, 3)` rotations with the heading about y they share taken out."""
+    heading = np.arctan2(
+        (body[..., 0, 2] - body[..., 2, 0]).sum(axis=-1),
+        (body[..., 0, 0] + body[..., 2, 2]).sum(axis=-1),
+    )
+    c, s = np.cos(heading), np.sin(heading)
+    back = np.zeros((*heading.shape, 3, 3))  # a turn of -heading about y
+    back[..., 0, 0] = back[..., 2, 2] = c
+    back[..., 0, 2], back[..., 2, 0], back[..., 1, 1] = -s, s, 1.0
+    out: fk.Floats = back[..., None, :, :] @ body
+    return out
+
+
+def donor_ends(m: Manifest, data: Data) -> Ends:
+    """The end poses of the manifest's donor moveset, on the donor's own skeleton."""
+    d = build.donor(m, data)
+    return ends(d.clips, d.skeleton, build.record_map(d, m.build))
+
+
+def fits_after(e: Ends, a: int, *, top: int | None = None) -> Scores:
+    """Every clip but `a` as `(id, degrees)`, best first: how far its first pose is from the
+    last of `a`. Equal scores go nearest the id of `a` first. `top` keeps that many."""
+    rows = [(i, float(s)) for i, s in zip(e.ids, e.scores(a), strict=True) if i != a]
+    rows.sort(key=lambda r: (round(r[1], 3), abs(r[0] - a), r[0]))
+    return rows if top is None else rows[:top]
+
+
+def neighbours(a: int, ids: Collection[int]) -> list[int]:
+    """`ids` but `a`, nearest first: its own stream by slot number, then the other streams by
+    how far off they are."""
+    stream, slot = divmod(a, SOURCE_BANK)
+
+    def apart(i: int) -> tuple[int, int, int]:
+        return abs(i // SOURCE_BANK - stream), abs(i % SOURCE_BANK - slot), i
+
+    return sorted((i for i in ids if i != a), key=apart)
@@ -0,0 +1,57 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+# SPDX-FileCopyrightText: 2026 sp00ktober
+"""Sequences: moves that run one after another through `Move.after`.
+
+A sequence is a chain of moves, each handing to the next. Its head is a move no other move's
+`after` names; a ring of moves with no head is headed by its alphabetically first. A move that
+two chains reach belongs to the first head, in the manifest's order.
+"""
+
+from __future__ import annotations
+
+from .manifest import Manifest, ManifestError
+
+
+def chain(m: Manifest, head: str) -> list[str]:
+    """`head` and the moves it hands to in turn, up to the first repeat."""
+    out: list[str] = []
+    name: str | None = head
+    while name is not None and name in m.moves and name not in out:
+        out.append(name)
+        name = m.moves[name].after
+    return out
+
+
+def loops(m: Manifest, head: str) -> bool:
+    """Whether the chain from `head` ends by handing back to one of its own moves."""
+    steps = chain(m, head)
+    return bool(steps) and m.moves[steps[-1]].after is not None
+
+
+def heads(m: Manifest) -> list[str]:
+    """Each sequence's head, in the manifest's order."""
+    named = {mv.after for mv in m.moves.values() if mv.after is not None}
+    out = [n for n in m.moves if n not in named]
+    reached = {s for h in out for s in chain(m, h)}
+    for n in sorted(m.moves):  # what is left is rings: every move in one is named by another
+        if n not in reached:
+            out.append(n)
+            reached.update(chain(m, n))
+    order = list(m.moves)
+    return sorted(out, key=order.index)
+
+
+def head_of(m: Manifest, name: str) -> str:
+    """The head of the sequence `name` belongs to."""
+    for h in heads(m):
+        if name in chain(m, h):
+            return h
+    raise ManifestError(f"no move {name!r}")
+
+
+def step_name(m: Manifest, head: str) -> str:
+    """The lowest `<head>_<k>` from k = 2 that no move has."""
+    k = 2
+    while f"{head}_{k}" in m.moves:
+        k += 1
+    return f"{head}_{k}"
@@ -0,0 +1,127 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+# SPDX-FileCopyrightText: 2026 sp00ktober
+import math
+from pathlib import Path
+
+import pytest
+from mhfu_port import continuity, manifest
+from mhfu_port.data import Data
+from mhp_formats.anim import Channel, Clip, Keyframe, Track, quantize
+from mhp_formats.skeleton import Bone, Skeleton
+
+PORTS = Path(__file__).parents[3] / "ports"
+ROT = (0x008, 0x010, 0x020)
+
+
+def skeleton() -> Skeleton:
+    """Joint 0 and the root 1 carry the travel; the body 2 and a limb 3 turn."""
+    return Skeleton(
+        [
+            Bone(parent=-1, child=1),
+            Bone(parent=0, child=2),
+            Bone(parent=1, child=3, position=(0.0, 0.0, 50.0)),
+            Bone(parent=2, position=(0.0, 30.0, 100.0)),
+        ]
+    )
+
+
+def turn(axis: int, degrees: float) -> Channel:
+    return Channel(ROT[axis], [Keyframe(quantize("rot", math.radians(degrees)), 0)])
+
+
+def held(channels: list[Channel], frames: int) -> Track:
+    """Each channel at its first key's value from frame 0 to `frames`."""
+    return Track(
+        [Channel(c.bit, [c.keyframes[0], c.keyframes[0]._replace(frame=frames)]) for c in channels]
+    )
+
+
+def clip(body: list[Channel], limb: list[Channel], frames: int = 10) -> Clip:
+    """A clip whose joints 2 and 3 hold the given channels."""
+    return Clip([Track(), Track(), held(body, frames), held(limb, frames)])
+
+
+def moveset(**poses: tuple[float, float]) -> dict[int, Clip]:
+    """Clip i holds the body at x degrees and the limb at y degrees about x."""
+    return {int(k[1:]): clip([turn(0, b)], [turn(0, ll)]) for k, (b, ll) in poses.items()}
+
+
+def test_a_clip_fits_itself_best_and_a_rotated_one_worse():
+    e = continuity.ends(moveset(c1=(0, 0), c2=(0, 0), c3=(0, 90), c4=(90, 90)), skeleton())
+    got = dict(continuity.fits_after(e, 1))
+    assert got[2] == pytest.approx(0.0) and got[3] == pytest.approx(45.0)
+    assert got[4] == pytest.approx(90.0), "both joints turn 90 degrees"
+    assert [i for i, _ in continuity.fits_after(e, 1)] == [2, 3, 4]
+    assert continuity.fits_after(e, 1, top=1) == [(2, pytest.approx(0.0, abs=1e-6))]
+
+
+def test_equal_scores_go_nearest_first():
+    e = continuity.ends(moveset(c1=(0, 0), c9=(0, 0), c3=(0, 0), c2=(0, 0)), skeleton())
+    assert [i for i, _ in continuity.fits_after(e, 1)] == [2, 3, 9]
+
+
+def test_the_body_heading_is_not_a_difference():
+    still = clip([turn(0, 30)], [turn(0, 10)])
+    faced = clip([turn(0, 30), turn(1, 70)], [turn(0, 10)])  # the same pose, turned about y
+    e = continuity.ends({1: still, 2: faced}, skeleton())
+    assert dict(continuity.fits_after(e, 1))[2] < 1.0
+
+
+def test_the_end_poses_are_the_clips_ends():
+    start = Track([Channel(ROT[0], [Keyframe(0, 0), Keyframe(quantize("rot", math.pi / 2), 8)])])
+    swing = Clip([Track(), Track(), start, Track()])
+    rest = clip([turn(0, 0)], [])
+    e = continuity.ends({1: swing, 2: rest, 3: clip([turn(0, 90)], [])}, skeleton())
+    after_swing, before_swing = dict(continuity.fits_after(e, 1)), dict(continuity.fits_after(e, 2))
+    assert after_swing[3] == pytest.approx(0.0, abs=0.1), "the swing ends where 3 begins"
+    assert before_swing[1] == pytest.approx(0.0), "and begins where the rest ends"
+
+
+def test_words():
+    assert [continuity.word(x) for x in (0.0, 10.0, 15.0, 20.0, 31.0)] == [
+        "good",
+        "good",
+        "fair",
+        "fair",
+        "poor",
+    ]
+
+
+def test_neighbours():
+    ids = [101, 103, 104, 200, 201, 230, 231, 232, 5]
+    assert continuity.neighbours(231, ids) == [230, 232, 201, 200, 104, 103, 101, 5]
+    assert continuity.neighbours(103, [103, 101, 104, 5]) == [104, 101, 5]
+
+
+# ---- the Zinogre's donor (MHP3RD_DATA) ----
+
+
+@pytest.fixture(scope="module")
+def zinogre(data: Data) -> continuity.Ends:
+    return continuity.donor_ends(manifest.load(PORTS / "zinogre.toml"), data)
+
+
+def rank(e: continuity.Ends, a: int, b: int) -> int:
+    return [i for i, _ in continuity.fits_after(e, a)].index(b) + 1
+
+
+@pytest.mark.parametrize("a, b", [(218, 219), (219, 220), (221, 222), (222, 223)])
+def test_the_backflip_parts_chain(zinogre, a, b):
+    assert rank(zinogre, a, b) <= 3
+
+
+def test_the_flinch_roll_parts_chain_crossed(zinogre):
+    """The donor's part 2s are crossed with its part 1s: 103 (_left_) ends where 108 (_right_)
+    begins, 4 degrees off, and 107 is 42 off."""
+    names = {103: "flinch_roll_left_part_1", 108: "flinch_roll_right_part_2"}
+    assert rank(zinogre, 103, 108) <= 3 and rank(zinogre, 104, 107) <= 3, names
+    assert dict(continuity.fits_after(zinogre, 103))[108] < continuity.GOOD
+
+
+def test_the_whole_moveset_ranks_fast(zinogre):
+    import time
+
+    t = time.perf_counter()
+    for a in zinogre.ids:
+        continuity.fits_after(zinogre, a)
+    assert time.perf_counter() - t < 1.0
@@ -0,0 +1,63 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+# SPDX-FileCopyrightText: 2026 sp00ktober
+from mhfu_port import manifest, sequence
+
+HEAD = """
+[port]
+name = "z"
+host_species = 75
+pac = "z.bin"
+[source]
+model = 5339
+[clips.a]
+slot = 1
+"""
+
+
+def moves(**after: str | None) -> manifest.Manifest:
+    """Own moves in the given order, each `after` the move named (None: no `after`)."""
+    body = "".join(
+        f'[moves.{n}]\nclip = "a"\n' + (f'after = "{a}"\n' if a else "") for n, a in after.items()
+    )
+    return manifest.loads(HEAD + body)
+
+
+def test_chain():
+    m = moves(c="d", a="b", b="c", d=None, solo=None)
+    assert sequence.chain(m, "a") == ["a", "b", "c", "d"]
+    assert sequence.chain(m, "c") == ["c", "d"]
+    assert sequence.chain(m, "solo") == ["solo"]
+    assert sequence.chain(m, "nope") == []
+
+
+def test_chain_stops_at_the_first_repeat():
+    m = moves(h="a", a="b", b="c", c="a")
+    assert sequence.chain(m, "h") == ["h", "a", "b", "c"]
+    assert sequence.loops(m, "h")
+    assert not sequence.loops(moves(a="b", b=None), "a")
+
+
+def test_heads():
+    m = moves(c="d", a="b", b="c", d=None, solo=None)
+    assert sequence.heads(m) == ["a", "solo"], "in manifest order"
+    assert [sequence.head_of(m, n) for n in "abcd"] == ["a"] * 4
+    assert sequence.head_of(m, "solo") == "solo"
+
+
+def test_a_ring_is_headed_by_its_first_name():
+    m = moves(z="y", y="x", x="z", lone=None)
+    assert sequence.heads(m) == ["x", "lone"] and sequence.head_of(m, "y") == "x"
+    assert sequence.chain(m, "x") == ["x", "z", "y"] and sequence.loops(m, "x")
+
+
+def test_a_join_belongs_to_the_first_head():
+    m = moves(p="join", q="join", join="end", end=None)
+    assert sequence.heads(m) == ["p", "q"]
+    assert sequence.head_of(m, "join") == "p" and sequence.head_of(m, "q") == "q"
+    assert sequence.chain(m, "q") == ["q", "join", "end"]
+
+
+def test_step_name():
+    m = moves(topple="topple_2", topple_2="topple_4", topple_4=None)
+    assert sequence.step_name(m, "topple") == "topple_3"
+    assert sequence.step_name(m, "fresh") == "fresh_2"