@@ -21,7 +21,7 @@
 from mhp_formats import anim
 from mhp_formats.anim import AnimPack
 
-from mhfu_studio.monster import clips
+from mhfu_studio.monster import clips, sequences
 from mhfu_studio.monster.document import PortDocument
 
 
@@ -36,6 +36,8 @@ class SourceClip:
     loop: bool
     name: str = ""
     label: str = ""
+    used: tuple[str, ...] = ()
+    """The moves that play it."""
 
     @property
     def stream(self) -> int | None:
@@ -80,7 +82,8 @@ def rows(self, others: Iterable[SourceClip] = ()) -> list[SourceClip]:
         for cid in sorted(self.donor):
             frames, loop = self.prints[cid]
             name, label = named.get(cid, ("", ""))
-            out.append(SourceClip(cid, ids.get(cid), frames, loop, name, label))
+            used = tuple(sequences.used_in(m, name)) if name else ()
+            out.append(SourceClip(cid, ids.get(cid), frames, loop, name, label, used))
         return [*out, *others]
 
     def name(self, cid: int, name: str, label: str, build: str | None = None) -> str:
 
@@ -8,6 +8,7 @@
 
 from typing import TYPE_CHECKING
 
+from mhfu_port import continuity
 from PySide6.QtCore import QSignalBlocker, Qt
 from PySide6.QtWidgets import QVBoxLayout, QWidget
 
@@ -50,6 +51,8 @@
     clips.UNCHECKABLE: "unchecked",
 }
 UNPLACED = "in no anim: the base monster has no anim left for it"
+ORDERS = (("id", "By id"), ("fit", "Fits after the one on screen"))
+FIT_COLUMN = 5
 
 
 def _page() -> tuple[QWidget, QVBoxLayout]:
@@ -110,12 +113,27 @@ def __init__(self, ws: MonsterWorkspace, studio: Studio) -> None:
         )
         self.filter.textChanged.connect(self._filter)
         lay.addWidget(self.filter)
+        self.order = kit.Segmented(
+            list(ORDERS),
+            tip="By id: the original's order. Fits after the one on screen: best first by how"
+            " well each clip's first pose continues where the clip on screen ends, to find the"
+            " next part of a chain.",
+            on=lambda v: self.studio.act(
+                "order clips", lambda: setattr(self.ws, "clip_order", v)
+            )(),
+            current=ws.clip_order,
+        )
+        self.order_note = kit.label(role="muted")
+        lay.addWidget(kit.row(self.order, stretch=True))
+        lay.addWidget(self.order_note)
         self.table = kit.Table(
-            ["Id", "Anim", "Frames", "Travel", "Name"],
+            ["Id", "Anim", "Frames", "Travel", "Name", "Fit", "Used in"],
             tip="Every clip of the original by its MHP3rd id (stream x 100 + slot), and the anim"
             " that plays it: what a script passes to force it. Click one, or step with the arrow"
             " keys, to play it from the start; a clip that repeats says loop after its frames;"
-            " Travel is how far the clip carries the body.",
+            " Travel is how far the clip carries the body; Fit, when ordered by it, is the mean"
+            " angle between the clip on screen's last pose and this clip's first; Used in names"
+            " the moves that play it.",
             swatch_column=1,
         )
         self.table.picked.connect(self._clicked)
@@ -374,8 +392,9 @@ def _table(self, vocab: Vocabulary) -> None:
         kit.put(self.filter, ws.clip_filter)
         needle = ws.clip_filter.strip().lower()
         speed = DEFAULT_SPEED if vp is None or vp.actor is None else vp.playback.speed
+        fit = self._fits()
         rows, data, colors, tips, levels = [], [], [], [], []
-        for r in self._rows:
+        for r in rated_first(self._rows, fit):
             cov = None if r.entry is None else vocab.coverage.slots.get(r.entry)
             text = " ".join(
                 [
@@ -384,6 +403,7 @@ def _table(self, vocab: Vocabulary) -> None:
                     r.name or "unnamed",
                     kind_text(cov),
                     r.label,
+                    *r.used,
                 ]
             )
             if needle and needle not in text.lower():
@@ -396,11 +416,13 @@ def _table(self, vocab: Vocabulary) -> None:
                     f"{r.frames} loop" if r.loop else str(r.frames),
                     f"{net:.0f}" if net >= 1.0 else "",
                     r.name,
+                    fit_text(fit.get(r.id)) if r.id is not None else "",
+                    ", ".join(r.used),
                 )
             )
             data.append(r.key)
             colors.append(None if cov is None else COVERAGE[cov.kind])
-            tips.append(row_tip(r, cov, speed))
+            tips.append(row_tip(r, cov, speed, fit.get(r.id) if r.id is not None else None))
             levels.append(level_of(cov))
         playing = self._playing()
         with QSignalBlocker(self.table):
@@ -410,6 +432,19 @@ def _table(self, vocab: Vocabulary) -> None:
             else:
                 self.table.select_data(playing)
 
+    def _fits(self) -> dict[int, float]:
+        """How well each clip follows the one on screen, when the table is ordered by it."""
+        ws = self.ws
+        kit.put(self.order, ws.clip_order)
+        by_fit = ws.clip_order == "fit"
+        self.table.setColumnHidden(FIT_COLUMN, not by_fit)
+        fit = ws.fits_after() if by_fit else {}
+        self.order_note.setVisible(by_fit and not fit)
+        self.order_note.setText(
+            ws.ends_note or "Play a clip of the original to rank the rest by it"
+        )
+        return fit
+
     def _editor(self, vocab: Vocabulary) -> None:
         ws = self.ws
         row = next((r for r in self._rows if r.key == self._picked), None)
@@ -476,12 +511,24 @@ def level_of(cov: SlotCoverage | None) -> Level | None:
     return "warning" if cov is not None and cov.kind == clips.FILLER else None
 
 
-def row_tip(r: SourceClip, cov: SlotCoverage | None, speed: float) -> str:
+def rated_first(rows: list[SourceClip], fit: dict[int, float]) -> list[SourceClip]:
+    """`rows` with the clips `fit` rates first, best first, the rest as they were."""
+    place = {cid: k for k, cid in enumerate(fit)}
+    return sorted(rows, key=lambda r: len(place) if r.id is None else place.get(r.id, len(place)))
+
+
+def fit_text(degrees: float | None) -> str:
+    return "" if degrees is None else f"{degrees:.0f}\u00b0 {continuity.word(degrees)}"
+
+
+def row_tip(r: SourceClip, cov: SlotCoverage | None, speed: float, fit: float | None = None) -> str:
     lines = []
     if r.id is not None:
         lines.append(f"MHP3rd clip {r.id}: stream {r.stream}, slot {r.id % 100}")
     lines.append(cov.why() if cov else UNPLACED if r.entry is None else "Kind unknown")
     lines.append(f"{wall_clock(r.frames, speed):.2f} s at speed {speed:.2f}")
+    if fit is not None:
+        lines.append(f"{fit_text(fit)} from the end of the clip on screen")
     if r.label:
         lines.append(r.label)
     return "\n".join(lines)
@@ -2,19 +2,22 @@
 # SPDX-FileCopyrightText: 2026 sp00ktober
 """The Moves dock: every move of the port, on a base monster's action or its own; an own move
 made from the clip on screen, renamed, deleted, its fields and steer edited, and played in the
-running game. Its attack windows are drawn on the Timeline. Under them, the rules."""
+running game. Its attack windows are drawn on the Timeline. The moves that follow one another are
+a sequence, grouped in the table and edited under the picked move. Under them, the rules."""
 
 from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from mhfu_port import sequence
 from mhfu_port.manifest import MOVE_ATTACKS, TURNS, Move
 from PySide6.QtWidgets import QAbstractSpinBox, QSpinBox, QVBoxLayout, QWidget
 
 from mhfu_studio.monster import rules
 from mhfu_studio.monster import validate as V
 from mhfu_studio.monster.panels.common import kind
 from mhfu_studio.monster.panels.rules import RulesSection
+from mhfu_studio.monster.panels.sequence import ClipPicker, StepChips
 from mhfu_studio.monster.panels.widgets import NoScene
 from mhfu_studio.shell.findings import Finding
 from mhfu_studio.shell.text import plain
@@ -38,6 +41,13 @@
 )
 
 
+def row_name(name: str, place: int, count: int) -> str:
+    """A move's cell in the table: a step under its head, or a head with its step count."""
+    if place:
+        return f"   \u2514 {name}"
+    return name if count == 1 else f"{name} \u00b7 {count} steps"
+
+
 def special(box: QSpinBox, text: str) -> QSpinBox:
     """`box` shows `text` at its lowest value, which means "none"."""
     box.setSpecialValueText(text)
@@ -55,7 +65,8 @@ def __init__(self, ws: MonsterWorkspace, studio: Studio) -> None:
         self.table = kit.Table(
             ["Move", "Plays on", "Clip", "Attacks"],
             tip="Your moves: on one of the base monster's actions, or your own, which the move"
-            " player plays whole. Click one to watch it.",
+            " player plays whole. The moves that follow one another are grouped under the first."
+            " Click one to watch it.",
         )
         self.table.picked.connect(
             lambda n: act("pick move", lambda: ws.select_move(str(n)))() if n else None
@@ -76,6 +87,7 @@ def __init__(self, ws: MonsterWorkspace, studio: Studio) -> None:
 
         self.editor = kit.Section("This move", tip="The picked own move: what the game plays")
         self.title = kit.label(role="title", wrap=False)
+        self.seq = self._sequence_section()
         self.clip = kit.label(role="muted")
         self.play_clip = kit.button(
             "Play its clip",
@@ -230,6 +242,7 @@ def __init__(self, ws: MonsterWorkspace, studio: Studio) -> None:
             body.addWidget(w)
         top: tuple[QWidget, ...] = (
             self.title,
+            self.seq,
             kit.row(self.clip, self.play_clip, self.in_game, self.force, stretch=True),
             self.game_hint,
             self.pair_note,
@@ -265,8 +278,111 @@ def __init__(self, ws: MonsterWorkspace, studio: Studio) -> None:
         for box in (self.length, self.main, self.sub, self.rate, self.angle, self.frames, self.dir):
             box.setButtonSymbols(QAbstractSpinBox.ButtonSymbols.NoButtons)
 
+    def _sequence_section(self) -> kit.Section:
+        """The picked move's sequence: a chip per step, the edits, the clip picker."""
+        ws, act = self.ws, self.studio.act
+        sec = kit.Section(
+            "Sequence", tip="The moves that follow one another, each handing to the next by Then"
+        )
+        #: how the picker was opened, and for which move
+        self._picking: tuple[str, str] | None = None
+        self.chips = StepChips()
+        self.chips.picked.connect(lambda n: act("pick step", lambda: ws.select_move(n))())
+        self.add_step = kit.button(
+            "Add step after",
+            tip="Lists the clips best fit first after this move's clip, and puts the one you click"
+            " in a new own move that follows this one",
+            on=lambda: self._open("add"),
+            icon="ph.plus",
+        )
+        self.change_clip = kit.button(
+            "Change clip",
+            tip="Lists the clips best fit first after the step before, and plays the one you"
+            " click in this step",
+            on=lambda: self._open("change"),
+            icon="ph.swap",
+        )
+        self.remove_step = kit.button(
+            "Remove step",
+            tip="Deletes this step; the move before it hands to the move after it. Refused while"
+            " a rule or an effect names it.",
+            on=act("remove step", ws.remove_step),
+            icon="ph.trash",
+        )
+        self.earlier = kit.button(
+            "Earlier",
+            tip="Swaps this step with the one before it",
+            on=act("earlier", lambda: ws.move_step(-1)),
+            icon="ph.arrow-left",
+        )
+        self.later = kit.button(
+            "Later",
+            tip="Swaps this step with the one after it",
+            on=act("later", lambda: ws.move_step(1)),
+            icon="ph.arrow-right",
+        )
+        self.split = kit.button(
+            "Split here",
+            tip="Ends the sequence before this step, which starts one of its own",
+            on=act("split sequence", ws.split_step),
+            icon="ph.link-break",
+        )
+        self.play_seq = kit.button(
+            "Play sequence",
+            tip="Plays the sequence from its first step, each clip after the other at the game's"
+            " speed, each turning as its move steers",
+            on=act("play sequence", ws.play_sequence),
+            icon="ph.play",
+        )
+        self.picker = ClipPicker(ws, self.studio)
+        self.picker.picked.connect(self._picked)
+        self.picker.cancelled.connect(self._close_picker)
+        self.picker.hide()
+        for w in (
+            self.chips,
+            kit.row(self.add_step, self.change_clip, self.remove_step, stretch=True),
+            kit.row(self.earlier, self.later, self.split, self.play_seq, stretch=True),
+            self.picker,
+        ):
+            sec.body.addWidget(w)
+        return sec
+
     # acting
 
+    def _open(self, mode: str) -> None:
+        if self.ws.move is not None:
+            self._picking = mode, self.ws.move
+            self._show_picker()
+
+    def _close_picker(self) -> None:
+        self._picking = None
+        self.picker.hide()
+
+    def _picked(self, clip: str) -> None:
+        mode = self._picking[0] if self._picking else ""
+        self._close_picker()
+        if mode == "add":
+            self.studio.act("add step", lambda: self.ws.add_step(clip))()
+        elif mode == "change":
+            self.studio.act("change clip", lambda: self.ws.set_step_clip(clip))()
+
+    def _show_picker(self) -> None:
+        """The picker for the move it was opened for, ranked after the clip it follows."""
+        ws, m = self.ws, self.ws.manifest
+        if self._picking is None or m is None or ws.move != self._picking[1]:
+            self._close_picker()
+            return
+        mode, name = self._picking
+        steps = ws.sequence_of()
+        i = steps.index(name)
+        if mode == "add":
+            after, title = m.moves[name].clip, f"A step after {name}"
+        else:
+            after = m.moves[steps[i - 1]].clip if i else None
+            title = f"The clip of {name}"
+        self.picker.show_after(after, title)
+        self.picker.show()
+
     def _rename(self) -> None:
         new = self.name.text().strip()
         if new and new != self.ws.move:
@@ -294,10 +410,13 @@ def sync(self) -> None:
         own = sum(mv.own for mv in m.moves.values())
         self.count.setText(f"{len(m.moves)} moves, {own} of them own")
         rows, data, tips = [], [], []
-        for n, mv in m.moves.items():
-            rows.append([n, kind(mv), mv.clip or f"anim {mv.anim}", self._attacks(mv)])
-            data.append(n)
-            tips.append(mv.label or ("" if mv.pair is None else "edit it in Actions"))
+        for steps in sequence.groups(m).values():
+            for k, n in enumerate(steps):
+                mv = m.moves[n]
+                shown = row_name(n, k, len(steps))
+                rows.append([shown, kind(mv), mv.clip or f"anim {mv.anim}", self._attacks(mv)])
+                data.append(n)
+                tips.append(mv.label or ("" if mv.pair is None else "edit it in Actions"))
         self.table.set_rows(rows, data, tips=tips)
         self.table.fit(ROWS)
         self.table.select_data(ws.move)
@@ -306,6 +425,8 @@ def sync(self) -> None:
         picked = None if ws.move is None else m.moves.get(ws.move)
         self.delete.setEnabled(picked is not None)
         self.editor.setVisible(picked is not None)
+        if picked is None:
+            self._close_picker()
         if picked is not None and ws.move is not None:
             self._sync_move(ws.move, picked)
         self.rules.sync(self._checks())
@@ -345,8 +466,22 @@ def _sync_move(self, name: str, mv: Move) -> None:
             kit.put(self.name, name)
         if own:
             self._sync_own(name, mv)
+        self._sync_sequence(name, own)
         self._findings(name)
 
+    def _sync_sequence(self, name: str, own: bool) -> None:
+        ws = self.ws
+        steps = ws.sequence_of(name)
+        i = steps.index(name)
+        self.chips.show_steps([ws.step_of(n) for n in steps], name)
+        for w in (self.add_step, self.change_clip, self.remove_step):
+            w.setEnabled(own)
+        self.earlier.setEnabled(i > 0)
+        self.later.setEnabled(i < len(steps) - 1)
+        self.split.setEnabled(i > 0)
+        if self._picking is not None:
+            self._show_picker()
+
     def _sync_own(self, name: str, mv: Move) -> None:
         ws, m = self.ws, self.ws.manifest
         assert m is not None