"""Headless smoke check for the hc package.
 
 There is no test runner in this project -- everything runs inside Houdini's
 embedded interpreter, and a broken command in the HC Panel just looks like
 "nothing happened". This catches the cheap half of that class of bug without
 launching the GUI:
 
     $HFS/bin/hython3.13 tools/check.py
 
 Run it from the repo root. It imports hc, binds every HCMaps entry (so a
 command whose method was renamed or deleted fails loudly), and exercises the
 pure logic that does not need a UI. It cannot replace testing in Houdini --
 anything touching hou.ui, panes or the network editor still has to be driven
 by hand -- but a failure here is always a real one.
 """
 
 import os
 import sys
 import time
 import types
 from pathlib import Path
 
 ROOT = Path(__file__).resolve().parent.parent
 sys.path.insert(0, str(ROOT / "python3.13libs"))
 os.environ.setdefault("HC_PATH", str(ROOT))
 
 import hou  # noqa: E402
 
 # hython has already imported `hc` from the checkout the package manifest
 # names before this script runs. In a git worktree that is the *other*
 # checkout, and every check below would silently exercise its code instead
 # of the one being edited. Drop that copy so the import below resolves
 # against ROOT.
 for _name, _mod in list(sys.modules.items()):
     if _name == "hc" or _name.startswith("hc."):
         _file = getattr(_mod, "__file__", None) or ""
         if not _file.startswith(str(ROOT / "python3.13libs")):
             del sys.modules[_name]
 
 from hc import (  # noqa: E402
     HCNetworkEditor,
     HCPane,
     HCParameterTab,
     HCPathTab,
     HCSceneViewer,
     HCSession,
     HCSettings,
     HCTab,
     hcschema,
     hcstate,
 )
 from hc import hccommands  # noqa: E402
 from hc.hcgeometryutils import merged_visible_geo  # noqa: E402
 from hc.hcmaps import HCMaps  # noqa: E402
 from hc.hcvisibility import childCategory, collect_visible_nodes  # noqa: E402
 
 
 passed = 0
 failed = 0
 
 
 def check(label, fn):
     global passed, failed
     try:
         result = fn()
     except Exception as e:
         print(f"  FAIL {label}: {type(e).__name__}: {e}")
         failed += 1
     else:
         print(f"  ok   {label}: {result}")
         passed += 1
 
 
 def blank(cls):
     """An uninitialized instance -- enough to resolve bound methods."""
     return cls.__new__(cls)
 
 
 def withTab(cls, **hou_attrs):
     """A blank wrapper around a fake hou tab answering `hou_attrs`.
 
     Binding commands evaluates each `available` predicate on the instance,
     and those read self.hou_tab -- which a blank() has not got.
     """
     instance = blank(cls)
     instance.hou_tab = types.SimpleNamespace(
         **{name: (lambda v=value: v) for name, value in hou_attrs.items()})
     return instance
 
 
 class nodeColoring:
     """Pin the node_coloring switch for one check.
 
     The maintenance checks exercise what updateNodeColors() does when it
     runs; whether it runs is the user's setting in hc_settings.json, which
     ships off since 3c95f98. Reading the file made four checks fail on a
     setting, not a bug. Use as a context manager or a decorator.
     """
 
     def __init__(self, enabled):
         self.enabled = enabled
 
     def __enter__(self):
         self.original = HCSettings.nodeColoringEnabled
         HCSettings.nodeColoringEnabled = lambda _self, enabled=self.enabled: enabled
 
     def __exit__(self, *exc):
         HCSettings.nodeColoringEnabled = self.original
 
     def __call__(self, fn):
         def wrapped():
             with self:
                 return fn()
         return wrapped
 
 
 def check_settings():
     print("settings")
     settings = HCSettings()
 
     def merged_defaults():
         # A section missing from hc_settings.json must still come back whole:
         # callers index straight into prefs()['node_graph']['node_color'].
         node_graph = HCSettings._merged(HCSettings.DEFAULTS, {"node_graph": {}})["node_graph"]
         missing = set(HCSettings.DEFAULTS["node_graph"]) - set(node_graph)
         assert not missing, f"defaults dropped: {sorted(missing)}"
         return f"{len(node_graph)} node_graph keys"
 
     check("prefs() overlays DEFAULTS", merged_defaults)
     check("nodeColor() parses the hex", lambda: settings.nodeColor())
     check("nodeShape()", lambda: settings.nodeShape())
     check("hcnetcursorEnabled()", lambda: settings.hcnetcursorEnabled())
 
     def copy_is_independent():
         original = settings.prefs()["node_graph"]["node_color"]
         settings.prefsCopy()["node_graph"]["node_color"] = "#000000"
         assert settings.prefs()["node_graph"]["node_color"] == original, \
             "prefsCopy() aliased the cache"
         return original
 
     check("prefsCopy() does not alias the cache", copy_is_independent)
 
     def cache_is_warm():
         start = time.perf_counter()
         for _ in range(2000):
             settings.prefs()
         micros = (time.perf_counter() - start) / 2000 * 1e6
         assert micros < 200, f"{micros:.0f}us per read -- cache not working"
         return f"{micros:.1f}us per read"
 
     check("prefs() is cached on the hot path", cache_is_warm)
 
     def schema_covers_the_file():
         """Every section in the shipped file must be declared in the schema.
 
         keycam used to be absent from DEFAULTS entirely, so keycam.py and
         hcguides.py had nothing to fall back on.
         """
         on_disk = set(settings.prefs())
         declared = set(hcschema.defaults())
         undeclared = on_disk - declared
         assert not undeclared, f"settings not in the schema: {sorted(undeclared)}"
         return f"{len(declared)} top-level sections"
 
     check("schema declares every section", schema_covers_the_file)
 
     def keycam_survives_a_missing_section():
         merged = HCSettings._merged(HCSettings.DEFAULTS, {"desktop_mode": "attached"})
         # The exact chains keycam.py and hcguides.py walk.
         assert merged["keycam"]["units"]["delta_r"] is not None
         assert merged["keycam"]["guides"]["axis_size"] is not None
         assert settings.keycam("units").get("delta_r") is not None
         assert settings.section("nope", "nothing") == {}, "section() must not return None"
         return "keycam reads survive an absent section"
 
     check("keycam has defaults", keycam_survives_a_missing_section)
 
     def widgets_come_from_declared_kinds():
         """delta_ow/delta_z are step magnitudes that happen to equal 1; the old
         panel guessed from the value and rendered them as checkboxes."""
         for name in ("delta_ow", "delta_z"):
             setting = hcschema.lookup(("keycam", "units", name))
             assert setting is not None, f"{name} not declared"
             assert setting.kind == "float", f"{name} is {setting.kind}, expected float"
         assert hcschema.lookup(("keycam", "guides", "bbox")).kind == "flag"
         assert hcschema.lookup(("node_graph", "hcnetcursor")).kind == "bool"
         return "step magnitudes declared float, flags declared flag"
 
     check("widget kinds are declared, not guessed", widgets_come_from_declared_kinds)
 
     def restart_flags():
         """The panel's restart notice: settings read only at startup are
         declared restart=True, and restartPending() compares the saved value
         with the snapshot uiready captured."""
         paths = hcschema.restart_paths()
         for expected in (("desktop_mode",), ("startup", "show_prompt"),
                          ("startup", "default_autosave_state"),
                          ("startup", "show_main_menu")):
             assert expected in paths, f"{expected} not declared restart-only: {paths}"
         assert all(hcschema.lookup(p).restart for p in paths)
         assert not hcschema.lookup(("node_graph", "node_shape")).restart, \
             "node_shape is read live by OnCreated.py"
         settings.captureStartupValues()
         assert settings.restartPending() == [], settings.restartPending()
         snapshot = settings.startupValues()
         snapshot["desktop_mode"] = "detached" if snapshot["desktop_mode"] == "attached" else "attached"
         try:
             assert settings.restartPending() == [("desktop_mode",)], settings.restartPending()
         finally:
             settings.captureStartupValues()
         return f"{len(paths)} restart-only settings; pending tracks the startup snapshot"
 
     check("restart-only settings", restart_flags)
 
 
 def check_commands():
     print("commands")
     maps = HCMaps()
     session, pane = blank(HCSession), blank(HCPane)
 
     for label, cls in (
         ("network editor", HCNetworkEditor),
         ("scene viewer", HCSceneViewer),
         ("details view", HCPathTab),
         ("parameters", HCParameterTab),
         ("other tabs", HCTab),
     ):
         def binds(c=cls):
             commands = maps.commands(session, pane, withTab(c, hasNetworkControls=True))
             assert commands, "no commands bound"
             for name, method in commands.items():
                 assert callable(method), f"{name} is not callable"
                 assert method.kind in hccommands.KINDS, f"{name}: kind {method.kind!r}"
             kinds = {}
             for bound in commands.values():
                 kinds[bound.kind] = kinds.get(bound.kind, 0) + 1
             return f"{len(commands)} commands ({kinds})"
 
         check(f"{label} panel binds", binds)
 
     def scoping_holds():
         """Where a command shows is the class it is declared on: Pin on
         HCPathTab reaches every path tab and no other; Replace Node stays in
         network editors. Path is the one command whose scope is a predicate,
         because plain HCTab tabs differ in whether they have a path bar."""
         for cls in (HCPathTab, HCParameterTab, HCNetworkEditor, HCSceneViewer):
             bound = maps.commands(session, pane, withTab(cls, hasNetworkControls=True))
             assert "Pin" in bound, f"{cls.__name__} lost Pin"
             assert bound["Pin"].kind == "toggle", f"{cls.__name__}: Pin is not a toggle"
             assert "Path" in bound, f"{cls.__name__} lost Path"
         other = maps.commands(session, pane, withTab(HCTab, hasNetworkControls=True))
         assert "Pin" not in other, "Pin leaked into tabs without a path"
         assert "Path" in other, "a plain tab with a path bar lost Path"
         bare = maps.commands(session, pane, withTab(HCTab, hasNetworkControls=False))
         assert "Path" not in bare, "Path offered on a tab with no path bar"
         network = maps.commands(session, pane, withTab(HCNetworkEditor, hasNetworkControls=True))
         parm = maps.commands(session, pane, withTab(HCParameterTab, hasNetworkControls=True))
         assert "Replace Node" in network, "network editors lost Replace Node"
         assert "Replace Node" not in parm, "Replace Node leaked into parameter tabs"
         return "class scope and the Path predicate hold"
 
     check("command scoping", scoping_holds)
 
     def controls_resolve():
         """Every state getter exists and every choice method takes a value.
 
         A getter named in a decorator is a string; nothing else checks it
         until the panel opens and the row's checkbox greys out.
         """
         problems = []
         for cls in (HCSession, HCPane, HCTab, HCPathTab, HCParameterTab,
                     HCNetworkEditor, HCSceneViewer):
             problems.extend(hccommands.verify(cls))
         assert not problems, "; ".join(problems)
         return "state getters and choice setters resolve"
 
     check("panel controls resolve", controls_resolve)
 
     def choices_have_values():
         """Choice commands list at least two (label, value) pairs and the
         value that reads back from the getter is one of them, or a toggle's
         getter is one the panel can coerce."""
         counted = 0
         for cls in (HCSession, HCPane, HCTab, HCNetworkEditor, HCSceneViewer):
             for label, (name, spec) in hccommands.declared(cls).items():
                 if spec.kind != "choice":
                     continue
                 assert len(spec.choices) >= 2, f"{label}: fewer than two choices"
                 values = [value for _, value in spec.choices]
                 assert len(set(values)) == len(values), f"{label}: duplicate values"
                 counted += 1
         assert counted, "no choice commands declared"
         return f"{counted} dropdowns"
 
     check("dropdown choices", choices_have_values)
 
     def state_coercion():
         """Houdini prefs are '0'/'1' strings; bool('0') is True."""
         assert hccommands.asBool("0") is False
         assert hccommands.asBool("1") is True
         assert hccommands.asBool(0) is False
         assert hccommands.asBool(2) is True
         assert hccommands.asBool(None) is False
         return "'0' reads as off"
 
     check("toggle state coercion", state_coercion)
 
     def update_mode_reads_back():
         """The Update Mode dropdown's getter returns one of its own values."""
         bound = maps.commands(session, pane, None)["Update Mode"]
         value = bound.state()
         values = [v for _, v in bound.choices]
         assert value in values, f"{value!r} not in {values}"
         return f"currently {value}"
 
     check("Update Mode state", update_mode_reads_back)
 
     def labels_are_unique():
         seen = {}
         for cls in (HCSession, HCPane, HCTab, HCPathTab, HCParameterTab,
                     HCNetworkEditor, HCSceneViewer):
             for label, (name, _) in hccommands.declared(cls).items():
                 if label in seen and seen[label] != (cls.__name__, name):
                     # Inherited commands legitimately repeat; a genuine clash is
                     # two different methods claiming one label.
                     prev_cls, prev_name = seen[label]
                     if prev_name != name:
                         raise AssertionError(
                             f"{label!r} claimed by {prev_cls}.{prev_name} and {cls.__name__}.{name}"
                         )
                 seen[label] = (cls.__name__, name)
         return f"{len(seen)} distinct labels"
 
     check("no duplicate command labels", labels_are_unique)
 
 
 def check_state():
     print("state")
 
     def scopes_differ():
         assert hcstate.PANE != hcstate.NETWORK
         store = hcstate.Store("_check_pane", hcstate.PANE)
         net = hcstate.Store("_check_network", hcstate.NETWORK)
         assert store.scope == hcstate.PANE and net.scope == hcstate.NETWORK
         return "PANE and NETWORK scopes registered"
 
     check("two declared scopes", scopes_differ)
 
     def eviction_drops_dead_panes():
         store = hcstate.Store("_check_evict", hcstate.PANE)
         store._data[999001] = "stale"
         store._data[999002] = "also stale"
         assert len(store) == 2
         store._evict(live_pane_ids={999002})
         assert len(store) == 1 and 999002 in store._data, "wrong entry evicted"
         store.clear()
         return "closed-pane entries are dropped"
 
     check("eviction", eviction_drops_dead_panes)
 
     def network_keys_separate_networks():
         store = hcstate.Store("_check_netkey", hcstate.NETWORK)
         store._data[(7, "/obj")] = "parent"
         store._data[(7, "/obj/geo1")] = "child"
         # Same pane, different network: descending must not read the parent's
         # entry. This was the selection-signature bug.
         assert store._data[(7, "/obj")] != store._data[(7, "/obj/geo1")]
         store._evict(live_pane_ids={7})
         assert len(store) == 2, "live pane entries were evicted"
         store._evict(live_pane_ids=set())
         store.clear()
         return "per-network entries stay distinct within a pane"
 
     check("network scope", network_keys_separate_networks)
 
 
 def check_chrome():
     print("chrome")
 
     def every_tab_answers():
         for cls in (HCTab, HCPathTab, HCParameterTab, HCNetworkEditor, HCSceneViewer):
             for name in ("isChromeVisible", "showChrome"):
                 assert callable(getattr(cls, name, None)), f"{cls.__name__} lacks {name}"
         return "all tab classes implement the chrome pair"
 
     check("polymorphic chrome", every_tab_answers)
 
     def overrides_extend_the_base():
         # Each override must call up, or a subclass silently drops the base
         # network-controls handling.
         import inspect
         for cls in (HCNetworkEditor, HCSceneViewer):
             for name in ("isChromeVisible", "showChrome"):
                 source = inspect.getsource(getattr(cls, name))
                 assert "super()" in source, f"{cls.__name__}.{name} does not call super()"
         return "subclass overrides chain to HCTab"
 
     check("chrome overrides chain", overrides_extend_the_base)
 
 
 def check_split_handles():
     """HCSplitHandles pinning, with fake panes standing in for hou.Pane.
 
     This is the one bit of pure-Qt UI code with logic worth testing: the
     handles used to be pinned from pane geometry Houdini had not laid out yet,
     so a dragged handle trailed its boundary and was left behind at the end.
     Needs an offscreen QApplication; skipped when Qt cannot start.
     """
     print("split handles")
     os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
     try:
         from PySide6 import QtWidgets
         from PySide6.QtCore import QRect
         app = QtWidgets.QApplication.instance() or QtWidgets.QApplication([])
     except Exception as e:
         print(f"  skip (no Qt: {type(e).__name__})")
         return
 
     import hc.hcsplithandles as sh
 
     class FakePane:
         _next = [1]
 
         def __init__(self, rect, children=None):
             self.rect = rect
             self.children = children or []
             self._id = FakePane._next[0]
             FakePane._next[0] += 1
 
         def id(self):
             return self._id
 
         def qtScreenGeometry(self):
             return self.rect
 
         def getSplitChild(self, i):
             if i < len(self.children):
                 return self.children[i]
             raise IndexError(i)
 
     main = QtWidgets.QWidget()
     main.setGeometry(0, 0, 1000, 800)
     main.show()
 
     def centre(handle):
         # `main` is a real top-level widget wherever the WM put it, so compare
         # in the screen space _pin computes in.
         return main.mapToGlobal(handle.geometry().center())
 
     left = FakePane(QRect(0, 0, 400, 800))
     right = FakePane(QRect(400, 0, 600, 800))
     split = FakePane(QRect(0, 0, 1000, 800), [left, right])
 
     mgr = sh.HCSplitHandles.__new__(sh.HCSplitHandles)
     mgr.main, mgr.handles, mgr._filter, mgr._tracker = main, [], None, None
     handle = sh._SplitHandle(main, split, horizontal_boundary=False, manager=mgr)
     mgr.handles.append(handle)
 
     def pins_to_the_boundary():
         mgr._pin(handle)
         x = centre(handle).x()
         assert abs(x - 400) <= 1, f"centred at {x}, expected ~400"
         return f"centre x={x}, boundary at 400"
 
     check("pins to the boundary", pins_to_the_boundary)
 
     def follows_a_boundary_moved_elsewhere():
         before = handle.geometry()
         left.rect = QRect(0, 0, 700, 800)
         right.rect = QRect(700, 0, 300, 800)
         mgr._pin(handle)
         assert handle.geometry() != before, "handle did not follow the boundary"
         x = centre(handle).x()
         assert abs(x - 700) <= 1, f"centred at {x}, expected ~700"
         return f"followed 400 -> {x}"
 
     check("follows a boundary moved elsewhere", follows_a_boundary_moved_elsewhere)
 
     def idle_tick_does_nothing():
         mgr._pin(handle)
         before = handle.geometry()
         calls = []
         original = handle.setGeometry
         handle.setGeometry = lambda *a: (calls.append(a), original(*a))[1]
         for _ in range(10):
             mgr._pin(handle)
         handle.setGeometry = original
         assert not calls, f"setGeometry called {len(calls)}x with nothing changed"
         assert handle.geometry() == before
         return "10 ticks, 0 widget writes"
 
     check("unchanged tick is free", idle_tick_does_nothing)
 
     def dragging_handle_is_left_alone():
         handle._origin = object()
         assert handle.isDragging()
         left.rect = QRect(0, 0, 200, 800)
         right.rect = QRect(200, 0, 800, 800)
         before = handle.geometry()
         mgr._pin_all()
         assert handle.geometry() == before, "_pin_all fought a handle mid-drag"
         handle._origin = None
         mgr._pin_all()
         x = centre(handle).x()
         assert abs(x - 200) <= 1, f"centred at {x}, expected ~200"
         return "skipped mid-drag, pinned on release"
 
     check("mid-drag handle is skipped", dragging_handle_is_left_alone)
 
     def handle_is_a_native_window():
         """Without its own X window the handle can be seen but never clicked.
 
         Houdini renders its UI into one QOpenGLWidget backed by a native
         QWindow, and on xcb a native window owns mouse input across its area.
         A plain QWidget sibling painted on top receives nothing -- the press
         goes to the GL surface, where Houdini hit-tests its own split bars.
         """
         from PySide6.QtCore import Qt
         assert handle.testAttribute(Qt.WA_NativeWindow), \
             "split handle is not a native window; clicks will fall through to Houdini"
         assert handle.internalWinId(), "native window was never created"
         return f"native, winId set"
 
     check("handle owns an X window", handle_is_a_native_window)
 
     def horizontal_boundary():
         top = FakePane(QRect(0, 0, 1000, 300))
         bottom = FakePane(QRect(0, 300, 1000, 500))
         vsplit = FakePane(QRect(0, 0, 1000, 800), [top, bottom])
         h = sh._SplitHandle(main, vsplit, horizontal_boundary=True, manager=mgr)
         mgr.handles.append(h)
         mgr._pin(h)
         y = centre(h).y()
         assert abs(y - 300) <= 1, f"centred at y={y}, expected ~300"
         g = h.geometry()
         assert g.width() > g.height(), "a horizontal boundary wants a wide handle"
         return f"centre y={y}, {g.width()}x{g.height()}"
 
     check("horizontal boundary", horizontal_boundary)
 
 
 
 def check_nodegraph_hooks():
     """nodegraphhooks subclasses Houdini classes it cannot import here.
 
     nodegraphbase is only importable inside Houdini's UI, so this reads both
     sources with ast instead. It exists because dropping an argument was
     invisible every other way: _PendingSelectionSyncAction lost the __init__
     that supplied `delay`, its base requires it with no default, and the
     resulting TypeError came out of createEventHandler on every mousedown.
     Houdini discards the event when the hook raises, so clicking a node did
     nothing -- with no traceback anywhere the test suite could see.
     """
     print("nodegraph hooks")
     import ast
 
     hfs = os.environ.get("HFS", "/opt/hfs")
     base_src = Path(hfs) / "houdini" / "python3.13libs" / "nodegraphbase.py"
     hooks_src = ROOT / "python3.13libs" / "nodegraphhooks.py"
 
     if not base_src.is_file():
         print(f"  skip (no nodegraphbase.py at {base_src})")
         return
 
     def classes(tree):
         return {n.name: n for n in ast.walk(tree) if isinstance(n, ast.ClassDef)}
 
     def required_args(cls_node):
         """Positional params of __init__ with no default, excluding self."""
         for item in cls_node.body:
             if isinstance(item, ast.FunctionDef) and item.name == "__init__":
                 args = item.args.args[1:]
                 return len(args) - len(item.args.defaults), True
         return None, False   # no __init__ of its own
 
     base_classes = classes(ast.parse(base_src.read_text()))
     hooks_tree = ast.parse(hooks_src.read_text())
     hook_classes = classes(hooks_tree)
 
     def base_of(node):
         for b in node.bases:
             if isinstance(b, ast.Attribute):
                 return b.attr
             if isinstance(b, ast.Name):
                 return b.id
         return None
 
     def verify(name, node, base_name):
         needed, own = required_args(node)
         if not own:
             needed, _ = required_args(base_classes[base_name])
         assert needed is not None, f"cannot determine {base_name}.__init__ arity"
 
         calls = [n for n in ast.walk(hooks_tree)
                  if isinstance(n, ast.Call) and isinstance(n.func, ast.Name)
                  and n.func.id == name]
         assert calls, f"{name} is never instantiated"
         for call in calls:
             given = len(call.args) + len(call.keywords)
             assert given >= needed, (
                 f"{name}(...) at line {call.lineno} passes {given} argument(s) "
                 f"but {base_name}.__init__ requires {needed}"
             )
         return f"{len(calls)} call site(s), {needed} required arg(s) from {base_name}"
 
     subclasses = [(n, node, base_of(node)) for n, node in hook_classes.items()
                   if base_of(node) in base_classes]
     if not subclasses:
         print("  skip (no nodegraphbase subclasses found)")
         return
     for name, node, base_name in subclasses:
         # Through check(), so a mismatch is a reported failure rather than a
         # traceback that takes the rest of the suite with it.
         check(f"{name} constructor arity",
               lambda n=name, nd=node, b=base_name: verify(n, nd, b))
 
     def one_mouseup_completer():
         """Houdini finishes pending actions with `for action in list: if
         action.completeAction(ev): list.remove(action)` -- removal while
         iterating, which skips the entry after the removed one. Two hc actions
         completing on the same mouseup never both ran on it: the drop swap
         lingered behind the grid sweep and fired on a later mouseup with a
         stale start position, so swaps only worked some of the time. Whatever
         runs after a mouse action has to share one class."""
         completers = []
         for name, node in hook_classes.items():
             for item in node.body:
                 if isinstance(item, ast.FunctionDef) and item.name == "completeAction":
                     if "mouseup" in ast.unparse(item):
                         completers.append(name)
         assert len(completers) == 1, \
             f"{len(completers)} pending actions complete on mouseup: {completers}"
         return f"only {completers[0]} completes on mouseup"
 
     check("one mouseup completer", one_mouseup_completer)
 
 
 def check_open_recent():
     print("open recent")
     from hc import hcsession
 
     def history_parses_newest_first():
         text = "HIP\n{\n/a/one.hip\n/b/two.hip\n/a/one.hip\n/c/three.hip\n}\nOTL\n{\n/x/lib.hda\n}\n"
         got = hcsession.parseFileHistory(text)
         assert got == ["/c/three.hip", "/a/one.hip", "/b/two.hip"], got
         assert hcsession.parseFileHistory("") == []
         return "newest first, deduplicated, OTL block ignored"
 
     check("file.history parser", history_parses_newest_first)
 
     def recent_files_exist():
         files = HCSession().recentHipFiles()
         assert all(Path(f).is_file() for f in files), files
         return f"{len(files)} recent hips on disk"
 
     check("recentHipFiles() only lists existing files", recent_files_exist)
 
 
 def check_status_circle():
     """The status circle's menu is built from the main-menu XML files with
     everything Python cannot run filtered out."""
     print("status circle")
     from hc import hcstatusbar
     import lxml.etree as ET
 
     def state_is_wellformed():
         state, minutes = hcstatusbar.hipState()
         assert state in ("saved", "unsaved", "autosave"), state
         assert isinstance(minutes, int)
         return f"{state}, {minutes} min"
 
     check("hipState()", state_is_wellformed)
 
     def menu_documents_are_runnable():
         files = hcstatusbar.mainMenuXMLFiles()
         assert files, "no MainMenuCommon.xml on the path"
         total = 0
         for path in files:
             xml = hcstatusbar._menuDocument(path)
             root = ET.fromstring(xml)
             assert root.tag == "menuDocument" and root[0].tag == "menu", path
             ids = [a.get("id") for a in root.iter("actionItem")]
             assert set(ids) <= set(hcstatusbar.ACTION_SYMBOLS), f"{path}: unmapped {ids}"
             assert not list(root.iter("toggleItem")), f"{path}: toggleItem left in"
             total += len(list(root.iter("scriptItem"))) + len(ids)
         base = ET.parse([f for f in files if f.startswith(hou.getenv("HFS"))][0]).getroot()
         declared = {a.get("id") for a in base.iter("actionItem")}
         missing = set(hcstatusbar.ACTION_SYMBOLS) - declared
         assert not missing, f"mapped symbols not in Houdini's menu: {sorted(missing)}"
         return f"{total} runnable items across {len(files)} files"
 
     check("menu XML filtered to runnable items", menu_documents_are_runnable)
 
     def circle_is_a_native_window():
         """Same lesson as the split handles: over Houdini's GL window a plain
         child widget is painted but never clicked."""
         from PySide6.QtCore import Qt
         circle = hcstatusbar.StatusCircle()
         try:
             assert circle.testAttribute(Qt.WA_NativeWindow), "status circle is not a native window"
             assert circle.internalWinId(), "native window was never created"
             assert not circle.mask().isEmpty(), "no window mask; native corners would show black"
         finally:
             circle.deleteLater()
         return "native, winId set, masked"
 
     check("circle owns an X window", circle_is_a_native_window)
 
 
 def check_geometry():
     """The visible-geometry walk, after HCNode was removed from under it."""
     print("geometry")
 
     obj = hou.node("/obj")
     shown_a = obj.createNode("geo", "chk_a")
     shown_a.createNode("box").setDisplayFlag(True)
     shown_b = obj.createNode("geo", "chk_b")
     shown_b.createNode("box").setDisplayFlag(True)
     shown_b.parmTuple("t").set((10, 0, 0))
     hidden = obj.createNode("geo", "chk_hidden")
     hidden.createNode("box").setDisplayFlag(True)
     hidden.setDisplayFlag(False)
     camera = obj.createNode("cam", "chk_cam")
 
     def category_handles_leaves():
         # HCNode.childCat() called .name() on childTypeCategory() with no guard,
         # so asking a SOP what it contains raised AttributeError on None.
         assert childCategory(obj) == "Object"
         assert childCategory(shown_a) == "Sop"
         leaf = shown_a.children()[0]
         assert childCategory(leaf) == "", "a childless node should report ''"
         return "Object / Sop / '' for a leaf"
 
     check("childCategory", category_handles_leaves)
 
     visible = collect_visible_nodes(obj.children())
 
     def walk_skips_hidden_and_cameras():
         parents = {n.parent().name() for n in visible}
         assert "chk_hidden" not in parents, "hidden object contributed geometry"
         assert "chk_cam" not in parents, "camera contributed geometry"
         assert parents >= {"chk_a", "chk_b"}, f"displayed objects missing: {parents}"
         return f"{len(visible)} display nodes, hidden and camera skipped"
 
     check("collect_visible_nodes", walk_skips_hidden_and_cameras)
 
     def transform_flag_is_honoured():
         world = merged_visible_geo(visible, apply_world_transform=True)
         local = merged_visible_geo(visible, apply_world_transform=False)
         assert len(world.points()) == len(local.points()), "point counts diverged"
         # chk_b sits at x=10; only the world-space merge should reach it.
         assert world.boundingBox().maxvec()[0] > 9, "world transform not applied"
         assert local.boundingBox().maxvec()[0] < 2, "world transform applied when off"
         return f"{len(world.points())} points merged, transform opt-in"
 
     check("merged_visible_geo", transform_flag_is_honoured)
 
     for node in (shown_a, shown_b, hidden, camera):
         node.destroy()
 
 
 def check_node_ops():
     print("node operations")
 
     def replace_rewires():
         """The rewire in HCNetworkEditor.replaceNode, minus the UI."""
         geo = hou.node("/obj").createNode("geo")
         source = geo.createNode("box")
         old = geo.createNode("mountain")
         sink = geo.createNode("null")
         old.setInput(0, source)
         sink.setInput(0, old)
 
         new = geo.createNode("twist")
         new.setPosition(old.position())
         for index, upstream in enumerate(old.inputs()):
             if upstream is not None:
                 new.setInput(index, upstream)
         for downstream in list(old.outputs()):
             for conn in downstream.inputConnections():
                 if conn.inputNode() == old:
                     downstream.setInput(conn.inputIndex(), new)
         new.setDisplayFlag(old.isDisplayFlagSet())
         new.setRenderFlag(old.isRenderFlagSet())
         new.bypass(old.isBypassed())
         new.setTemplateFlag(old.isTemplateFlagSet())
         new.setColor(old.color())
         old_tag = old.userData("hc_custom_color")
         if old_tag is None:
             new.destroyUserData("hc_custom_color", must_exist=False)
         else:
             new.setUserData("hc_custom_color", old_tag)
         old.destroy()
 
         assert sink.inputs()[0] == new, "downstream lost its input"
         assert new.inputs()[0] == source, "upstream was not reconnected"
         assert len(geo.children()) == 3, "the replaced node outlived the swap"
         geo.destroy()
         return "inputs and outputs preserved"
 
     check("replaceNode rewire", replace_rewires)
 
     def update_mode_toggles():
         before = hou.updateModeSetting()
         target = (hou.updateMode.AutoUpdate if before == hou.updateMode.Manual
                   else hou.updateMode.Manual)
         hou.setUpdateMode(target)
         after = hou.updateModeSetting()
         hou.setUpdateMode(before)
         assert after == target, "update mode did not change"
         return f"{before.name()} -> {after.name()}"
 
     check("toggleUpdateMode", update_mode_toggles)
 
     def snap_lands_on_grid():
         """OnCreated.py and HCNetworkEditor must agree on where the grid is."""
         node_graph = HCSettings().nodeGraph()
         step_x = max(node_graph.get("grid_x_step", 2.0), 0.25)
         step_y = max(node_graph.get("grid_y_step", 1.0), 0.25)
         offset_x = node_graph.get("node_center_offset_x", 0.5)
         offset_y = node_graph.get("node_center_offset_y", 0.15)
 
         position = hou.Vector2(3.7, 2.3)
         snapped = hou.Vector2(
             round((position[0] + offset_x) / step_x) * step_x - offset_x,
             round((position[1] + offset_y) / step_y) * step_y - offset_y,
         )
         for center, step, axis in (
             (snapped[0] + offset_x, step_x, "x"),
             (snapped[1] + offset_y, step_y, "y"),
         ):
             assert abs(center / step - round(center / step)) < 1e-9, \
                 f"{axis} center is off grid"
         return f"step ({step_x}, {step_y}): {tuple(position)} -> {tuple(snapped)}"
 
     check("new-node grid snap", snap_lands_on_grid)
 
     def snap_prefs_follow_the_setting():
         """Houdini's Snap to Grid only captures within `snapradius`, so hard
         snapping is that radius pushed past half a grid step, with node-to-node
         snapping off so it cannot win instead. Off must hand back Houdini's
         own defaults, not leave the wide radius behind."""
         from hc import hcnetworkeditor as ne
 
         setting = hcschema.lookup(("node_graph", "grid_snap"))
         assert setting is not None and setting.kind == "bool", "grid_snap is not a bool setting"
         assert setting.default is True, "grid_snap must default on"
 
         class FakePane:
             def id(self):
                 return 987654
 
         class FakeTab:
             def __init__(self):
                 self.prefs = {}
 
             def pane(self):
                 return FakePane()
 
             def setPref(self, name, value):
                 self.prefs[name] = value
 
         max_half_step = max(setting.range[1] for setting in (
             hcschema.lookup(("node_graph", "grid_x_step")),
             hcschema.lookup(("node_graph", "grid_y_step")))) / 2.0
         assert float(ne.SNAP_PREFS_HARD["snapradius"]) > max_half_step, \
             "hard snap radius does not cover the widest grid step"
         assert ne.SNAP_PREFS_HARD["dosnapping"] == "0", "node snapping must be off in hard mode"
 
         original = HCSettings.nodeGraph
         seen = {}
         try:
             for hard in (True, False):
                 HCSettings.nodeGraph = lambda _self, hard=hard: {"grid_snap": hard}
                 tab = FakeTab()
                 editor = ne.HCNetworkEditor(tab)
                 editor._syncSnapPrefs()
                 wanted = ne.SNAP_PREFS_HARD if hard else ne.SNAP_PREFS_SOFT
                 assert tab.prefs == wanted, f"grid_snap={hard}: wrote {tab.prefs}, wanted {wanted}"
                 # Same wanted set again must not write: this runs on every event.
                 tab.prefs.clear()
                 editor._syncSnapPrefs()
                 assert tab.prefs == {}, f"grid_snap={hard}: rewrote prefs with nothing changed"
                 seen[hard] = wanted["snapradius"]
         finally:
             HCSettings.nodeGraph = original
         return f"radius {seen[True]} on, {seen[False]} off; no rewrite when unchanged"
 
     check("snap prefs follow grid_snap", snap_prefs_follow_the_setting)
 
     def sweep_snaps_the_network():
         """The post-action sweep nodegraphhooks queues: every off-grid node in
         the displayed network lands on the grid, nodes already there are left
         alone, and it is gated on grid_snap."""
         from hc import hcnetworkeditor as ne
 
         geo = hou.node("/obj").createNode("geo")
         try:
             nodes = [geo.createNode("null") for _ in range(3)]
             offsets = (hou.Vector2(0.37, 0.21), hou.Vector2(-1.13, 0.48), hou.Vector2(0, 0))
 
             class FakePane:
                 def id(self):
                     return 987655
 
             class FakeTab:
                 def pane(self):
                     return FakePane()
 
                 def setPref(self, name, value):
                     pass
 
                 def pwd(self):
                     return geo
 
             editor = ne.HCNetworkEditor(FakeTab())
             for node, offset in zip(nodes, offsets):
                 editor.snapToGrid(node)
                 node.setPosition(node.position() + offset)
             off_before = sum(not editor._isOnGrid(n.position()) for n in nodes)
             assert off_before == 2, f"expected 2 nodes off grid to start, got {off_before}"
 
             original = HCSettings.gridSnapEnabled
             try:
                 HCSettings.gridSnapEnabled = lambda _self: False
                 assert editor.sweepToGrid() == 0, "sweep ran with grid_snap off"
                 HCSettings.gridSnapEnabled = lambda _self: True
                 moved = editor.sweepToGrid()
             finally:
                 HCSettings.gridSnapEnabled = original
             assert moved == 2, f"sweep moved {moved} nodes, wanted 2"
             assert all(editor._isOnGrid(n.position()) for n in nodes), "a node is still off grid"
             assert editor.sweepToGrid() == 0, "a second sweep still moved nodes"
             return "2 of 3 snapped, none on the second pass, nothing with grid_snap off"
         finally:
             geo.destroy()
 
     check("post-action sweep", sweep_snaps_the_network)
 
     def drop_swaps_positions():
         """swapDroppedNode: a node dragged into another node's cell sends
         that node to the cell it left. Same cell only, nearest wins when
         cells overlap, wiring untouched, gated on drop_swap."""
         from hc import hcnetworkeditor as ne
 
         geo = hou.node("/obj").createNode("geo")
         try:
             a = geo.createNode("null", "a")
             b = geo.createNode("null", "b")
             c = geo.createNode("null", "c")
             b.setInput(0, a)
 
             class FakePane:
                 def id(self):
                     return 987658
 
             class FakeTab:
                 def pane(self):
                     return FakePane()
 
                 def setPref(self, name, value):
                     pass
 
                 def pwd(self):
                     return geo
 
                 def flashMessage(self, *args):
                     pass
 
             editor = ne.HCNetworkEditor(FakeTab())
             step = editor._gridStep()
             for node, cell in ((a, (0, 0)), (b, (1, 0)), (c, (3, 0))):
                 node.setPosition(hou.Vector2(cell[0] * step[0], cell[1] * step[1]))
                 editor.snapToGrid(node)
             a_start, b_start, c_start = a.position(), b.position(), c.position()
 
             # Simulate the drag: a lands exactly on b's cell.
             a.setPosition(b_start)
             assert editor.swapDroppedNode(a.path(), (a_start[0], a_start[1])) == b, "b was not displaced"
             assert b.position().isAlmostEqual(a_start), f"b went to {b.position()}, not {a_start}"
             assert a.position().isAlmostEqual(b_start), "the dragged node must stay where it was dropped"
             # a fed b, so they trade places in the chain: b now feeds a.
             assert a.inputs() == (b,) and not b.inputs(), \
                 f"linked pair did not swap places: a<-{a.inputs()}, b<-{b.inputs()}"
             assert c.position().isAlmostEqual(c_start), "a bystander moved"
 
             # No movement, or a drop on an empty cell, swaps nothing.
             assert editor.swapDroppedNode(a.path(), (b_start[0], b_start[1])) is None, "swapped without a move"
             a.setPosition(hou.Vector2(c_start[0] - 2 * step[0], c_start[1]))
             assert editor.swapDroppedNode(a.path(), (b_start[0], b_start[1])) is None, "swapped on an empty cell"
 
             original = HCSettings.dropSwapEnabled
             try:
                 HCSettings.dropSwapEnabled = lambda _self: False
                 a.setPosition(c_start)
                 assert editor.swapDroppedNode(a.path(), (b_start[0], b_start[1])) is None, "swapped with drop_swap off"
             finally:
                 HCSettings.dropSwapEnabled = original
             return "a onto b: b takes a's cell and a's place in the chain; no-ops for no move, empty cell, setting off"
         finally:
             geo.destroy()
 
     check("drop to swap", drop_swaps_positions)
 
     def linked_swap_trades_chain_places():
         """P -> X -> Y -> Q with a side output X -> Z and a second input W -> Y:
         dropping Y onto X must give P -> Y -> X -> Q, Y -> Z, W -> X. Unlinked
         nodes only trade cells, and a node that cannot take the inputs it
         would inherit leaves the wiring alone."""
         from hc import hcnetworkeditor as ne
 
         geo = hou.node("/obj").createNode("geo")
         try:
             P, W, Z, Q = (geo.createNode("null", n) for n in ("P", "W", "Z", "Q"))
             X = geo.createNode("merge", "X")
             Y = geo.createNode("merge", "Y")
             X.setInput(0, P)
             Y.setInput(0, X)
             Y.setInput(1, W)
             Z.setInput(0, X)
             Q.setInput(0, Y)
 
             class FakePane:
                 def id(self):
                     return 987659
 
             class FakeTab:
                 def __init__(self):
                     self.flashed = []
 
                 def pane(self):
                     return FakePane()
 
                 def setPref(self, name, value):
                     pass
 
                 def pwd(self):
                     return geo
 
                 def flashMessage(self, image, message, duration):
                     self.flashed.append(message)
 
             tab = FakeTab()
             editor = ne.HCNetworkEditor(tab)
             step = editor._gridStep()
             for node, cell in ((P, (0, 2)), (X, (0, 1)), (Y, (0, 0)), (Q, (0, -1)),
                                (W, (1, 1)), (Z, (1, 0))):
                 node.setPosition(hou.Vector2(cell[0] * step[0], cell[1] * step[1]))
                 editor.snapToGrid(node)
             x_start, y_start = X.position(), Y.position()
 
             def wiring(node):
                 return sorted((c.inputIndex(), c.inputItem().name()) for c in node.inputConnections())
 
             Y.setPosition(x_start)  # the drag: Y dropped onto X
             assert editor.swapDroppedNode(Y.path(), (y_start[0], y_start[1])) == X
             assert X.position().isAlmostEqual(y_start), "X did not take Y's cell"
             assert wiring(Y) == [(0, "P")], f"Y should inherit X's input P, has {wiring(Y)}"
             assert wiring(X) == [(0, "Y"), (1, "W")], f"X should take Y's place, has {wiring(X)}"
             assert wiring(Z) == [(0, "Y")], f"X's side output should now come from Y, has {wiring(Z)}"
             assert wiring(Q) == [(0, "X")], f"Y's output should now come from X, has {wiring(Q)}"
             assert not tab.flashed, f"unexpected message: {tab.flashed}"
 
             # Unlinked: W onto Z trades cells only.
             w_start, z_start = W.position(), Z.position()
             W.setPosition(z_start)
             assert editor.swapDroppedNode(W.path(), (w_start[0], w_start[1])) == Z
             assert Z.position().isAlmostEqual(w_start)
             assert wiring(Z) == [(0, "Y")] and wiring(X) == [(0, "Y"), (1, "W")], "unlinked swap touched wiring"
 
             # Infeasible: Q (one input) onto X (which now has two inputs) would
             # hand Q two inputs. Cells swap, wiring stays, and it says why.
             q_start, x_now = Q.position(), X.position()
             Q.setPosition(x_now)
             assert editor.swapDroppedNode(Q.path(), (q_start[0], q_start[1])) == X
             assert X.position().isAlmostEqual(q_start), "cells should still swap"
             assert wiring(X) == [(0, "Y"), (1, "W")] and wiring(Q) == [(0, "X")], "infeasible swap changed wiring"
             assert tab.flashed and "too few inputs" in tab.flashed[-1], f"no explanation: {tab.flashed}"
             return "P->Y->X->Q with Y->Z and W->X; unlinked pair keeps wiring; infeasible pair explained"
         finally:
             geo.destroy()
 
     check("linked swap trades chain places", linked_swap_trades_chain_places)
 
     def keyboard_step_swaps_too():
         """translateSelectedNodes (the alt+hjkl moves): a lone selected node
         stepped onto a neighbour's cell swaps with it like a drop does; two
         nodes stepping onto empty cells just move."""
         from hc import hcnetworkeditor as ne
 
         geo = hou.node("/obj").createNode("geo")
         try:
             a = geo.createNode("null", "a")
             b = geo.createNode("null", "b")
             c = geo.createNode("null", "c")
             b.setInput(0, a)
 
             class FakePane:
                 def id(self):
                     return 987660
 
             class FakeTab:
                 def __init__(self):
                     self.view = hou.BoundingRect(-20.0, -20.0, 20.0, 20.0)
 
                 def pane(self):
                     return FakePane()
 
                 def setPref(self, name, value):
                     pass
 
                 def pwd(self):
                     return geo
 
                 def itemRect(self, node):
                     pos = node.position()
                     return hou.BoundingRect(pos[0], pos[1], pos[0] + 1.0, pos[1] + 0.3)
 
                 def visibleBounds(self):
                     return hou.BoundingRect(self.view)
 
                 def setVisibleBounds(self, bounds, *args):
                     self.view = hou.BoundingRect(bounds)
 
                 def flashMessage(self, *args):
                     pass
 
             editor = ne.HCNetworkEditor(FakeTab())
             editor.updateCurrentNodeOverlay = lambda force=False: None
             step = editor._gridStep()
             for node, cell in ((a, (0, 1)), (b, (0, 0)), (c, (2, 0))):
                 node.setPosition(hou.Vector2(cell[0] * step[0], cell[1] * step[1]))
                 editor.snapToGrid(node)
             a_start, b_start, c_start = a.position(), b.position(), c.position()
 
             a.setSelected(True, clear_all_selected=True)
             editor.translateSelectedNodes("down")  # a steps onto b
             assert a.position().isAlmostEqual(b_start), f"a should be on b's old cell, is at {a.position()}"
             assert b.position().isAlmostEqual(a_start), f"b should take a's old cell, is at {b.position()}"
             assert a.inputs() == (b,) and not b.inputs(), "linked pair did not trade chain places"
             assert c.position().isAlmostEqual(c_start), "a bystander moved"
 
             # Two nodes stepping onto empty cells: both just move.
             a.setSelected(True, clear_all_selected=True)
             b.setSelected(True)
             a_pos, b_pos = a.position(), b.position()
             editor.translateSelectedNodes("right")
             assert a.position().isAlmostEqual(a_pos + hou.Vector2(step[0], 0.0))
             assert b.position().isAlmostEqual(b_pos + hou.Vector2(step[0], 0.0))
             assert c.position().isAlmostEqual(c_start), "a group move swapped with a bystander"
             return "lone step onto a neighbour swaps cells and chain; a group step onto empty cells only moves"
         finally:
             geo.destroy()
 
     check("keyboard step swaps too", keyboard_step_swaps_too)
 
     def group_step_reorders_chain():
         """A selection stepped onto a bystander sends it to the cell the
         group freed and through the chain: P -> a -> b -> c -> Q with {a, b}
         stepped down onto c gives P -> c -> a -> b -> Q, c in a's old cell.
         Runs are per line: {a, b} stepped right onto c and d, one each in
         their rows, swaps the pairs independently."""
         from hc import hcnetworkeditor as ne
 
         geo = hou.node("/obj").createNode("geo")
         try:
             P, a, b, c, Q = (geo.createNode("null", n) for n in ("P", "a", "b", "c", "Q"))
             a.setInput(0, P); b.setInput(0, a); c.setInput(0, b); Q.setInput(0, c)
 
             class FakePane:
                 def id(self):
                     return 987661
 
             class FakeTab:
                 def __init__(self):
                     self.view = hou.BoundingRect(-20.0, -20.0, 20.0, 20.0)
 
                 def pane(self):
                     return FakePane()
 
                 def setPref(self, name, value):
                     pass
 
                 def pwd(self):
                     return geo
 
                 def itemRect(self, node):
                     pos = node.position()
                     return hou.BoundingRect(pos[0], pos[1], pos[0] + 1.0, pos[1] + 0.3)
 
                 def visibleBounds(self):
                     return hou.BoundingRect(self.view)
 
                 def setVisibleBounds(self, bounds, *args):
                     self.view = hou.BoundingRect(bounds)
 
                 def flashMessage(self, *args):
                     pass
 
             editor = ne.HCNetworkEditor(FakeTab())
             editor.updateCurrentNodeOverlay = lambda force=False: None
             step = editor._gridStep()
 
             def place(node, cell):
                 node.setPosition(hou.Vector2(cell[0] * step[0], cell[1] * step[1]))
                 editor.snapToGrid(node)
 
             for node, cell in ((P, (0, 4)), (a, (0, 3)), (b, (0, 2)), (c, (0, 1)), (Q, (0, 0))):
                 place(node, cell)
             start = {n: n.position() for n in (P, a, b, c, Q)}
             a.setSelected(True, clear_all_selected=True)
             b.setSelected(True)
             editor.translateSelectedNodes("down")
             assert a.position().isAlmostEqual(start[b]) and b.position().isAlmostEqual(start[c]), "the group did not step"
             assert c.position().isAlmostEqual(start[a]), f"c should take a's old cell, is at {c.position()}"
             assert P.position().isAlmostEqual(start[P]) and Q.position().isAlmostEqual(start[Q]), "a bystander moved"
             chain = [Q]
             while chain[-1].inputs() and chain[-1].inputs()[0] is not None:
                 chain.append(chain[-1].inputs()[0])
             assert [n.name() for n in chain] == ["Q", "b", "a", "c", "P"], [n.name() for n in chain]
             assert not P.inputs() and P.outputs() == (c,), "P lost its output"
 
             # Two rows, one bystander each: each run of one swaps with its own.
             d = geo.createNode("null", "d")
             for node, cell in ((a, (0, 1)), (b, (0, 0)), (c, (1, 1)), (d, (1, 0)), (P, (5, 5)), (Q, (5, 6))):
                 place(node, cell)
             for n in (a, b, c, d, P, Q):
                 for i in range(len(n.inputs())):
                     n.setInput(i, None)
             c.setInput(0, a); d.setInput(0, b)
             a.setSelected(True, clear_all_selected=True)
             b.setSelected(True)
             a_pos, b_pos, c_pos, d_pos = a.position(), b.position(), c.position(), d.position()
             editor.translateSelectedNodes("right")
             assert a.position().isAlmostEqual(c_pos) and c.position().isAlmostEqual(a_pos), "row 1 did not swap"
             assert b.position().isAlmostEqual(d_pos) and d.position().isAlmostEqual(b_pos), "row 0 did not swap"
             assert a.inputs() == (c,) and b.inputs() == (d,) and not c.inputs() and not d.inputs(), "rows did not trade chain places"
             return "{a, b} onto c: c takes a's cell and the head of the chain; rows swap independently"
         finally:
             geo.destroy()
 
     check("group step reorders the chain", group_step_reorders_chain)
 
     def excise_heals_the_chain():
         """exciseNode (alt+x): the current node leaves its chain, its
         consumers take its feed, and it steps to the nearest free cell on
         its right, still current. With nothing feeding it the consumers are
         unplugged."""
         from hc import hcnetworkeditor as ne
 
         geo = hou.node("/obj").createNode("geo")
         try:
             P, N, Q, R, S = (geo.createNode("null", n) for n in ("P", "N", "Q", "R", "S"))
             N.setInput(0, P); Q.setInput(0, N); R.setInput(0, N)
 
             class FakePane:
                 def id(self):
                     return 987662
 
             class FakeTab:
                 def pane(self):
                     return FakePane()
 
                 def setPref(self, name, value):
                     pass
 
                 def pwd(self):
                     return geo
 
                 def flashMessage(self, *args):
                     pass
 
             editor = ne.HCNetworkEditor(FakeTab())
             step = editor._gridStep()
 
             def place(node, cell):
                 node.setPosition(hou.Vector2(cell[0] * step[0], cell[1] * step[1]))
                 editor.snapToGrid(node)
 
             for node, cell in ((P, (0, 3)), (N, (0, 2)), (S, (1, 2)), (Q, (0, 1)), (R, (1, 1))):
                 place(node, cell)
             two_right = N.position() + hou.Vector2(2 * step[0], 0.0)
             N.setCurrent(True, clear_all_selected=True)
             editor.exciseNode()
             assert Q.inputs() == (P,) and R.inputs() == (P,), "consumers did not take N's feed"
             assert not N.inputs() and not N.outputs(), "N still wired"
             assert N.position().isAlmostEqual(two_right), f"N should skip S's cell, is at {N.position()}"
             assert N.isCurrent() and geo.selectedChildren() == (N,), "N is not the current node"
 
             P.setCurrent(True, clear_all_selected=True)
             editor.exciseNode()
             assert Q.inputs() == () and R.inputs() == (), "consumers of an unfed node were not unplugged"
             return "P -> N -> {Q, R} became P -> {Q, R}, N two cells right past S; unfed P unplugs its consumers"
         finally:
             geo.destroy()
 
     check("excise heals the chain", excise_heals_the_chain)
 
     def pans_reach_the_editor():
         """hou.NetworkEditor.setVisibleBounds drops a change that keeps the
         zoom unless set_center_when_scale_rejected is passed (the docs say
         the reverse; measured live). Every pan in the package funnels through
         setBounds, so that one call must pass it -- with it missing, the
         cursor follow, centerOnCursor and translateView were all no-ops."""
         from hc import hcnetworkeditor as ne
 
         class FakePane:
             def id(self):
                 return 987656
 
         class FakeTab:
             def __init__(self):
                 self.calls = []
                 self.view = hou.BoundingRect(0.0, 0.0, 10.0, 5.0)
 
             def pane(self):
                 return FakePane()
 
             def setPref(self, name, value):
                 pass
 
             def visibleBounds(self):
                 return hou.BoundingRect(self.view)
 
             def setVisibleBounds(self, bounds, *args):
                 self.calls.append((hou.BoundingRect(bounds), args))
                 self.view = hou.BoundingRect(bounds)
 
         tab = FakeTab()
         editor = ne.HCNetworkEditor(tab)
         editor.updateCurrentNodeOverlay = lambda force=False: None
 
         # A cursor rect just past the right edge: a pure pan, zoom unchanged.
         editor._frameRectInView(hou.BoundingRect(11.0, 2.0, 12.0, 3.0))
         assert len(tab.calls) == 1, f"expected one pan, got {len(tab.calls)}"
         bounds, args = tab.calls[0]
         assert args and args[-1] is True, \
             f"pan called setVisibleBounds{(bounds,) + args}: the same-zoom flag is missing"
         assert abs(bounds.size()[0] - 10.0) < 1e-9, "a follow pan must not change the zoom"
         assert bounds.max()[0] >= 12.0, f"view {bounds} does not reach the cursor"
         return "same-zoom flag passed; follow pan keeps zoom and reaches the cursor"
 
     check("pans reach the editor", pans_reach_the_editor)
 
     def initial_cursor_anchors_on_the_editor_current_node():
         """After a hip load no child has the current flag, but the editor still
         names the file's current node; the initial cursor must anchor there,
         not on the node nearest the view centre."""
         from hc import hcnetworkeditor as ne
 
         geo = hou.node("/obj").createNode("geo")
         try:
             near = geo.createNode("null", "near")
             far = geo.createNode("null", "far")
             near.setPosition(hou.Vector2(0.0, 0.0))
             far.setPosition(hou.Vector2(20.0, 20.0))
             assert not far.isCurrent() and not near.isCurrent(), "a fresh node is already current"
 
             class FakePane:
                 def id(self):
                     return 987657
 
             class FakeTab:
                 def __init__(self, current):
                     self.current = current
 
                 def pane(self):
                     return FakePane()
 
                 def setPref(self, name, value):
                     pass
 
                 def pwd(self):
                     return geo
 
                 def currentNode(self):
                     return self.current
 
                 def visibleBounds(self):
                     # Centred on `near`, so the nearest-node fallback would pick it.
                     return hou.BoundingRect(-5.0, -5.0, 5.0, 5.0)
 
             state = ne.HCNetworkEditor(FakeTab(far))._initialHcnetcursorState()
             rect = ne.HCNetworkEditor(FakeTab(far))._hcnetcursorRectFromState(state)
             assert rect.contains(far.position() + hou.Vector2(0.5, 0.15)), \
                 f"cursor {rect} is not over the editor's current node at {far.position()}"
 
             # The editor naming the network itself, or a node elsewhere, is no anchor.
             for stale in (geo, hou.node("/obj")):
                 state = ne.HCNetworkEditor(FakeTab(stale))._initialHcnetcursorState()
                 rect = ne.HCNetworkEditor(FakeTab(stale))._hcnetcursorRectFromState(state)
                 assert rect.contains(near.position() + hou.Vector2(0.5, 0.15)), \
                     f"with editor current {stale.path()} the cursor went to {rect}, not the nearest node"
             return "anchors on the editor's current child; falls back to nearest otherwise"
         finally:
             geo.destroy()
 
     check("initial cursor anchor after load", initial_cursor_anchors_on_the_editor_current_node)
 
     def pwd_is_a_real_node():
         """HCPathTab.pwd() returned an HCNode with no path(), so path() -- and
         the Show Path Message command through it -- raised AttributeError."""
         import inspect
         from hc import HCPathTab
         source = inspect.getsource(HCPathTab.pwd)
         assert "HCNode" not in source, "pwd() is wrapping again"
         node = hou.node("/obj")
         assert callable(node.path) and node.path() == "/obj"
         return "pwd() hands back a hou.Node"
 
     check("pwd returns a hou.Node", pwd_is_a_real_node)
 
 
 def check_panel():
     print("settings panel")
 
     def pypanel_name_matches():
         """The interface name lives in two files. If they drift, the pypanel
         still registers and the tab still opens from the pane tab menu, but
         HCSession.openSettings() silently stops finding it and floats a second
         copy on every invocation."""
         import xml.etree.ElementTree as ET
         from hc.hcsettings import HCSettingsPanel
         path = ROOT / "python_panels" / "hc_settings.pypanel"
         assert path.exists(), f"missing {path}"
         names = [e.get("name") for e in ET.parse(path).getroot().iter("interface")]
         assert HCSettingsPanel.INTERFACE_NAME in names, \
             f"INTERFACE_NAME {HCSettingsPanel.INTERFACE_NAME!r} not in {names}"
         return f"{HCSettingsPanel.INTERFACE_NAME!r} declared in both"
 
     check("pypanel interface name", pypanel_name_matches)
 
     def panel_is_not_a_dialog():
         """A QDialog reparented into a pane tab keeps dialog behaviour (it can
         swallow Esc and close itself out of the tab). onCreateInterface() has
         to hand Houdini a plain QWidget."""
         from PySide6.QtWidgets import QDialog, QWidget
         from hc.hcsettings import HCSettingsPanel
         assert issubclass(HCSettingsPanel, QWidget), "panel is not a QWidget"
         assert not issubclass(HCSettingsPanel, QDialog), "panel is a QDialog again"
         return "HCSettingsPanel is a plain QWidget"
 
     check("panel base class", panel_is_not_a_dialog)
 
 
 def check_node_colors():
     """The rule updateNodeColors() enforces: HC owns a node's color only while
     the node still wears the color HC last wrote to it."""
     print("node colors")
 
     from hc.hcsettings import colorsMatch, formatHex, parseHex
     settings = HCSettings()
 
     def hex_round_trips():
         assert parseHex("#607070") == parseHex("607070"), "the # is not optional"
         assert formatHex(parseHex("#607070")) == "#607070", "round trip lost the value"
         assert formatHex(hou.Color((1.0, 0.0, 0.0))) == "#ff0000", "hou.Color not handled"
         for junk in ("", "#ff", "blue", "#gggggg", None):
             assert parseHex(junk) is None, f"{junk!r} parsed as a color"
         return "parse/format agree, junk rejected"
 
     check("hex helpers", hex_round_trips)
 
     def every_color_default_parses():
         """A `color` whose default is not a color hands the panel, and every
         caller, a fallback that is itself broken."""
         found = []
 
         def walk(schema, path):
             for key, value in schema.items():
                 if isinstance(value, dict):
                     walk(value, path + (key,))
                 elif value.kind == "color":
                     assert parseHex(value.default) is not None, \
                         f"{'.'.join(path + (key,))} default {value.default!r} is not a color"
                     found.append(".".join(path + (key,)))
 
         walk(hcschema.SCHEMA, ())
         assert found, "no color settings declared"
         return ", ".join(found)
 
     check("color defaults", every_color_default_parses)
 
     def fallback_is_per_setting():
         """Each color falls back to its own declared default, not a shared one."""
         arrow = ("node_graph", "current_node_arrow_color")
         node = ("node_graph", "node_color")
         assert settings.colorHex(*arrow) != settings.colorHex(*node), \
             "two colors resolved to the same value"
         for path in (arrow, node):
             declared = hcschema.lookup(path).default
             # A key absent from the file must still resolve to its own default.
             assert formatHex(parseHex(declared)) == settings.colorHex(*path), \
                 f"{path[-1]} did not resolve to its declared default"
         # The arrow color has to still be the value it was hardcoded to.
         assert colorsMatch(settings.color(*arrow), hou.Color((0.38, 0.56, 0.56))), \
             "the arrow color moved when it was pulled into the schema"
         return f"{settings.colorHex(*arrow)} arrow, {settings.colorHex(*node)} node"
 
     check("per-setting color fallback", fallback_is_per_setting)
 
     def bad_hex_falls_back_to_schema():
         # Not to a second hardcoded color: the fallback has to be the value the
         # settings panel shows for a missing key.
         schema_default = hcschema.lookup(("node_graph", "node_color")).default
         assert HCSettings._merged(
             HCSettings.DEFAULTS, {"node_graph": {}}
         )["node_graph"]["node_color"] == schema_default, "defaults drifted"
         assert settings.nodeColorHex() == formatHex(settings.nodeColorRGB()), \
             "nodeColorHex and nodeColorRGB disagree"
         return f"schema default {schema_default}"
 
     check("nodeColor fallback", bad_hex_falls_back_to_schema)
 
     RED = hou.Color((1.0, 0.0, 0.0))
     GREEN = hou.Color((0.0, 1.0, 0.0))
 
     @nodeColoring(True)
     def only_unchanged_nodes_are_recolored():
         default = settings.nodeColor()
         default_hex = settings.nodeColorHex()
         geo = hou.node("/obj").createNode("geo")
 
         managed = geo.createNode("box")
         managed.setUserData("hc_custom_color", default_hex)
         managed.setColor(default)
 
         hand = geo.createNode("box")
         hand.setUserData("hc_custom_color", default_hex)
         hand.setColor(RED)  # recolored since HC last wrote it
 
         untagged = geo.createNode("box")
         untagged.destroyUserData("hc_custom_color", must_exist=False)
         untagged.setColor(GREEN)
 
         legacy = geo.createNode("box")
         legacy.setUserData("hc_custom_color", "1")  # pre-record tag
         legacy.setColor(GREEN)
 
         blank(HCSession).updateNodeColors()
 
         assert colorsMatch(managed.color(), default), "managed node was not maintained"
         assert colorsMatch(hand.color(), RED), "hand-picked color was reverted"
         assert colorsMatch(untagged.color(), GREEN), "untagged node was recolored"
         assert colorsMatch(legacy.color(), default), "legacy '1' tag was not adopted"
         assert legacy.userData("hc_custom_color") == default_hex, \
             "legacy tag was not upgraded to the color record"
 
         geo.destroy()
         return "hand-picked colors survive, legacy tags adopted"
 
     check("updateNodeColors ownership", only_unchanged_nodes_are_recolored)
 
     @nodeColoring(True)
     def second_pass_writes_nothing():
         """Every setColor marks the hip modified, and 456.py runs this on load."""
         geo = hou.node("/obj").createNode("geo")
         node = geo.createNode("box")
         node.setUserData("hc_custom_color", "1")
         node.setColor(RED)
 
         session = blank(HCSession)
         first = session.updateNodeColors()
         second = session.updateNodeColors()
         assert first >= 1, "the node needing a recolor was not counted"
         assert second == 0, f"{second} redundant write(s) on an unchanged scene"
 
         geo.destroy()
         return "idempotent: no writes when nothing changed"
 
     check("updateNodeColors is idempotent", second_pass_writes_nothing)
 
     @nodeColoring(True)
     def opting_out_is_reversible():
         """Set Node Colors / Reset Node Colors, minus the UI.
 
         Dropping the tag has to be undoable by hand, or coloring one node is a
         one-way door out of the setting.
         """
         default = settings.nodeColor()
         default_hex = settings.nodeColorHex()
         geo = hou.node("/obj").createNode("geo")
         node = geo.createNode("box")
         session = blank(HCSession)
 
         # Set Node Colors: an explicit color, tag dropped.
         node.setColor(RED)
         node.destroyUserData("hc_custom_color", must_exist=False)
         session.updateNodeColors()
         assert colorsMatch(node.color(), RED), "opting out did not stick"
 
         # Reset Node Colors: default color, tag re-recorded.
         node.setColor(default)
         node.setUserData("hc_custom_color", default_hex)
         session.updateNodeColors()
         assert colorsMatch(node.color(), default), "reset node was not maintained"
         assert node.userData("hc_custom_color") == default_hex, "reset lost the tag"
 
         geo.destroy()
         return "opt out, then opt back in"
 
     check("resetNodeColors round trip", opting_out_is_reversible)
 
     @nodeColoring(True)
     def recolor_is_one_undo():
         """A scene-wide recolor must cost one ctrl-Z, not one per node."""
         if not hou.undos.areEnabled():
             return "skipped: undos disabled in this interpreter"
 
         geo = hou.node("/obj").createNode("geo")
         nodes = []
         for _ in range(3):
             node = geo.createNode("box")
             node.setUserData("hc_custom_color", "1")
             node.setColor(RED)
             nodes.append(node)
 
         session = blank(HCSession)
         hou.undos.clear()
         session.updateNodeColors()
 
         labels = hou.undos.undoLabels()
         assert len(labels) == 1, f"{len(labels)} undo entries for one recolor: {labels}"
 
         # And an unchanged scene must not leave an empty entry behind.
         session.updateNodeColors()
         assert hou.undos.undoLabels() == labels, \
             f"a no-op pass pushed an undo entry: {hou.undos.undoLabels()}"
 
         hou.undos.performUndo()
         assert all(colorsMatch(n.color(), RED) for n in nodes), \
             "one undo did not revert every node"
 
         geo.destroy()
         return f"3 nodes, 1 undo entry ({labels[0]})"
 
     check("updateNodeColors undo grouping", recolor_is_one_undo)
 
 
 def check_current_node():
     """HCNetworkEditor.currentNode() has to answer with the node that is
     current *now*, inside the displayed network.
 
     hou.NetworkEditor.currentNode() answers with the editor's last-known
     current node instead. It keeps naming a node after that node stops being
     current, and it falls back to the network itself when the editor has no
     current child there. So Rename Node and the flag toggles could act on
     whatever had been current a moment ago, and at /obj -- where the fallback
     applies -- the off-screen arrow never drew at all, its guard
     `current.parent() != pwd()` reducing to `pwd().parent() != pwd()`.
 
     The staleness lives in the editor, so it cannot be reproduced without a
     pane. What is checkable here is the rule the fix rests on: read isCurrent()
     off the children, and answer None when none of them is current. currentNode()
     only touches hou_tab.pwd(), so a stub tab is enough to drive it.
     """
     print("current node")
 
     class _StubTab:
         def __init__(self, node):
             self._node = node
 
         def pwd(self):
             return self._node
 
     def finds_the_current_child():
         geo = hou.node("/obj").createNode("geo")
         a = geo.createNode("box")
         b = geo.createNode("sphere")
         editor = blank(HCNetworkEditor)
         editor.hou_tab = _StubTab(geo)
 
         b.setCurrent(True, clear_all_selected=True)
         found = editor.currentNode()
         assert found == b, f"expected the current child, got {found}"
         assert found != geo, "handed back the network itself"
 
         a.setCurrent(True, clear_all_selected=True)
         assert editor.currentNode() == a, "did not follow the current node"
 
         geo.destroy()
         return "follows the current child"
 
     check("currentNode finds the child", finds_the_current_child)
 
     def current_implies_selected():
         """currentNode() looks through selectedChildren() first, which is only
         a fast path as long as the current node is always in there."""
         geo = hou.node("/obj").createNode("geo")
         a = geo.createNode("box")
         b = geo.createNode("sphere")
 
         a.setCurrent(True, clear_all_selected=True)
         assert a.isSelected(), "setCurrent did not select"
 
         # Selecting another node moves current with it...
         b.setSelected(True)
         assert b.isCurrent() and not a.isCurrent(), "current did not follow selection"
 
         # ...and deselecting clears it, so there is no current-but-unselected
         # node for the fast path to miss.
         b.setSelected(False)
         assert not b.isCurrent(), "a deselected node stayed current"
 
         for node in (a, b):
             node.setCurrent(True, clear_all_selected=True)
             assert node in geo.selectedChildren(), (
                 "the current node is not in selectedChildren -- the fast path "
                 "in HCNetworkEditor.currentNode() is no longer sufficient"
             )
 
         geo.destroy()
         return "current is always selected, so the fast path suffices"
 
     check("current implies selected", current_implies_selected)
 
     def empty_network_is_none():
         geo = hou.node("/obj").createNode("geo")
         editor = blank(HCNetworkEditor)
         editor.hou_tab = _StubTab(geo)
         assert editor.currentNode() is None, \
             "an empty network reported a current node"
         geo.destroy()
         return "None, not the network"
 
     check("currentNode on an empty network", empty_network_is_none)
 
     def nothing_current_is_none():
         """The headless stand-in for the editor's staleness: children exist,
         none of them is current, so the answer is None rather than a leftover."""
         geo = hou.node("/obj").createNode("geo")
         node = geo.createNode("box")
         editor = blank(HCNetworkEditor)
         editor.hou_tab = _StubTab(geo)
 
         node.setCurrent(True, clear_all_selected=True)
         assert editor.currentNode() == node, "precondition: the node is current"
 
         node.setSelected(False)  # also clears current
         assert not node.isCurrent(), "precondition: nothing is current now"
         assert editor.currentNode() is None, \
             "answered with a node that is no longer current"
 
         geo.destroy()
         return "None once nothing is current"
 
     check("currentNode goes None", nothing_current_is_none)
 
     def no_network_is_none():
         """pwd() can be None -- seen live while floating pane tabs were being
         created and closed -- and the overlay reached currentNode() through
         the event hook, which raised on every event until the editor had a
         network again."""
         editor = blank(HCNetworkEditor)
         editor.hou_tab = _StubTab(None)
         assert editor.currentNode() is None, "answered without a network"
         return "None without a network"
 
     check("currentNode without a network", no_network_is_none)
 
     def overlay_skips_without_network():
         """The stub has pwd() and nothing else: touching the editor to draw
         raises AttributeError, so returning quietly is the only way through."""
         editor = blank(HCNetworkEditor)
         editor.hou_tab = _StubTab(None)
         editor.updateCurrentNodeOverlay()
         editor.updateCurrentNodeOverlay(force=True)
         return "draws nothing"
 
     check("overlay without a network", overlay_skips_without_network)
 
     def hook_skips_without_network():
         """The event hook lets the event through untouched rather than
         reading a network the editor has not got. nodegraphhooks cannot be
         imported without hou.ui (Houdini's nodegraphbase needs it at import),
         so this reads the source: the guard has to come before the hook
         wraps the editor."""
         source = (ROOT / "python3.13libs" / "nodegraphhooks.py").read_text()
         body = source[source.index("def createEventHandler("):]
         guard = body.find("editor.pwd() is None")
         wrap = body.find("HCNetworkEditor(editor)")
         assert guard != -1, "the hook no longer checks for a missing network"
         assert wrap != -1 and guard < wrap, "the hook wraps the editor before checking its network"
         return "guard precedes the wrapper"
 
     check("hook without a network", hook_skips_without_network)
 
     def guards_stay_gone():
         """The `current.parent()` guards only fired in the fallback case, and
         threw the answer away when they did. currentNode() now returns a child
         of pwd() or None, so there is nothing left for them to check."""
         source = (ROOT / "python3.13libs" / "hc" / "hcnetworkeditor.py").read_text()
         for gone in ("current.parent() != ed.pwd()",
                      "current.parent() == self.hou_tab.pwd()"):
             assert gone not in source, f"the guard {gone!r} is back"
         # One reader of the editor's answer is allowed: _editorCurrentChild,
         # the post-load fallback anchor for the hcnetcursor, which documents
         # that it is reading a possibly stale value and only uses it when it
         # is a child of pwd(). Nothing else may bypass the wrapper.
         import ast
         tree = ast.parse(source)
         readers = set()
         for func in ast.walk(tree):
             if isinstance(func, ast.FunctionDef):
                 if "self.hou_tab.currentNode()" in ast.unparse(func):
                     readers.add(func.name)
         assert readers <= {"_editorCurrentChild"}, \
             f"callers bypass the wrapper and get the editor's stale answer: {sorted(readers)}"
         return "only _editorCurrentChild reads the editor's answer"
 
     check("guards stay gone", guards_stay_gone)
 
 
 def check_disable_switches():
     """Both features have to be switchable off, all the way off.
 
     hcnetcursor was already declared and already honoured by the drawing code,
     but nodegraphhooks kept moving the invisible cursor and kept swallowing the
     unmodified f key -- so "off" left f doing nothing instead of Houdini's
     frame-selection.
     """
     print("disable switches")
 
     settings = HCSettings()
 
     def both_are_declared():
         for key in ("node_coloring", "hcnetcursor"):
             setting = hcschema.lookup(("node_graph", key))
             assert setting is not None, f"node_graph.{key} is not declared"
             assert setting.kind == "bool", f"{key} is {setting.kind}, not a checkbox"
             assert setting.default is True, f"{key} defaults off -- it must default on"
         return "node_coloring and hcnetcursor, both bool, both default on"
 
     check("declared and default on", both_are_declared)
 
     def coloring_off_is_a_no_op():
         geo = hou.node("/obj").createNode("geo")
         node = geo.createNode("box")
         node.setUserData("hc_custom_color", "1")   # would be recolored
         node.setColor(hou.Color((1.0, 0.0, 0.0)))
 
         session = blank(HCSession)
         with nodeColoring(False):
             assert session.updateNodeColors() == 0, "recolored while switched off"
             assert node.userData("hc_custom_color") == "1", "rewrote the tag while off"
 
         # And the tag is still there, so turning it back on resumes.
         with nodeColoring(True):
             assert session.updateNodeColors() >= 1, "did not resume when switched on"
         geo.destroy()
         return "no writes while off, resumes after"
 
     check("node_coloring off", coloring_off_is_a_no_op)
 
     def hooks_gate_on_the_setting():
         """The hook runs per UI event and cannot be driven without a pane, so
         read the structure instead: every hcnetcursor call it makes has to sit
         under an `if` that tests the setting."""
         import ast
 
         source = (ROOT / "python3.13libs" / "nodegraphhooks.py").read_text()
         tree = ast.parse(source)
 
         def calls_under(node):
             """Names of hcnetcursor methods called anywhere beneath node."""
             out = set()
             for sub in ast.walk(node):
                 if isinstance(sub, ast.Call) and isinstance(sub.func, ast.Attribute):
                     if "hcnetcursor" in sub.func.attr.lower():
                         out.add(sub.func.attr)
             return out
 
         cursor_calls = calls_under(tree)
         # updateCurrentNodeOverlay is deliberately ungated: it is what removes
         # the cursor image when the setting is turned off, and it also draws
         # the off-screen arrow, which has nothing to do with the cursor.
         must_gate = {"moveHcnetcursorToPosition", "fitHcnetcursorToSelectedNodes",
                      "frameHcnetcursor", "refreshHcnetcursor"}
         present = cursor_calls & must_gate
         assert present, f"no cursor calls found to check, only {sorted(cursor_calls)}"
 
         gated = set()
         for node in ast.walk(tree):
             # Calls inside `if ...hcnetcursorEnabled...:`
             if isinstance(node, ast.If) and "hcnetcursorEnabled" in ast.unparse(node.test):
                 gated |= calls_under(node)
             # ...or anywhere in a function that opens with an early-return guard.
             if isinstance(node, ast.FunctionDef):
                 for stmt in node.body:
                     if (isinstance(stmt, ast.If)
                             and "hcnetcursorEnabled" in ast.unparse(stmt.test)
                             and any(isinstance(b, ast.Return) for b in stmt.body)):
                         gated |= calls_under(node)
                         break
 
         # refreshHcnetcursor sits in the modifier-change branch and is a redraw,
         # not a cursor move -- it is allowed through like updateCurrentNodeOverlay.
         required = present - {"refreshHcnetcursor"}
         missing = required - gated
         assert not missing, f"not gated on hcnetcursorEnabled: {sorted(missing)}"
         return "gated: " + ", ".join(sorted(required))
 
     check("hcnetcursor off", hooks_gate_on_the_setting)
 
     def accessors_read_the_file():
         for name in ("nodeColoringEnabled", "hcnetcursorEnabled"):
             assert getattr(settings, name)() in (True, False), f"{name} is not a bool"
         return "both accessors return bools"
 
     check("accessors", accessors_read_the_file)
 
 
 def check_cursor_image():
     """The network cursor picture is painted on demand, in the set colour."""
     print("network cursor image")
     import tempfile
     from hc import hcnetcursorimage
 
     def painted_to_spec():
         from PySide6.QtGui import QImage
         with tempfile.TemporaryDirectory() as tmp:
             path = os.path.join(tmp, "hcnetcursor_3x2_a1b2c3.png")
             hcnetcursorimage.paint(path, 600, 200, "#a1b2c3")
             image = QImage(path)
             assert (image.width(), image.height()) == (600, 200), \
                 f"{image.width()}x{image.height()}"
             edge = image.pixelColor(2, 100)
             assert edge.name() == "#a1b2c3" and edge.alpha() == 255, \
                 f"edge {edge.name()} a={edge.alpha()}"
             inside = image.pixelColor(300, 100)
             assert inside.alpha() == 0, f"centre alpha {inside.alpha()}"
             just_in = image.pixelColor(hcnetcursorimage.BORDER, 100)
             assert just_in.alpha() == 0, "outline wider than BORDER"
         return "600x200, 5px outline, transparent inside"
 
     check("painted to spec", painted_to_spec)
 
     def cached_per_colour():
         a = hcnetcursorimage.image_file(1, 1, "#d8b34b")
         b = hcnetcursorimage.image_file(1, 1, "#D8B34B")
         c = hcnetcursorimage.image_file(1, 1, "#000000")
         assert a == b, "colour case made a second file"
         assert a != c, "different colours share a file"
         assert os.path.exists(a) and os.path.exists(c)
         assert hcnetcursorimage.image_file(1.99, 0.99, "#d8b34b").endswith("_199x99_d8b34b.png"), \
             "picture not sized by the box in units"
         assert hcnetcursorimage.image_file(40, 1, "#d8b34b").endswith("_2400x100_d8b34b.png"), \
             "oversize cursor not clamped"
         return os.path.dirname(a)
 
     check("one file per size and colour", cached_per_colour)
 
     def old_paths_recognised():
         """Hips saved with the cursor showing still name the retired asset dir."""
         assert hcnetcursorimage.is_cursor_image(
             "/x/hou-control/config/hcnetcursor_assets/hcnetcursor_2x1.png")
         assert hcnetcursorimage.is_cursor_image(
             hcnetcursorimage.image_file(1, 1, "#d8b34b"))
         assert not hcnetcursorimage.is_cursor_image("/x/backdrop.png")
         assert not (ROOT / "config" / "hcnetcursor_assets").exists(), \
             "static asset set is still checked in"
         return "old and new paths both filtered out"
 
     check("stale cursor images are filtered", old_paths_recognised)
 
     def settings_declared():
         for key in ("hcnetcursor", "hcnetcursor_color", "hcnetcursor_margin"):
             setting = hcschema.lookup(("node_graph", key))
             assert setting is not None, f"{key} missing"
             assert setting.group == "Network Cursor", f"{key} in {setting.group!r}"
         assert hcschema.lookup(("node_graph", "hcnetcursor")).label == "Network Cursor"
         settings = HCSettings()
         assert settings.hcnetcursorColorHex().startswith("#")
         low, high = hcschema.lookup(("node_graph", "hcnetcursor_margin")).range
         assert low <= settings.hcnetcursorMargin() <= high
         return f"colour {settings.hcnetcursorColorHex()}, margin {settings.hcnetcursorMargin()}"
 
     check("cursor settings", settings_declared)
 
 
 def check_view_regions():
     """What hcviewregions sends the compositor for one window."""
     print("view regions")
     from hc.hcviewregions import HCViewRegions
 
     def empty_is_drag_nowhere():
         """No view panes must not be sent as `clear`: to the compositor that
         word restores the whole-window drag, which is what turned a swipe
         over the HC Panel into a row pick."""
         args = HCViewRegions.wire([])
         assert args == ["0,0,0,0"], args
         assert "clear" not in args
         return "zero-area rect, not clear"
 
     check("no panes sends a zero-area rect", empty_is_drag_nowhere)
 
     def rects_are_integers():
         args = HCViewRegions.wire([(10.6, 20.2, 300.9, 400.1), (0, 0, 5, 5)])
         assert args == ["10,20,300,400", "0,0,5,5"], args
         return "x,y,w,h per rect"
 
     check("rect wire format", rects_are_integers)
 
     def publishes_are_reaped():
         """A `ccectl` child nobody waited on sat as a zombie under
         houdini-bin for sixteen minutes (2026-09-15): CPython reaps a dropped
         Popen only when the next one is made, and the next publish is the
         next layout change. Stand in for ccectl with a script that exits and
         one that hangs, and drive publish/reap by hand."""
         import os
         import stat
         import tempfile
         import time
         from hc import hcviewregions
 
         def stand_in(tmp, name, body):
             path = os.path.join(tmp, name)
             with open(path, "w") as f:
                 f.write("#!/bin/sh\n" + body + "\n")
             os.chmod(path, os.stat(path).st_mode | stat.S_IXUSR)
             return path
 
         def zombie(proc):
             try:
                 with open(f"/proc/{proc.pid}/stat") as f:
                     return f.read().rsplit(")", 1)[1].split()[0] == "Z"
             except OSError:
                 return False
 
         def drain(vr):
             deadline = time.monotonic() + 5
             while vr.reap() and time.monotonic() < deadline:
                 time.sleep(0.01)
 
         with tempfile.TemporaryDirectory() as tmp:
             vr = HCViewRegions()
             vr._exe = stand_in(tmp, "ccectl-exits", "exit 0")
             vr.publish(1, [])
             assert len(vr._pending) == 1, vr._pending
             proc = vr._pending[0][0]
             drain(vr)
             assert not vr._pending, "finished publish not reaped"
             assert proc.returncode == 0, proc.returncode
             assert not zombie(proc), "reaped child is still a zombie"
 
             # A hung child is left alone until it outlives PUBLISH_TIMEOUT,
             # then killed and collected on a later reap.
             vr._exe = stand_in(tmp, "ccectl-hangs", "sleep 60")
             vr.publish(2, [])
             proc, started = vr._pending[0]
             assert vr.reap(started + 1) == 1, "live child dropped"
             assert proc.poll() is None, "live child killed early"
             vr.reap(started + hcviewregions.PUBLISH_TIMEOUT + 1)
             drain(vr)
             assert not vr._pending, "killed child never collected"
             assert proc.returncode not in (None, 0), proc.returncode
             assert not zombie(proc), "killed child is still a zombie"
         return "poll on tick, kill after timeout"
 
     check("publishes are reaped", publishes_are_reaped)
 
 
 def check_startup_script():
     """scripts/123.py reads hc_settings.json without importing hc.
 
     That is deliberate -- an exception in a startup script costs the whole
     launch -- but it means the file carries its own fallbacks instead of going
     through HCSettings and its DEFAULTS merge, and those can drift. They had:
     123.py fell back to default_autosave_state=False while the schema declared
     True. Importing the module here would run the startup logic, so read the
     literals out of the source instead.
     """
     print("startup script")
 
     import ast
 
     def fallbacks_match_the_schema():
         path = ROOT / "scripts" / "123.py"
         tree = ast.parse(path.read_text())
         declared = None
         for node in tree.body:
             if isinstance(node, ast.Assign) and any(
                     getattr(t, "id", None) == "_DEFAULTS" for t in node.targets):
                 declared = ast.literal_eval(node.value)
         assert declared, "123.py no longer declares a _DEFAULTS dict"
 
         for key, value in declared.items():
             setting = hcschema.lookup(("startup", key))
             assert setting is not None, f"startup.{key} is not declared in hcschema"
             assert setting.default == value, (
                 f"123.py falls back to startup.{key}={value!r}, "
                 f"hcschema says {setting.default!r}"
             )
         return f"{len(declared)} fallback(s) agree with hcschema"
 
     check("123.py fallbacks", fallbacks_match_the_schema)
 
     def prompt_is_gated_on_the_setting():
         """The dialog must not be constructed when show_prompt is off."""
         source = (ROOT / "scripts" / "123.py").read_text()
         assert 'show_prompt' in source, "123.py does not read show_prompt"
         assert source.count("StartupPrompt(last_file)") == 1, \
             "more than one path constructs the dialog"
         # The only construction site has to sit under the gate.
         gate = source.index("if show_prompt:")
         assert gate < source.index("StartupPrompt(last_file)"), \
             "the dialog is built before the show_prompt gate"
         return "the dialog is built only under the gate"
 
     check("startup prompt gate", prompt_is_gated_on_the_setting)
 
     def post_load_script_calls_real_methods():
         """scripts/456.py runs after every hip load and, like 123.py, cannot
         be imported here without running it. Every HCSession method it names
         must exist -- a rename would only surface as a traceback on the next
         file open -- and the hcnetcursor reset must be among them: without it
         the node under the cursor sat unhighlighted after a load."""
         path = ROOT / "scripts" / "456.py"
         tree = ast.parse(path.read_text())
         called = set()
         for node in ast.walk(tree):
             if (isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute)
                     and isinstance(node.func.value, ast.Call)
                     and getattr(node.func.value.func, "id", None) == "HCSession"):
                 called.add(node.func.attr)
         assert called, "456.py no longer calls HCSession()"
         missing = sorted(name for name in called if not callable(getattr(HCSession, name, None)))
         assert not missing, f"456.py calls HCSession methods that do not exist: {missing}"
         assert "resetHcnetcursorsDeferred" in called, "456.py does not reset the hcnetcursor after a load"
         return "calls " + ", ".join(sorted(called))
 
     check("456.py calls real methods", post_load_script_calls_real_methods)
 
 
 def main():
     check_settings()
     check_panel()
     check_commands()
     check_state()
     check_chrome()
     check_split_handles()
     check_nodegraph_hooks()
     check_open_recent()
     check_status_circle()
     check_geometry()
     check_node_ops()
     check_node_colors()
     check_current_node()
     check_disable_switches()
     check_cursor_image()
     check_view_regions()
     check_startup_script()
     print(f"\n{passed} passed, {failed} failed")
     return 1 if failed else 0
 
 
 if __name__ == "__main__":
     sys.exit(main())