@@ -160,7 +160,12 @@ def _settle(self) -> None:
         if gesture is None:
             return
         done = gesture
-        self.studio.act("edit behaviour", lambda: self.ws.edit("", done.commit))()
+
+        def edit() -> None:
+            self.ws.edit("", done.commit)
+            self.sync()  # the window syncs a turn on: after the view would have put the canvas back
+
+        self.studio.act("edit behaviour", edit)()
         m = self.ws.manifest
         if made is not None and m is not None and made in m.behaviour.blocks:
             self.view.select([made])
 
@@ -20,8 +20,18 @@
 from mhfu_port.behaviour import ID
 from NodeGraphQt import BaseNode, NodeBaseWidget, NodeGraph, Port
 from NodeGraphQt.qgraphics.node_base import NodeItem
-from PySide6.QtCore import QRectF, QSignalBlocker, Qt, QTimer, Signal
-from PySide6.QtGui import QFont, QKeyEvent, QPainter, QShowEvent, QUndoCommand, QUndoStack
+from PySide6.QtCore import QEvent, QObject, QPoint, QRectF, QSignalBlocker, Qt, QTimer, Signal
+from PySide6.QtGui import (
+    QFont,
+    QInputDevice,
+    QKeyEvent,
+    QNativeGestureEvent,
+    QPainter,
+    QShowEvent,
+    QUndoCommand,
+    QUndoStack,
+    QWheelEvent,
+)
 from PySide6.QtWidgets import (
     QComboBox,
     QDoubleSpinBox,
@@ -53,6 +63,11 @@
 NONE = "none"
 #: where a number field with no bound ends
 _FAR = 10**9
+#: a scroll without pixels moves this many pixels per angle unit (a notch of 120 is ~3 lines)
+_ANGLE_PX = 0.5
+#: the zoom per angle unit of a wheel, as NodeGraphQt has it, and the scale the canvas keeps to
+_WHEEL = 1.001
+_SCALE = (0.05, 3.0)
 
 
 class ParamLike(Protocol):
@@ -134,6 +149,65 @@ def endMacro(self) -> None:  # noqa: N802
         pass
 
 
+class _Navigation(QObject):
+    """The canvas as macOS canvas apps move: two-finger scroll pans; a pinch, Ctrl/Cmd+scroll and
+    a mouse wheel zoom, within `_SCALE`. NodeGraphQt's own wheel zoom has no limit."""
+
+    def __init__(self, viewer: Any) -> None:
+        super().__init__(viewer)
+        self._viewer = viewer
+        viewer.viewport().installEventFilter(self)
+
+    def eventFilter(self, watched: QObject, event: QEvent) -> bool:  # noqa: N802
+        if isinstance(event, QWheelEvent):
+            if self._pad(event):
+                self._pan(event.pixelDelta(), event.angleDelta())
+            else:
+                angle = event.angleDelta()
+                self._zoom(_WHEEL ** (angle.y() or angle.x()), event.position().toPoint())
+            return True
+        if (
+            isinstance(event, QNativeGestureEvent)
+            and event.gestureType() == Qt.NativeGestureType.ZoomNativeGesture
+        ):
+            self._zoom(1.0 + event.value(), event.position().toPoint())
+            return True
+        return False
+
+    @staticmethod
+    def _pad(ev: QWheelEvent) -> bool:
+        """A scroll from a touchpad (or any device sending pixels or phases), not zooming."""
+        if ev.modifiers() & (
+            Qt.KeyboardModifier.ControlModifier | Qt.KeyboardModifier.MetaModifier
+        ):
+            return False
+        return (
+            not ev.pixelDelta().isNull()
+            or ev.phase() != Qt.ScrollPhase.NoScrollPhase
+            or ev.pointingDevice().type() == QInputDevice.DeviceType.TouchPad
+        )
+
+    def _pan(self, pixels: QPoint, angle: QPoint) -> None:
+        """The content follows the fingers: the scene rect moves against them."""
+        dx, dy = (
+            (pixels.x(), pixels.y())
+            if not pixels.isNull()
+            else (angle.x() * _ANGLE_PX, angle.y() * _ANGLE_PX)
+        )
+        v = self._viewer
+        a, b = v.mapToScene(QPoint(0, 0)), v.mapToScene(QPoint(round(dx), round(dy)))
+        x, y, w, h = v.scene_rect()
+        v.set_scene_rect([x + a.x() - b.x(), y + a.y() - b.y(), w, h])
+
+    def _zoom(self, factor: float, at: QPoint) -> None:
+        """Scales about `at` (view pixels); a canvas past a limit may still come back."""
+        v = self._viewer
+        now = v.transform().m11()
+        lo, hi = min(_SCALE[0], now), max(_SCALE[1], now)
+        f = min(max(factor, lo / now), hi / now)
+        v.scale(f, f, v.mapToScene(at))
+
+
 class _Item(NodeItem):  # type: ignore[misc]
     """A node's drawing: a badge in the title bar, and no renaming."""
 
@@ -423,6 +497,7 @@ def __init__(self, parent: QWidget | None = None) -> None:
         self._framed = False  # the first non-empty `show` frames its nodes
 
         viewer = self._graph.viewer()
+        self._navigation = _Navigation(viewer)
         viewer.setMinimumSize(240, 160)
         for act in (viewer.qaction_for_undo(), viewer.qaction_for_redo()):
             act.setShortcuts([])  # else Ctrl+Z stops here, at an empty stack, not at the studio
@@ -614,20 +689,15 @@ def _sync(self, s: _Shown, spec: NodeSpec) -> None:
         x, y = view.xy_pos
         if abs(x - spec.at[0]) > 1e-3 or abs(y - spec.at[1]) > 1e-3:
             view.xy_pos = spec.at
-        resized = False
         for param in spec.params:
             f = s.fields[param.name]
-            opts = self._options(spec, param)
-            if f.set_options(opts):
-                resized = True
+            f.set_options(self._options(spec, param))
             want = spec.values.get(param.name)
             if (want is not None or f.optional) and not f.same(want):
                 f.set_value(want)
         if not s.fields[NOTE].same(spec.label):
             s.fields[NOTE].set_value(spec.label)
-        if resized:
-            view.draw_node()
-        view.setToolTip(spec.tip)  # after `draw_node`, which sets NodeGraphQt's own
+        view.setToolTip(spec.tip)  # NodeGraphQt sets its own when it draws the node
 
     def _tint(self, role: str) -> tuple[tuple[int, ...], tuple[int, ...]] | None:
         ink = self._roles.get(role)
 
@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+import itertools
 from collections.abc import Callable
 from pathlib import Path
 from typing import Any
@@ -22,7 +23,7 @@
 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.QtCore import QPoint, QPointF, QRectF, Qt
 from PySide6.QtTest import QTest
 from PySide6.QtWidgets import QComboBox, QDockWidget, QToolButton
 
@@ -178,6 +179,76 @@ def test_the_window_opens_the_dock(
     assert dock.height() > 2 * strip.height() and dock.geometry().bottom() < strip.geometry().top()
 
 
+def open_hosted(
+    make_window: Callable[..., Any], qtbot: Any, port_doc: PortDocument
+) -> tuple[MonsterWorkspace, BehaviourPanel]:
+    """The dock in a real `Window`, which syncs a turn after a change, over the `graph` port."""
+    own = MonsterWorkspace()
+    own.doc = port_doc
+    port_doc.edit(graph)
+    host = Hosted(own)
+    w = make_window(host)
+    host.focus = "Behaviour"
+    w.studio.changed()
+    w.sync()
+    qtbot.wait(60)
+    dock = w.findChild(QDockWidget, "monster/Behaviour")
+    assert dock is not None and isinstance(dock.widget(), BehaviourPanel)
+    return own, dock.widget()
+
+
+def applies(p: BehaviourPanel, node: str, name: str, monkeypatch: pytest.MonkeyPatch) -> list[Any]:
+    """Every value of `node.name` the view is told to draw, in order."""
+    seen: list[Any] = []
+    real = p.view._apply
+
+    def apply(nodes: Any, links: Any) -> None:
+        seen.extend(n.values[name] for n in nodes if n.id == node)
+        real(nodes, links)
+
+    monkeypatch.setattr(p.view, "_apply", apply)
+    return seen
+
+
+def test_an_accepted_edit_applies_once_in_the_window(
+    make_window: Callable[..., Any],
+    qtbot: Any,
+    port_doc: PortDocument,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    own, p = open_hosted(make_window, qtbot, port_doc)
+    seen = applies(p, "b1", "frames", monkeypatch)
+    field(p, "b1", "frames")._ctl.setValue(45)
+    qtbot.wait(80)
+    assert doc(own).manifest.behaviour.blocks["b1"].params == {"frames": 45}
+    assert seen == [45] and field(p, "b1", "frames").get_value() == 45
+
+
+def test_a_refused_edit_reverts_once_in_the_window(
+    make_window: Callable[..., Any],
+    qtbot: Any,
+    port_doc: PortDocument,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    blk = Block("host_state", (0.0, 0.0), {"mains": [0]})
+    port_doc.edit(lambda m: m.behaviour.blocks.__setitem__("b4", blk))
+    own, p = open_hosted(make_window, qtbot, port_doc)
+    before = doc(own).manifest
+    seen = applies(p, "b4", "mains", monkeypatch)
+    field(p, "b4", "mains")._ctl.menu().actions()[0].trigger()  # unticks the only main state
+    qtbot.wait(80)
+    assert doc(own).manifest is before and "main states" in own.message
+    assert seen == [[0]] and field(p, "b4", "mains").get_value() == (0,)
+
+
+def test_a_block_made_in_the_window_is_selected(
+    make_window: Callable[..., Any], qtbot: Any, port_doc: PortDocument
+) -> None:
+    own, p = open_hosted(make_window, qtbot, port_doc)
+    create(qtbot, p, KINDS["on_noticed"].title, QPoint(300, 120))
+    assert "b4" in doc(own).manifest.behaviour.blocks and p.view.selected() == ["b4"]
+
+
 def test_empty(qtbot: Any) -> None:
     p = make(qtbot, MonsterWorkspace())
     assert p.pages.currentWidget() is p.no_scene
@@ -247,6 +318,22 @@ def test_the_zinogre_opens(
     assert field(p, "b2", "hi").get_value() == 1000.0
 
 
+def test_a_new_name_keeps_every_node_size_on_the_zinogre(
+    qtbot: Any, ws: MonsterWorkspace, zinogre_toml: Path, synthetic_pac: bytes
+) -> None:
+    from mhfu_studio.monster.core.scene import Scene
+
+    zin = PortDocument.open(zinogre_toml)
+    ws.load(Scene.from_bytes(synthetic_pac, "z", path=zinogre_toml.with_suffix(".bin")), zin)
+    p = make(qtbot, ws)
+    p.view.grab()  # a paint: the fitted graph is small, and NodeGraphQt hides small nodes' widgets
+    sizes = {i: (s.view.width, s.view.height) for i, s in p.view._shown.items()}
+    flag = next(i for i, b in zin.manifest.behaviour.blocks.items() if "flag" in b.params)
+    type_name(qtbot, p, flag, "flag", "brand_new")
+    assert zin.manifest.behaviour.blocks[flag].params["flag"] == "brand_new"
+    assert {i: (s.view.width, s.view.height) for i, s in p.view._shown.items()} == sizes
+
+
 def test_spread_out_is_one_step(panel: BehaviourPanel, ws: MonsterWorkspace) -> None:
     before = doc(ws).manifest
     panel.spread.click()
@@ -256,6 +343,21 @@ def test_spread_out_is_one_step(panel: BehaviourPanel, ws: MonsterWorkspace) ->
     assert doc(ws).manifest == before
 
 
+def test_no_two_nodes_of_the_zinogre_overlap(
+    qtbot: Any, ws: MonsterWorkspace, zinogre_toml: Path, synthetic_pac: bytes
+) -> None:
+    from mhfu_studio.monster.core.scene import Scene
+
+    zin = PortDocument.open(zinogre_toml)
+    ws.load(Scene.from_bytes(synthetic_pac, "z", path=zinogre_toml.with_suffix(".bin")), zin)
+    p = make(qtbot, ws)
+    rects = {
+        i: QRectF(*n.view.xy_pos, n.view.width, n.view.height) for i, n in p.view._shown.items()
+    }
+    clash = [(a, b) for a, b in itertools.combinations(rects, 2) if rects[a].intersects(rects[b])]
+    assert clash == []
+
+
 def test_part_and_main_options(panel: BehaviourPanel, ws: MonsterWorkspace) -> None:
     doc(ws).edit(lambda m: m.behaviour.blocks.__setitem__("b4", Block("on_flinch", (0.0, 0.0))))
     panel.sync()