macos/codeeditapp-codeedit/tests/test_ax_structure.py

"""AX STRUCTURE tests for CodeEdit (app.codeedit.CodeEdit).

Generated ONLY from verifier/recon.md (## APP / ## PRIMITIVES / ## AX_TREE / ## STRUCTURE).

Lane contract
-------------
* 4 pure-existence GATE tests (jump_kind="none", depth=0): the fresh-launch surfaces that
  must exist — the welcome window + its 3 named action buttons, the recent-projects
  AXOutline + role diversity, the AXMenuBar with its 10 named menus, and the welcome
  window's interactive-widget inventory + AX tree depth.
* 11 shape-delta REACH tests (jump_kind="reach"), one per row of recon's
  `Shape-delta pairs` table, each proved with kit.rb_showing() before/after ONE navigation
  chain and kit.rb_reach() as the assertion, plus the SPECIFIC named widgets recon recorded.
* 4 of the reach tests are depth>=2 (workspace -> editor text area, workspace -> inspector
  pane, workspace -> navigator hide/restore, Settings -> "Text Editing" pane detail).

Environment constraints honoured (recon "ENVIRONMENT CONSTRAINTS")
------------------------------------------------------------------
* no plain keystrokes / Escape anywhere — sheets and panels are dismissed with their own
  "Cancel" button (dismiss_panel_or_sheet),
* CG clicks (never AXPress) for SwiftUI list rows, Settings sidebar panes and workspace
  toolbar buttons,
* none of the forbidden controls is ever pressed (Quit, Close Workspace, Check for
  updates.../Check Now, Install, Contributors, Help items, Locations path buttons,
  Discard All Changes...).
"""

# ── PRIMITIVES (copied VERBATIM from recon.md ## PRIMITIVES) ─────────────────
import json
import os
import shutil
import subprocess
import time

import pytest

import rb_testgen_kit as kit
import verifier_helpers as helpers

RESULTS_DIR = os.environ.get("RESULTS_DIR", os.path.join(os.path.dirname(__file__), "results"))
FIXTURES_DIR = os.environ.get("FIXTURES_DIR") or os.path.join(os.path.dirname(__file__), "fixtures")


def screenshot_assert(test_name, description, results_dir=None):
    results_dir = results_dir or RESULTS_DIR
    ss_dir = os.path.join(results_dir, "screenshots")
    os.makedirs(ss_dir, exist_ok=True)
    ss_path = os.path.join(ss_dir, f"{test_name}.png")
    try:
        subprocess.run(["screencapture", "-x", ss_path], timeout=5)
    except Exception:
        pass
    af = os.path.join(ss_dir, "assertions.json")
    data = {}
    if os.path.exists(af):
        try:
            with open(af) as f:
                data = json.load(f)
        except Exception:
            data = {}
    data[f"{test_name}.png"] = description
    with open(af, "w") as f:
        json.dump(data, f, indent=2)


def win_id(ax, w):
    return ax.get(w.id, ["AXIdentifier"]).get("AXIdentifier")


def all_windows(ax):
    return ax.find(role="window", max_depth=1, max_results=20)


def find_window(ax, ident=None, title=None, timeout=8.0):
    end = time.time() + timeout
    while True:
        for w in all_windows(ax):
            if ident is not None and win_id(ax, w) == ident:
                return w
            if title is not None and (w.name or "") == title:
                return w
        if time.time() >= end:
            return None
        time.sleep(0.25)


def close_window(ax, w):
    if w is None:
        return False
    for b in ax.find(role="button", root_id=w.id, max_results=200, max_depth=3):
        if ax.get(b.id, ["AXSubrole"]).get("AXSubrole") == "AXCloseButton":
            ax.action(b.id, "AXPress")
            time.sleep(0.8)
            return True
    return False


def values_in(ax, root_id, max_results=400, max_depth=18):
    """Every non-empty AXValue string under root (labels, fields, popups)."""
    out = []
    for e in ax.find(root_id=root_id, max_results=max_results, max_depth=max_depth):
        v = ax.get(e.id, ["AXValue"]).get("AXValue")
        if isinstance(v, str) and v.strip():
            out.append(v)
    return out


def names_in(ax, root_id, role=None, max_results=400, max_depth=18):
    return [e.name for e in ax.find(role=role, root_id=root_id,
                                    max_results=max_results, max_depth=max_depth) if e.name]


def buttons_named(ax, root_id, name):
    return [b for b in ax.find(role="button", root_id=root_id, max_results=300, max_depth=16)
            if (b.name or "") == name]


def menu_item(ax, *path):
    mbi = [m for m in ax.find(role="menu_bar_item", max_results=20, max_depth=3)
           if (m.name or "") == path[0]]
    if not mbi:
        return None
    cur = mbi[0].id
    for label in path[1:]:
        items = ax.find(role="menu_item", root_id=cur, max_results=300, max_depth=2)
        hit = [i for i in items if (i.name or "") == label]
        if not hit:
            return None
        cur = hit[0].id
    return cur


def menu_items(ax, *path):
    """Item NAMES directly under a menu-bar item (or a submenu item)."""
    root = menu_item(ax, *path) if len(path) > 1 else None
    if root is None:
        mbi = [m for m in ax.find(role="menu_bar_item", max_results=20, max_depth=3)
               if (m.name or "") == path[0]]
        if not mbi:
            return []
        menus = ax.find(role="menu", root_id=mbi[0].id, max_results=2, max_depth=1)
        if not menus:
            return []
        root = menus[0].id
    else:
        menus = ax.find(role="menu", root_id=root, max_results=2, max_depth=1)
        if not menus:
            return []
        root = menus[0].id
    return [i.name for i in ax.find(role="menu_item", root_id=root, max_results=100, max_depth=1)
            if (i.name or "")]


def rb_enter_menu_item(ax, *path, wait=1.6):
    mid = menu_item(ax, *path)
    if mid is None:
        return False
    ax.action(mid, "AXPress")
    time.sleep(wait)
    return True


def rb_enter_welcome(ax):
    w = find_window(ax, ident="welcome", timeout=3)
    if w is None:
        rb_enter_menu_item(ax, "Window", "Welcome to CodeEdit")
        w = find_window(ax, ident="welcome", timeout=6)
    return w


def rb_enter_settings_window(ax):
    w = find_window(ax, ident="settings", timeout=1)
    if w is None:
        rb_enter_menu_item(ax, "CodeEdit", "Settings...", wait=2.0)
        w = find_window(ax, ident="settings", timeout=8)
    return w


def rb_reach_settings_pane(ax, pane):
    """Select a Settings sidebar pane. MUST be a CG click (AXPress does NOT select)."""
    w = rb_enter_settings_window(ax)
    if w is None:
        return None
    bs = buttons_named(ax, w.id, pane)
    if not bs:
        return None
    ax.click_element_cg(bs[-1].id)
    time.sleep(1.0)
    return find_window(ax, ident="settings", timeout=3)


def rb_enter_about_window(ax):
    rb_enter_menu_item(ax, "CodeEdit", "About CodeEdit", wait=2.0)
    return find_window(ax, ident="about", timeout=6)


def rb_enter_extensions_window(ax):
    rb_enter_menu_item(ax, "Extensions", "Open Extensions Window", wait=2.0)
    return find_window(ax, ident="extensions", timeout=6)


def rb_enter_clone_sheet(ax):
    w = rb_enter_welcome(ax)
    bs = buttons_named(ax, w.id, "Clone Git Repository...")
    if not bs:
        return None
    ax.action(bs[0].id, "AXPress")
    end = time.time() + 6
    while time.time() < end:
        s = ax.find(role="sheet", max_results=3, max_depth=6)
        if s:
            return s[0]
        time.sleep(0.25)
    return None


def rb_enter_save_panel(ax):
    w = rb_enter_welcome(ax)
    bs = buttons_named(ax, w.id, "Create New File...")
    if bs:
        ax.action(bs[0].id, "AXPress")
    return find_window(ax, title="Save", timeout=8)


def rb_enter_open_panel(ax):
    w = rb_enter_welcome(ax)
    bs = buttons_named(ax, w.id, "Open File or Folder...")
    if bs:
        ax.action(bs[0].id, "AXPress")
    return find_window(ax, title="Open Workspace or File", timeout=8)


def dismiss_panel_or_sheet(ax):
    """Escape does not work here — press the panel/sheet's own Cancel button."""
    for b in ax.find(role="button", max_results=120, max_depth=10):
        if (b.name or "") == "Cancel":
            ax.action(b.id, "AXPress")
            time.sleep(1.0)
            return True
    return False


def rb_enter_workspace(ax, folder_name="sample_project", timeout=20.0):
    """Open the fixture folder as a workspace the way Finder does: hand the folder to the
    RUNNING app's own bundle (discovered from its pid at runtime — portable)."""
    from AppKit import NSWorkspace, NSRunningApplication, NSWorkspaceOpenConfiguration
    from Foundation import NSURL
    src = os.path.join(FIXTURES_DIR, folder_name)
    base = os.path.join("/tmp", "rb_codeedit_ws")
    dst = os.path.join(base, folder_name)
    if os.path.isdir(base):
        shutil.rmtree(base, ignore_errors=True)
    os.makedirs(base, exist_ok=True)
    shutil.copytree(src, dst)
    ra = NSRunningApplication.runningApplicationWithProcessIdentifier_(int(ax._pid))
    cfg = NSWorkspaceOpenConfiguration.configuration()
    cfg.setActivates_(True)
    NSWorkspace.sharedWorkspace().openURLs_withApplicationAtURL_configuration_completionHandler_(
        [NSURL.fileURLWithPath_(dst)], ra.bundleURL(), cfg, None)
    return find_window(ax, ident="workspace", timeout=timeout)


def project_navigator(ax, ws):
    for o in ax.find(role="outline", root_id=ws.id, max_results=10, max_depth=14):
        if (o.name or "") == "Project Navigator":
            return o
    return None


def navigator_rows(ax, ws):
    nav = project_navigator(ax, ws)
    if nav is None:
        return []
    return [ax.get(t.id, ["AXValue"]).get("AXValue")
            for t in ax.find(role="text_field", root_id=nav.id, max_results=60, max_depth=8)]


def rb_reach_editor(ax, ws, filename):
    """Click a file row in the Project Navigator; returns the editor AXTextArea (or None)."""
    nav = project_navigator(ax, ws)
    if nav is None:
        return None
    rows = ax.find(role="text_field", root_id=nav.id, max_results=60, max_depth=8)
    tgt = [t for t in rows if ax.get(t.id, ["AXValue"]).get("AXValue") == filename]
    if not tgt:
        return None
    ax.click_element_cg(tgt[0].id)
    end = time.time() + 8
    while time.time() < end:
        ta = ax.find(role="text_area", root_id=ws.id, max_results=5, max_depth=18)
        if ta:
            return ta[0]
        time.sleep(0.3)
    return None


def rb_enter_command_palette(ax, ws):
    """Command Palette / Open Quickly only exist while a WORKSPACE window is open."""
    ax.action(ws.id, "AXRaise")
    time.sleep(0.5)
    rb_enter_menu_item(ax, "View", "Show Command Palette", wait=1.6)
    return _overlay_window(ax)


def rb_enter_open_quickly(ax, ws):
    ax.action(ws.id, "AXRaise")
    time.sleep(0.5)
    rb_enter_menu_item(ax, "File", "Open Quickly", wait=1.6)
    return _overlay_window(ax)


def _overlay_window(ax):
    """The palette/quick-open overlay is a borderless AXWindow: no title, no AXIdentifier."""
    for w in all_windows(ax):
        if win_id(ax, w) is None and not (w.name or ""):
            return w
    return None


def overlay_rows(ax, pal):
    return [v for v in (ax.get(t.id, ["AXValue"]).get("AXValue")
                        for t in ax.find(role="label", root_id=pal.id,
                                         max_results=60, max_depth=14)) if v]


def overlay_type(ax, pal, text):
    tf = ax.find(role="text_field", root_id=pal.id, max_results=5, max_depth=8)
    if not tf:
        return False
    ax.set_value(tf[0].id, text)
    time.sleep(1.3)
    return True


def switch_for_label(ax, root_id, label):
    """The AXCheckBox(AXSwitch) that follows the AXStaticText whose AXValue == label."""
    seq = ax.find(root_id=root_id, max_results=400, max_depth=18)
    idx = None
    for i, e in enumerate(seq):
        if e.role == "label" and ax.get(e.id, ["AXValue"]).get("AXValue") == label:
            idx = i
            break
    if idx is None:
        return None
    for e in seq[idx + 1:idx + 4]:
        if e.role == "checkbox":
            return e
    return None


def popup_for_label(ax, root_id, label):
    seq = ax.find(root_id=root_id, max_results=400, max_depth=18)
    idx = None
    for i, e in enumerate(seq):
        if e.role == "label" and ax.get(e.id, ["AXValue"]).get("AXValue") == label:
            idx = i
            break
    if idx is None:
        return None
    for e in seq[idx + 1:idx + 4]:
        if e.role == "popup":
            return e
    return None


def popup_options(ax, popup):
    ax.action(popup.id, "AXPress")
    time.sleep(0.8)
    menus = ax.find(role="menu", root_id=popup.id, max_results=3, max_depth=2)
    out = []
    if menus:
        for i in ax.find(role="menu_item", root_id=menus[0].id, max_results=40, max_depth=2):
            out.append(i.name or ax.get(i.id, ["AXValue"]).get("AXValue"))
        ax.action(menus[0].id, "AXCancel")
        time.sleep(0.4)
    return [o for o in out if o]


def popup_pick(ax, popup, option):
    ax.action(popup.id, "AXPress")
    time.sleep(0.8)
    menus = ax.find(role="menu", root_id=popup.id, max_results=3, max_depth=2)
    if not menus:
        return False
    for i in ax.find(role="menu_item", root_id=menus[0].id, max_results=40, max_depth=2):
        if (i.name or ax.get(i.id, ["AXValue"]).get("AXValue")) == option:
            ax.action(i.id, "AXPick")
            time.sleep(1.0)
            return True
    ax.action(menus[0].id, "AXCancel")
    return False


# ── STRUCTURE-lane constants + local navigation helpers ──────────────────────
# Every window below is located by a SEMANTIC key (visible title / a named widget it
# contains) with the recon AXIdentifier accepted as an equally valid match — never by
# child index or tree path, so a recreation built on a different hierarchy still matches.

WELCOME_TITLE = "Welcome To CodeEdit"
WELCOME_BUTTONS = ("Create New File...", "Clone Git Repository...", "Open File or Folder...")
MENU_BAR_ITEMS = ["CodeEdit", "File", "Edit", "View", "Find", "Navigate",
                  "Source Control", "Extensions", "Window", "Help"]
SETTINGS_PANES = ["General", "Accounts", "Navigation", "Themes", "Text Editing",
                  "Terminal", "Search", "Source Control", "Locations"]
WELCOME_ROLES = ("button", "label", "image", "scroll_area", "outline", "column", "group")
NAV_ROWS = ("sample_project", "src", "README.md", "hello.py", "notes.txt")
# Snapshot depth used for EVERY kit.rb_showing() call below. recon observed the "role|name"
# keys of its shape deltas at the kit default (12); DEEP is deeper still, and a deeper snapshot
# is a strict SUPERSET of a shallower one — so no key recon recorded can be missed.
DEEP = 16


def tree_depth(node, d=0):
    """Max AX nesting depth of an ax.tree() dict (0 == the root node itself)."""
    kids = (node or {}).get("children") or []
    if not kids:
        return d
    return max(tree_depth(k, d + 1) for k in kids)


def node_count(node):
    return 1 + sum(node_count(k) for k in ((node or {}).get("children") or []))


def roles_under(ax, root_id, max_depth=10, max_results=300):
    return {e.role for e in ax.find(root_id=root_id, max_results=max_results,
                                    max_depth=max_depth)}


def shows(ax, snapshot, role, name, root_id=None, max_depth=DEEP):
    """True iff a widget with this short ROLE and this visible NAME is present — either as a
    'role|name' key in the rb_showing() snapshot, or (depth-proof fallback) by a scoped
    ax.find that also accepts the label carried in AXValue instead of AXTitle. Locating by
    role + visible label keeps the check framework-agnostic (no child index, no tree path)."""
    if f"{role}|{name}" in snapshot:
        return True
    for e in ax.find(role=role, root_id=root_id, max_results=400, max_depth=max_depth):
        if (e.name or "") == name:
            return True
        if str(ax.get(e.id, ["AXValue"]).get("AXValue") or "") == name:
            return True
    return False


def window_containing(ax, role, name, max_depth=8):
    """The AXWindow holding a descendant with this ROLE + visible NAME (semantic locator,
    used for the About window whose own title is the empty string)."""
    for w in all_windows(ax):
        for e in ax.find(role=role, root_id=w.id, max_results=200, max_depth=max_depth):
            if (e.name or "") == name:
                return w
    return None


def rb_enter_welcome_surface(ax):
    """The fresh-launch welcome window: AXIdentifier 'welcome' OR title 'Welcome To CodeEdit'."""
    w = find_window(ax, ident="welcome", title=WELCOME_TITLE, timeout=3)
    if w is None:
        rb_enter_welcome(ax)
        w = find_window(ax, ident="welcome", title=WELCOME_TITLE, timeout=6)
    return w


def rb_enter_settings_surface(ax, pane_title="General"):
    """CodeEdit > Settings...  -> the settings window (id 'settings' OR title == the pane)."""
    w = find_window(ax, ident="settings", title=pane_title, timeout=0.2)
    if w is not None:
        return w
    rb_enter_menu_item(ax, "CodeEdit", "Settings...", wait=2.0)
    return find_window(ax, ident="settings", title=pane_title, timeout=8)


def rb_reach_settings_pane_surface(ax, pane):
    """Select a Settings sidebar pane with a REAL CG click (AXPress does NOT select a
    SwiftUI List row). Takes buttons_named(...)[-1] because 'Search' names two buttons."""
    w = rb_enter_settings_surface(ax)
    if w is None:
        return None
    bs = buttons_named(ax, w.id, pane)
    if not bs:
        return None
    ax.click_element_cg(bs[-1].id)
    time.sleep(1.2)
    return find_window(ax, ident="settings", title=pane, timeout=4)


def rb_enter_about_surface(ax):
    """CodeEdit > About CodeEdit -> the about window (title is ''; id 'about' or content)."""
    rb_enter_menu_item(ax, "CodeEdit", "About CodeEdit", wait=2.0)
    w = find_window(ax, ident="about", timeout=4)
    if w is None:
        w = window_containing(ax, "button", "Acknowledgements")
    return w


def rb_enter_extensions_surface(ax):
    """Extensions > Open Extensions Window -> window id 'extensions' / title 'Extensions'."""
    rb_enter_menu_item(ax, "Extensions", "Open Extensions Window", wait=2.0)
    return find_window(ax, ident="extensions", title="Extensions", timeout=6)


def rb_enter_workspace_surface(ax, folder_name="sample_project"):
    """Open FIXTURES_DIR/<folder_name> as a workspace; accept id 'workspace' OR the folder
    name as the window title."""
    ws = rb_enter_workspace(ax, folder_name=folder_name, timeout=3.0)
    if ws is None:
        ws = find_window(ax, ident="workspace", title=folder_name, timeout=15)
    return ws


def rb_reach_workspace_toolbar(ax, ws, name, wait=1.8):
    """Toggle a workspace toolbar button by its visible NAME (Navigator Sidebar / Inspector
    Sidebar). Workspace toolbar buttons need a REAL CG click (recon ENVIRONMENT CONSTRAINT 3).
    Searched in the AXToolbar first (cheap) and only then window-wide, so a recreation that
    puts the control elsewhere in the hierarchy still matches."""
    ax.action(ws.id, "AXRaise")
    time.sleep(0.4)
    bs = []
    for tb in ax.find(role="toolbar", root_id=ws.id, max_results=3, max_depth=5):
        bs = [b for b in ax.find(role="button", root_id=tb.id, max_results=60, max_depth=6)
              if (b.name or "") == name]
        if bs:
            break
    if not bs:
        bs = buttons_named(ax, ws.id, name)
    if not bs:
        return False
    ax.click_element_cg(bs[0].id)
    time.sleep(wait)
    return True


# ── GATE: the surfaces that must exist on a fresh launch (existence only) ────

class TestStructureGate:
    """The <=30% existence gate — no trigger, just the fresh-launch skeleton."""

    @pytest.mark.rb(depth=0, jump_kind="none")
    def test_gate_welcome_window_and_named_buttons(self, ax):
        """Exactly ONE welcome AXWindow (AXIdentifier 'welcome', title 'Welcome To CodeEdit')
        holding the 3 named push buttons plus 'Close', all exposing AXPress."""
        cands = [w for w in all_windows(ax)
                 if win_id(ax, w) == "welcome" or "welcome" in (w.name or "").lower()]
        assert len(cands) == 1, (
            "expected exactly 1 welcome AXWindow (AXIdentifier 'welcome' / title "
            f"'{WELCOME_TITLE}'), got {[(win_id(ax, w), w.name) for w in all_windows(ax)]}")
        w = cands[0]
        assert (w.name or "") == WELCOME_TITLE, (
            f"welcome window title = {w.name!r}, expected {WELCOME_TITLE!r}")

        btn_names = set(names_in(ax, w.id, role="button", max_depth=8))
        for label in WELCOME_BUTTONS:
            assert label in btn_names, (
                f"welcome window is missing the push button {label!r} (buttons={sorted(btn_names)})")
        assert "Close" in btn_names, "welcome window is missing its 'Close' button"

        for label in WELCOME_BUTTONS:
            bs = buttons_named(ax, w.id, label)
            assert bs, f"button {label!r} vanished between lookups"
            assert "AXPress" in (bs[0].actions or []), (
                f"button {label!r} exposes no AXPress action")

        screenshot_assert(
            "structure_test_welcome_window",
            "CodeEdit 'Welcome To CodeEdit' window, a centred panel about 740x460: a large "
            "CodeEdit app icon at the top with the title 'CodeEdit' and 'Version 0.3.1 (42)' "
            "under it, then three full-width rows with SF-Symbol icons on the left half "
            "reading 'Create New File...', 'Clone Git Repository...' and "
            "'Open File or Folder...'; the right column is an empty recent-projects list "
            "showing 'No Recent Projects'. A small close button sits at the window's top-left.",
            RESULTS_DIR)

    @pytest.mark.rb(depth=0, jump_kind="none")
    def test_gate_welcome_recent_projects_outline_and_role_diversity(self, ax):
        """The welcome window contains AXScrollArea > AXOutline 'Sidebar' > AXColumn (the
        recent-projects list) and exposes at least the 7 recon roles."""
        w = rb_enter_welcome_surface(ax)
        assert w is not None, "no welcome window (AXIdentifier 'welcome' / title 'Welcome To CodeEdit')"

        scrolls = ax.find(role="scroll_area", root_id=w.id, max_results=5, max_depth=6)
        assert scrolls, "welcome window has no AXScrollArea for the recent-projects list"
        sidebars = [o for o in ax.find(role="outline", root_id=scrolls[0].id,
                                       max_results=5, max_depth=4)
                    if (o.name or "") == "Sidebar"]
        assert sidebars, "no AXOutline named 'Sidebar' inside the welcome AXScrollArea"
        assert ax.find(role="column", root_id=sidebars[0].id, max_results=5, max_depth=3), \
            "the recent-projects AXOutline 'Sidebar' exposes no AXColumn"

        roles = roles_under(ax, w.id, max_depth=8)
        for expected in WELCOME_ROLES:
            assert expected in roles, (
                f"welcome window exposes no {expected!r} role (roles={sorted(roles)})")
        assert len(roles) >= 7, f"role diversity too low: {sorted(roles)}"

    @pytest.mark.rb(depth=0, jump_kind="none")
    def test_gate_menu_bar_named_menus(self, ax):
        """The AXMenuBar exposes exactly the 10 named app menus (besides the system 'Apple'
        item); CodeEdit owns 'Settings...' + 'About CodeEdit' and Extensions owns exactly
        'Open Extensions Window'."""
        assert ax.find(role="menu_bar", max_results=3, max_depth=2), \
            "application exposes no AXMenuBar"

        names = [m.name for m in ax.find(role="menu_bar_item", max_results=20, max_depth=3)
                 if (m.name or "")]
        app_menus = [n for n in names if n != "Apple"]
        assert app_menus == MENU_BAR_ITEMS, (
            f"menu-bar items = {app_menus!r}, expected {MENU_BAR_ITEMS!r}")

        code_edit_items = menu_items(ax, "CodeEdit")
        assert "Settings..." in code_edit_items, f"CodeEdit menu = {code_edit_items!r}"
        assert "About CodeEdit" in code_edit_items, f"CodeEdit menu = {code_edit_items!r}"
        ext_items = menu_items(ax, "Extensions")
        assert ext_items == ["Open Extensions Window"], f"Extensions menu = {ext_items!r}"

    @pytest.mark.rb(depth=0, jump_kind="none")
    def test_gate_welcome_interactive_inventory_and_tree_depth(self, ax):
        """Interactive inventory of the welcome window: >=4 AXPress-able widgets whose names
        are the 3 actions + 'Close', a single 'Version …' AXStaticText, >=8 AX nodes total
        and a subtree at least 4 levels deep (window > group > scroll area > outline > column)."""
        w = rb_enter_welcome_surface(ax)
        assert w is not None, "no welcome window (AXIdentifier 'welcome' / title 'Welcome To CodeEdit')"

        els = ax.find(root_id=w.id, max_results=300, max_depth=10)
        pressable = [e for e in els if "AXPress" in (e.actions or [])]
        assert len(pressable) >= 4, (
            f"only {len(pressable)} AXPress-able widgets in the welcome window, expected >=4")
        pressable_names = {e.name for e in pressable if e.name}
        for label in WELCOME_BUTTONS + ("Close",):
            assert label in pressable_names, (
                f"{label!r} is not an AXPress-able widget (pressable={sorted(pressable_names)})")

        version_labels = [e for e in els if e.role == "label"
                          and str(ax.get(e.id, ["AXValue"]).get("AXValue") or "").startswith("Version")]
        assert len(version_labels) == 1, (
            f"expected exactly 1 'Version …' AXStaticText in the welcome window, "
            f"got {len(version_labels)}")

        subtree = ax.tree(max_depth=10, root_id=w.id)
        assert node_count(subtree) >= 8, (
            f"welcome window subtree has only {node_count(subtree)} AX nodes")
        depth = tree_depth(subtree)
        assert depth >= 4, (
            f"welcome window AX subtree is only {depth} levels deep, expected >=4 "
            "(window > hosting group > scroll area > outline > column)")


# ── Shape deltas: stand-alone windows opened from the menu bar ───────────────

class TestWindowSurfaceReach:

    @pytest.mark.rb(depth=1, jump_kind="reach",
                    expect="CodeEdit > Settings... adds window|General (id 'settings') holding "
                           "an AXSplitGroup 'settings, SidebarNavigationSplitView', 2 AXOutline "
                           "'Sidebar', an AXToolbar and the 9 sidebar pane buttons General, "
                           "Accounts, Navigation, Themes, Text Editing, Terminal, Search, "
                           "Source Control, Locations (recon +59 nodes; >=30 asserted)")
    def test_settings_window_reach(self, ax):
        before = kit.rb_showing(ax, max_depth=DEEP)
        w = rb_enter_settings_surface(ax)
        after = kit.rb_showing(ax, max_depth=DEEP)
        assert kit.rb_reach(before, after, target="window|General", source=None), (
            "no 'General' settings window appeared after CodeEdit > Settings... "
            f"(new nodes: {sorted(list(after - before))[:12]})")

        assert w is not None, "no settings window (AXIdentifier 'settings' / title 'General')"
        assert (w.name or "") == "General", (
            f"settings window title = {w.name!r}, expected the selected pane name 'General'")
        assert len(after - before) >= 30, (
            f"the settings window only added {len(after - before)} AX nodes (recon: +59)")

        split = ax.find(role="split_group", root_id=w.id, max_results=10, max_depth=8)
        assert split, "settings window contains no AXSplitGroup"
        split_ids = [ax.get(s.id, ["AXIdentifier"]).get("AXIdentifier") for s in split]
        assert any(sid and "SidebarNavigationSplitView" in str(sid) for sid in split_ids), (
            "settings window has no AXSplitGroup identified as the sidebar navigation split "
            f"view (identifiers = {split_ids!r}, recon: 'settings, SidebarNavigationSplitView')")

        outlines = [o for o in ax.find(role="outline", root_id=w.id, max_results=10, max_depth=12)
                    if (o.name or "") == "Sidebar"]
        assert len(outlines) >= 2, (
            f"expected 2 AXOutline 'Sidebar' in the Settings sidebar, got {len(outlines)}")
        assert ax.find(role="toolbar", root_id=w.id, max_results=3, max_depth=5), \
            "settings window has no AXToolbar"

        btn_names = set(names_in(ax, w.id, role="button", max_depth=16))
        for pane in SETTINGS_PANES:
            assert pane in btn_names, (
                f"Settings sidebar is missing the {pane!r} pane button "
                f"(buttons={sorted(btn_names)})")

        screenshot_assert(
            "structure_test_settings_window",
            "CodeEdit Settings window titled 'General' floating over the welcome window: a "
            "left sidebar with a search field and 9 colour-icon rows (General, Accounts, "
            "Navigation, Themes, Text Editing, Terminal, Search, Source Control, Locations) "
            "with 'General' highlighted, and a right detail pane of grouped rows containing "
            "popup menus (Appearance, Show Issues, Reopen Behavior, File Extensions), several "
            "toggle switches and two radio pairs (Color/Monochrome and Top/Side).",
            RESULTS_DIR)

    @pytest.mark.rb(depth=1, jump_kind="reach",
                    expect="CodeEdit > About CodeEdit adds the about window (id 'about', empty "
                           "title) with button|Contributors, button|Acknowledgements, "
                           "link|MIT License and label|Copyright © 2022-2024 CodeEdit "
                           "(recon +6 nodes; >=4 asserted)")
    def test_about_window_reach(self, ax):
        before = kit.rb_showing(ax, max_depth=DEEP)
        w = rb_enter_about_surface(ax)
        after = kit.rb_showing(ax, max_depth=DEEP)
        assert kit.rb_reach(before, after, target="button|Acknowledgements", source=None), (
            "no About window with an 'Acknowledgements' button appeared "
            f"(new nodes: {sorted(list(after - before))[:12]})")

        assert w is not None, "no About window (AXIdentifier 'about' / 'Acknowledgements' button)"
        assert len(after - before) >= 4, (
            f"the About window only added {len(after - before)} AX nodes (recon: +6)")

        for role, name in (("button", "Contributors"), ("button", "Acknowledgements"),
                           ("link", "MIT License"),
                           ("label", "Copyright © 2022-2024 CodeEdit")):
            assert shows(ax, after, role, name, root_id=w.id), (
                f"About window is missing the {role} {name!r}")

        links = [ln.name for ln in ax.find(role="link", root_id=w.id,
                                           max_results=5, max_depth=10)]
        assert links == ["MIT License"], f"About window AXLinks = {links!r}, expected ['MIT License']"

    @pytest.mark.rb(depth=1, jump_kind="reach",
                    expect="Extensions > Open Extensions Window adds window|Extensions "
                           "(id 'extensions') with button|Hide Sidebar, label|Select an "
                           "extension, popup|more toolbar items, an AXToolbar, an AXSplitter "
                           "and one empty AXOutline 'Sidebar' (recon +9 nodes; >=5 asserted)")
    def test_extensions_window_reach(self, ax):
        before = kit.rb_showing(ax, max_depth=DEEP)
        w = rb_enter_extensions_surface(ax)
        after = kit.rb_showing(ax, max_depth=DEEP)
        assert kit.rb_reach(before, after, target="window|Extensions", source=None), (
            "no 'Extensions' window appeared after Extensions > Open Extensions Window "
            f"(new nodes: {sorted(list(after - before))[:12]})")

        assert w is not None, "no Extensions window (AXIdentifier 'extensions' / title 'Extensions')"
        assert (w.name or "") == "Extensions", f"Extensions window title = {w.name!r}"
        assert len(after - before) >= 5, (
            f"the Extensions window only added {len(after - before)} AX nodes (recon: +9)")

        for role, name in (("button", "Hide Sidebar"), ("label", "Select an extension"),
                           ("popup", "more toolbar items")):
            assert shows(ax, after, role, name, root_id=w.id), (
                f"Extensions window is missing the {role} {name!r}")
        assert ax.find(role="toolbar", root_id=w.id, max_results=3, max_depth=5), \
            "Extensions window has no AXToolbar"
        assert ax.find(role="splitter", root_id=w.id, max_results=3, max_depth=10), \
            "Extensions window has no AXSplitter"
        outlines = [o.name for o in ax.find(role="outline", root_id=w.id,
                                            max_results=5, max_depth=12)]
        assert "Sidebar" in outlines, (
            f"Extensions window outlines = {outlines!r}, expected the extension-list "
            "AXOutline 'Sidebar'")


# ── Shape deltas: modal sheet / file panels raised from the welcome window ───

class TestModalSurfaceReach:

    @pytest.mark.rb(depth=1, jump_kind="reach",
                    expect="welcome 'Clone Git Repository...' raises exactly 1 AXSheet with "
                           "label|Clone a repository, label|Enter a git repository URL:, one "
                           "AXTextField, button|Cancel and a DISABLED button|Clone, while the "
                           "welcome window stays the only AXWindow")
    def test_clone_sheet_reach(self, ax):
        before = kit.rb_showing(ax, max_depth=DEEP)
        sheet = rb_enter_clone_sheet(ax)
        after = kit.rb_showing(ax, max_depth=DEEP)
        assert kit.rb_reach(before, after, target="label|Clone a repository", source=None), (
            "'Clone Git Repository...' raised no sheet titled 'Clone a repository' "
            f"(new nodes: {sorted(list(after - before))[:12]})")

        assert sheet is not None, "'Clone Git Repository...' raised no AXSheet"
        sheets = ax.find(role="sheet", max_results=5, max_depth=6)
        assert len(sheets) == 1, f"expected exactly 1 AXSheet, got {len(sheets)}"
        hosts = [w for w in all_windows(ax)
                 if win_id(ax, w) == "welcome" or (w.name or "") == WELCOME_TITLE]
        assert len(hosts) == 1, "the clone sheet must sit on the single welcome window"

        for role, name in (("label", "Clone a repository"),
                           ("label", "Enter a git repository URL:"),
                           ("button", "Cancel"), ("button", "Clone")):
            assert shows(ax, after, role, name, root_id=sheet.id), (
                f"clone sheet is missing the {role} {name!r}")
        fields = ax.find(role="text_field", root_id=sheet.id, max_results=5, max_depth=8)
        assert len(fields) == 1, (
            f"expected exactly 1 AXTextField (the git URL) in the clone sheet, got {len(fields)}")
        clone_btn = buttons_named(ax, sheet.id, "Clone")
        assert clone_btn, "clone sheet has no 'Clone' button"
        assert clone_btn[0].enabled is False, \
            "'Clone' must be AXEnabled == False while the URL field is empty"

        dismiss_panel_or_sheet(ax)

    @pytest.mark.rb(depth=1, jump_kind="reach",
                    expect="welcome 'Open File or Folder...' swaps the window list: "
                           "window|Welcome To CodeEdit LEAVES it and window|Open Workspace or "
                           "File (id 'open-panel') with button|Open + button|Cancel appears "
                           "(recon +47 nodes; >=20 asserted)")
    def test_open_panel_reach(self, ax):
        before = kit.rb_showing(ax, max_depth=DEEP)
        panel = rb_enter_open_panel(ax)
        after = kit.rb_showing(ax, max_depth=DEEP)
        assert kit.rb_reach(before, after,
                            target="window|Open Workspace or File",
                            source="window|Welcome To CodeEdit"), (
            "'Open File or Folder...' did not replace the welcome window with the "
            f"'Open Workspace or File' panel (new nodes: {sorted(list(after - before))[:12]})")

        assert panel is not None, "no window titled 'Open Workspace or File'"
        assert len(after - before) >= 20, (
            f"the open panel only added {len(after - before)} AX nodes (recon: +47)")

        titles = [(w.name or "") for w in all_windows(ax)]
        assert WELCOME_TITLE not in titles, (
            "the welcome window must leave the AX window list while the modal open panel "
            f"is up; window list = {titles!r}")
        for name in ("Open", "Cancel"):
            assert shows(ax, after, "button", name, root_id=panel.id), (
                f"the open panel is missing the {name!r} button")

        dismiss_panel_or_sheet(ax)

    @pytest.mark.rb(depth=1, jump_kind="reach",
                    expect="welcome 'Create New File...' adds window|Save (id 'save-panel') "
                           "with label|Save As:, text_field|Untitled, a 'Where:' AXPopUpButton, "
                           "button|Save and button|Cancel (recon +13 nodes; >=6 asserted)")
    def test_save_panel_reach(self, ax):
        before = kit.rb_showing(ax, max_depth=DEEP)
        panel = rb_enter_save_panel(ax)
        after = kit.rb_showing(ax, max_depth=DEEP)
        assert kit.rb_reach(before, after, target="window|Save", source=None), (
            "'Create New File...' raised no 'Save' panel window "
            f"(new nodes: {sorted(list(after - before))[:12]})")

        assert panel is not None, "no window titled 'Save'"
        assert len(after - before) >= 6, (
            f"the save panel only added {len(after - before)} AX nodes (recon: +13)")

        for role, name in (("label", "Save As:"), ("text_field", "Untitled"),
                           ("button", "Save"), ("button", "Cancel")):
            assert shows(ax, after, role, name, root_id=panel.id), (
                f"the save panel is missing the {role} {name!r}")
        assert ax.find(role="popup", root_id=panel.id, max_results=5, max_depth=12), \
            "the save panel has no 'Where:' AXPopUpButton"

        dismiss_panel_or_sheet(ax)


# ── Shape deltas: the workspace window and its panes ─────────────────────────

# ── Shape delta: a Settings pane and its own detail widgets (depth 2) ────────

class TestSettingsPaneStructureReach:

    @pytest.mark.rb(depth=2, jump_kind="reach",
                    expect="Settings (General) -> CG-click the sidebar pane 'Text Editing': the "
                           "window title becomes 'Text Editing', the General row "
                           "label|Reopen Behavior DISAPPEARS and label|Prefer Indent Using, "
                           "label|Indent Width, label|Tab Width, label|Font Size, "
                           "label|Bracket Pair Highlight APPEAR")
    def test_settings_text_editing_pane_reach(self, ax):
        w = rb_enter_settings_surface(ax)
        assert w is not None, "no settings window (AXIdentifier 'settings' / title 'General')"
        assert (w.name or "") == "General", (
            f"Settings must open on the 'General' pane, window title = {w.name!r}")

        before = kit.rb_showing(ax, max_depth=DEEP)
        w2 = rb_reach_settings_pane_surface(ax, "Text Editing")
        after = kit.rb_showing(ax, max_depth=DEEP)
        assert kit.rb_reach(before, after, target="label|Prefer Indent Using",
                            source="label|Reopen Behavior"), (
            "selecting the 'Text Editing' pane did not swap the General detail rows for the "
            f"Text Editing ones (new nodes: {sorted(list(after - before))[:12]})")

        assert w2 is not None, "the settings window vanished after selecting a pane"
        assert (w2.name or "") == "Text Editing", (
            f"the settings window title should equal the selected pane, got {w2.name!r}")
        for name in ("Indent Width", "Tab Width", "Font Size", "Bracket Pair Highlight",
                     "Wrap lines to editor width"):
            assert shows(ax, after, "label", name, root_id=w2.id), (
                f"the Text Editing pane is missing the label {name!r}")

        btn_names = set(names_in(ax, w2.id, role="button", max_depth=16))
        for pane in SETTINGS_PANES:
            assert pane in btn_names, (
                f"the Settings sidebar lost the {pane!r} pane button after switching panes "
                f"(buttons={sorted(btn_names)})")