feat(studio): the dock reads behaviour.params and refused; a window test that runs

The one-path copy that found the refused paths goes: the refused blocks come from
`behaviour.refused`, and a finding names the blocks that share a reason. A move's automatic
column clears the grid's own spacing. Spread out keeps the order of rows and columns, so no
path's priority changes (tested on the Zinogre); NodeGraphQt's auto_layout_nodes does not,
it put the flinch path first. The dock opens in a window offscreen, over the real Behaviour
dock spec, and the display-only assertions are gone.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

Author: sp00ktober

apps/studio/src/mhfu_studio/monster/behaviour.py

@@ -11,13 +11,12 @@
 
 from __future__ import annotations
 
-import dataclasses
 import typing
 from collections.abc import Callable, Mapping, Sequence
 from typing import Any, NamedTuple, Protocol
 
 from mhfu_port import behaviour, sequence
-from mhfu_port.behaviour import KINDS, Behaviour, Block, MoveNode, Param, Path
+from mhfu_port.behaviour import KINDS, Block, MoveNode, Param, Path
 from mhfu_port.manifest import Manifest, ManifestError
 
 from mhfu_studio.monster.document import PortDocument
@@ -28,8 +27,6 @@
 IN, OUT = "in", "out"
 PLAY, WHILE, THEN = "play", "while playing", "then"
 """A move node's ports: the input, then the two outputs."""
-BLOCK_W, MOVE_W = 280, 380
-"""How far right of a block, or a move's node, the next column starts: a node's width and a gap."""
 ROLE_TITLES = {
     "event": "Events",
     "state": "State",
@@ -146,8 +143,8 @@ 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."""
     b = m.behaviour
-    clear = [blk.at[0] + BLOCK_W for blk in b.blocks.values()]
-    clear += [n.at[0] + MOVE_W for n in b.moves.values()]
+    clear = [blk.at[0] + behaviour.COLUMN for blk in b.blocks.values()]
+    clear += [n.at[0] + behaviour.LEFT for n in b.moves.values()]
     x = max(clear, default=float(behaviour.LEFT))
     order = [n for steps in sequence.groups(m).values() for n in steps]
     return {
@@ -163,8 +160,8 @@ class Reading(NamedTuple):
     priority: dict[str, list[int]]
     """Block id -> the 1-based places in `paths` of the paths that play from it."""
     loose: list[str]
-    refused: dict[Path, str]
-    """The paths `compile` refuses, and why."""
+    refused: dict[str, str]
+    """Block id -> why, for the blocks on a path `compile` refuses."""
     capped: str | None
     """Set when the paths outnumber the rules the seam holds."""
 
@@ -174,7 +171,7 @@ def read(m: Manifest) -> Reading:
     priority: dict[str, list[int]] = {}
     for k, p in enumerate(ps, 1):
         priority.setdefault(p.blocks[-1], []).append(k)
-    return Reading(ps, priority, behaviour.loose(m), refusals(m, ps), capped(m, ps))
+    return Reading(ps, priority, behaviour.loose(m), behaviour.refused(m), capped(m, ps))
 
 
 def capped(m: Manifest, ps: Sequence[Path] | None = None) -> str | None:
@@ -183,31 +180,6 @@ def capped(m: Manifest, ps: Sequence[Path] | None = None) -> str | None:
     return f"{n} paths, the seam holds {behaviour.SEAM_RULES}" if n > behaviour.SEAM_RULES else None
 
 
-def refusals(m: Manifest, ps: Sequence[Path] | None = None) -> dict[Path, str]:
-    """Why `compile` refuses each path it does, in its words: each path alone."""
-    out: dict[Path, str] = {}
-    for p in behaviour.paths(m) if ps is None else ps:
-        try:
-            behaviour.compile(_alone(m, p))
-        except ManifestError as e:
-            out[p] = str(e).partition(": ")[2]
-    return out
-
-
-def _alone(m: Manifest, p: Path) -> Manifest:
-    """`m` with the graph cut down to the path `p`."""
-    b = m.behaviour
-    blocks = {}
-    for k, i in enumerate(p.blocks):
-        last = k == len(p.blocks) - 1
-        blk = b.blocks[i]
-        blocks[i] = dataclasses.replace(
-            blk, next=[] if last else [p.blocks[k + 1]], play=[p.play] if last else []
-        )
-    moves = {} if p.during is None else {p.during: MoveNode(b.moves[p.during].at, [p.blocks[0]])}
-    return dataclasses.replace(m, behaviour=Behaviour(blocks, moves))
-
-
 def part_options(m: Manifest, optional: bool) -> list[tuple[str, int | None]]:
     """The parts to pick from: the manifest's named ones, then `part k`; `any` for none."""
     named: dict[int, str] = {}
@@ -472,8 +444,8 @@ def place(m: Manifest) -> None:
 
 
 def spread(doc: Edits, kx: float = 1.5, ky: float = 1.7) -> str:
-    """Every placed node's place scaled out from the origin: a graph laid on a tight grid (the
-    rules of a schema 1 file) stops overlapping, and which block is higher stays so."""
+    """Every placed node's place scaled out from the origin, so crowded nodes stop overlapping.
+    A scale keeps the order of the canvas rows and columns, so every path's priority holds."""
     b = doc.manifest.behaviour
 
     def scale(m: Manifest) -> None:

apps/studio/src/mhfu_studio/monster/panels/behaviour.py

@@ -67,8 +67,8 @@ def __init__(self, ws: MonsterWorkspace, studio: Studio) -> None:
         )
         self.spread = kit.button(
             "Spread out",
-            tip="Moves every node away from the top left so none overlaps: a graph made from"
-            " rules is laid out tight",
+            tip="Moves every node away from the top left so crowded ones stop overlapping; which"
+            " block is higher stays so, and so does every path's priority",
             on=studio.act("spread nodes", lambda: ws.edit("", self._spread)),
             icon="ph.arrows-out-simple",
         )
@@ -182,8 +182,9 @@ def _blocks(m: Manifest, r: graph.Reading) -> list[NodeSpec]:
         out = []
         for i, blk in m.behaviour.blocks.items():
             k = KINDS[blk.kind]
-            why = list(dict.fromkeys(w for p, w in r.refused.items() if i in p.blocks))
+            why = r.refused.get(i)
             marks = [*(f"#{n}" for n in r.priority.get(i, [])), *([WARN] if why else [])]
+            values = model.params(blk)
             options: dict[str, list[tuple[str, object]]] = {}
             for p in k.params:
                 if p.type == "part":
@@ -199,12 +200,12 @@ def _blocks(m: Manifest, r: graph.Reading) -> list[NodeSpec]:
                     (graph.IN,),
                     (graph.OUT,),
                     k.params,
-                    {p.name: blk.params.get(p.name, p.default) for p in k.params},
+                    {p.name: values.get(p.name) for p in k.params},
                     options,
                     " ".join(marks),
                     i in r.loose,
                     blk.label,
-                    "\n".join([k.tip, *(f"{WARN} {w}" for w in why)]),
+                    "\n".join([k.tip, *([f"{WARN} {why}"] if why else [])]),
                 )
             )
         return out

apps/studio/src/mhfu_studio/monster/validate.py

@@ -555,17 +555,20 @@ def _rules(m: Manifest) -> list[Rule]:
 
 
 def _behaviour(m: Manifest) -> list[Finding]:
-    """What `compile` refuses: each path, and more paths than the seam holds rules."""
+    """What `compile` refuses: the blocks of a bad path, and more paths than the seam holds."""
+    by_reason: dict[str, list[str]] = {}
+    for i, why in behaviour.refused(m).items():
+        by_reason.setdefault(why, []).append(i)
     out = [
         _f(
             "error",
             "BEHAVIOUR_PATH_REFUSED",
-            f"behaviour path {' > '.join(p.blocks)} plays {p.play}",
+            f"behaviour blocks {', '.join(ids)}",
             why,
-            ("block", p.blocks[0]),
+            ("block", ids[0]),
             BEHAVIOUR,
         )
-        for p, why in graph.refusals(m).items()
+        for why, ids in by_reason.items()
     ]
     if (cap := graph.capped(m)) is not None:
         out.append(

apps/studio/tests/monster/test_behaviour.py

@@ -259,7 +259,7 @@ def test_the_users_example(d: PortDocument) -> None:
 
 
 def test_moves_without_a_node_sit_in_a_column_in_sequence_order(d: PortDocument) -> None:
-    x = 260.0 + B.BLOCK_W
+    x = 260.0 + model.COLUMN
     want = {
         n: (x, float(k * model.ROW)) for k, n in enumerate(["stamp", "stamp_2", "flinch_head"], 1)
     }
@@ -278,8 +278,8 @@ def test_what_the_graph_says_of_itself(d: PortDocument) -> None:
     r = B.read(d.manifest)
     assert [p.play for p in r.paths] == ["stamp", "flinch_head"]
     assert r.priority == {"b1": [1], "b4": [2]} and r.loose == []
-    [(path, why)] = r.refused.items()
-    assert path.blocks == ("b2", "b3", "b4") and "two 'Then wait' blocks" in why
+    assert set(r.refused) == {"b2", "b3", "b4"}
+    assert all("two 'Then wait' blocks" in why for why in r.refused.values())
     assert r.capped is None
 
 
@@ -300,6 +300,28 @@ def test_spread_keeps_the_order(d: PortDocument) -> None:
     assert undone(d, before)
 
 
+def test_spread_keeps_every_priority(ports: Path) -> None:
+    z = PortDocument(manifest.load(ports / "zinogre.toml"))
+    order = [(p.blocks, p.play, p.during) for p in model.paths(z.manifest)]
+    rules = model.compile(z.manifest)
+    for _ in range(3):
+        B.spread(z)
+        assert [(p.blocks, p.play, p.during) for p in model.paths(z.manifest)] == order
+    assert model.compile(z.manifest) == rules
+
+
+def test_spread_keeps_a_tie_a_tie(d: PortDocument) -> None:
+    B.add_block(d, "on_noticed", (260.0, 0.0))
+    B.add_block(d, "on_flinch", (100.0, 0.0))
+
+    def order() -> list[tuple[tuple[str, ...], str]]:
+        return [(p.blocks, p.play) for p in model.paths(d.manifest)]
+
+    before = order()
+    B.spread(d)
+    assert order() == before
+
+
 def test_the_cap(d: PortDocument) -> None:
     def many(m: Manifest) -> None:
         for k in range(model.SEAM_RULES + 1):
@@ -332,6 +354,7 @@ def test_the_zinogre_reads(ports: Path) -> None:
     assert len(m.behaviour.blocks) == 15 and len(r.paths) == 7
     assert sorted(n for ns in r.priority.values() for n in ns) == list(range(1, 8))
     assert r.loose == [] and r.refused == {} and r.capped is None
+    assert min(b.at[0] for b in m.behaviour.blocks.values()) == model.LEFT
     assert {w.dst for w in B.wires(m) if w.dst_port == "play"} >= {"move:flinch_head"}
     assert len(B.spots(m)) == len(m.moves)
 

apps/studio/tests/monster/test_validate.py

@@ -275,7 +275,7 @@ def test_a_refused_path_is_a_finding(make):
         '\n[behaviour.blocks.b3]\nkind = "cooldown"\nat = [0.0, 0.0]\nframes = 9\nplay = ["o"]\n'
     )
     f = found(V.validate(make(OWN + two), sources={1: 1}), "BEHAVIOUR_PATH_REFUSED")
-    assert (f.level, f.where) == ("error", "behaviour path b1 > b2 > b3 plays o")
+    assert (f.level, f.where) == ("error", "behaviour blocks b1, b2, b3")
     assert (f.target, f.focus) == (("block", "b1"), V.BEHAVIOUR) and "two" in f.message
     assert "OWN_MOVE_REFUSED" not in found(V.validate(make(OWN + two), sources={1: 1}))
 

apps/studio/tests/monster/ui/test_behaviour.py

@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+from collections.abc import Callable
 from pathlib import Path
 from typing import Any
 
@@ -18,9 +19,12 @@
 from mhfu_studio.monster.panels.node_graph import GraphView, LinkSpec
 from mhfu_studio.monster.workspace import MonsterWorkspace
 from mhfu_studio.shell.studio import Studio
+from mhfu_studio.shell.workspace import Dock
 from mhfu_studio.ui import kit, theme
+from mhfu_studio.ui.testing import FakeWorkspace
 from PySide6.QtCore import QPoint, QPointF, Qt
 from PySide6.QtTest import QTest
+from PySide6.QtWidgets import QDockWidget
 
 LEFT, NONE = Qt.MouseButton.LeftButton, Qt.KeyboardModifier.NoModifier
 STAMP, FLINCH, STEP = B.move_id("stamp"), B.move_id("flinch_head"), B.move_id("stamp_2")
@@ -141,6 +145,39 @@ def test_the_dock_is_registered_at_the_bottom() -> None:
     assert (dock.area, dock.shown, dock.alone) == ("bottom", False, False)
 
 
+class Hosted(FakeWorkspace):
+    """A fake workspace carrying the monster workspace's own Behaviour dock, and a strip that
+    is never tabbed under it, as the Timeline is."""
+
+    def __init__(self, own: MonsterWorkspace) -> None:
+        super().__init__("monster")
+        self.own = own
+
+    def docks(self) -> tuple[Dock, ...]:
+        [spec] = [d for d in self.own.docks() if d.label == "Behaviour"]
+        strip = Dock("Strip", "bottom", lambda s: kit.Panel(), "A panel never tabbed", alone=True)
+        return (*super().docks(), spec, strip)
+
+
+def test_the_window_opens_the_dock(
+    make_window: Callable[..., Any], qtbot: Any, port_doc: PortDocument
+) -> None:
+    own = MonsterWorkspace()
+    own.doc = port_doc
+    host = Hosted(own)
+    w = make_window(host)
+    dock = w.findChild(QDockWidget, "monster/Behaviour")
+    strip = w.findChild(QDockWidget, "monster/Strip")
+    assert dock is not None and strip is not None and not dock.isVisible()
+    assert isinstance(dock.widget(), BehaviourPanel) and kit.missing_tips(dock.widget()) == []
+    host.focus = "Behaviour"  # what the Moves dock's button asks for
+    w.studio.changed()
+    w.sync()
+    qtbot.wait(20)
+    assert dock.isVisible() and w.dockWidgetArea(dock) == Qt.DockWidgetArea.BottomDockWidgetArea
+    assert dock.height() > 2 * strip.height() and dock.geometry().bottom() < strip.geometry().top()
+
+
 def test_empty(qtbot: Any) -> None:
     p = make(qtbot, MonsterWorkspace())
     assert p.pages.currentWidget() is p.no_scene

apps/studio/tests/monster/ui/test_workspace.py

@@ -216,11 +216,6 @@ def test_window_builds_the_docks(
         d = w.findChild(QDockWidget, f"monster/{label}")
         assert d is not None and isinstance(d.widget(), cls)
         assert kit.missing_tips(d.widget()) == []
-    from mhfu_studio.monster.panels.behaviour import BehaviourPanel
-
-    behaviour = w.findChild(QDockWidget, "monster/Behaviour")
-    assert behaviour is not None and isinstance(behaviour.widget(), BehaviourPanel)
-    assert not behaviour.isVisible() and kit.missing_tips(behaviour.widget()) == []
     actions = w.findChild(QDockWidget, "monster/Actions")
     assert actions is not None and actions.isVisible(), "in front of Clips"
     clips = w.findChild(QDockWidget, "monster/Clips")
@@ -229,10 +224,6 @@ def test_window_builds_the_docks(
     w.studio.changed()
     w.sync()
     assert clips.isVisible()
-    ws.focus("Behaviour")
-    w.studio.changed()
-    w.sync()
-    assert behaviour.isVisible() and behaviour.height() > 200
 
 
 def test_window_shows_the_host(