Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

34.9 KB
Raw Blame
# SPDX-License-Identifier: AGPL-3.0-only
# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0

"""Unsloth extra-UI Playwright test: Compare tab, Recipes editor, /export, /studio, Settings tabs."""

import json
import os
import re
import sys
import time
import urllib.error
import urllib.parse
import urllib.request
from pathlib import Path
from playwright.sync_api import expect, sync_playwright

sys.path.insert(0, str(Path(__file__).resolve().parent))
from _playwright_robust import (  # noqa: E402
    chromium_launch_args,
    click_and_wait_for_response,
    evaluate_fetch,
    install_view_transition_killer,
    install_wall_clock_watchdog,
    is_benign_page_error,
    recover_or_replace_page,
    report_failing_step,
    robust_evaluate,
    step_budget_s,
    wait_for_first,
    wait_for_health,
    click_forced,
)

BASE = os.environ["BASE_URL"]
OLD = os.environ["STUDIO_OLD_PW"]
NEW = os.environ.get("STUDIO_NEW_PW", "ExtraUi-NEW-2026!")
GGUF_REPO = os.environ.get("GGUF_REPO", "unsloth/gemma-3-270m-it-GGUF")
GGUF_VARIANT = os.environ.get("GGUF_VARIANT", "UD-Q4_K_XL")
ART_DIR = os.environ.get("PW_ART_DIR", "logs/playwright_extra")
ART = Path(ART_DIR)
ART.mkdir(parents = True, exist_ok = True)
STRICT = os.environ.get("STUDIO_UI_STRICT", "0") == "1"
# The Voice-picker media-access crash is specific to headless Chromium on macOS.
MACOS_RUNNER = os.environ.get("RUNNER_OS", "").lower() == "macos" or sys.platform == "darwin"
TURN_TIMEOUT_MS = int(os.environ.get("STUDIO_UI_TURN_TIMEOUT_MS", "180000"))
WALL_TIMEOUT_S = float(os.environ.get("STUDIO_UI_WALL_TIMEOUT_S", "720"))
FETCH_TIMEOUT_MS = int(os.environ.get("STUDIO_UI_FETCH_TIMEOUT_MS", "30000"))
LOAD_FETCH_TIMEOUT_MS = int(os.environ.get("STUDIO_UI_LOAD_TIMEOUT_MS", "180000"))
# Blackholed egress can hang the search with no transport failure, so allow declaring offline.
HF_OFFLINE = os.environ.get("STUDIO_UI_HF_OFFLINE", "0") == "1"
# Searched rows arrive up to 15.3s later (300ms debounce + 15s HF_SEARCH_TIMEOUT_MS in
# use-hub-model-search.ts); 15.5s outlives that abort. A still-open search re-bases the wait.
WHEEL_ROWS_TIMEOUT_MS = 15_500
WHEEL_DEADLINE_S = 30.0
# The picker runs two searches in sequence, so re-basing onto the second must be allowed.
WHEEL_DEADLINE_MAX_S = 75.0

_SLOW_LANE = max(1.0, TURN_TIMEOUT_MS / 180_000)
STEP_BUDGET_S = step_budget_s(240 * _SLOW_LANE)
NO_STEP_CEILING = 0

_n = [0]
_failed: list[str] = []
_watchdog = None


def step(s: str, budget_s: float | None = None) -> None:
    """Start step `s`; it may run `budget_s` (default STEP_BUDGET_S) before the run stops."""
    print(f"[ui-extra] STEP {s}", flush = True)
    if _watchdog is not None:
        _watchdog.begin_step(s, STEP_BUDGET_S if budget_s is None else budget_s)


def info(s: str) -> None:
    print(f"[ui-extra] {s}", flush = True)


def fail(m: str) -> None:
    print(f"[ui-extra] FAIL: {m}", flush = True)
    _failed.append(m)


def soft_fail(m: str) -> None:
    if STRICT:
        fail(m)
    else:
        info(f"WARN (strict-off): {m}")


def runtime_warn(m: str) -> None:
    """Warn about a runtime-coupled assertion (Compare-pane streaming) that STRICT does not gate."""
    info(f"WARN (runtime): {m}")


def page_crashed(pg, exc: Exception) -> bool:
    """True when the browser/page/context died (a macos-14 renderer crash) rather than a live-page
    assertion failing -- so the caller can downgrade CI-environment flakiness to a runtime warning."""
    try:
        if pg.is_closed():
            return True
    except Exception:
        return True
    msg = str(exc).lower()
    return "has been closed" in msg or "target closed" in msg or "crash" in msg


with sync_playwright() as p:
    # begin_step() restarts the inactivity budget, so the same number is also the whole-run total.
    _watchdog = install_wall_clock_watchdog(
        WALL_TIMEOUT_S,
        label = "ui-extra",
        info = info,
        total_deadline_s = WALL_TIMEOUT_S,
    )
    report_failing_step(_watchdog, label = "ui-extra")
    # The shell health wait can pass before the auth DB migrates on macOS.
    wait_for_health(BASE, timeout = 30.0, info = info)
    browser = p.chromium.launch(
        headless = True,
        args = chromium_launch_args(),
    )
    ctx = browser.new_context(
        viewport = {"width": 1280, "height": 900},
        reduced_motion = "reduce",
    )
    install_view_transition_killer(ctx)

    # Collected for the whole session: the frontend backs off 30s after a failed Hub request
    # (REMOTE_OFFLINE_TTL_MS). Bound to the context so a replacement page is covered.
    hf_unreachable: list[str] = []
    wheel_step_active = [False]
    hf_inflight: dict[object, float] = {}

    def _is_hub_url(url: str) -> bool:
        """Only the exact host huggingface.co counts; a substring also matches datasets-
        server.huggingface.co."""
        try:
            return urllib.parse.urlsplit(url).netloc.lower() == "huggingface.co"
        except Exception:
            return False

    def _note_hf_unreachable(why: str) -> None:
        if not hf_unreachable:
            info(f"WARN Hugging Face unreachable from this runner: {why}")
        hf_unreachable.append(why)

    def _on_request(req) -> None:
        try:
            if _is_hub_url(req.url):
                hf_inflight[req] = time.monotonic()
        except Exception:
            pass

    def _on_requestfailed(req) -> None:
        try:
            hf_inflight.pop(req, None)
            if not _is_hub_url(req.url):
                return
            failure = req.failure or ""
            # ERR_ABORTED also ends a superseded query, so it only means unreachable during the wheel step.
            if "ERR_ABORTED" in failure and not wheel_step_active[0]:
                return
            _note_hf_unreachable(f"request failed: {failure}")
        except Exception:
            pass

    def _on_requestfinished(req) -> None:
        try:
            hf_inflight.pop(req, None)
        except Exception:
            pass

    def _on_response(resp) -> None:
        # 429/5xx is the Hub refusing; any other 4xx is a request the app built wrong.
        try:
            if not _is_hub_url(resp.url):
                return
            if resp.status == 429 or resp.status >= 500:
                _note_hf_unreachable(f"HTTP {resp.status}")
            elif hf_unreachable:
                # A served response proves a route to the Hub, so drop stale failures, as markRemoteNetworkOnline does.
                info(
                    f"Hugging Face reachable again (HTTP {resp.status}); dropping "
                    f"{len(hf_unreachable)} earlier failure(s)"
                )
                hf_unreachable.clear()
        except Exception:
            pass

    ctx.on("request", _on_request)
    ctx.on("requestfailed", _on_requestfailed)
    ctx.on("requestfinished", _on_requestfinished)
    ctx.on("response", _on_response)
    page = ctx.new_page()
    page.set_default_timeout(60_000)
    page_errors = []

    def _on_pageerror(e):
        msg = str(e)
        if is_benign_page_error(msg):
            info(f"WARN ignoring benign pageerror: {msg!r}")
            return
        page_errors.append(msg)

    page.on("pageerror", _on_pageerror)

    def shoot(name: str) -> None:
        _n[0] += 1
        try:
            page.screenshot(
                path = str(ART / f"{_n[0]:02d}-{name}.png"),
                full_page = True,
                timeout = 90_000,
                animations = "disabled",
            )
        except Exception as _shoot_err:
            info(f"WARN: screenshot {name} failed: {_shoot_err}")

    step("setup: change-password + model load", NO_STEP_CEILING)
    # Form re-renders on macOS can detach the password fields mid-fill.
    form_err: Exception | None = None
    for _form_attempt in range(3):
        try:
            page.goto(f"{BASE}/change-password", wait_until = "domcontentloaded", timeout = 60_000)
            try:
                page.wait_for_load_state("networkidle", timeout = 30_000)
            except Exception:
                pass
            pw_field = page.locator("#new-password")
            pw_field.wait_for(state = "visible", timeout = 60_000)
            pw_field.fill(NEW, timeout = 60_000)
            page.fill("#confirm-password", NEW, timeout = 60_000)
            status, _ = click_and_wait_for_response(
                page,
                url_substr = "/api/auth/change-password",
                method = "POST",
                do_click = lambda: page.locator('button[type="submit"]').click(),
                timeout_ms = 30_000,
                info = lambda m: print(f"[ui-extra]   {m}", flush = True),
            )
            if status is not None and status >= 400:
                raise AssertionError(
                    f"change-password POST returned {status}; see page_errors={page_errors[:1]!r}"
                )
            form_err = None
            break
        except Exception as e:
            form_err = e
            try:
                cur_url = page.url
            except Exception:
                cur_url = "<page closed>"
            print(
                f"[extra-ui]   change-password form attempt {_form_attempt + 1} failed: "
                f"{type(e).__name__}: {str(e)[:200]}; page.url={cur_url}; "
                f"page_errors={len(page_errors)}",
                flush = True,
            )
            if _form_attempt < 2:
                # ERR_NO_BUFFER_SPACE needs the OS to recover socket buffers.
                if "ERR_NO_BUFFER_SPACE" in str(e):
                    backoff_s = 5 if _form_attempt == 0 else 15
                    print(
                        f"[extra-ui]   ENOBUFS detected; sleeping {backoff_s}s "
                        f"before retry to let OS recover socket buffers...",
                        flush = True,
                    )
                    time.sleep(backoff_s)
                page = recover_or_replace_page(
                    page,
                    ctx,
                    default_timeout_ms = 60_000,
                    info = lambda m: print(f"[extra-ui]   recovery: {m}", flush = True),
                )
    if form_err is not None:
        raise form_err
    # The post-submit re-render can crash the renderer on macOS.
    try:
        page.wait_for_load_state("networkidle", timeout = 30_000)
    except Exception:
        pass
    composer = page.locator('textarea[aria-label="Message input"]')
    last_err: Exception | None = None
    for _attempt in range(2):
        try:
            composer.wait_for(state = "visible", timeout = 60_000)
            last_err = None
            break
        except Exception as e:
            last_err = e
            try:
                cur_url = page.url
            except Exception:
                cur_url = "<page closed>"
            print(
                f"[extra-ui]   composer.wait_for attempt {_attempt + 1} failed: "
                f"{type(e).__name__}: {str(e)[:200]}; page.url={cur_url}; "
                f"page_errors={len(page_errors)}",
                flush = True,
            )
            try:
                shoot(f"01-composer-wait-attempt-{_attempt + 1}-fail")
            except Exception:
                pass
            if _attempt == 0:
                page = recover_or_replace_page(
                    page,
                    ctx,
                    default_timeout_ms = 60_000,
                    goto_url = BASE,
                    settle_networkidle = True,
                    info = lambda m: print(f"[extra-ui]   recovery: {m}", flush = True),
                )
                composer = page.locator('textarea[aria-label="Message input"]')
    if last_err is not None:
        raise last_err
    shoot("01-chat-loaded")

    token = robust_evaluate(page, "() => localStorage.getItem('unsloth_auth_token')")
    if not token:
        fail("no access token after change-password")
        sys.exit(1)
    load_resp = evaluate_fetch(
        page,
        f"{BASE}/api/inference/load",
        method = "POST",
        headers = {
            "Authorization": f"Bearer {token}",
            "Content-Type": "application/json",
        },
        body = {
            "model_path": GGUF_REPO,
            "gguf_variant": GGUF_VARIANT,
            "is_lora": False,
            "max_seq_length": 2048,
        },
        timeout_ms = LOAD_FETCH_TIMEOUT_MS,
    )
    if load_resp.get("error"):
        fail(f"/api/inference/load wedged: {load_resp['error']!r}")
        sys.exit(1)
    if load_resp["status"] != 200:
        fail(f"/api/inference/load -> {load_resp['status']}: {load_resp.get('body')!r}")
        sys.exit(1)
    info(f"loaded model: {(load_resp['body'] or {}).get('display_name')}")
    page.reload()
    composer = page.locator('textarea[aria-label="Message input"]')
    composer.wait_for(state = "visible", timeout = 60_000)

    health_resp = evaluate_fetch(
        page,
        f"{BASE}/api/health",
        timeout_ms = FETCH_TIMEOUT_MS,
    )
    if health_resp.get("error"):
        fail(f"/api/health wedged: {health_resp['error']!r}")
        sys.exit(1)
    health = health_resp.get("body") or {}
    chat_only = bool(health.get("chat_only"))
    info(f"chat_only mode: {chat_only}")

    # 1. Compare tab.
    step("Compare tab: send to two panes")
    compare_opened = False
    # Waited for, not counted: the composer can be on screen before it is in the accessibility tree.
    plus_btn = wait_for_first(
        page.get_by_role("button", name = re.compile(r"Tools and attachments", re.I))
    )
    if plus_btn is not None:
        click_forced(plus_btn)
        # A miss here is a real branch (the item lives under "More"), so keep the wait short.
        compare_item = wait_for_first(
            page.get_by_role("menuitem", name = re.compile(r"Compare chat", re.I)),
            timeout_ms = 2000,
        )
        if compare_item is None:
            more_trigger = wait_for_first(
                page.get_by_role("menuitem", name = re.compile(r"^More$", re.I)),
                timeout_ms = 2000,
            )
            if more_trigger is not None:
                more_trigger.hover()
                compare_item = wait_for_first(
                    page.get_by_role("menuitem", name = re.compile(r"Compare chat", re.I)),
                    timeout_ms = 2000,
                )
                if compare_item is None:
                    click_forced(more_trigger)
                    compare_item = wait_for_first(
                        page.get_by_role("menuitem", name = re.compile(r"Compare chat", re.I)),
                        timeout_ms = 2000,
                    )
        if compare_item is not None:
            click_forced(compare_item)
            compare_opened = True
    if not compare_opened:
        missing = (
            "the composer's Tools and attachments button"
            if plus_btn is None
            else "the Compare chat menu item"
        )
        soft_fail(f"Compare nav not found: {missing} never appeared")
    else:
        view = wait_for_first(page.locator('[data-tour="chat-compare-view"]'), timeout_ms = 15_000)
        if view is not None:
            wait_for_first(
                page.get_by_placeholder(re.compile(r"Send to both models", re.I)).or_(
                    view.locator("textarea")
                ),
                timeout_ms = 10_000,
            )
        shoot("02-compare-opened")
        if view is None:
            soft_fail("[data-tour='chat-compare-view'] not found after Compare click")
        else:
            ok_count_before = len(page.locator('[data-role="assistant"]').all())
            cmp_composer = page.get_by_placeholder(
                re.compile(r"Send to both models", re.I),
            ).first
            if cmp_composer.count() == 0:
                cmp_composer = view.locator("textarea").first
            if cmp_composer.count() == 0:
                soft_fail("compare composer textarea not found")
            else:
                cmp_composer.click()
                cmp_composer.fill("Reply with: A")
                cmp_composer.press("Enter")
                # Panes have no explicit model in CI, so the backend may reject; downgrade to runtime_warn.
                first_pair_arrived = False
                try:
                    page.wait_for_function(
                        """(want) => {
                            return document.querySelectorAll(
                                '[data-role="assistant"]'
                            ).length >= want;
                        }""",
                        arg = ok_count_before + 2,
                        timeout = 60_000,
                    )
                    info("OK Compare: 2 new assistant bubbles after first prompt")
                    first_pair_arrived = True
                except Exception as exc:
                    runtime_warn(
                        f"Compare: 2 bubbles didn't appear (panes likely "
                        f"have no model selected): {exc!r}"
                    )
                shoot("03-compare-after-A")

                if not first_pair_arrived:
                    runtime_warn(
                        "Compare: skipped the second prompt's 60s wait; the first prompt's bubbles never appeared"
                    )
                else:
                    cmp_composer.fill("Reply with: B")
                    cmp_composer.press("Enter")
                    try:
                        page.wait_for_function(
                            """(want) => {
                                return document.querySelectorAll(
                                    '[data-role="assistant"]'
                                ).length >= want;
                            }""",
                            arg = ok_count_before + 4,
                            timeout = 60_000,
                        )
                        info("OK Compare: 4 total new assistant bubbles after second prompt")
                    except Exception as exc:
                        runtime_warn(
                            f"Compare: 4 bubbles didn't appear (panes likely "
                            f"have no model selected): {exc!r}"
                        )
                    shoot("04-compare-after-B")

    page.goto(f"{BASE}/chat")
    composer = page.locator('textarea[aria-label="Message input"]')
    composer.wait_for(state = "visible", timeout = 60_000)

    # 2. Recipes editor.
    step("Recipes editor: click first template + Preview dialog")
    page.goto(f"{BASE}/data-recipes")
    wait_for_first(page.locator('[data-tour="recipes-templates"] button'), timeout_ms = 15_000)
    shoot("05-recipes-list")
    templates = page.locator("main button").filter(has_not_text = re.compile(r"^(\+|Create)"))
    n_templates = templates.count()
    info(f"recipe templates visible: {n_templates}")
    if n_templates == 0:
        soft_fail("no recipe template cards found")
    else:
        try:
            templates.first.scroll_into_view_if_needed()
            templates.first.click()
            # The first `main button` is the "New Recipe" trigger, which opens a menu.
            wait_for_first(
                page.locator(
                    ".react-flow__renderer, .react-flow, [data-testid*='react-flow'], "
                    "[role='dialog'], [role='menu']"
                ),
                timeout_ms = 15_000,
            )
            shoot("06-recipe-opened")
            canvas = page.locator(
                ".react-flow__renderer, .react-flow, [data-testid*='react-flow']"
            ).first
            if canvas.count() == 0:
                info("(no React-Flow canvas; template may have opened a dialog)")
            else:
                info("OK React-Flow canvas mounted")
        except Exception as exc:
            soft_fail(f"recipe template click failed: {exc!r}")

    # 3. Export route.
    step(f"Export route ({'chat-only self-gated' if chat_only else 'form fields'})")
    page.goto(f"{BASE}/export")
    wait_for_first(
        page.locator('[data-tour="export-cta"]').or_(
            page.get_by_text(re.compile(r"Export unavailable", re.I))
        ),
        timeout_ms = 15_000,
    )
    shoot("07-export")
    if chat_only:
        if "/export" not in page.url:
            soft_fail(f"chat-only mode should keep /export reachable; url={page.url}")
        else:
            unavailable = page.get_by_text(re.compile(r"Export unavailable", re.I)).first
            # The gate renders only after the hardware query answers, later than the form satisfying the wait above.
            try:
                unavailable.wait_for(state = "visible", timeout = 15_000)
                info("OK chat-only /export rendered the unavailable gate")
            except Exception:
                soft_fail("chat-only /export did not show the export unavailable gate within 15s")
    else:
        cta = page.locator('[data-tour="export-cta"]').first
        if cta.count() == 0:
            soft_fail("[data-tour='export-cta'] not found in /export")
        else:
            info("OK [data-tour='export-cta'] visible")
        hf_token = wait_for_first(
            page.get_by_placeholder(re.compile(r"hf[_\\.\\-]", re.I))
            .or_(page.locator('input[placeholder*="token" i], input[placeholder*="huggingface" i]'))
            .or_(page.locator('input[name="hf_token"], input[id*="hf-token"]')),
            timeout_ms = 8_000,
        )
        if hf_token is not None:
            info("OK HF token input visible")
        else:
            info(
                "WARN HF token input not located in /export after 8s "
                "(likely lazy-loaded behind a disclosure section -- "
                "non-blocking for upload flow)"
            )

    # 4. Unsloth training route.
    step(f"Unsloth route ({'chat-only redirect' if chat_only else 'tabs + sections'})")
    page.goto(f"{BASE}/studio")
    if chat_only:
        try:
            page.wait_for_url(lambda u: "/studio" not in u, timeout = 15_000)
        except Exception:
            pass
    else:
        wait_for_first(page.locator('[data-tour="studio-params"]'), timeout_ms = 15_000)
        wait_for_first(page.get_by_role("tab"), timeout_ms = 5_000)
    shoot("08-studio")
    if chat_only:
        if "/studio" in page.url:
            soft_fail(f"chat-only mode should redirect /studio -> /chat; url={page.url}")
        else:
            info(f"OK chat-only redirected /studio -> {page.url}")
    else:
        for tab_name in ("Configure", "Current run", "History"):
            tab = page.get_by_role("tab", name = re.compile(rf"^\s*{tab_name}\s*$", re.I)).first
            if tab.count() == 0:
                soft_fail(f"tab '{tab_name}' not found in /studio")
            else:
                info(f"OK tab '{tab_name}' visible")
        for anchor in ("studio-model-picker", "studio-dataset", "studio-params"):
            el = page.locator(f'[data-tour="{anchor}"]').first
            if el.count() == 0:
                soft_fail(f"[data-tour='{anchor}'] not found")
            else:
                info(f"OK [data-tour='{anchor}'] visible")

    # 5. Settings dialog tabs.
    step("Settings dialog: cycle through tabs")
    page.goto(f"{BASE}/chat")
    composer.wait_for(state = "visible", timeout = 60_000)
    dictate = page.get_by_role("button", name = "Dictate").first
    if dictate.count() == 0:
        fail("Chat Dictate button not found")
    elif dictate.get_attribute("type") != "button":
        fail("Chat Dictate control must use type=button, not submit the composer")
    else:
        info("OK Chat Dictate control is type=button")

    page.keyboard.press("Control+,")
    settings = wait_for_first(page.get_by_role("dialog"), timeout_ms = 5_000)
    if settings is None:
        page.keyboard.press("Meta+,")
        settings = wait_for_first(page.get_by_role("dialog"), timeout_ms = 5_000)
    if settings is None:
        soft_fail("Settings dialog didn't open with Cmd/Ctrl-,")
    else:
        shoot("09-settings-open")
        candidate_tabs = (
            "General",
            "Profile",
            "Appearance",
            "Chat",
            "Developer",
            "Voice",
            "About",
        )
        seen_tabs = []
        for tab_name in candidate_tabs:
            btn = page.get_by_role(
                "button",
                name = re.compile(rf"^\s*{tab_name}\s*$", re.I),
            ).first
            if btn.count() == 0:
                continue
            try:
                btn.click()
                try:
                    btn.locator("span.bg-accent").first.wait_for(state = "attached", timeout = 5_000)
                    page.wait_for_function(
                        """() => {
                            const dialog = document.querySelector('[role="dialog"]');
                            return !!dialog && (dialog.innerText || '').trim().length > 30;
                        }""",
                        timeout = 5_000,
                    )
                except Exception:
                    pass
                body_text = page.evaluate(
                    """() => {
                        const dialog = document.querySelector('[role="dialog"]');
                        return dialog ? (dialog.innerText || '').trim().length : 0;
                    }"""
                )
                if body_text > 30:
                    info(f"OK Settings tab '{tab_name}' body length={body_text}")
                    seen_tabs.append(tab_name)
                else:
                    soft_fail(f"Settings tab '{tab_name}' body suspiciously short: {body_text}")
            except Exception as exc:
                soft_fail(f"Settings tab '{tab_name}' click failed: {exc!r}")
        step("Voice model picker: real mouse-wheel scrolling")
        # By test id: the tab label is translated.
        voice_tab = page.get_by_test_id("settings-tab-voice").first
        if voice_tab.count() == 0:
            fail("Voice settings tab not found")
        else:
            # The dictation dropdown can crash headless Chromium on macOS; there a crash is only a warning.
            try:
                voice_tab.click()
                page.get_by_test_id("dictation-engine-trigger").click()
                page.get_by_test_id("dictation-engine-model").click()
                page.get_by_test_id("stt-model-trigger").click()
                wheel_step_active[0] = True
                results = page.get_by_test_id("stt-model-results")
                # Wheel the searched rows: the pre-search built-in list overflows first, and during the search the list
                # is one spinner row. Snapshot built-in rows and require a different list.
                builtin_rows_js = """() => {
                    const node = document.querySelector('[data-testid="stt-model-results"]');
                    if (!node) return "";
                    return Array.from(node.querySelectorAll('button'))
                        .map((row) => row.innerText).join("\\u0000");
                }"""
                try:
                    results.locator("button").first.wait_for(state = "attached", timeout = 10_000)
                except Exception as builtin_err:
                    info(f"WARN built-in model rows never rendered: {builtin_err!r}")
                builtin_rows = robust_evaluate(page, builtin_rows_js)
                page.get_by_test_id("stt-model-search").fill("whisper")
                query_typed_at = time.monotonic()
                searched_rows_overflow = """(builtin) => {
                    const node = document.querySelector('[data-testid="stt-model-results"]');
                    if (!node || node.scrollHeight <= node.clientHeight) return false;
                    const rows = Array.from(node.querySelectorAll('button'));
                    if (rows.length === 0) return false;
                    return rows.map((row) => row.innerText).join("\\u0000") !== builtin;
                }"""
                rows_overflow = """() => {
                    const node = document.querySelector('[data-testid="stt-model-results"]');
                    return !!node
                        && node.querySelectorAll('button').length > 0
                        && node.scrollHeight > node.clientHeight;
                }"""
                scrolled_js = """() => {
                    const node = document.querySelector('[data-testid="stt-model-results"]');
                    return !!node && node.scrollTop > 0;
                }"""
                wheel_started_at = time.monotonic()
                wheel_deadline = wheel_started_at + WHEEL_DEADLINE_S
                wheel_scrolled = False
                cleared_search = False
                extended_for: set = set()
                next_rows_ms = float(WHEEL_ROWS_TIMEOUT_MS)

                def search_abort_extension() -> tuple:
                    """Budget rebased onto in-flight search; only requests after typing count."""
                    live = [(at, req) for req, at in hf_inflight.items() if at >= query_typed_at]
                    if not live:
                        return None, 0.0
                    started, req = min(live, key = lambda pair: pair[0])
                    return req, max(
                        0.0, (started - time.monotonic()) * 1000 + WHEEL_ROWS_TIMEOUT_MS
                    )

                while not wheel_scrolled:
                    remaining_ms = (wheel_deadline - time.monotonic()) * 1000
                    if remaining_ms <= 0:
                        break
                    rows_ms = min(remaining_ms, next_rows_ms)
                    next_rows_ms = float(WHEEL_ROWS_TIMEOUT_MS)
                    try:
                        if cleared_search:
                            page.wait_for_function(rows_overflow, timeout = rows_ms)
                        else:
                            page.wait_for_function(
                                searched_rows_overflow,
                                arg = builtin_rows,
                                timeout = rows_ms,
                            )
                    except Exception as row_err:
                        if page_crashed(page, row_err):
                            raise
                        if not (cleared_search or hf_unreachable or HF_OFFLINE):
                            open_req, extra_ms = search_abort_extension()
                            if (
                                open_req is not None
                                and open_req not in extended_for
                                and extra_ms > 0
                            ):
                                extended_for.add(open_req)
                                next_rows_ms = extra_ms
                                # Push the step deadline past the re-based request, or the second search is cut off mid-flight.
                                wheel_deadline = min(
                                    wheel_started_at + WHEEL_DEADLINE_MAX_S,
                                    max(wheel_deadline, time.monotonic() + extra_ms / 1000),
                                )
                                info(
                                    "WARN search rows are not in and a Hugging Face request is "
                                    f"still open; waiting {extra_ms / 1000:.1f}s more for it to "
                                    "answer or abort"
                                )
                                continue
                        # The built-in list is only accepted on proof the Hub is unreachable or a declared offline runner.
                        offline = bool(hf_unreachable) or HF_OFFLINE
                        if cleared_search or not offline:
                            break
                        why = hf_unreachable[0] if hf_unreachable else "STUDIO_UI_HF_OFFLINE=1"
                        info(
                            f"WARN no 'whisper' search rows and the Hub is unreachable ({why}); "
                            "wheeling the built-in list instead"
                        )
                        cleared_search = True
                        page.get_by_test_id("stt-model-search").fill("")
                        continue
                    results.hover()
                    page.mouse.wheel(0, 700)
                    try:
                        page.wait_for_function(scrolled_js, timeout = 2_000)
                    except Exception as wheel_err:
                        if page_crashed(page, wheel_err):
                            raise
                        continue
                    wheel_scrolled = True
                if wheel_scrolled:
                    info("OK Voice model picker mouse wheel changed scrollTop")
                else:
                    try:
                        geom = robust_evaluate(
                            page,
                            """() => {
                                const node = document.querySelector('[data-testid="stt-model-results"]');
                                if (!node) return null;
                                return {
                                    scrollTop: node.scrollTop,
                                    scrollHeight: node.scrollHeight,
                                    clientHeight: node.clientHeight,
                                    rows: node.querySelectorAll('button').length,
                                };
                            }""",
                        )
                    except Exception as geom_err:
                        geom = f"<unreadable: {geom_err!r}>"
                    fail(
                        f"Voice model picker did not wheel-scroll: {geom} "
                        f"hub_unreachable={hf_unreachable[:1] or False} "
                        f"cleared_search={cleared_search}"
                    )
            except Exception as exc:
                if page_crashed(page, exc) and MACOS_RUNNER:
                    runtime_warn(f"Voice model picker aborted (browser/page unstable): {exc!r}")
                    page = recover_or_replace_page(
                        page,
                        ctx,
                        default_timeout_ms = 60_000,
                        info = lambda m: info(f"recovery: {m}"),
                    )
                else:
                    fail(f"Voice model picker did not wheel-scroll: {exc!r}")
            finally:
                wheel_step_active[0] = False
        # After a crash closed the context, the returned page is closed; skip teardown.
        if not page.is_closed():
            shoot("10-settings-tabs-visited")
            # The first Escape may only close the voice picker's popover.
            dialogs = page.get_by_role("dialog")
            for _escape in range(2):
                page.keyboard.press("Escape")
                try:
                    expect(dialogs).to_have_count(0, timeout = 2_000)
                    break
                except AssertionError:
                    pass
        info(f"visited Settings tabs: {seen_tabs}")
        if not seen_tabs:
            soft_fail("no Settings tabs were visitable")

    if page_errors:
        info(f"WARN {len(page_errors)} pageerror events; first: {page_errors[0]!r}")
        fail(f"{len(page_errors)} pageerror events")

    if _failed:
        info(f"FAILED: {len(_failed)} assertion(s)")
        for m in _failed:
            info(f"  - {m}")
        sys.exit(1)
    info("PASS extra UI flow")
    _watchdog.cancel()
    try:
        browser.close()
    except Exception:
        pass