iCode-TUI 0.29.1__py3-none-any.whl

chrys/app/tui/util/git_branch.py

@@ -0,0 +1,326 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Git branch discovery and HEAD-file monitoring for TUI workspace chrome."""
+
+from __future__ import annotations
+
+import contextlib
+import logging
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+GIT_BRANCH_POLL_INTERVAL_SECONDS = 7.0
+
+_GIT_DIR_PREFIX = "gitdir:"
+_REFS_HEADS_PREFIX = "refs/heads/"
+_HEAD_NAME = "HEAD"
+
+
+@dataclass(frozen=True, slots=True)
+class GitBranchSnapshot:
+    """Current git branch metadata for a workspace cwd."""
+
+    cwd: str
+    branch: str = ""
+    head_path: Path | None = None
+    git_marker_path: Path | None = None
+    repo_root: Path | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class _GitPaths:
+    repo_root: Path
+    git_dir: Path
+    git_marker_path: Path
+
+
+@dataclass(frozen=True, slots=True)
+class _WatchTarget:
+    watch_dirs: tuple[Path, ...]
+    head_path: Path | None
+    git_marker_path: Path | None
+    pending_head_parent: Path | None = None
+    non_git_cwd: Path | None = None
+
+
+def format_workspace_subtitle(cwd: str, branch: str) -> str:
+    """Return the chat border subtitle for *cwd* and an optional git branch."""
+    if not cwd:
+        return ""
+    if not branch:
+        return cwd
+    return f"{cwd} ({branch})"
+
+
+def read_git_branch_snapshot(cwd: str) -> GitBranchSnapshot:
+    """Read git branch metadata for *cwd* without invoking git."""
+    start = _path_from_cwd(cwd)
+    if start is None:
+        return GitBranchSnapshot(cwd=cwd)
+    paths = _find_git_paths(start)
+    if paths is None:
+        return GitBranchSnapshot(cwd=cwd)
+    head_path = paths.git_dir / _HEAD_NAME
+    branch = _read_head_branch(head_path)
+    return GitBranchSnapshot(
+        cwd=cwd,
+        branch=branch,
+        head_path=head_path,
+        git_marker_path=paths.git_marker_path,
+        repo_root=paths.repo_root,
+    )
+
+
+class GitBranchMonitor:
+    """Watch the git HEAD file for a workspace cwd.
+
+    The monitor uses watchdog file notifications. Callers should still refresh on
+    semantic UI events such as tool completion because those updates are cheap
+    and cover environments where native file notifications are unavailable.
+    """
+
+    def __init__(self, on_change: Callable[[], None]) -> None:
+        self._on_change = on_change
+        self._cwd = ""
+        self._active = False
+        self._observer: Any | None = None
+        self._target: _WatchTarget | None = None
+
+    @property
+    def watching(self) -> bool:
+        """Return whether a native filesystem watcher is currently active."""
+        return self._observer is not None
+
+    @property
+    def active(self) -> bool:
+        """Return whether monitoring has been started."""
+        return self._active
+
+    def start(self, cwd: str) -> GitBranchSnapshot:
+        """Activate monitoring for *cwd* and return the current snapshot."""
+        self._active = True
+        return self.configure(cwd)
+
+    def configure(self, cwd: str) -> GitBranchSnapshot:
+        """Switch monitoring to *cwd* and return the current snapshot."""
+        self._cwd = cwd
+        snapshot = read_git_branch_snapshot(cwd)
+        self._sync_watch_target(snapshot)
+        return snapshot
+
+    def refresh(self) -> GitBranchSnapshot:
+        """Re-read current branch metadata and adjust watcher paths if needed."""
+        snapshot = read_git_branch_snapshot(self._cwd)
+        self._sync_watch_target(snapshot)
+        return snapshot
+
+    def stop(self) -> None:
+        """Stop native file monitoring."""
+        self._active = False
+        self._target = None
+        self._stop_observer()
+
+    def _sync_watch_target(self, snapshot: GitBranchSnapshot) -> None:
+        target = _watch_target_for_snapshot(snapshot)
+        if target == self._target:
+            if self._active and self._observer is None and target is not None:
+                self._start_observer(target)
+            return
+        self._target = target
+        self._stop_observer()
+        if not self._active or target is None:
+            return
+        self._start_observer(target)
+
+    def _start_observer(self, target: _WatchTarget) -> None:
+        from watchdog.events import FileSystemEventHandler
+        from watchdog.observers import Observer
+
+        on_change = self._on_change
+
+        class _HeadEventHandler(FileSystemEventHandler):
+            def on_any_event(self, event: object) -> None:
+                if _event_matches_watch_target(event, target):
+                    on_change()
+
+        observer = Observer()
+        try:
+            for watch_dir in target.watch_dirs:
+                observer.schedule(_HeadEventHandler(), str(watch_dir), recursive=False)
+            observer.start()
+        except OSError, RuntimeError:
+            logger.debug("failed to start git branch file monitor", exc_info=True)
+            with contextlib.suppress(RuntimeError):
+                observer.stop()
+            return
+        self._observer = observer
+
+    def _stop_observer(self) -> None:
+        observer = self._observer
+        if observer is None:
+            return
+        self._observer = None
+        with contextlib.suppress(RuntimeError):
+            observer.stop()
+        with contextlib.suppress(RuntimeError):
+            observer.join(timeout=1.0)
+
+
+def _path_from_cwd(cwd: str) -> Path | None:
+    raw = cwd.strip()
+    if not raw:
+        return None
+    try:
+        return Path(raw).expanduser().resolve(strict=False)
+    except OSError, RuntimeError:
+        logger.debug("failed to resolve workspace cwd for git branch lookup: %s", cwd, exc_info=True)
+        return None
+
+
+def _find_git_paths(start: Path) -> _GitPaths | None:
+    for candidate in (start, *start.parents):
+        marker = candidate / ".git"
+        if marker.is_dir():
+            return _GitPaths(repo_root=candidate, git_dir=marker, git_marker_path=marker)
+        if marker.is_file():
+            git_dir = _read_gitdir_file(marker, candidate)
+            if git_dir is not None:
+                return _GitPaths(repo_root=candidate, git_dir=git_dir, git_marker_path=marker)
+        if _looks_like_bare_git_dir(candidate):
+            return _GitPaths(repo_root=candidate, git_dir=candidate, git_marker_path=candidate / _HEAD_NAME)
+    return None
+
+
+def _read_gitdir_file(marker: Path, repo_root: Path) -> Path | None:
+    text = _read_first_line(marker)
+    if not text.lower().startswith(_GIT_DIR_PREFIX):
+        return None
+    raw_git_dir = text[len(_GIT_DIR_PREFIX) :].strip()
+    if not raw_git_dir:
+        return None
+    git_dir = Path(raw_git_dir)
+    if not git_dir.is_absolute():
+        git_dir = repo_root / git_dir
+    try:
+        return git_dir.expanduser().resolve(strict=False)
+    except OSError, RuntimeError:
+        logger.debug("failed to resolve gitdir from %s", marker, exc_info=True)
+        return None
+
+
+def _looks_like_bare_git_dir(candidate: Path) -> bool:
+    return (candidate / _HEAD_NAME).is_file() and (candidate / "objects").is_dir() and (candidate / "refs").is_dir()
+
+
+def _read_head_branch(head_path: Path) -> str:
+    text = _read_first_line(head_path)
+    if not text:
+        return ""
+    if text.startswith("ref:"):
+        ref = text[4:].strip()
+        if ref.startswith(_REFS_HEADS_PREFIX):
+            return ref[len(_REFS_HEADS_PREFIX) :]
+        return ref
+    if len(text) >= 7 and all(char in "0123456789abcdefABCDEF" for char in text):
+        return f"detached {text[:7]}"
+    return ""
+
+
+def _read_first_line(path: Path) -> str:
+    try:
+        raw = path.read_bytes()
+    except OSError:
+        return ""
+    return raw.decode("utf-8", errors="replace").splitlines()[0].strip() if raw else ""
+
+
+def _watch_target_for_snapshot(snapshot: GitBranchSnapshot) -> _WatchTarget | None:
+    watch_dirs: list[Path] = []
+    pending_head_parent = None
+    if snapshot.head_path is not None:
+        head_parent = snapshot.head_path.parent
+        if head_parent.is_dir():
+            _append_existing_dir(watch_dirs, head_parent)
+        else:
+            pending_head_parent = head_parent
+            _append_existing_dir(watch_dirs, _nearest_existing_parent(head_parent))
+    if snapshot.git_marker_path is not None:
+        _append_existing_dir(watch_dirs, snapshot.git_marker_path.parent)
+    non_git_cwd = None
+    if snapshot.head_path is None:
+        non_git_cwd = _path_from_cwd(snapshot.cwd)
+        if non_git_cwd is not None:
+            _append_existing_dir(watch_dirs, non_git_cwd)
+    if not watch_dirs:
+        return None
+    return _WatchTarget(
+        watch_dirs=tuple(watch_dirs),
+        head_path=snapshot.head_path,
+        git_marker_path=snapshot.git_marker_path,
+        pending_head_parent=pending_head_parent,
+        non_git_cwd=non_git_cwd,
+    )
+
+
+def _nearest_existing_parent(path: Path) -> Path:
+    for candidate in (path, *path.parents):
+        if candidate.is_dir() and candidate.parent != candidate:
+            return candidate
+    return path
+
+
+def _append_existing_dir(paths: list[Path], path: Path) -> None:
+    if not path.is_dir():
+        return
+    if path not in paths:
+        paths.append(path)
+
+
+def _event_matches_watch_target(event: object, target: _WatchTarget) -> bool:
+    for raw_path in _event_paths(event):
+        path = _event_path(raw_path)
+        if path is None:
+            continue
+        if target.head_path is not None and _path_matches_head(path, target.head_path):
+            return True
+        if target.git_marker_path is not None and _path_matches_git_marker(path, target.git_marker_path):
+            return True
+        if target.pending_head_parent is not None and _path_touches_pending_head_parent(
+            path,
+            target.pending_head_parent,
+        ):
+            return True
+        if target.non_git_cwd is not None and path.parent == target.non_git_cwd and path.name == ".git":
+            return True
+    return False
+
+
+def _event_paths(event: object) -> tuple[object, object]:
+    return (getattr(event, "src_path", ""), getattr(event, "dest_path", ""))
+
+
+def _event_path(raw: object) -> Path | None:
+    if not isinstance(raw, str) or not raw:
+        return None
+    try:
+        return Path(raw).expanduser().resolve(strict=False)
+    except OSError, RuntimeError:
+        return None
+
+
+def _path_matches_head(path: Path, head_path: Path) -> bool:
+    if path == head_path:
+        return True
+    return path.parent == head_path.parent and path.name.startswith(_HEAD_NAME)
+
+
+def _path_matches_git_marker(path: Path, marker: Path) -> bool:
+    return path == marker
+
+
+def _path_touches_pending_head_parent(path: Path, pending_head_parent: Path) -> bool:
+    return path == pending_head_parent or path in pending_head_parent.parents

chrys/app/tui/util/invocation_progress.py

@@ -0,0 +1,57 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Shared display of agent progress and reported usage."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from chrys.app.tui.util.formatting import format_token_count
+from chrys.foundation.i18n import MessageRef, msg
+from chrys.foundation.i18n.formatting import format_message
+
+_SUB_AGENT_SPEND = msg("tui.tool_card.sub_agent.spend", fallback="Spend: {spend}")
+_SUB_AGENT_TOOL_CALLS = msg("tui.tool_card.sub_agent.tool_calls", fallback="Tool calls: {n}")
+_SUB_AGENT_CTX_TOKENS = msg("tui.tool_card.sub_agent.ctx_tokens", fallback="Ctx: {tokens} tokens")
+_SUB_AGENT_TOKENS = msg("tui.tool_card.sub_agent.tokens", fallback="{tokens} tokens")
+_SUB_AGENT_ZERO_REPORTED_TOKENS = msg(
+    "tui.tool_card.sub_agent.zero_reported_tokens",
+    fallback="0 reported tokens",
+)
+_SUB_AGENT_UNREPORTED_ATTEMPTS = msg(
+    "tui.tool_card.sub_agent.unreported_attempts",
+    fallback="{count} unreported attempt",
+    plural_fallback="{count} unreported attempts",
+)
+_SUB_AGENT_COMPACTIONS = msg("tui.tool_card.sub_agent.compactions", fallback="Compactions: {n}")
+
+
+def invocation_progress_parts(
+    *,
+    tool_calls: int = 0,
+    context_tokens: int = 0,
+    usage_tokens: int = 0,
+    unreported_attempts: int = 0,
+    compactions: int = 0,
+    include_zero: bool = False,
+    render: Callable[[MessageRef], str] = format_message,
+) -> list[str]:
+    """Format counters without conflating current context size with cumulative spend."""
+    parts: list[str] = []
+    if tool_calls > 0 or include_zero:
+        parts.append(render(_SUB_AGENT_TOOL_CALLS.bind(n=tool_calls)))
+    if context_tokens > 0:
+        parts.append(render(_SUB_AGENT_CTX_TOKENS.bind(tokens=format_token_count(context_tokens))))
+    if usage_tokens or unreported_attempts or include_zero:
+        spend = (
+            render(_SUB_AGENT_TOKENS.bind(tokens=format_token_count(usage_tokens)))
+            if usage_tokens or not unreported_attempts
+            else render(_SUB_AGENT_ZERO_REPORTED_TOKENS.bind())
+        )
+        if unreported_attempts:
+            attempts = render(_SUB_AGENT_UNREPORTED_ATTEMPTS.bind(count=unreported_attempts))
+            spend += f" · {attempts}"
+        parts.append(render(_SUB_AGENT_SPEND.bind(spend=spend)))
+    if compactions > 0:
+        parts.append(render(_SUB_AGENT_COMPACTIONS.bind(n=compactions)))
+    return parts

chrys/app/tui/util/logo.py

@@ -0,0 +1,32 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Terminal wordmarks for the application and its welcome modes."""
+
+TUI_LOGO = """
+   ▄   ▄▄▄▄
+   ▀██████▀          █▄
+ ▀▀  ██              ██
+ ██  ██     ▄███▄ ▄████ ▄█▀█▄
+ ██  ██     ██ ██ ██ ██ ██▄█▀
+▄██  ▀█████▄▀███▀▄█▀███▄▀█▄▄▄
+"""
+
+CHAT_LOGO = """
+ ▄   ▄▄▄▄
+ ▀██████▀ █▄          █▄
+   ██     ██         ▄██▄
+   ██     ████▄ ▄▀▀█▄ ██
+   ██     ██ ██ ▄█▀██ ██
+   ▀█████▄██ ██▄▀█▄██▄██
+"""
+
+WORKFLOW_LOGO = """
+  ▄▄▄                             ▄▄ ▄▄
+ █▀██  ██  ██▀▀                  ██   ██
+   ██  ██  ██       ▄     ▄▄    ▄██▄  ██
+   ██  ██  ██ ▄███▄ ████▄ ██ ▄█▀ ██   ██ ▄███▄▀█▄ █▄ ██▀
+   ██▄ ██▄ ██ ██ ██ ██    ████   ██   ██ ██ ██ ██▄██▄██
+   ▀████▀███▀▄▀███▀▄█▀   ▄██ ▀█▄▄██  ▄██▄▀███▀  ▀██▀██▀
+                                 ██
+                                ▀▀
+"""

chrys/app/tui/util/message_gate.py

@@ -0,0 +1,35 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Dropping the messages that given widgets post to themselves, for code that awaits.
+
+``MessagePump.prevent()`` only guards synchronous code: every task in the App shares its stack, so
+while a block inside it awaits, the prevented types are dropped for every widget. A tab bar the reader
+clicks meanwhile then moves its selection while its content stays put.
+"""
+
+from __future__ import annotations
+
+from contextlib import contextmanager
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from textual.message import Message
+    from textual.message_pump import MessagePump
+
+
+@contextmanager
+def messages_disabled(message_type: type[Message], *pumps: MessagePump) -> Iterator[None]:
+    """Drop *message_type* posted to *pumps* until the block ends, including while it awaits.
+
+    Messages that other widgets post are unaffected. Blocks on one widget must not overlap: the first
+    to end enables the type again.
+    """
+    for pump in pumps:
+        pump.disable_messages(message_type)
+    try:
+        yield
+    finally:
+        for pump in pumps:
+            pump.enable_messages(message_type)

chrys/app/tui/util/mutation_sources.py

@@ -0,0 +1,14 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Helpers for mutation provenance values displayed by the TUI."""
+
+from __future__ import annotations
+
+from chrys.service.mutations.types import MutationSource
+
+
+def merge_mutation_source(current: str, source: str) -> str:
+    """Merge mutation provenance while preserving any implicit marker."""
+    if current == MutationSource.IMPLICIT.value or source == MutationSource.IMPLICIT.value:
+        return MutationSource.IMPLICIT.value
+    return source or current

chrys/app/tui/util/picker_text.py

@@ -0,0 +1,27 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Text layout shared by the profile pickers."""
+
+from __future__ import annotations
+
+import textwrap
+
+_DESC_INDENT = "    "
+"""Indent for description lines (matches width of '  - ')."""
+
+
+def wrap_description(desc: str, width: int) -> str:
+    """Wrap description text so continuation lines align after '  - '."""
+    if not desc:
+        return ""
+    indent = _DESC_INDENT
+    first_prefix = "  - "
+    # Available width for text on the first and subsequent lines
+    text_width = max(width - len(indent), 20)
+    lines = textwrap.wrap(desc, width=text_width)
+    if not lines:
+        return ""
+    result = first_prefix + lines[0]
+    for line in lines[1:]:
+        result += "\n" + indent + line
+    return result

chrys/app/tui/util/removal.py

@@ -0,0 +1,47 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Widget removal that cancelling its caller cannot cut short.
+
+Textual's removal awaitable gathers the removed widgets' message loops, so cancelling the wait
+cancels them. A widget cancelled while it waits for its own children to exit never detaches: it
+stays in the DOM, blank and without a message loop, and the App's message loop, which awaits the
+same removal, ends as well. Code that a cancellable task can run (a worker, a flow task, or an
+EventBus handler, which runs inside the publishing engine task) removes through these helpers.
+
+A cancelled caller waits for the removal to finish before its cancellation goes on, so whatever runs
+after it, and any lock it holds, sees the widgets already gone. Cancelling it again ends that wait at
+once; the removal still finishes.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable
+
+    from textual.widget import Widget
+
+
+async def finish_shielded(operation: Awaitable[object]) -> None:
+    """Await *operation* (a removal such as ``Tabs.clear()``, or a coroutine built on one) to its end."""
+    task = asyncio.ensure_future(operation)
+    try:
+        await asyncio.shield(task)
+    except asyncio.CancelledError:
+        # The cancellation outranks whatever the operation raises.
+        with contextlib.suppress(Exception):
+            await asyncio.shield(task)
+        raise
+
+
+async def remove_shielded(widget: Widget) -> None:
+    """Remove *widget* to the end, even when the caller is cancelled."""
+    await finish_shielded(widget.remove())
+
+
+async def remove_children_shielded(container: Widget) -> None:
+    """Remove *container*'s children to the end, even when the caller is cancelled."""
+    await finish_shielded(container.remove_children())

chrys/app/tui/util/rich_style.py

@@ -0,0 +1,36 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Rich styles built from Textual color values."""
+
+from __future__ import annotations
+
+from rich.style import Style
+from textual.color import Color, ColorParseError
+
+
+def rich_style_from_textual_color(
+    color: str | None,
+    *,
+    background: str | None = None,
+    bold: bool | None = None,
+    dim: bool | None = None,
+    reverse: bool | None = None,
+) -> Style:
+    """Convert a plain Textual color token to a concrete Rich style.
+
+    Textual's ANSI color names use an ``ansi_`` prefix that Rich doesn't
+    accept in style strings. Parsing through Textual first preserves the
+    ANSI color number while giving Rich a native color object. Composite
+    CSS values such as ``auto 60%`` and text-style values must instead be
+    resolved through a component class and ``get_component_rich_style()``.
+    Invalid input falls back to an attribute-only style rather than crashing.
+    """
+    try:
+        rich_color = Color.parse(color).rich_color if color is not None else None
+    except ColorParseError:
+        rich_color = None
+    try:
+        rich_background = Color.parse(background).rich_color if background is not None else None
+    except ColorParseError:
+        rich_background = None
+    return Style(color=rich_color, bgcolor=rich_background, bold=bold, dim=dim, reverse=reverse)

chrys/app/tui/util/source_text.py

@@ -0,0 +1,12 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Display-only normalization and control-character filtering for literal source text."""
+
+from __future__ import annotations
+
+from chrys.foundation.i18n.formatting import sanitize_terminal_block
+
+
+def sanitize_source_text(source: str, *, tab_size: int = 4) -> str:
+    """Preserve line breaks and indentation before replacing C0/C1 and DEL controls."""
+    return sanitize_terminal_block(source).expandtabs(tab_size)

chrys/app/tui/util/static_update.py

@@ -0,0 +1,88 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Replace a ``Static``'s content, laying the screen out only when the widget's geometry changes.
+
+``Static.update()`` defaults to ``layout=True``. A layout request from a widget in the chat
+transcript clears the arrangement of every auto-sized ancestor up to the chat panel and makes the
+Screen reflow, and the reflow's cost grows with the mounted transcript. Running tool cards update a
+spinner frame eight times a second, an elapsed-time label once a second and a streamed output tail
+per line, and almost none of those updates changes the widget's size.
+
+Textual caches each widget's box model per set of arrangement inputs and reuses it until the widget
+itself requests a layout; a content change that skips the layout therefore must leave the box model
+unchanged. Only an ``auto`` width or height reads the content, so a widget without either never needs
+one. Otherwise the new content is measured the way the arrangement measures it, at the laid-out
+width, and compared with the laid-out size: the width and height the arrangement last gave the
+widget are fixed points of its clamping, so an equal measurement yields the same box model.
+
+Geometry comes from ``outer_size``, which the last arrangement stored on the widget. ``size`` and
+``region`` look the widget up in the compositor map, which an offscreen repaint invalidates, so
+reading them could rebuild the map for the whole transcript.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from textual.content import Content
+from textual.geometry import Size
+
+if TYPE_CHECKING:
+    from textual.visual import VisualType
+    from textual.widget import Widget
+    from textual.widgets import Static
+
+_NEVER_ARRANGED = Size(0, 0)
+
+
+def update_static_in_place(static: Static, content: VisualType) -> None:
+    """Replace *static*'s content, requesting a layout only when its box model would change.
+
+    Behaves like ``static.update(content)`` whenever the new content can change the widget's size,
+    and like ``static.update(content, layout=False)`` otherwise.
+    """
+    static.update(content, layout=False)
+    if _content_changes_geometry(static):
+        static.refresh(layout=True)
+
+
+def _content_changes_geometry(static: Static) -> bool:
+    styles = static.styles
+    width_rule = styles.width
+    height_rule = styles.height
+    auto_width = width_rule is not None and width_rule.is_auto
+    auto_height = height_rule is not None and height_rule.is_auto
+    if not (auto_width or auto_height):
+        return False
+    if not static.is_mounted:
+        return True
+    outer = static.outer_size
+    if outer == _NEVER_ARRANGED:
+        # No arrangement has measured the widget, so no cached box model holds its old content: the
+        # arrangement that first shows a widget below a hidden ancestor measures the current content.
+        # An auto-width widget can legitimately arrange to zero cells, so it keeps its layout.
+        return auto_width or _in_displayed_tree(static)
+    if static.is_container or styles.overflow_x != "hidden" or styles.overflow_y != "hidden":
+        # Children are measured through the layout, and a scrollbar adds cells between measuring
+        # and clamping; neither is predicted here.
+        return True
+    gutter = styles.gutter
+    content_width = outer.width - gutter.width
+    if auto_width:
+        if static.expand or static.shrink or not isinstance(static.render(), Content):
+            # Only text content measures its optimal width independently of the container, whose
+            # arrangement width the widget does not store.
+            return True
+        if static.get_content_width(static.container_size, static.container_size) != content_width:
+            return True
+    if auto_height:
+        # A leaf widget's height depends on its content width alone; the container and viewport
+        # arguments only matter to a widget that arranges children.
+        measured = static.get_content_height(static.container_size, static.container_size, content_width)
+        if measured != outer.height - gutter.height:
+            return True
+    return False
+
+
+def _in_displayed_tree(widget: Widget) -> bool:
+    return all(node.display for node in widget.ancestors_with_self)