diff --git a/CLAUDE.md b/CLAUDE.md
index 1864960..4a4c46b 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -129,8 +129,8 @@ cd src && for f in aws_analyzer/[!_]*.py aws_analyzer/[!_]*/__init__.py; do m="$
   makes (`monkeypatch.setattr(s3mod, "_require", ...)`, `monkeypatch.setattr(chatmod, "_cell_number", ...)`: the
   chat's View asks it), on the `_kit` (or `_bedrock`) module for a call it makes
   (`monkeypatch.setattr(viewmod, "_progress_bar_class", ...)` with `from aws_analyzer._kit import view as viewmod`:
-  `_BaseView._progress` makes that call, and `_BaseView.__init__` asks `_in_notebook` there too; an explorer's
-  once-per-cell display asks `_cell_number` on `_kit.window`).
+  `_ProgressLine`, the line `_BaseView._progress` shows, makes that call, and `_BaseView.__init__` asks
+  `_in_notebook` there too; an explorer's once-per-cell display asks `_cell_number` on `_kit.window`).
   The exception is a companion (`COMPANIONS` in `.claude/skills/check/rules.py`): `s3_explorer.py` imports `s3`
   (lazily, inside `_s3_module()`), reuses its helpers instead of copying them. Its
   public commands are guarded by `_kit`'s `@_window_errors`, through its `_ready` (nothing runs without s3.py) and
diff --git a/ruff.toml b/ruff.toml
index 3c3dcbc..e1e544d 100644
--- a/ruff.toml
+++ b/ruff.toml
@@ -29,13 +29,6 @@ select = ["E4", "E7", "E9", "F", "B006", "BLE001", "ERA001", "C901", "PLR0912",
 ".claude/skills/demo/shots.py" = ["C901", "PLR0912", "PLR0913", "PLR0915"]
 ".claude/skills/release/release.py" = ["BLE001", "C901", "PLR0912", "PLR0915"]
 "src/aws_analyzer/_bedrock.py" = ["C901", "PLR0912", "PLR0915"]
-"src/aws_analyzer/_kit/fmt.py" = ["C901"]
-"src/aws_analyzer/_kit/highlight.py" = ["C901"]
-"src/aws_analyzer/_kit/jsontree.py" = ["PLR0913"]
-"src/aws_analyzer/_kit/progress.py" = ["BLE001"]
-"src/aws_analyzer/_kit/render.py" = ["C901", "PLR0912", "PLR0915"]
-"src/aws_analyzer/_kit/view.py" = ["BLE001", "C901", "PLR0915"]
-"src/aws_analyzer/_kit/window.py" = ["BLE001", "C901", "PLR0913"]
 "src/aws_analyzer/agent/analyzer.py" = ["PLR0913"]
 "src/aws_analyzer/agent/harness.py" = ["BLE001", "C901", "PLR0913"]
 "src/aws_analyzer/agent/llm.py" = ["PLR0913"]
diff --git a/src/aws_analyzer/_kit/analyzer.py b/src/aws_analyzer/_kit/analyzer.py
index 9e82fc8..df754dc 100644
--- a/src/aws_analyzer/_kit/analyzer.py
+++ b/src/aws_analyzer/_kit/analyzer.py
@@ -20,20 +20,28 @@ class _BaseAnalyzer:
     """
     What every <Service>Analyzer starts with: a boto3 session (session=, or one made from region= and profile=),
     the retry settings its clients use (self._config), and its prices, the service's list prices with prices= over
-    them. Nothing here talks to AWS until the service asks.
+    them (a copy, so the module's price table never changes). Nothing here talks to AWS until the service asks.
+
+    What the service sets:
+
+        _LIST_PRICES  its price table (S3_PRICES, ...), which prices= overrides
+        client        its main client
+        _clients      the clients _cached_client made, by service name
+        _lock         held while _cached_client makes a client
+        max_workers   how many threads _map uses; 1 runs in order, as a Stubber answers
     """
 
-    _LIST_PRICES: dict[str, Any] = {}  # the service's price table (S3_PRICES, ...), which prices= overrides
-    client: Any  # the service's main client, which the service makes
-    _clients: dict[Any, Any]  # _cached_client's clients by service name (the service sets it up, with its _lock)
-    _lock: Any  # held while _cached_client makes a client: boto3 sessions aren't thread-safe
-    max_workers: int  # how many threads _map uses (the service sets it); 1 runs in order, as a Stubber answers
+    _LIST_PRICES: dict[str, Any] = {}
+    client: Any
+    _clients: dict[Any, Any]
+    _lock: Any
+    max_workers: int
 
     def __init__(self, session: Any = None, *, region: str | None = None, profile: str | None = None,
                  prices: dict[str, Any] | None = None):
         self.session = session or boto3.Session(profile_name=profile, region_name=region)
         self._config = Config(retries={"max_attempts": 10, "mode": "adaptive"}, max_pool_connections=50)
-        self.prices = {**self._LIST_PRICES, **(prices or {})}  # a copy: the module's table never changes
+        self.prices = {**self._LIST_PRICES, **(prices or {})}
 
     @property
     def region(self) -> str:
@@ -41,10 +49,11 @@ def region(self) -> str:
 
     def _cached_client(self, service: str, make: Callable[[], Any]) -> Any:
         """
-        The client for `service`, made by make() the first time it's needed (or the one passed in clients=).
+        The client for `service`, made by make() the first time it's needed (or the one passed in clients=). It's
+        made under the lock: boto3 sessions aren't thread-safe, and the windows read from threads.
         """
         if service not in self._clients:
-            with self._lock:  # sessions aren't thread-safe, and the windows read from threads
+            with self._lock:
                 if service not in self._clients:
                     self._clients[service] = make()
         return self._clients[service]
diff --git a/src/aws_analyzer/_kit/blocks.py b/src/aws_analyzer/_kit/blocks.py
index 9be72ea..afedd35 100644
--- a/src/aws_analyzer/_kit/blocks.py
+++ b/src/aws_analyzer/_kit/blocks.py
@@ -5,6 +5,9 @@
 each block by what's registered for its type: its HTML, or its lines of text. These are the blocks every service
 uses (render.py draws them); a service's own blocks (_Passage, _Steps, _Wiring, ...) are defined in its module and
 register how they're drawn with @_draws when it's imported.
+
+The registries @_draws fills: _HTML (block type -> its HTML), _TEXT (block type -> its lines in text mode) and
+_CELLS (table cell type -> its HTML, given the cell's text).
 """
 
 from __future__ import annotations
@@ -15,66 +18,110 @@
 
 @dataclass
 class _Title:
+    """
+    The report's title, with a line under it (sub).
+    """
+
     text: str
     sub: str = ""
 
 
 @dataclass
 class _Cards:
-    items: list[tuple[str, ...]]  # (label, value), or (label, value, tone) with tone 'warn' | 'bad' | 'ok'
+    """
+    The few numbers that matter, as cards. Each item is (label, value), or (label, value, tone) with tone 'warn',
+    'bad' or 'ok'.
+    """
+
+    items: list[tuple[str, ...]]
 
 
 @dataclass
 class _Table:
+    """
+    A table of rows under its headers.
+
+        rows        cells are text, or _Tone for a coloured status (or another type registered as a cell)
+        bars        0..1 per row, drawn as an extra column headed bar_label
+        tree        the first column holds indented tree labels
+        max_rows    None for the view's default, 0 for no cap
+        code_cols   columns holding calls to copy, shown as code
+        prose_cols  columns of sentences this tool wrote (findings): the calls in them shown as code
+        collapsed   a secondary view: folded under its title in HTML
+        path_cols   columns of keys and paths: the file name always shows, a long folder is shortened
+        sortable    in HTML a click on a column's header sorts by it (tree tables never sort)
+    """
+
     headers: list[str]
-    rows: list[list[Any]]  # cells are text, or _Tone for a coloured status (or another type registered as a cell)
+    rows: list[list[Any]]
     title: str = ""
-    bars: list[float] | None = None  # 0..1 per row, drawn as an extra column
+    bars: list[float] | None = None
     bar_label: str = "Share"
-    tree: bool = False  # first column holds indented tree labels
-    max_rows: int | None = None  # None = view default, 0 = no cap
-    code_cols: tuple[int, ...] = ()  # columns holding calls to copy, shown as code
-    prose_cols: tuple[int, ...] = ()  # columns of sentences this tool wrote (findings): calls in them shown as code
-    collapsed: bool = False  # a secondary view: folded under its title in HTML
-    path_cols: tuple[int, ...] = ()  # columns of keys / paths: the file name always shows, a long folder is shortened
-    sortable: bool = True  # in HTML a click on a column's header sorts by it (tree tables never sort)
+    tree: bool = False
+    max_rows: int | None = None
+    code_cols: tuple[int, ...] = ()
+    prose_cols: tuple[int, ...] = ()
+    collapsed: bool = False
+    path_cols: tuple[int, ...] = ()
+    sortable: bool = True
 
 
 @dataclass
 class _Note:
+    """
+    A sentence on its own, at a level: 'info', 'warn' or 'ok'.
+    """
+
     text: str
-    level: str = "info"  # 'info' | 'warn' | 'ok'
+    level: str = "info"
 
 
 @dataclass
 class _Text:
+    """
+    Text shown as it is.
+
+        wrap       prose: wrap long lines instead of scrolling sideways
+        code       a snippet to copy: in HTML one click selects all of it
+        collapsed  a secondary view (raw JSON): folded under its title in HTML
+    """
+
     text: str
     title: str = ""
-    wrap: bool = False  # prose: wrap long lines instead of scrolling sideways
-    code: bool = False  # a snippet to copy: in HTML one click selects all of it
-    collapsed: bool = False  # a secondary view (raw JSON): folded under its title in HTML
+    wrap: bool = False
+    code: bool = False
+    collapsed: bool = False
 
 
 @dataclass
 class _Findings:
-    items: list[tuple[str, str]]  # (level, message) pairs from a *_findings function
-    empty: str = ""  # said (as an ok note) when there are none; nothing when blank
+    """
+    The (level, message) pairs from a *_findings function, and what to say (as an ok note) when there are none;
+    nothing when `empty` is blank.
+    """
+
+    items: list[tuple[str, str]]
+    empty: str = ""
 
 
 @dataclass
 class _Next:
-    items: list[tuple[str, str]]  # (call, what it shows): the commands worth running next, arguments filled in
+    """
+    The commands worth running next, as (call, what it shows), with their arguments filled in.
+    """
+
+    items: list[tuple[str, str]]
     title: str = "Next"
 
 
 @dataclass
 class _Tone:
     """
-    A table cell with a status colour: a pill in HTML, plain text elsewhere.
+    A table cell with a status colour (tone: 'warn', 'bad' or 'ok'): a pill in HTML, plain text elsewhere.
     """
 
     text: str
-    tone: str = "warn"  # 'warn' | 'bad' | 'ok'
+    tone: str = "warn"
 
     def __str__(self) -> str:
         return self.text
@@ -84,15 +131,21 @@ def __str__(self) -> str:
 class _Report:
     """
     One report being drawn: what each block's drawing function gets besides the block.
+
+        max_rows  the view's cap on table rows; 0 for no cap
+        badge     the chip before each title (HTML), so reports from different services are easy to tell apart
+        root      the service's root class, which scopes the CSS rules
+        blocks    the whole report, for a block that needs to know what else is in it
+        rules     CSS rules the blocks need beyond the stylesheet (a table's filters and columns): a <style> after it
+        parts     what blocks share while the report is drawn (see shared)
     """
 
-    max_rows: int  # the view's cap on table rows; 0 = no cap
-    badge: str = ""  # the chip before each title (HTML), so reports from different services are easy to tell apart
-    root: str = ""  # the service's root class, which scopes the CSS rules below
-    blocks: tuple[Any, ...] = ()  # the whole report, for a block that needs to know what else is in it
-    rules: set[str] = field(default_factory=set)  # CSS rules the blocks need beyond the stylesheet (a table's
-    # filters and columns): a <style> after it
-    parts: dict[Any, Any] = field(default_factory=dict)  # what blocks share while the report is drawn (see shared)
+    max_rows: int
+    badge: str = ""
+    root: str = ""
+    blocks: tuple[Any, ...] = ()
+    rules: set[str] = field(default_factory=set)
+    parts: dict[Any, Any] = field(default_factory=dict)
 
     def shared(self, key: Any, make: Callable[[], Any]) -> Any:
         """
@@ -104,9 +157,9 @@ def shared(self, key: Any, make: Callable[[], Any]) -> Any:
         return self.parts[key]
 
 
-_HTML: dict[type, Callable[[Any, _Report], str]] = {}  # block type -> its HTML
-_TEXT: dict[type, Callable[[Any, _Report], list[str]]] = {}  # block type -> its lines in text mode
-_CELLS: dict[type, Callable[[Any, str], str]] = {}  # table cell type -> its HTML, given the cell's text
+_HTML: dict[type, Callable[[Any, _Report], str]] = {}
+_TEXT: dict[type, Callable[[Any, _Report], list[str]]] = {}
+_CELLS: dict[type, Callable[[Any, str], str]] = {}
 
 
 def _draws(kind: type, mode: str) -> Callable[[Callable], Callable]:
diff --git a/src/aws_analyzer/_kit/fmt.py b/src/aws_analyzer/_kit/fmt.py
index 92622c9..aeab914 100644
--- a/src/aws_analyzer/_kit/fmt.py
+++ b/src/aws_analyzer/_kit/fmt.py
@@ -1,6 +1,12 @@
 """
 Numbers, sizes, money, times and counts: parsing what users type in, and formatting what reports show; the time
 zone reports show times in (set_timezone); file names' extensions; and Stat, a running count and its total bytes.
+
+HOURS_PER_MONTH is how AWS turns an hourly price into a monthly one.
+
+The zone reports show times in is set_timezone()'s choice (_chosen, which is _DEFAULT until it's called). Until then
+it's the zone the AWS_ANALYZER_TZ environment variable (TIMEZONE_ENV) names, for every notebook, worked out once per
+value (_from_env), else UTC.
 """
 
 from __future__ import annotations
@@ -13,7 +19,7 @@
 from datetime import date, datetime, timedelta, timezone, tzinfo
 from typing import Any
 
-HOURS_PER_MONTH = 730  # how AWS turns an hourly price into a monthly one
+HOURS_PER_MONTH = 730
 
 _SIZE_RE = re.compile(r"^\s*(\d+(?:\.\d+)?)\s*([kmgtp]?)i?b?\s*$", re.IGNORECASE)
 _RELATIVE_TIME_RE = re.compile(r"^\s*(\d+(?:\.\d+)?)\s*([smhdw])\s*$", re.IGNORECASE)
@@ -52,14 +58,14 @@ def _utcnow() -> datetime:
     return datetime.now(timezone.utc)
 
 
-# ----------------------------------------------------------------------------- the time zone reports show
-
-TIMEZONE_ENV = "AWS_ANALYZER_TZ"  # names the zone for every notebook, before any of them calls set_timezone()
+TIMEZONE_ENV = "AWS_ANALYZER_TZ"
 _OFFSET_RE = re.compile(r"^(?:UTC|GMT)?\s*([+-])(\d{1,2})(?::?(\d{2}))?$", re.IGNORECASE)
 _NUMERIC_ZONE_RE = re.compile(r"^(?:UTC|GMT)?[+-][\d:]+$")
-_DEFAULT = object()  # no set_timezone() yet: AWS_ANALYZER_TZ's zone, else UTC
-_chosen: Any = _DEFAULT  # what set_timezone() chose: a tzinfo, or None for this machine's own zone
-_from_env: dict[str, tzinfo | None] = {}  # AWS_ANALYZER_TZ's value -> its zone, worked out once per value
+_SHORT_ZONE_RE = re.compile(r"[A-Z]{2,5}")
+_LONGEST_OFFSET = timedelta(hours=14)
+_DEFAULT = object()
+_chosen: Any = _DEFAULT
+_from_env: dict[str, tzinfo | None] = {}
 
 
 def set_timezone(zone: str | tzinfo | None) -> str:
@@ -98,28 +104,55 @@ def _zone_from(value: str | tzinfo) -> tzinfo | None:
         return timezone.utc
     offset = _OFFSET_RE.match(text)
     if offset:
-        sign, hours, minutes = offset.groups()
-        delta = timedelta(hours=int(hours), minutes=int(minutes or 0))
-        if delta > timedelta(hours=14) or int(minutes or 0) >= 60:
-            raise ValueError(f"{value!r} isn't an offset from UTC: they run from -12:00 to +14:00")
-        return timezone(-delta if sign == "-" else delta)
+        return _offset_zone(offset, value)
+    return _named_zone(text, value)
+
+
+def _offset_zone(offset: re.Match, value: str) -> tzinfo:
+    """
+    The fixed zone an offset from UTC names ('+05:30', 'UTC-4'). One past +14:00, or with 60 minutes or more,
+    raises a ValueError.
+    """
+    sign, hours, minutes = offset.groups()
+    delta = timedelta(hours=int(hours), minutes=int(minutes or 0))
+    if delta > _LONGEST_OFFSET or int(minutes or 0) >= 60:
+        raise ValueError(f"{value!r} isn't an offset from UTC: they run from -12:00 to +14:00")
+    return timezone(-delta if sign == "-" else delta)
+
+
+def _zone_places(names: set[str]) -> dict[str, str]:
+    """
+    Each way to name a tz database zone, lowercase with spaces for underscores, -> its name: its full name
+    ('asia/kolkata', 'america/new york') and its city alone ('kolkata', 'new york'). Where two zones share a city,
+    the one with fewer parts in its name wins: 'louisville' is America/Louisville, not America/Kentucky/Louisville.
+    """
+    places: dict[str, str] = {}
+    for name in sorted(names, key=lambda n: (n.count("/"), n)):
+        full = name.lower().replace("_", " ")
+        places.setdefault(full, name)
+        places.setdefault(full.rsplit("/", 1)[-1], name)
+    return places
+
+
+def _named_zone(text: str, value: str) -> tzinfo:
+    """
+    The tz database zone named by its full name or its city, in any case. A Python without a tz database (Windows
+    has none of its own) or a name it can't find raises a ValueError that says what it takes, with the closest
+    names.
+    """
     from zoneinfo import ZoneInfo, available_timezones
 
     names = available_timezones()
-    if not names:  # Windows has no tz database of its own
+    if not names:
         raise ValueError(f"Can't look up {value!r}: this Python has no time zone database. pip install tzdata, or "
                          "give an offset, like '+05:30'")
-    places: dict[str, str] = {}  # 'asia/kolkata', 'kolkata', 'america/new york', 'new york' -> its name
-    for name in sorted(names, key=lambda n: (n.count("/"), n)):  # 'louisville': America/, not America/Kentucky/
-        full = name.lower().replace("_", " ")
-        places.setdefault(full, name)
-        places.setdefault(full.rsplit("/", 1)[-1], name)
+    places = _zone_places(names)
     asked = re.sub(r"[\s_]+", " ", text.lower())
     if asked in places:
         return ZoneInfo(places[asked])
     close = dict.fromkeys(places[c] for c in difflib.get_close_matches(asked, list(places), n=3, cutoff=0.7))
     hint = f" Did you mean {' or '.join(map(repr, close))}?" if close else ""
-    if re.fullmatch(r"[A-Z]{2,5}", text):
+    if _SHORT_ZONE_RE.fullmatch(text):
         hint += f" A short name like {text} can mean more than one zone (IST is India's, Ireland's and Israel's)."
     raise ValueError(f"{value!r} isn't a time zone set_timezone() knows.{hint} Name it the way the tz database does "
                      "('Asia/Kolkata', 'America/New_York'), by its city ('kolkata'), or by its offset ('+05:30')")
@@ -181,7 +214,7 @@ def parse_time(
     """
     datetime/date, ISO string ('2024-05-01', '2024-05-01T10:00Z'), or a relative
     age like '7d', '12h', '30m', '2w' meaning "that long ago". Naive values are in the zone reports show times in:
-    UTC, unless set_timezone() chose another.
+    UTC, unless set_timezone() chose another ('local' is this machine's zone, which astimezone() reads).
     """
     if value is None:
         return None
@@ -200,7 +233,7 @@ def parse_time(
     if moment.tzinfo:
         return moment
     zone = _display_zone()
-    return moment.astimezone() if zone is None else moment.replace(tzinfo=zone)  # astimezone(): this machine's
+    return moment.astimezone() if zone is None else moment.replace(tzinfo=zone)
 
 
 def human_age(when: datetime | None, now: datetime | None = None) -> str:
@@ -326,13 +359,14 @@ def _as_count(value: Any, name: str) -> int | None:
 
 def file_extension(key: str) -> str:
     """
-    'a/data.csv.gz' -> 'csv.gz', 'a/part-0.snappy.parquet' -> 'parquet', 'a/README' -> '(none)'.
+    'a/data.csv.gz' -> 'csv.gz', 'a/part-0.snappy.parquet' -> 'parquet'. A name without an extension ('README',
+    'name.', '.env') is '(none)'.
     """
     if key.endswith("/"):
         return "(folder marker)"
     parts = key.rsplit("/", 1)[-1].lower().split(".")
     if len(parts) < 2 or parts[-1] == "" or (len(parts) == 2 and parts[0] == ""):
-        return "(none)"  # 'README', 'name.', '.env'
+        return "(none)"
     ext = parts[-1]
     if (
         ext in _COMPRESSION_EXTS
diff --git a/src/aws_analyzer/_kit/highlight.py b/src/aws_analyzer/_kit/highlight.py
index 38ea2f9..27755de 100644
--- a/src/aws_analyzer/_kit/highlight.py
+++ b/src/aws_analyzer/_kit/highlight.py
@@ -33,6 +33,41 @@ def _json_source_html(text: str) -> str:
 
 
 _PY_LITERALS = frozenset({"True", "False", "None"})
+_LAYOUT_TOKENS = (tokenize.ENDMARKER, tokenize.INDENT, tokenize.DEDENT)
+_NOT_CODE_TOKENS = (tokenize.NL, tokenize.NEWLINE, tokenize.COMMENT)
+
+
+def _python_css(token: tokenize.TokenInfo, previous: str, following: str) -> str:
+    """
+    The colour class of one Python token, given the code tokens just before and after it ('' when there's none):
+    a string followed by ':' is a dict key, a name followed by '(' a call, and a name followed by '=' inside a
+    call's brackets a keyword argument.
+    """
+    if token.type == tokenize.COMMENT:
+        return "pc"
+    if token.type == tokenize.STRING:
+        return "jk" if following == ":" else "js"
+    if token.type == tokenize.NUMBER:
+        return "jn"
+    if token.type != tokenize.NAME:
+        return ""
+    if token.string in _PY_LITERALS:
+        return "jl"
+    if keyword.iskeyword(token.string):
+        return "pk"
+    if following == "(":
+        return "pf"
+    if following == "=" and previous in ("(", ","):
+        return "pa"
+    return ""
+
+
+def _source_offset(line_starts: list[int], position: tuple[int, int], code: str) -> int:
+    """
+    Where a token's (line, column) position is in the code, counted in characters.
+    """
+    line, column = position
+    return line_starts[line - 1] + column if line - 1 < len(line_starts) else len(code)
 
 
 def _python_html(code: str) -> str:
@@ -41,39 +76,28 @@ def _python_html(code: str) -> str:
     comments in their own colours. Every piece is escaped; code that doesn't tokenize is shown plain.
     """
     try:
-        tokens = [t for t in tokenize.generate_tokens(io.StringIO(code).readline)
-                  if t.type not in (tokenize.ENDMARKER, tokenize.INDENT, tokenize.DEDENT)]
+        tokens = [token for token in tokenize.generate_tokens(io.StringIO(code).readline)
+                  if token.type not in _LAYOUT_TOKENS]
     except (tokenize.TokenError, SyntaxError):
         return _esc(code)
-    starts = [0]
+
+    line_starts = [0]
     for line in code.splitlines(keepends=True):
-        starts.append(starts[-1] + len(line))
-    real = [t for t in tokens if t.type not in (tokenize.NL, tokenize.NEWLINE, tokenize.COMMENT)]
-    after = {id(t): real[k + 1].string if k + 1 < len(real) else "" for k, t in enumerate(real)}
-    before = {id(t): real[k - 1].string if k else "" for k, t in enumerate(real)}
+        line_starts.append(line_starts[-1] + len(line))
+    code_tokens = [token for token in tokens if token.type not in _NOT_CODE_TOKENS]
+    following = {id(token): code_tokens[k + 1].string if k + 1 < len(code_tokens) else ""
+                 for k, token in enumerate(code_tokens)}
+    previous = {id(token): code_tokens[k - 1].string if k else "" for k, token in enumerate(code_tokens)}
+
     out, last = [], 0
-    for t in tokens:
-        a = starts[t.start[0] - 1] + t.start[1] if t.start[0] - 1 < len(starts) else len(code)
-        b = starts[t.end[0] - 1] + t.end[1] if t.end[0] - 1 < len(starts) else len(code)
-        if a < last or b <= a:
+    for token in tokens:
+        start = _source_offset(line_starts, token.start, code)
+        end = _source_offset(line_starts, token.end, code)
+        if start < last or end <= start:
             continue
-        css = ""
-        if t.type == tokenize.COMMENT:
-            css = "pc"
-        elif t.type == tokenize.STRING:
-            css = "jk" if after.get(id(t)) == ":" else "js"
-        elif t.type == tokenize.NUMBER:
-            css = "jn"
-        elif t.type == tokenize.NAME:
-            if t.string in _PY_LITERALS:
-                css = "jl"
-            elif keyword.iskeyword(t.string):
-                css = "pk"
-            elif after.get(id(t)) == "(":
-                css = "pf"
-            elif after.get(id(t)) == "=" and before.get(id(t)) in ("(", ","):
-                css = "pa"
-        out.append(_esc(code[last:a]))
-        out.append(f'<span class="{css}">{_esc(code[a:b])}</span>' if css else _esc(code[a:b]))
-        last = b
+        css = _python_css(token, previous.get(id(token), ""), following.get(id(token), ""))
+        piece = _esc(code[start:end])
+        out.append(_esc(code[last:start]))
+        out.append(f'<span class="{css}">{piece}</span>' if css else piece)
+        last = end
     return "".join(out) + _esc(code[last:])
diff --git a/src/aws_analyzer/_kit/jsontree.py b/src/aws_analyzer/_kit/jsontree.py
index b34c524..e950e66 100644
--- a/src/aws_analyzer/_kit/jsontree.py
+++ b/src/aws_analyzer/_kit/jsontree.py
@@ -4,6 +4,17 @@
 script (it still works in a saved notebook); in text it's indented JSON, all of it unfolded.
 
 A service that shows one adds `_json_tree_css(_ROOT)` to the rules it passes to `_base_css`.
+
+How much a tree shows, so the notebook stays small:
+
+    _JSON_KEYS    keys of one object (more when the tree's `items` is bigger)
+    _JSON_ROWS    lines in the whole tree
+    _JSON_OPEN    lines shown unfolded at first: the shallow levels open first, big parts stay folded
+    _JSON_DEPTH   how deep objects and arrays are read; deeper ones stay folded, with nothing inside
+    _JSON_INLINE  characters of an array of plain values shown on one line: [3, 224, 224]
+    _JSON_STRING  characters of a string shown whole; a longer one folds to its start, and a click shows it
+    _JSON_FULL    characters of one string shown at most
+    _TEXT_WIDTH   characters of a line in text mode, where an array of plain values wraps like words
 """
 
 from __future__ import annotations
@@ -17,39 +28,55 @@
 from .render import _prose
 from .text import _esc
 
-_JSON_KEYS = 100  # keys of one object a JSON tree shows (more when n is bigger)
-_JSON_ROWS = 2_000  # lines one JSON tree shows at most, so the notebook stays small
-_JSON_OPEN = 80  # lines a JSON tree shows unfolded at first: the shallow levels open first, big parts stay folded
-_JSON_DEPTH = 100  # objects and arrays nested deeper than this stay folded, with nothing inside
-_JSON_INLINE = 80  # an array of plain values this short shows on one line: [3, 224, 224]
-_JSON_STRING = 120  # a longer string folds to its start; a click shows all of it
-_JSON_FULL = 20_000  # characters of one string shown at most
+_JSON_KEYS = 100
+_JSON_ROWS = 2_000
+_JSON_OPEN = 80
+_JSON_DEPTH = 100
+_JSON_INLINE = 80
+_JSON_STRING = 120
+_JSON_FULL = 20_000
+_TEXT_WIDTH = 100
+_STRING_START = 80
 
 
 @dataclass
 class _JNode:
     """
     One line of a _JsonTree: a value, or an object / array whose children are the lines under it.
+
+        path      how Python reaches it in the loaded file: data['Records'][0]
+        key       its key in an object, as JSON ('"name"')
+        index     its place in an array
+        kind      'value', 'object', 'array' or 'string' (a long one, folded to its start)
+        tokens    a value as (css class, text) pieces
+        total     an object's keys, an array's items, a long string's characters
+        more      children not shown
+        cut       the file goes on past it: it was cut off at the end of the preview
+        parsed    a string holding JSON, shown as the JSON it holds
+        packed    an array of plain values (an embedding, labels): its items wrap like words
+        text      a long string's text, up to _JSON_FULL characters
+        open      it starts unfolded
     """
 
-    path: str  # how Python reaches it in the loaded file: data['Records'][0]
-    key: str | None = None  # its key in an object, as JSON ('"name"')
-    index: int | None = None  # its place in an array
-    kind: str = "value"  # 'value' | 'object' | 'array' | 'string' (a long one, folded to its start)
-    tokens: list[tuple[str, str]] = field(default_factory=list)  # a value as (css class, text) pieces
+    path: str
+    key: str | None = None
+    index: int | None = None
+    kind: str = "value"
+    tokens: list[tuple[str, str]] = field(default_factory=list)
     children: list[_JNode] = field(default_factory=list)
-    total: int = 0  # an object's keys, an array's items, a long string's characters
-    more: int = 0  # children not shown
-    cut: bool = False  # the file goes on past it: it was cut off at the end of the preview
-    parsed: bool = False  # a string holding JSON, shown as the JSON it holds
-    packed: bool = False  # an array of plain values (an embedding, labels): its items wrap like words
-    text: str = ""  # a long string's text, up to _JSON_FULL characters
-    open: bool = False  # starts unfolded
+    total: int = 0
+    more: int = 0
+    cut: bool = False
+    parsed: bool = False
+    packed: bool = False
+    text: str = ""
+    open: bool = False
 
 
 def _json_tokens(value: Any) -> list[tuple[str, str]]:
     """
-    A plain value (or an empty object or array) as coloured pieces of JSON.
+    A plain value (or an empty object or array) as coloured pieces of JSON. Anything else, which can't come from
+    a JSON file (a date), shows as its text.
     """
     if isinstance(value, str):
         return [("js", json.dumps(value, ensure_ascii=False))]
@@ -59,7 +86,7 @@ def _json_tokens(value: Any) -> list[tuple[str, str]]:
         return [("jd", json.dumps(value))]
     if isinstance(value, (dict, list)):
         return [("jp", "{}" if isinstance(value, dict) else "[]")]
-    return [("js", json.dumps(str(value), ensure_ascii=False))]  # not from a JSON file (a date): its text
+    return [("js", json.dumps(str(value), ensure_ascii=False))]
 
 
 def _json_inline(values: list) -> list[tuple[str, str]] | None:
@@ -107,23 +134,29 @@ class _JsonTree:
     `name` is what the value is called in Python, where each line's path (its tooltip) starts: S3's preview loads a
     file as `data`, Lambda's configuration is a Function's `raw`. `collapsed=True` folds the whole tree under its
     title, a secondary view like a collapsed _Text.
+
+    After it's made: `capped` holds 'item' when an array had more items than it shows and 'key' when an object had
+    more keys, `full` says the tree stopped at _JSON_ROWS lines, and `folded` that an object or array starts folded,
+    so unfold("all") would show more (the S3 explorer's "Expand all").
     """
 
-    def __init__(self, value: Any, items: int = 20, cut: int = 0, title: str = "", *, name: str = "data",
-                 collapsed: bool = False):
+    def __init__(self, value: Any, items: int = 20, cut: int = 0, title: str = "", *,  # noqa: PLR0913
+                 name: str = "data", collapsed: bool = False):
         self.items, self.rows, self.cut, self.title = max(items, 1), 0, cut > 0, title
         self.collapsed = collapsed
-        self.capped: set[str] = set()  # 'item' / 'key': an array / object had more than it shows
-        self.full = False  # the tree stopped at _JSON_ROWS lines
+        self.capped: set[str] = set()
+        self.full = False
         self.root = self._node(value, name, cut, 0)
         self._unfold()
-        # an object or array starts folded: unfold("all") would show more (the S3 explorer's "Expand all")
         self.folded = any(not node.open for node in self._nodes() if node.kind in ("object", "array"))
 
-    def _node(self, value: Any, path: str, cut: int, depth: int, key: str | None = None,
-              index: int | None = None) -> _JNode:
+    def _node(self, value: Any, path: str, cut: int, depth: int) -> _JNode:
+        """
+        The line for a value at `path`, `depth` objects and arrays deep, and the lines under it. `cut` is how many
+        of the objects and arrays along its end were cut off.
+        """
         self.rows += 1
-        node = _JNode(path, key, index)
+        node = _JNode(path)
         if isinstance(value, str):
             inner = _json_inside(value)
             if inner is None:
@@ -148,10 +181,12 @@ def _node(self, value: Any, path: str, cut: int, depth: int, key: str | None = N
                 break
             inner_cut = cut - 1 if cut and i == len(value) - 1 else 0
             if node.kind == "object":
-                node.children.append(self._node(child, f"{node.path}[{name!r}]", inner_cut, depth + 1,
-                                                key=json.dumps(name, ensure_ascii=False)))
+                child_node = self._node(child, f"{node.path}[{name!r}]", inner_cut, depth + 1)
+                child_node.key = json.dumps(name, ensure_ascii=False)
             else:
-                node.children.append(self._node(child, f"{node.path}[{i}]", inner_cut, depth + 1, index=i))
+                child_node = self._node(child, f"{node.path}[{i}]", inner_cut, depth + 1)
+                child_node.index = i
+            node.children.append(child_node)
         node.packed = node.kind == "array" and all(c.kind == "value" and not c.parsed for c in node.children)
         return node
 
@@ -163,7 +198,7 @@ def _string(self, node: _JNode, value: str) -> _JNode:
             node.tokens = _json_tokens(value)
             return node
         node.kind, node.total, node.text = "string", len(value), value[:_JSON_FULL]
-        node.tokens = [("js", json.dumps(value[:80].rstrip(), ensure_ascii=False)[:-1] + '…"')]  # its start
+        node.tokens = [("js", json.dumps(value[:_STRING_START].rstrip(), ensure_ascii=False)[:-1] + '…"')]
         return node
 
     def _nodes(self) -> Iterator[_JNode]:
@@ -257,7 +292,8 @@ def walk(node: _JNode, last: bool) -> None:
 
 def _json_tree_text(tree: _JsonTree) -> str:
     """
-    A _JsonTree as indented JSON, all of it unfolded.
+    A _JsonTree as indented JSON, all of it unfolded. An array of plain values wraps its items like words, in
+    lines of _TEXT_WIDTH characters.
     """
     lines: list[str] = []
 
@@ -272,12 +308,12 @@ def walk(node: _JNode, depth: int, last: bool) -> None:
         else:
             start, end = "{}" if node.kind == "object" else "[]"
             lines.append(f"{pad}{lead}{start}")
-            if node.packed:  # items wrap like words, at 100 characters
+            if node.packed:
                 line = ""
                 for i, child in enumerate(node.children):
                     item = "".join(text for _, text in child.tokens)
                     item += "" if i == len(node.children) - 1 and not node.more else ","
-                    if line and len(pad) + 2 + len(line) + 1 + len(item) > 100:
+                    if line and len(pad) + 2 + len(line) + 1 + len(item) > _TEXT_WIDTH:
                         lines.append(f"{pad}  {line}")
                         line = ""
                     line += (" " if line else "") + item
diff --git a/src/aws_analyzer/_kit/progress.py b/src/aws_analyzer/_kit/progress.py
index 8f3f72b..0bf3d17 100644
--- a/src/aws_analyzer/_kit/progress.py
+++ b/src/aws_analyzer/_kit/progress.py
@@ -15,14 +15,15 @@
 
 def _progress_bar_class(notebook: bool) -> Any:
     """
-    tqdm's widget bar in a notebook (it needs ipywidgets) or its text bar elsewhere; None without tqdm.
+    tqdm's widget bar in a notebook (it needs ipywidgets) or its text bar elsewhere; None without tqdm, or with
+    one too old to import cleanly, whatever it raises: the plain progress line takes over.
     """
     try:
         if notebook:
             importlib.import_module("ipywidgets")
             return importlib.import_module("tqdm.notebook").tqdm
         return importlib.import_module("tqdm").tqdm
-    except Exception:  # not installed, or too old to import cleanly: the plain progress line takes over
+    except Exception:  # noqa: BLE001
         return None
 
 
diff --git a/src/aws_analyzer/_kit/render.py b/src/aws_analyzer/_kit/render.py
index 0bac344..819821e 100644
--- a/src/aws_analyzer/_kit/render.py
+++ b/src/aws_analyzer/_kit/render.py
@@ -10,6 +10,14 @@
 Tables sort by a click on a header, filter a column of a few repeated values and choose their columns, and a finding
 reads as a headline over its detail. All of it is plain HTML and CSS (radio buttons, selects and checkboxes in a form,
 read by :has() rules), never JavaScript, so it still works in a reopened notebook, where scripts don't run.
+
+_BASE_RULES are the rules every service's reports share. "{root}" in them stands for the service's root class,
+filled in by str.replace, not str.format: the rules are full of braces. A header click can sort by the first
+_SORT_COLUMNS columns, since each needs two CSS rules.
+
+A table's controls carry _HIDE, which hides them until the stylesheet shows them, so a notebook opened without its
+styles (JupyterLab strips <style> from an untrusted notebook) shows a plain table. JupyterLab's sanitizer drops a
+bare `hidden` attribute, but keeps hidden="hidden".
 """
 
 from __future__ import annotations
@@ -25,11 +33,7 @@
 from .fmt import _plural, file_extension
 from .text import _clip, _esc, _pad, _text_bar, _width
 
-# ----------------------------------------------------------------------------- the stylesheet
-
-_SORT_COLUMNS = 12  # columns a header click can sort by: each needs two CSS rules
-# The rules every service's reports share. "{root}" stands for the service's root class (filled in by str.replace,
-# not str.format: the rules are full of braces).
+_SORT_COLUMNS = 12
 _BASE_RULES = """\
 .{root}{font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Helvetica,Arial,sans-serif;font-size:13px;line-height:1.45}
 .{root} h3{margin:10px 0 2px;font-size:16px}
@@ -189,18 +193,15 @@ def _base_css(root: str, extra: str = "", *, theme: str = "", restyle: dict[str,
     return "\n".join(["<style>", *filter(None, [theme, "\n".join(rules), extra]), "</style>"])
 
 
-# ----------------------------------------------------------------------------- sentences and calls
-
-_NUMERIC_RE = re.compile(r"^-?(<?\$)?[\d,]+(\.\d+)?\+?( ?(B|KB|MB|GB|TB|PB|%|s))?$")  # right-aligned in tables
-# A command in a sentence: a call (kb_info(), documents(status='FAILED'), .core.find(...), S3View().preview('s3://..'))
-# or an AWS CLI command with its options (aws dynamodb update-table --table-name orders --deletion-protection-enabled).
+_NUMERIC_RE = re.compile(r"^-?(<?\$)?[\d,]+(\.\d+)?\+?( ?(B|KB|MB|GB|TB|PB|%|s))?$")
 _CALL_RE = re.compile(
     r"((?<![\w.])\.?(?:[A-Za-z_]\w*(?:\(\))?\.)*[A-Za-z_]\w*"
     r"\((?:[^()'\"]|'[^']*'|\"[^\"]*\"|\((?:[^()'\"]|'[^']*'|\"[^\"]*\")*\))*\)"
     r"|\baws [a-z0-9-]+ [a-z0-9-]+(?: --[\w-]+(?: (?!--)[^\s,;]*[^\s,;.])?)*)"
 )
 _TONES = ("warn", "bad", "ok")
-_MARKS = {"warn": "[!] ", "ok": "[ok] "}  # text-mode prefix of a note by level; anything else is "[i] "
+_MARKS = {"warn": "[!] ", "ok": "[ok] "}
+_INFO_MARK = "[i] "
 _SELECT = ' title="Click to select, then copy"'
 
 
@@ -213,6 +214,10 @@ def _prose(value: Any, money: bool = False) -> str:
     Escaped HTML for a sentence this tool wrote, with the calls in it as code that one click selects
     (and, with money=True, amounts like $12.40/month stressed). The text is split on the calls and every
     piece escaped before it's wrapped, so nothing in it becomes markup.
+
+    A call is what _CALL_RE finds: a Python call (kb_info(), documents(status='FAILED'), .core.find(...),
+    S3View().preview('s3://..')) or an AWS CLI command with its options (aws dynamodb update-table --table-name
+    orders --deletion-protection-enabled).
     """
     pieces = _CALL_RE.split("" if value is None else str(value))
     return "".join(
@@ -227,10 +232,11 @@ def _prose(value: Any, money: bool = False) -> str:
 def _masked(text: str) -> str:
     """
     The text with its commands and anything in brackets blanked out (same length), so a sentence is never
-    split inside them: 'Something went wrong (RuntimeError: boom)' has no lead.
+    split inside them: 'Something went wrong (RuntimeError: boom)' has no lead. Brackets inside brackets are
+    blanked from the innermost out.
     """
     masked, before = _CALL_RE.sub(lambda m: "x" * len(m.group(0)), text), None
-    while masked != before:  # innermost brackets first
+    while masked != before:
         before, masked = masked, re.sub(r"[(\[][^()\[\]]*[)\]]", lambda m: "x" * len(m.group(0)), masked)
     return masked
 
@@ -306,18 +312,23 @@ def _call(name: str, *args: Any, **kwargs: Any) -> str:
     """
     _call('tree', 's3://b/', depth=2) -> "tree('s3://b/', depth=2)": a next step, ready to copy.
     """
+    arguments = [_literal(a) for a in args] + [f"{k}={_literal(v)}" for k, v in kwargs.items()]
+    return f"{name}({', '.join(arguments)})"
 
-    def literal(value: Any) -> str:  # repr, but DynamoDB numbers read 42 rather than Decimal('42')
-        if type(value).__name__ == "Decimal":
-            return str(value)
-        if isinstance(value, dict):
-            return "{" + ", ".join(f"{literal(k)}: {literal(v)}" for k, v in value.items()) + "}"
-        if isinstance(value, (list, tuple)):
-            inner = ", ".join(map(literal, value)) + ("," if isinstance(value, tuple) and len(value) == 1 else "")
-            return f"[{inner}]" if isinstance(value, list) else f"({inner})"
-        return repr(value)
 
-    return f"{name}({', '.join([literal(a) for a in args] + [f'{k}={literal(v)}' for k, v in kwargs.items()])})"
+def _literal(value: Any) -> str:
+    """
+    A value as Python to copy: its repr, except that DynamoDB numbers read 42 rather than Decimal('42'), inside
+    lists, tuples and dicts too.
+    """
+    if type(value).__name__ == "Decimal":
+        return str(value)
+    if isinstance(value, dict):
+        return "{" + ", ".join(f"{_literal(k)}: {_literal(v)}" for k, v in value.items()) + "}"
+    if isinstance(value, (list, tuple)):
+        inner = ", ".join(map(_literal, value)) + ("," if isinstance(value, tuple) and len(value) == 1 else "")
+        return f"[{inner}]" if isinstance(value, list) else f"({inner})"
+    return repr(value)
 
 
 def _signature(function: Callable) -> str:
@@ -329,26 +340,26 @@ def _signature(function: Callable) -> str:
     return str(sig.replace(parameters=params, return_annotation=inspect.Signature.empty))
 
 
-# ----------------------------------------------------------------------------- tables: sorting, filters, keys
-
 _SORT_UNITS = {"B": 1, "KB": 1024, "MB": 1024**2, "GB": 1024**3, "TB": 1024**4, "PB": 1024**5, "ms": 1}
 _SORT_NUMBER_RE = re.compile(
     r"^(-?)(<?)\$?([\d,]*\.?\d+)\+?(?: ?(B|KB|MB|GB|TB|PB|%|ms))?(?: of [\d,]+| \([^()]*\))?$")
 _SORT_AGE_RE = re.compile(r"^(\d+)(y|mo|d|h|m) ago$")
-# '2024-05-01', '2024-05-01 14:02', or a time with its zone's name: '2024-05-01 14:02:31 IST', '... UTC+05:30'
 _SORT_DATE_RE = re.compile(
     r"^\d{4}-\d{2}-\d{2}(?:[ T]\d{2}:\d{2}(?::\d{2})?(?: [A-Z]{2,5}(?:[+-]\d{2}(?::\d{2})?)?)?)?$")
 _AGE_SECONDS = {"y": 365 * 86400, "mo": 30 * 86400, "d": 86400, "h": 3600, "m": 60}
-_SORT_WORDS = {  # a column's kind -> what its first and second header click show
+_SORT_WORDS = {
     "number": ("largest first", "smallest first"),
     "age": ("oldest first", "newest first"),
     "date": ("newest first", "oldest first"),
     "text": ("A to Z", "Z to A"),
 }
-_FILTER_VALUES = 12  # a column gets a filter when it holds 2 to this many different values, some repeated
-_FILTER_COLUMNS = 3  # filters per table at most, the leftmost columns first
-# Hides the table controls until the stylesheet shows them, so a notebook opened without its styles (JupyterLab
-# strips <style> from an untrusted notebook) shows a plain table. Its sanitizer drops a bare `hidden`, not this.
+_FILTER_VALUES = 12
+_FILTER_COLUMNS = 3
+_FILTER_MIN_ROWS = 6
+_SORT_MIN_ROWS = 3
+_CHOOSER_MIN_COLUMNS = 3
+_SCROLL_ROWS = 30
+_SHORT_CELL = 16
 _HIDE = ' hidden="hidden"'
 
 
@@ -356,7 +367,8 @@ def _sort_key(text: str) -> tuple[int, Any] | None:
     """
     What a table cell sorts by: (0, number) for sizes, money, counts, percentages and ages ('2.1 GB' is
     bytes, '<$0.01' half a cent, '3d ago' seconds), (1, text) for dates, (2, parts) for the rest in natural
-    order ('epoch-2' before 'epoch-10'). None for an empty cell, which sorts last both ways.
+    order ('epoch-2' before 'epoch-10'). None for an empty cell, which sorts last both ways. A date is
+    '2024-05-01', '2024-05-01 14:02', or a time with its zone's name: '2024-05-01 14:02:31 IST', '... UTC+05:30'.
     """
     text = text.split("\n", 1)[0].strip().removeprefix("📁 ")
     if text in ("", "-", "—"):
@@ -377,7 +389,8 @@ def _sort_key(text: str) -> tuple[int, Any] | None:
 
 def _sort_kind(values: list[str], keys: list[tuple[int, Any]]) -> str:
     """
-    'number', 'age', 'date' or 'text': what most of a column's cells hold, which decides its first sort.
+    'number', 'age', 'date' or 'text': what most of a column's cells hold, which decides its first sort
+    (_SORT_WORDS says what its first and second header click show).
     """
     cls = Counter(key[0] for key in keys).most_common(1)[0][0]
     if cls:
@@ -405,11 +418,14 @@ def _filters(block: _Table, columns: list[list[str]], numeric: list[bool]) -> li
     """
     The columns that get a filter: a few different values, some repeated (a storage class, a status, a
     region), never numbers, dates, keys or sentences -> [(column, [(value, rows), ...] most rows first)].
+
+    A column gets one when it holds 2 to _FILTER_VALUES different values, some repeated, in a table of
+    _FILTER_MIN_ROWS rows or more; at most _FILTER_COLUMNS per table, the leftmost columns first.
     """
     found: list[tuple[int, list[tuple[str, int]]]] = []
     for j, column in enumerate(columns):
         skip = set(block.prose_cols) | set(block.code_cols) | set(block.path_cols) | ({0} if block.tree else set())
-        if len(found) == _FILTER_COLUMNS or len(column) < 6:
+        if len(found) == _FILTER_COLUMNS or len(column) < _FILTER_MIN_ROWS:
             break
         values = [value.strip() for value in column if value.strip()]
         if j in skip or numeric[j] or any("\n" in value or ", " in value for value in values):
@@ -421,7 +437,10 @@ def _filters(block: _Table, columns: list[list[str]], numeric: list[bool]) -> li
     return found
 
 
-_ICONS = {  # extension -> the icon in front of a file's name, in key columns and in s3_explorer's list
+_PATH_CHARACTERS = 86
+_FOLDER_CHARACTERS = 56
+_SHORTEST_FOLDER = 12
+_ICONS = {
     **dict.fromkeys(("csv", "tsv", "tab", "psv", "parquet", "pq", "orc", "feather", "arrow", "ipc", "avro"), "📊"),
     **dict.fromkeys(("xlsx", "xlsm", "xls"), "📗"),
     **dict.fromkeys(("json", "jsonl", "ndjson", "yaml", "yml", "toml", "xml", "ini", "cfg", "conf"), "📋"),
@@ -441,13 +460,14 @@ def _filters(block: _Table, columns: list[list[str]], numeric: list[bool]) -> li
 
 def _file_icon(key: str) -> str:
     """
-    📁 for a folder, else the file's icon by its extension: 📊 tables, 📕 PDF, 🖼️ pictures, 🧠 models, ...,
-    📄 for anything else. 'data.csv.gz' is a table and 'logs.tar.gz' an archive.
+    📁 for a folder, else the file's icon by its extension (_ICONS, which s3_explorer's list uses too): 📊 tables,
+    📕 PDF, 🖼️ pictures, 🧠 models, ..., 📄 for anything else, a file without an extension too. 'data.csv.gz' is a
+    table and 'logs.tar.gz' an archive.
     """
     if key.endswith("/"):
         return "📁"
     ext = file_extension(key)
-    if ext.startswith("("):  # '(none)'
+    if ext == "(none)":
         return "📄"
     return _ICONS.get(ext.split(".")[0], _ICONS.get(ext.rsplit(".", 1)[-1], "📄"))
 
@@ -456,21 +476,27 @@ def _path_html(text: str) -> str:
     """
     A key in a table cell: its icon (📁 for a folder, 📊 for a table, ... by _file_icon), its folder dimmed and,
     when long, shortened from the left (the nearest folders stay), then the file name in full. Each line of the
-    cell is one key. The icon is only drawn: the cell's text, which sorts and copies, is the key alone.
+    cell is one key; a line that isn't one ('… and 3 more', '(none)') shows as it is. The icon is only drawn: the
+    cell's text, which sorts and copies, is the key alone.
+
+    A folder takes up to _FOLDER_CHARACTERS (its 30em); a long name leaves it less, so the line stays within about
+    _PATH_CHARACTERS, but never less than _SHORTEST_FOLDER.
     """
     lines = []
     for line in text.split("\n"):
+        icon = ""
         if line.startswith("📁 "):
             icon, line = "📁", line[2:]
-        else:
-            icon = "" if line in ("", "-") or line.startswith(("…", "(")) else _file_icon(line)
+        is_key = not line.startswith(("…", "("))
+        if not icon and is_key and line not in ("", "-"):
+            icon = _file_icon(line)
         folder, _, name = line.rstrip("/").rpartition("/")
         name += line[len(line.rstrip("/")):]
-        folder = f"{folder}/" if folder and not line.startswith(("…", "(")) else ""  # not '… and 3 more'
+        folder = f"{folder}/" if folder and is_key else ""
         if not folder:
             name = line
-        room = 86 - len(name)  # a long name leaves less room for its folder (30em, about 56 characters)
-        cap = f' style="max-width:{max(room, 12)}ch"' if room < 56 else ""
+        room = _PATH_CHARACTERS - len(name)
+        cap = f' style="max-width:{max(room, _SHORTEST_FOLDER)}ch"' if room < _FOLDER_CHARACTERS else ""
         lines.append('<span class="pl">' + (f'<span class="pi">{icon}</span>' if icon else "")
                      + (f'<span class="pd"{cap}>{_esc(folder)}</span>' if folder else "")
                      + f'<span class="pn">{_esc(name)}</span></span>')
@@ -488,9 +514,6 @@ def _clip_path(text: str, width: int = 90) -> str:
     return "…" + (tail[cut:] if 0 <= cut < len(tail) - 1 else tail)
 
 
-# ----------------------------------------------------------------------------- the shared blocks
-
-
 def _tone(item: tuple[str, ...]) -> str:
     """
     The tone of a card: its third element, when it's one this renderer colours.
@@ -599,10 +622,184 @@ def _cell_html(cell: Any, text: str) -> str:
     return draw(cell, text) if draw else _esc(text)
 
 
+def _column_texts(block: _Table, rows: list[list[Any]]) -> list[list[str]]:
+    """
+    Each column's cells as text: '' where a row is short of it or the cell is None.
+    """
+    return [["" if j >= len(row) or row[j] is None else str(row[j]) for row in rows]
+            for j in range(len(block.headers))]
+
+
+def _is_numeric(column: list[str]) -> bool:
+    """
+    Whether most of a column's filled cells are numbers, sizes, money or percentages, which are right-aligned.
+    """
+    numbers = sum(bool(_NUMERIC_RE.match(value)) for value in column if value)
+    filled = sum(bool(value) for value in column)
+    return numbers * 2 > filled > 0
+
+
+def _table_sorts(block: _Table, rows: list[list[Any]],
+                 columns: list[list[str]]) -> dict[int, tuple[list[int], list[int], str]]:
+    """
+    The columns a click on their header sorts by -> each row's place sorted up and sorted down, and the column's
+    kind (_sort_kind). A table sorts when it has _SORT_MIN_ROWS rows or more and isn't a tree or a list of calls
+    (help() keeps its order). A column sorts unless it holds sentences or all its cells are the same; the bar column
+    sorts by its bars.
+    """
+    sorts_at_all = block.sortable and not block.tree and 0 not in block.code_cols and len(rows) >= _SORT_MIN_ROWS
+    if not sorts_at_all:
+        return {}
+    width = len(block.headers)
+    sorts: dict[int, tuple[list[int], list[int], str]] = {}
+    for j in range(min(width + (block.bars is not None), _SORT_COLUMNS)):
+        if j in block.prose_cols:
+            continue
+        values = columns[j] if j < width else []
+        keys = [_sort_key(v) for v in values] if j < width else [(0, float(b)) for b in block.bars[: len(rows)]]
+        present = [key for key in keys if key is not None]
+        if len(set(present)) > 1:
+            sorts[j] = (*_ranks(keys), _sort_kind(values, present))
+    return sorts
+
+
+def _sort_labels(header: str, kind: str) -> str:
+    """
+    A sortable header: three labels over radio buttons, one showing at a time, that step through the column's
+    first sort, the other way, and back to the original order.
+    """
+    first, second = _SORT_WORDS[kind]
+    radios = ("ra", "rd") if kind == "text" else ("rd", "ra")
+    steps = ((1, radios[0], f"Sort: {first}"), (2, radios[1], f"Sort: {second}"),
+             (3, "rn", "Back to the original order"))
+    return "".join(f'<label class="o{n}" title="{tip}"{_HIDE if n > 1 else ""}>'
+                   f'<input type="radio" name="s" class="{radio}"{_HIDE}>{_esc(header)}</label>'
+                   for n, radio, tip in steps)
+
+
+def _header_html(j: int, header: str, numeric: bool, sort: tuple[list[int], list[int], str] | None) -> str:
+    """
+    The header of column j: right-aligned over numbers, and the labels a click sorts by when it sorts.
+    """
+    css = ["n"] if numeric else []
+    inner = _esc(header)
+    if sort:
+        inner = _sort_labels(header, sort[2])
+        css = ["srt", f"k{j}", *css]
+    return f'<th class="{" ".join(css)}">{inner}</th>' if css else f"<th>{inner}</th>"
+
+
+def _cell_td(block: _Table, j: int, cell: Any) -> str:
+    """
+    One cell of column j: a tree label, a call to copy, a sentence with its lead in bold, a key, a number
+    (right-aligned), or text, which doesn't wrap when it's _SHORT_CELL characters or fewer.
+    """
+    text = "" if cell is None else str(cell)
+    inner, attrs = _cell_html(cell, text), ""
+    if block.tree and j == 0:
+        css = "tree"
+    elif j in block.code_cols and text:
+        css, inner = "c", f"<code{_SELECT}>{inner}</code>"
+    elif j in block.prose_cols:
+        css, inner = "", _lead(text)
+    elif j in block.path_cols and text:
+        css, inner = "p", _path_html(text)
+        attrs = f' title="{_esc(text)}"' if "/" in text.rstrip("/") else ""
+    elif _NUMERIC_RE.match(text):
+        css = "n"
+    else:
+        css = "s" if len(text) <= _SHORT_CELL and "\n" not in text else ""
+    return f'<td class="{css}"{attrs}>{inner}</td>' if css else f"<td>{inner}</td>"
+
+
+def _bar_td(fraction: float) -> str:
+    """
+    The bar column's cell: the fraction as a bar and a percentage.
+    """
+    pct = max(0.0, min(1.0, fraction)) * 100
+    return (f'<td class="bar"><span class="track"><span class="fill" style="width:{pct:.1f}%">'
+            f"</span></span>{pct:.1f}%</td>")
+
+
+def _row_cells(block: _Table, i: int, row: list[Any]) -> str:
+    """
+    Row i's cells, and its bar when the table has them.
+    """
+    cells = [_cell_td(block, j, cell) for j, cell in enumerate(row)]
+    if block.bars is not None:
+        cells.append(_bar_td(block.bars[i]))
+    return "".join(cells)
+
+
+def _row_attributes(i: int, columns: list[list[str]], sorts: dict[int, tuple[list[int], list[int], str]],
+                    positions: dict[int, dict[str, int]]) -> str:
+    """
+    Row i's class, naming the value it holds in each filtered column (f<column>v<value's place>), and its style, its
+    place in each sortable column sorted up and down (--a<column>, --d<column>), which the CSS orders rows by.
+    """
+    marks = [f"f{j}v{places[columns[j][i].strip()]}" for j, places in positions.items() if columns[j][i].strip()]
+    order = ";".join(f"--a{j}:{up[i]};--d{j}:{down[i]}" for j, (up, down, _) in sorts.items())
+    return (f' class="{" ".join(marks)}"' if marks else "") + (f' style="{order}"' if order else "")
+
+
+def _columns_menu(heads: list[str], report: _Report) -> str:
+    """
+    The Columns menu: a checkbox per column that hides the column when it's ticked off, and a button that resets
+    the table. The rules that hide them go into report.rules.
+    """
+    root = report.root
+    report.rules.update(f".{root} form.tbl:has(.cv{j}:not(:checked)) tr>:nth-child({j + 1}){{display:none}}"
+                        for j in range(len(heads)))
+    boxes = "".join(f'<label><input type="checkbox" class="cv{j}" checked>{_esc(header)}</label>'
+                    for j, header in enumerate(heads))
+    return ('<details class="cols"><summary title="Choose the columns to show">Columns</summary><div class="menu">'
+            + boxes
+            + '<button type="reset" title="Every column, the original order and no filters">Reset table'
+            "</button></div></details>")
+
+
+def _filter_controls(filters: list[tuple[int, list[tuple[str, int]]]], heads: list[str], report: _Report) -> str:
+    """
+    A select per filtered column, its values with how many rows hold each. The rules that hide the other rows go
+    into report.rules.
+    """
+    root = report.root
+    for j, values in filters:
+        report.rules.update(f".{root} form.tbl:has(.f{j} .v{i}:checked) tbody tr:not(.f{j}v{i}){{display:none}}"
+                            for i in range(len(values)))
+    selects = "".join(
+        f'<label class="flt">{_esc(heads[j])}<select class="f{j}"><option class="all" selected>All</option>'
+        + "".join(f'<option class="v{i}">{_esc(value)} ({count:,})</option>' for i, (value, count) in enumerate(values))
+        + "</select></label>"
+        for j, values in filters
+    )
+    return '<span class="tl">Filter</span>' + selects
+
+
+def _filter_foot(row_count: int) -> str:
+    """
+    The line under a filtered table: how many rows match, and a button that clears the filters.
+    """
+    return (f'<div class="tf"{_HIDE}><span><span class="cnt"></span> of {row_count:,} rows match</span>'
+            '<button type="reset">Clear filters</button></div>')
+
+
+def _table_frame(block: _Table, tools: str, content: str) -> str:
+    """
+    The table under its title, with its controls beside the title, or folded under its title when it's collapsed.
+    """
+    if block.collapsed:
+        return (f'<details class="sec"><summary>{_prose(block.title or "Details")} ({len(block.rows):,})</summary>'
+                f"{tools}{content}</details>")
+    title = f"<h4>{_prose(block.title)}</h4>" if block.title else ""
+    head = f'<div class="tt">{title}{tools}</div>' if title and tools else title + tools
+    return head + content
+
+
 @_draws(_Table, "html")
 def _table_html(block: _Table, report: _Report) -> str:
     """
-    A _Table as HTML. Over 30 rows it scrolls under a sticky header. With 3 rows or more, a click on a
+    A _Table as HTML. Over _SCROLL_ROWS rows it scrolls under a sticky header. With 3 rows or more, a click on a
     header sorts by that column (largest, newest or A to Z first; again for the other way; a third click
     for the original order); a column of a few repeated values gets a filter; with 3 columns or more, a
     Columns menu ticks columns off. All plain HTML and CSS: radio buttons, selects and checkboxes in a form,
@@ -611,111 +808,38 @@ def _table_html(block: _Table, report: _Report) -> str:
     """
     if not block.rows:
         return (f"<h4>{_prose(block.title)}</h4>" if block.title else "") + '<div class="more">(none)</div>'
+
     rows, hidden = _visible_rows(block, report.max_rows)
-    width = len(block.headers)
-    columns = [["" if j >= len(row) or row[j] is None else str(row[j]) for row in rows] for j in range(width)]
-    numeric = [
-        sum(bool(_NUMERIC_RE.match(v)) for v in column if v) * 2 > sum(bool(v) for v in column) > 0
-        for column in columns
-    ]
-    sorts: dict[int, tuple[list[int], list[int], str]] = {}
-    if block.sortable and not block.tree and 0 not in block.code_cols and len(rows) >= 3:  # help() keeps its order
-        for j in range(min(width + (block.bars is not None), _SORT_COLUMNS)):
-            if j in block.prose_cols:
-                continue
-            values = columns[j] if j < width else []
-            keys = [_sort_key(v) for v in values] if j < width else [(0, float(b)) for b in block.bars[: len(rows)]]
-            present = [key for key in keys if key is not None]
-            if len(set(present)) > 1:
-                sorts[j] = (*_ranks(keys), _sort_kind(values, present))
+    columns = _column_texts(block, rows)
+    numeric = [_is_numeric(column) for column in columns]
+    sorts = _table_sorts(block, rows, columns)
     filters = _filters(block, columns, numeric)
     heads = list(block.headers) + ([block.bar_label] if block.bars is not None else [])
-    cells_th = []
-    for j, header in enumerate(heads):
-        css = ["n"] if j < width and numeric[j] else []
-        inner = _esc(header)
-        if j in sorts:
-            first, second = _SORT_WORDS[sorts[j][2]]
-            radios = ("ra", "rd") if sorts[j][2] == "text" else ("rd", "ra")
-            inner = "".join(
-                f'<label class="o{n}" title="{tip}"{_HIDE if n > 1 else ""}>'
-                f'<input type="radio" name="s" class="{radio}"{_HIDE}>{_esc(header)}</label>'
-                for n, radio, tip in ((1, radios[0], f"Sort: {first}"), (2, radios[1], f"Sort: {second}"),
-                                      (3, "rn", "Back to the original order"))
-            )
-            css = ["srt", f"k{j}", *css]
-        cells_th.append(f'<th class="{" ".join(css)}">{inner}</th>' if css else f"<th>{inner}</th>")
-    position = {j: {value: i for i, (value, _) in enumerate(values)} for j, values in filters}
-    body = []
-    for i, row in enumerate(rows):
-        cells = []
-        for j, cell in enumerate(row):
-            text = "" if cell is None else str(cell)
-            inner, attrs = _cell_html(cell, text), ""
-            if block.tree and j == 0:
-                css = "tree"
-            elif j in block.code_cols and text:
-                css, inner = "c", f"<code{_SELECT}>{inner}</code>"
-            elif j in block.prose_cols:
-                css, inner = "", _lead(text)
-            elif j in block.path_cols and text:
-                css, inner = "p", _path_html(text)
-                attrs = f' title="{_esc(text)}"' if "/" in text.rstrip("/") else ""
-            elif _NUMERIC_RE.match(text):
-                css = "n"
-            else:
-                css = "s" if len(text) <= 16 and "\n" not in text else ""
-            cells.append(f'<td class="{css}"{attrs}>{inner}</td>' if css else f"<td>{inner}</td>")
-        if block.bars is not None:
-            pct = max(0.0, min(1.0, block.bars[i])) * 100
-            cells.append(
-                f'<td class="bar"><span class="track"><span class="fill" style="width:{pct:.1f}%">'
-                f"</span></span>{pct:.1f}%</td>"
-            )
-        marks = [f"f{j}v{position[j][columns[j][i].strip()]}" for j, _ in filters if columns[j][i].strip()]
-        order = ";".join(f"--a{j}:{up[i]};--d{j}:{down[i]}" for j, (up, down, _) in sorts.items())
-        body.append("<tr" + (f' class="{" ".join(marks)}"' if marks else "")
-                    + (f' style="{order}"' if order else "") + f">{''.join(cells)}</tr>")
-    choose = len(heads) >= 3  # a column chooser: tick off the columns you don't need
-    interactive = bool(sorts or filters or choose)
-    grid = f' style="--gc:repeat({len(heads)},auto)"' if interactive else ""
-    table = (
-        f'<div class="tw{" scroll" if len(rows) > 30 else ""}"><table class="t"{grid}><thead><tr>{"".join(cells_th)}'
-        f"</tr></thead><tbody>{''.join(body)}</tbody></table></div>"
-    )
-    tools = foot = more = ""
-    root = report.root
-    if choose:
-        report.rules.update(f".{root} form.tbl:has(.cv{j}:not(:checked)) tr>:nth-child({j + 1}){{display:none}}"
-                            for j in range(len(heads)))
-        tools = ('<details class="cols"><summary title="Choose the columns to show">Columns</summary><div class="menu">'
-                 + "".join(f'<label><input type="checkbox" class="cv{j}" checked>{_esc(header)}</label>'
+    chooses_columns = len(heads) >= _CHOOSER_MIN_COLUMNS
+    interactive = bool(sorts or filters or chooses_columns)
+
+    header_cells = "".join(_header_html(j, header, j < len(block.headers) and numeric[j], sorts.get(j))
                            for j, header in enumerate(heads))
-                 + '<button type="reset" title="Every column, the original order and no filters">Reset table'
-                 "</button></div></details>")
+    positions = {j: {value: i for i, (value, _) in enumerate(values)} for j, values in filters}
+    body = "".join(f"<tr{_row_attributes(i, columns, sorts, positions)}>{_row_cells(block, i, row)}</tr>"
+                   for i, row in enumerate(rows))
+    grid = f' style="--gc:repeat({len(heads)},auto)"' if interactive else ""
+    scroll = " scroll" if len(rows) > _SCROLL_ROWS else ""
+    table = (f'<div class="tw{scroll}"><table class="t"{grid}><thead><tr>{header_cells}'
+             f"</tr></thead><tbody>{body}</tbody></table></div>")
+
+    tools = _columns_menu(heads, report) if chooses_columns else ""
+    foot = ""
     if filters:
-        for j, values in filters:
-            report.rules.update(f".{root} form.tbl:has(.f{j} .v{i}:checked) tbody tr:not(.f{j}v{i}){{display:none}}"
-                                for i in range(len(values)))
-        tools += '<span class="tl">Filter</span>' + "".join(
-            f'<label class="flt">{_esc(heads[j])}<select class="f{j}"><option class="all" selected>All</option>'
-            + "".join(f'<option class="v{i}">{_esc(value)} ({count:,})</option>'
-                      for i, (value, count) in enumerate(values))
-            + "</select></label>"
-            for j, values in filters
-        )
-        foot = (f'<div class="tf"{_HIDE}><span><span class="cnt"></span> of {len(rows):,} rows match</span>'
-                '<button type="reset">Clear filters</button></div>')
+        tools += _filter_controls(filters, heads, report)
+        foot = _filter_foot(len(rows))
     tools = f'<div class="tb"{_HIDE}>{tools}</div>' if tools else ""
+    more = ""
     if hidden:
         also = f"; sorting and filters use the {len(rows):,} shown" if sorts or filters else ""
         more = f'<div class="more">{_esc(_hidden(hidden, block, report.max_rows) + also)}</div>'
-    if block.collapsed:
-        out = (f'<details class="sec"><summary>{_prose(block.title or "Details")} ({len(block.rows):,})</summary>'
-               f"{tools}{table}{foot}{more}</details>")
-    else:
-        title = f"<h4>{_prose(block.title)}</h4>" if block.title else ""
-        out = (f'<div class="tt">{title}{tools}</div>' if title and tools else title + tools) + table + foot + more
+
+    out = _table_frame(block, tools, table + foot + more)
     return f'<form class="tbl" method="dialog" autocomplete="off">{out}</form>' if interactive else out
 
 
@@ -752,7 +876,7 @@ def _cards_lines(block: _Cards, report: _Report) -> list[str]:
 
 @_draws(_Note, "text")
 def _note_lines(block: _Note, report: _Report) -> list[str]:
-    return [_MARKS.get(block.level, "[i] ") + block.text]
+    return [_MARKS.get(block.level, _INFO_MARK) + block.text]
 
 
 @_draws(_Findings, "text")
@@ -760,7 +884,7 @@ def _findings_lines(block: _Findings, report: _Report) -> list[str]:
     items = _ordered(block.items)
     if items:
         return ["", f"-- Findings: {_counts(items, ', ')} --"] + [
-            _MARKS.get(level, "[i] ") + message for level, message in items
+            _MARKS.get(level, _INFO_MARK) + message for level, message in items
         ]
     return ["[ok] " + block.empty] if block.empty else []
 
@@ -800,9 +924,6 @@ def _text_lines(block: _Text, report: _Report) -> list[str]:
     return (["", f"-- {block.title} --"] if block.title else []) + [block.text]
 
 
-# ----------------------------------------------------------------------------- whole reports
-
-
 def _block_html(block: Any, report: _Report) -> str:
     """
     One block as HTML, drawn by what's registered for its type.
diff --git a/src/aws_analyzer/_kit/view.py b/src/aws_analyzer/_kit/view.py
index 3c420fb..cf37b0e 100644
--- a/src/aws_analyzer/_kit/view.py
+++ b/src/aws_analyzer/_kit/view.py
@@ -42,6 +42,13 @@ def _commands(cls: type) -> dict[str, Callable]:
     return commands
 
 
+def _about(command: Callable) -> str:
+    """
+    What help() says a command does: the first paragraph of its docstring, on one line.
+    """
+    return " ".join((inspect.getdoc(command) or "").split("\n\n")[0].split())
+
+
 def _which_prices(prices: dict[str, Any], list_prices: dict[str, Any]) -> str:
     """
     How a report names the prices its costs come from: AWS's list prices, or the ones passed in prices=.
@@ -53,7 +60,9 @@ def _friendly_errors(method: Callable) -> Callable:
     """
     Show AWS and input errors as a readable note instead of a traceback. The view says what an AWS error means
     (_explain_call, which is _explain unless the command's arguments help), which other errors are shown as they are
-    (_DATA_ERRORS) and what to say about its own (_extra_note); anything else still raises.
+    (_DATA_ERRORS) and what to say about its own (_extra_note); anything else still raises. A _Hint is a question
+    back to the user (which knowledge base?), not an error, so it's a plain note, and a missing optional package's
+    ImportError already says what to pip install.
     """
 
     @functools.wraps(method)
@@ -65,9 +74,9 @@ def wrapper(self: _BaseView, *args: Any, **kwargs: Any) -> None:
             code, message = error.get("Code", "Error"), error.get("Message", str(exc))
             explained = self._explain_call(code, message, method.__name__, args, kwargs)
             self._show([_Note(f"{code}: {explained}  [{method.__name__}]", "warn")])
-        except _Hint as exc:  # a question back to the user (which knowledge base?), not an error
+        except _Hint as exc:
             self._show([_Note(str(exc))])
-        except ImportError as exc:  # a missing optional package: the message says what to pip install
+        except ImportError as exc:
             self._show([_Note(f"{str(exc).rstrip('.')}.", "warn")])
         except (BotoCoreError, *self._DATA_ERRORS) as exc:
             self._show([_Note(f"{type(exc).__name__}: {exc}  [{method.__name__}]", "warn")])
@@ -80,22 +89,151 @@ def wrapper(self: _BaseView, *args: Any, **kwargs: Any) -> None:
     return wrapper
 
 
+_LINE_EVERY = 0.5
+
+
+class _ProgressLine:
+    """
+    The progress one _BaseView._progress block shows: a tqdm bar while tqdm works, else a line with the count, time,
+    rate and time left, redrawn at most every _LINE_EVERY seconds, and only once the work has run that long. In a
+    notebook the line is an HTML output that's replaced; elsewhere (or without IPython) it's rewritten in place on
+    stderr.
+
+    Only one shows at a time: the view's _progress_owner is the line showing now, and a line that starts showing
+    clears the one before it. `stopped` is set when the work was interrupted, so a tqdm widget stays, red, where it
+    stopped.
+    """
+
+    def __init__(self, view: _BaseView, label: str, unit: str):
+        self.view, self.label, self.unit = view, label, unit
+        self.notebook = view.use_html and _in_notebook()
+        self.bar_class = _progress_bar_class(self.notebook) if view.progress == "auto" else None
+        self.bar: Any = None
+        self.handle: Any = None
+        self.started: float = time.monotonic()
+        self.total: int | None = None
+        self.shown = 0.0
+        self.width = 0
+        self.stopped = False
+
+    def tick(self, count: int, total: int | None = None) -> None:
+        """
+        tick(count) reports a running count; tick(done, total) a known total, and a new total starts a new bar.
+        """
+        if self.view.progress == "off":
+            return
+        if self.bar_class is not None and self._update_bar(count, total):
+            return
+        self._update_line(count, total)
+
+    def _update_bar(self, count: int, total: int | None) -> bool:
+        """
+        Moves the tqdm bar to `count`. False when tqdm fails, whatever it raises (an old tqdm, or a broken widget
+        front end): the plain line takes over from then on.
+        """
+        try:
+            if self.bar is not None and total != self.bar.total:
+                self._close_bar()
+            if self.bar is None:
+                self._take_over()
+                self.bar = _progress_bar(self.bar_class, self.label, self.unit, total)
+            self.bar.update(count - self.bar.n)
+            return True
+        except Exception:  # noqa: BLE001
+            self.bar_class = None
+            return False
+
+    def _update_line(self, count: int, total: int | None) -> None:
+        now = time.monotonic()
+        if total != self.total:
+            self.started, self.total = now, total
+        if now - self.started < _LINE_EVERY or now - self.shown < _LINE_EVERY:
+            return
+        self.shown = now
+        self._take_over()
+        text = _progress_text(self.label, self.unit, count, total, now - self.started)
+        if self.notebook:
+            self._show_in_notebook(text)
+        else:
+            self.width = max(self.width, len(text))
+            self.view._progress_to_terminal(text.ljust(self.width))
+
+    def _show_in_notebook(self, text: str) -> None:
+        """
+        The line in the cell's output, replacing the last one. Outside IPython display() returns no handle, and
+        nothing shows.
+        """
+        from IPython.display import HTML, display
+
+        if self.handle is None:
+            self.handle = display(HTML(""), display_id=True)
+        if self.handle is not None:
+            self.handle.update(HTML(f'<div style="opacity:.6">{_esc(text)}</div>'))
+
+    def _take_over(self) -> None:
+        """
+        Makes this the line the view shows, clearing the one that showed before.
+        """
+        owner = self.view._progress_owner
+        if owner is not self:
+            if owner is not None:
+                owner.clear()
+            self.view._progress_owner = self
+
+    def _close_bar(self) -> None:
+        """
+        Closes the tqdm bar. One that finished early (a file it couldn't read) is marked done, so it isn't left as a
+        red "failed" widget; one that was interrupted is left as it is.
+        """
+        if self.bar is None:
+            return
+        if not self.stopped and self.bar.total and self.bar.n < self.bar.total:
+            self.bar.total = self.bar.n
+        self.bar.close()
+        self.bar = None
+
+    def clear(self) -> None:
+        """
+        Takes the bar or the line away.
+        """
+        self._close_bar()
+        if self.handle is not None:
+            from IPython.display import HTML
+
+            self.handle.update(HTML(""))
+        elif self.width:
+            self.view._progress_to_terminal(" " * self.width + "\r")
+            self.width = 0
+
+
 class _BaseView:
     """
     What every <Service>View starts with: the mode, max_rows and progress options, how a report is shown,
     progress while a long command runs, help(), and the hooks @_friendly_errors asks. The only command here is
     help(); every other one is the service's, decorated with @_friendly_errors, and renders a report and returns
     nothing.
+
+    What a service's View sets:
+
+        core          its analyzer: the View's __init__ makes one when it isn't given one
+        _render_html  its look: its stylesheet, root class and badge
+        _GROUPS       help() lists the commands in these groups, in this order
+        _START        help()'s "Start here": (call, what it shows)
+        _PROGRESS     the label and unit _progress() shows when it's given none
+        _DATA_ERRORS  errors shown as notes ("ValueError: ..."), besides AWS's
+
+    _render_text, how a report reads as text, is the same for every service, and _progress_owner is the progress
+    line showing now (see _ProgressLine).
     """
 
-    core: Any  # the service's analyzer: the View's __init__ makes one when it isn't given one
-    _render_html: Callable[[list[Any], int], str]  # the service's look: its stylesheet, root class and badge
-    _render_text = staticmethod(_render_text)  # how a report reads as text, the same for every service
-    _GROUPS: dict[str, tuple[str, ...]] = {}  # help() lists the commands in these groups, in this order
-    _START: tuple[tuple[str, str], ...] = ()  # help()'s "Start here": (call, what it shows)
-    _PROGRESS = ("Reading", "items read")  # the label and unit _progress() shows when it's given none
-    _DATA_ERRORS: tuple[type[Exception], ...] = (ValueError, TypeError)  # shown as notes: "ValueError: ..."
-    _progress_owner: Callable[[], None] | None = None  # clears the progress bar showing now
+    core: Any
+    _render_html: Callable[[list[Any], int], str]
+    _render_text = staticmethod(_render_text)
+    _GROUPS: dict[str, tuple[str, ...]] = {}
+    _START: tuple[tuple[str, str], ...] = ()
+    _PROGRESS = ("Reading", "items read")
+    _DATA_ERRORS: tuple[type[Exception], ...] = (ValueError, TypeError)
+    _progress_owner: _ProgressLine | None = None
 
     def __init__(self, *, mode: str = "auto", max_rows: int = 50, progress: str = "auto"):
         if mode not in ("auto", "html", "text"):
@@ -106,13 +244,15 @@ def __init__(self, *, mode: str = "auto", max_rows: int = 50, progress: str = "a
         self.max_rows = max_rows
         self.progress = progress
 
-    # ------------------------------------------------------------------ plumbing
-
     def _show(self, blocks: list[Any]) -> None:
+        """
+        Shows a report: as HTML in Jupyter, else as text. With mode='html' outside Jupyter (no IPython), it's shown
+        as text with a note saying why, and from then on as text.
+        """
         if self.use_html:
             try:
                 from IPython.display import HTML, display
-            except ImportError:  # mode='html' outside Jupyter: show text, and say why (once)
+            except ImportError:
                 self.use_html = False
                 note = "mode='html' only works in Jupyter (IPython isn't installed here), so this is shown as text."
                 blocks = [*blocks, _Note(note, "warn")]
@@ -121,6 +261,13 @@ def _show(self, blocks: list[Any]) -> None:
                 return
         print(self._render_text(blocks, self.max_rows))
 
+    @staticmethod
+    def _progress_to_terminal(text: str) -> None:
+        """
+        Rewrites the progress line in place on stderr, outside a notebook.
+        """
+        print("\r" + text, end="", file=sys.stderr, flush=True)
+
     @contextmanager
     def _progress(self, label: str | None = None,
                   unit: str | None = None) -> Generator[Callable[..., None], None, None]:
@@ -131,84 +278,18 @@ def _progress(self, label: str | None = None,
         at a time: when a nested _progress starts showing, the outer one's bar goes away. Without a label or a
         unit, it shows the View's _PROGRESS.
         """
-        label = self._PROGRESS[0] if label is None else label
-        unit = self._PROGRESS[1] if unit is None else unit
-        notebook = self.use_html and _in_notebook()  # elsewhere (or without IPython) the plain line goes to stderr
-        bar_class = [_progress_bar_class(notebook) if self.progress == "auto" else None]
-        bar: list[Any] = [None]
-        handle: list[Any] = [None]
-        started: list[Any] = [time.monotonic(), None]  # when the current total started, and that total
-        shown, width, stopped = [0.0], [0], [False]
-
-        def close_bar() -> None:
-            if bar[0] is not None:
-                if not stopped[0] and bar[0].total and bar[0].n < bar[0].total:
-                    bar[0].total = bar[0].n  # done early (a file it couldn't read): no red "failed" widget
-                bar[0].close()
-                bar[0] = None
-
-        def clear() -> None:
-            close_bar()
-            if handle[0] is not None:
-                from IPython.display import HTML
-
-                handle[0].update(HTML(""))
-            elif width[0]:
-                print("\r" + " " * width[0] + "\r", end="", file=sys.stderr, flush=True)
-                width[0] = 0
-
-        def take_over() -> None:
-            owner = self._progress_owner
-            if owner is not clear:
-                if owner is not None:
-                    owner()
-                self._progress_owner = clear
-
-        def tick(count: int, total: int | None = None) -> None:
-            if self.progress == "off":
-                return
-            if bar_class[0] is not None:
-                try:
-                    if bar[0] is not None and total != bar[0].total:
-                        close_bar()
-                    if bar[0] is None:
-                        take_over()
-                        bar[0] = _progress_bar(bar_class[0], label, unit, total)
-                    bar[0].update(count - bar[0].n)
-                    return
-                except Exception:  # an old tqdm or a broken widget front end: use the plain line instead
-                    bar_class[0] = None
-            now = time.monotonic()
-            if total != started[1]:
-                started[:] = [now, total]
-            if now - started[0] < 0.5 or now - shown[0] < 0.5:
-                return
-            shown[0] = now
-            take_over()
-            text = _progress_text(label, unit, count, total, now - started[0])
-            if notebook:
-                from IPython.display import HTML, display
-
-                if handle[0] is None:
-                    handle[0] = display(HTML(""), display_id=True)
-                if handle[0] is not None:  # display() returns None outside IPython
-                    handle[0].update(HTML(f'<div style="opacity:.6">{_esc(text)}</div>'))
-            else:
-                width[0] = max(width[0], len(text))
-                print("\r" + text.ljust(width[0]), end="", file=sys.stderr, flush=True)
-
+        line = _ProgressLine(self, self._PROGRESS[0] if label is None else label,
+                             self._PROGRESS[1] if unit is None else unit)
         try:
-            yield tick
+            yield line.tick
         except BaseException:
-            stopped[0] = True  # interrupted: a tqdm widget stays, red, where it stopped
+            line.stopped = True
             raise
         finally:
-            clear()
-            if self._progress_owner is clear:
+            line.clear()
+            if self._progress_owner is line:
                 self._progress_owner = None
 
-    # ------------------------------------------------------------------ what @_friendly_errors asks
-
     def _explain(self, code: str, message: str) -> str:
         """
         What an AWS error means, and what to do about it. The service's View says more where it can; here, AWS's
@@ -235,18 +316,12 @@ def _price_basis(self) -> str:
         """
         return _which_prices(self.core.prices, self.core._LIST_PRICES)
 
-    # ------------------------------------------------------------------ help
-
     def help(self, command: Any = None) -> None:
         """
         Every command, grouped by task; help('name') shows one command in full.
         """
         view = type(self).__name__
         commands = _commands(type(self))
-
-        def about(name: str) -> str:  # the docstring's first paragraph, on one line
-            return " ".join((inspect.getdoc(commands[name]) or "").split("\n\n")[0].split())
-
         if command is not None:
             name = getattr(command, "__name__", str(command))
             if name not in commands:
@@ -265,7 +340,8 @@ def about(name: str) -> str:  # the docstring's first paragraph, on one line
             _Next(list(self._START), title="Start here"),
         ]
         for group, names in groups.items():
-            rows = [[f"{name}{_signature(commands[name])}", about(name)] for name in names if name in commands]
+            rows = [[f"{name}{_signature(commands[name])}", _about(commands[name])] for name in names
+                    if name in commands]
             if rows:
                 blocks.append(_Table(["Command", "What it shows"], rows, title=group, max_rows=0, code_cols=(0,)))
         zone = _tz_label()
diff --git a/src/aws_analyzer/_kit/window.py b/src/aws_analyzer/_kit/window.py
index 697d55f..bb3be73 100644
--- a/src/aws_analyzer/_kit/window.py
+++ b/src/aws_analyzer/_kit/window.py
@@ -165,10 +165,11 @@ class _Window:
 
     A window says where an error goes (_warn: its status line) and what an AWS error means (_explain: its View's),
     in its own words (_reword: an explorer turns a report's commands into its tabs). Its pickers (_Picker) go in
-    pickers, and its backdrop, the invisible button under an open list, calls _close_lists.
+    pickers, and its backdrop, the invisible button under an open list, calls _close_lists. `quiet` is set while
+    the code, not a person, changes a widget (_quietly), so the widget's observer does nothing.
     """
 
-    quiet = False  # set while the code (not a person) changes a widget, so its observer does nothing
+    quiet = False
     pickers: list[_Picker]
     backdrop: Any
 
@@ -204,11 +205,16 @@ def _command_failed(self, exc: Exception, command: str) -> bool:
         return False
 
     def _safely(self, handler: Callable[..., Any]) -> Callable[..., Any]:
+        """
+        A widget callback that says any error it raises in the window (_warn): raised, it would only reach the
+        browser's log, and the click would seem to do nothing.
+        """
+
         @functools.wraps(handler)
         def run(*args: Any, **kwargs: Any) -> Any:
             try:
                 return handler(*args, **kwargs)
-            except Exception as exc:  # shown in the window: a widget callback's error would go to the browser log
+            except Exception as exc:  # noqa: BLE001
                 self._warn(self._error_text(exc))
                 return None
 
@@ -256,6 +262,22 @@ def _close_lists(self) -> None:
             picker.close()
 
 
+@dataclasses.dataclass
+class _Job:
+    """
+    A job _Explorer._later runs in the background: its key and number (a newer job of the same key makes its
+    result go unused), what to do with its result or its error, and the status line it shows while it counts, as
+    long as the line is still owner's.
+    """
+
+    key: str
+    number: int
+    done: Callable[[Any], None]
+    failed: Callable[[BaseException], None]
+    counting: str = ""
+    owner: str = ""
+
+
 class _Explorer(_Window):
     """
     What the knowledge base and Lambda explorers share on top of _Window: the status line under the tabs, AWS read
@@ -266,22 +288,35 @@ class _Explorer(_Window):
     (_tab_bar) and the pages, and _frame puts them in the window. _show_tab(key) opens a tab, and _html(blocks) draws
     a report the way the window shows them. _PREFIX starts its CSS class names (.kbx-app, .kbx-tab, ...), and
     _THREADS names its worker threads.
+
+    What it keeps:
+
+        shown      page -> the blocks drawn there last (for tests, and the curious)
+        _w         ipywidgets, when the window shows (else the explorer shows reports)
+        _jobs      background job -> its latest number: an older one's result is dropped
+        _tasks     background job -> its asyncio task (tests wait for them)
+        _counted   how much the background read has read so far
+        _said      the status line: its text, level, whether it's busy, and whose it is
+        _shown_at  the cell the window was last shown in
+        pickers    the fields that open a list, of which one is open at a time
     """
 
     _PREFIX = "explorer"
     _THREADS = "explorer"
+    _WORKERS = 4
+    _COUNT_EVERY = 0.4
 
     def __init__(self) -> None:
-        self.shown: dict[str, list[Any]] = {}  # page -> the blocks drawn there last (for tests, and the curious)
+        self.shown: dict[str, list[Any]] = {}
         self.quiet = False
-        self._w: Any = None  # ipywidgets, when the window shows (else the explorer shows reports)
-        self._jobs: dict[str, int] = {}  # background job -> its latest number: an older one's result is dropped
-        self._tasks: dict[str, Any] = {}  # background job -> its asyncio task (tests wait for them)
+        self._w: Any = None
+        self._jobs: dict[str, int] = {}
+        self._tasks: dict[str, Any] = {}
         self._pool: ThreadPoolExecutor | None = None
-        self._counted = 0  # what the background read has read so far
-        self._said: tuple[str, str, bool, str] = ("", "", False, "")  # the status line: text, level, busy, whose
+        self._counted = 0
+        self._said: tuple[str, str, bool, str] = ("", "", False, "")
         self._shown_at: Any = object()
-        self.pickers: list[_Picker] = []  # the fields that open a list: one open at a time
+        self.pickers: list[_Picker] = []
 
     def _load_widgets(self, mode: str) -> str:
         """
@@ -305,9 +340,12 @@ def _ipython_display_(self) -> None:
             self._display()
 
     def _display(self) -> None:
+        """
+        Shows the window in the running cell's output; outside IPython there's nowhere to show widgets.
+        """
         self._shown_at = _cell_number()
         if self._shown_at is None:
-            return  # outside IPython there's nowhere to show widgets
+            return
         from IPython.display import display
 
         display(self.root)
@@ -397,56 +435,75 @@ def _draw(self, page: str, widget: Any, blocks: list[Any]) -> None:
 
     def _workers(self) -> ThreadPoolExecutor:
         if self._pool is None:
-            self._pool = ThreadPoolExecutor(max_workers=4, thread_name_prefix=self._THREADS)
+            self._pool = ThreadPoolExecutor(max_workers=self._WORKERS, thread_name_prefix=self._THREADS)
         return self._pool
 
-    def _later(self, key: str, work: Callable[[], Any], done: Callable[[Any], None],
+    def _later(self, key: str, work: Callable[[], Any], done: Callable[[Any], None],  # noqa: PLR0913
                failed: Callable[[BaseException], None] | None = None, counting: str = "", owner: str = "") -> None:
         """
         Runs work() off the notebook's event loop, then done(result) on it, so a click returns at once and the
         window keeps answering while AWS is read. Without a running loop (a script, the tests) it runs here and now.
-        A newer job of the same key makes this one's result go unused. counting: the status line to show while it runs
-        and the line is still owner's, {n} standing for the count read so far.
+        A newer job of the same key makes this one's result go unused. Whatever work() raises goes to failed (by
+        default said in the status line). counting: the status line to show while it runs and the line is still
+        owner's, {n} standing for the count read so far.
         """
-        self._jobs[key] = job = self._jobs.get(key, 0) + 1
-        failed = failed or (lambda exc: self._status(self._error_text(exc), "warn"))
-
-        def finish(handler: Callable[[Any], None], value: Any) -> None:
-            if self._jobs.get(key) != job:
-                return
-            try:
-                handler(value)
-            except Exception as exc:  # a bug in drawing it: said in the window, like a click's
-                self._status(self._error_text(exc), "warn")
-
+        self._jobs[key] = number = self._jobs.get(key, 0) + 1
+        job = _Job(key, number, done, failed or self._say_error, counting, owner)
         loop = _running_loop()
         if loop is None:
-            try:
-                result = work()
-            except Exception as exc:
-                finish(failed, exc)
-            else:
-                finish(done, result)
+            self._run_now(job, work)
+        else:
+            self._tasks[key] = loop.create_task(self._run_in_background(job, loop, work))
+
+    def _say_error(self, exc: BaseException) -> None:
+        self._status(self._error_text(exc), "warn")
+
+    def _is_latest(self, job: _Job) -> bool:
+        return self._jobs.get(job.key) == job.number
+
+    def _hand_back(self, job: _Job, handler: Callable[[Any], None], value: Any) -> None:
+        """
+        Gives a job's result (or its error) to its handler, unless a newer job of its key started since. A bug in
+        drawing it is said in the window, like a click's.
+        """
+        if not self._is_latest(job):
             return
+        try:
+            handler(value)
+        except Exception as exc:  # noqa: BLE001
+            self._say_error(exc)
 
-        async def run() -> None:
-            future = loop.run_in_executor(self._workers(), work)
-            while counting and not future.done():
-                await asyncio.wait([future], timeout=0.4)
-                if self._jobs.get(key) == job and not future.done() and self._counted and self._said[3] == owner:
-                    self._status(counting.replace("{n}", f"{self._counted:,}"), busy=True, owner=owner)
-            try:
-                result = await future
-            except Exception as exc:
-                finish(failed, exc)
-            else:
-                finish(done, result)
-            finally:
-                if self._tasks.get(key) is task:
-                    del self._tasks[key]
+    def _run_now(self, job: _Job, work: Callable[[], Any]) -> None:
+        try:
+            result = work()
+        except Exception as exc:  # noqa: BLE001
+            self._hand_back(job, job.failed, exc)
+        else:
+            self._hand_back(job, job.done, result)
 
-        task = loop.create_task(run())
-        self._tasks[key] = task
+    async def _run_in_background(self, job: _Job, loop: asyncio.AbstractEventLoop, work: Callable[[], Any]) -> None:
+        future = loop.run_in_executor(self._workers(), work)
+        await self._count_while_waiting(job, future)
+        try:
+            result = await future
+        except Exception as exc:  # noqa: BLE001
+            self._hand_back(job, job.failed, exc)
+        else:
+            self._hand_back(job, job.done, result)
+        finally:
+            if self._tasks.get(job.key) is asyncio.current_task():
+                del self._tasks[job.key]
+
+    async def _count_while_waiting(self, job: _Job, future: asyncio.Future) -> None:
+        """
+        While a job that counts runs, says how much it has read every _COUNT_EVERY seconds, as long as the status
+        line is still its owner's and no newer job of its key started.
+        """
+        while job.counting and not future.done():
+            await asyncio.wait([future], timeout=self._COUNT_EVERY)
+            still_counting = self._is_latest(job) and not future.done() and self._said[3] == job.owner
+            if still_counting and self._counted:
+                self._status(job.counting.replace("{n}", f"{self._counted:,}"), busy=True, owner=job.owner)
 
     def _drop(self, *keys: str) -> None:
         """
@@ -469,19 +526,23 @@ class _Picker:
     A subclass says what the search box finds a choice by (_fields; _query rewrites what's typed first, an ARN into
     its name), a choice's value (_key), and draws the field's face, the list (_draw_list) and its lines, and what a
     click on one does (_clicked). prefix starts the CSS classes (kbx: .kbx-field, .kbx-trig, .kbx-opt, ...).
+
+    What it keeps: `problem`, why there's nothing to list (it couldn't be read), shown under the list; `message`,
+    what went wrong with the last Enter; `shown`, the values of the lines the list shows, top to bottom; and `rows`,
+    value -> (its line, the line's button, its text).
     """
 
-    def __init__(self, app: _Window, w: Any, prefix: str, *, on_pick: Callable[[Any], None],
+    def __init__(self, app: _Window, w: Any, prefix: str, *, on_pick: Callable[[Any], None],  # noqa: PLR0913
                  on_text: Callable[[str], None] | None, placeholder: str, tooltip: str | None = None,
                  close_width: str | None = None, list_width: str | None = None,
                  field_layout: dict[str, str] | None = None):
         layout = w.Layout
         self.app, self.w, self.prefix, self.on_pick, self.on_text = app, w, prefix, on_pick, on_text
         self.choices: list[Any] = []
-        self.problem = ""  # why there's nothing to list (it couldn't be read), shown under the list
-        self.message = ""  # what went wrong with the last Enter
-        self.shown: list[str] = []  # the values of the lines the list shows, top to bottom
-        self.rows: dict[str, tuple[Any, Any, Any]] = {}  # value -> (its line, the line's button, its text)
+        self.problem = ""
+        self.message = ""
+        self.shown: list[str] = []
+        self.rows: dict[str, tuple[Any, Any, Any]] = {}
         trigger, self.button, self.face = _row_button(w, (f"{prefix}-trig", f"{prefix}-trig-b", f"{prefix}-face"),
                                                       app._safely(lambda _button: self.toggle()), tooltip=tooltip)
         self.search = w.Text(placeholder=placeholder, continuous_update=True,
@@ -515,9 +576,13 @@ def _opening(self) -> None:
         """
 
     def open(self) -> None:
+        """
+        Opens the list, closing any other open one: one list is open at a time. The search box takes the keys
+        (ipywidgets 8 can focus it).
+        """
         if not self._can_open() or self.is_open:
             return
-        for other in self.app.pickers:  # one list open at a time
+        for other in self.app.pickers:
             if other is not self:
                 other.close()
         self._opening()
@@ -526,7 +591,7 @@ def open(self) -> None:
         self.app.backdrop.layout.display = ""
         _class_if(self.field, f"{self.prefix}-open", True)
         self._draw_list()
-        if hasattr(self.search, "focus"):  # ipywidgets 8
+        if hasattr(self.search, "focus"):
             self.search.focus()
 
     def close(self) -> None:
diff --git a/tests/test_style.py b/tests/test_style.py
index ea4891c..fcd4e7d 100644
--- a/tests/test_style.py
+++ b/tests/test_style.py
@@ -29,14 +29,6 @@
     ".claude/skills/release/release.py": 4,
     "src/aws_analyzer/__init__.py": 3,
     "src/aws_analyzer/_bedrock.py": 83,
-    "src/aws_analyzer/_kit/analyzer.py": 7,
-    "src/aws_analyzer/_kit/blocks.py": 28,
-    "src/aws_analyzer/_kit/fmt.py": 11,
-    "src/aws_analyzer/_kit/jsontree.py": 25,
-    "src/aws_analyzer/_kit/progress.py": 1,
-    "src/aws_analyzer/_kit/render.py": 26,
-    "src/aws_analyzer/_kit/view.py": 21,
-    "src/aws_analyzer/_kit/window.py": 17,
     "src/aws_analyzer/agent/analyzer.py": 10,
     "src/aws_analyzer/agent/answers.py": 18,
     "src/aws_analyzer/agent/budget.py": 10,