@@ -89,16 +89,28 @@ starting where the last stood, facing as it faced, and the Timeline's bar above
 shows the steps (click one to pick it). Picking or playing anything else starts clips where
 they normally start.
 
-The Behaviour tab beside the 3D view (the button under the moves, or View > Panels) draws the
-port's `[behaviour]` graph: every move and block is a node, and right-click adds a block (the
-palette is `mhfu_port.behaviour.KINDS`). A wire from a block's `out` feeds the next block's `in`,
-or plays a move at its `play`; a move's `while playing` starts a path while it plays, and its
-`then` hands to another move (`after`). Any other wire is refused in the status line. `#2` is a
-block's path rank (higher on the canvas is checked first, but every path that plays nothing runs
-before all the others), `⚠` a path the game refuses (the tip says why), faded a block on no
-complete path. Delete removes blocks and their links; a move is
-deleted in Moves. Every gesture is one undo step. The tab has no docks until you open one on it,
-and keeps them apart from the 3D view's; Findings stays open across tabs.
+The Behaviour tab beside the 3D view (the button under the moves, or View > Panels) edits the
+port's `[behaviour]` graph as rules. The outline on the left lists what starts a rule: an event,
+a state between moves, or a move playing, each with its rule count and ranks; pick one and its
+rules are rows, or pick All rules for every one. A row is a frame titled `#rank · trigger · note`,
+in the order the game checks them (`#1` first; rules that play nothing go first): the rule's blocks left to right, then the move
+it plays as a dashed reference (`×n` when n rules play it) whose tip names those rules and the
+move's `then` sequence. A block or reference you select is edited in the bar below: its params
+and note, the move a reference plays, and Play, which plays the move in the game and is off,
+with the reason in its tip, when it cannot. `+ Rule` adds a rule checked last; right-click a
+block to insert one after it or delete it, and drag a frame to reorder it among its trigger's
+rules (in All, among its own trigger's only; the status says so). `⚠` marks a rule the game
+refuses (the tip says why). Every gesture is one undo step.
+
+All rules has a header toggle: In order (the default, kept per document) shows every rule as a
+row, each starting with its trigger, and Canvas shows the stored graph as a free canvas.
+Right-click adds a block (the palette is `mhfu_port.behaviour.KINDS`); a wire from a block's `out`
+feeds the next block's `in`, or plays a move at its `play`; a move's `while playing` starts a rule
+while it plays, and its `then` hands to another move (`after`); any other wire is refused in the
+status line. Selecting a node dims all but the rules through it. Spread out loosens the layout, a
+faded block is on no complete rule, and rows write no block position. A move is deleted in Moves.
+The tab has no docks until you open one on it, and keeps them apart from the 3D view's; Findings
+stays open across tabs.
 
 Effect blocks (violet) change the monster's counters and flags when their path fires. A path may
 end at an effect with nothing to play: it applies its effects, keeps its `#n` on that block, and
 
@@ -31,6 +31,9 @@
 """A move node's ports: the input, then the two outputs."""
 ALL = "all"
 """The scope that is the whole canvas, as stored; any other is a trigger's key."""
+ORDER, CANVAS = "order", "canvas"
+"""What All shows: every rule as a framed row in the order they are checked, or the canvas as
+stored."""
 INSERTABLE = ("condition", "modifier", "effect")
 """The roles of the blocks a rule holds besides its first."""
 ROLE_TITLES = {"state": "State"}
@@ -141,6 +144,48 @@ def wires(m: Manifest) -> list[Wire]:
     return out
 
 
+class Focus(NamedTuple):
+    """What stays bright when nodes are selected."""
+
+    nodes: frozenset[str]
+    wires: frozenset[Wire]
+
+
+def focus(m: Manifest, ps: Sequence[Path], ids: Collection[str]) -> Focus | None:
+    """The rules through `ids`, whole, with the moves each hands on to; the nodes `ids` always.
+    None when nothing is selected."""
+    if not ids:
+        return None
+    nodes, lit = set(ids), set[Wire]()
+    for p in ps:
+        names = sequence.chain(m, p.play) if p.play else []
+        steps = [move_id(n) for n in names]
+        start = [move_id(p.during)] if p.during else []
+        if not {*start, *p.blocks, *steps} & set(ids):
+            continue
+        lit.update(Wire(a, OUT, b, IN) for a, b in zip(p.blocks, p.blocks[1:], strict=False))
+        if start:
+            lit.add(Wire(start[0], WHILE, p.blocks[0], IN))
+        if steps:
+            lit.add(Wire(p.blocks[-1], OUT, steps[0], PLAY))
+        lit.update(
+            Wire(move_id(n), THEN, move_id(after), PLAY)
+            for n in names
+            if (after := m.moves[n].after) in m.moves
+        )
+        nodes.update(start, p.blocks, steps)
+    return Focus(frozenset(nodes), frozenset(lit))
+
+
+def then(m: Manifest, name: str) -> list[str]:
+    """The moves `name` hands to in turn; a sequence that rings ends with the move it hands back
+    to."""
+    steps = sequence.chain(m, name)[1:]
+    last = steps[-1] if steps else name
+    back = m.moves[last].after if last in m.moves else None
+    return [*steps, *([back] if back else [])]
+
+
 def spots(m: Manifest) -> dict[str, Point]:
     """Where each move sits: its node's place, else a column right of everything placed, in
     sequence order so a chain sits together."""